method2testcases stringlengths 118 3.08k |
|---|
### Question:
BlobChecker implements RegistryEndpointProvider<Optional<BlobDescriptor>> { @Override public Optional<BlobDescriptor> handleHttpResponseException(ResponseException responseException) throws ResponseException { if (responseException.getStatusCode() != HttpStatusCodes.STATUS_CODE_NOT_FOUND) { throw responseException; } if (responseException.getContent() == null) { return Optional.empty(); } ErrorCodes errorCode = ErrorResponseUtil.getErrorCode(responseException); if (errorCode == ErrorCodes.BLOB_UNKNOWN) { return Optional.empty(); } throw responseException; } BlobChecker(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
DescriptorDigest blobDigest); @Override Optional<BlobDescriptor> handleResponse(Response response); @Override Optional<BlobDescriptor> handleHttpResponseException(ResponseException responseException); @Override URL getApiRoute(String apiRouteBase); @Nullable @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override String getHttpMethod(); @Override String getActionDescription(); }### Answer:
@Test public void testHandleHttpResponseException() throws IOException { ResponseException mockResponseException = Mockito.mock(ResponseException.class); Mockito.when(mockResponseException.getStatusCode()) .thenReturn(HttpStatusCodes.STATUS_CODE_NOT_FOUND); ErrorResponseTemplate emptyErrorResponseTemplate = new ErrorResponseTemplate() .addError(new ErrorEntryTemplate(ErrorCodes.BLOB_UNKNOWN.name(), "some message")); Mockito.when(mockResponseException.getContent()) .thenReturn(JsonTemplateMapper.toUtf8String(emptyErrorResponseTemplate)); Assert.assertFalse( testBlobChecker.handleHttpResponseException(mockResponseException).isPresent()); }
@Test public void testHandleHttpResponseException_invalidStatusCode() { ResponseException mockResponseException = Mockito.mock(ResponseException.class); Mockito.when(mockResponseException.getStatusCode()).thenReturn(-1); try { testBlobChecker.handleHttpResponseException(mockResponseException); Assert.fail("Non-404 status codes should not be handled"); } catch (ResponseException ex) { Assert.assertEquals(mockResponseException, ex); } } |
### Question:
BlobChecker implements RegistryEndpointProvider<Optional<BlobDescriptor>> { @Override public URL getApiRoute(String apiRouteBase) throws MalformedURLException { return new URL( apiRouteBase + registryEndpointRequestProperties.getImageName() + "/blobs/" + blobDigest); } BlobChecker(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
DescriptorDigest blobDigest); @Override Optional<BlobDescriptor> handleResponse(Response response); @Override Optional<BlobDescriptor> handleHttpResponseException(ResponseException responseException); @Override URL getApiRoute(String apiRouteBase); @Nullable @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override String getHttpMethod(); @Override String getActionDescription(); }### Answer:
@Test public void testGetApiRoute() throws MalformedURLException { Assert.assertEquals( new URL("http: testBlobChecker.getApiRoute("http: } |
### Question:
BlobChecker implements RegistryEndpointProvider<Optional<BlobDescriptor>> { @Nullable @Override public BlobHttpContent getContent() { return null; } BlobChecker(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
DescriptorDigest blobDigest); @Override Optional<BlobDescriptor> handleResponse(Response response); @Override Optional<BlobDescriptor> handleHttpResponseException(ResponseException responseException); @Override URL getApiRoute(String apiRouteBase); @Nullable @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override String getHttpMethod(); @Override String getActionDescription(); }### Answer:
@Test public void testGetContent() { Assert.assertNull(testBlobChecker.getContent()); } |
### Question:
BlobChecker implements RegistryEndpointProvider<Optional<BlobDescriptor>> { @Override public List<String> getAccept() { return Collections.emptyList(); } BlobChecker(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
DescriptorDigest blobDigest); @Override Optional<BlobDescriptor> handleResponse(Response response); @Override Optional<BlobDescriptor> handleHttpResponseException(ResponseException responseException); @Override URL getApiRoute(String apiRouteBase); @Nullable @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override String getHttpMethod(); @Override String getActionDescription(); }### Answer:
@Test public void testGetAccept() { Assert.assertEquals(0, testBlobChecker.getAccept().size()); } |
### Question:
BlobChecker implements RegistryEndpointProvider<Optional<BlobDescriptor>> { @Override public String getActionDescription() { return "check BLOB exists for " + registryEndpointRequestProperties.getServerUrl() + "/" + registryEndpointRequestProperties.getImageName() + " with digest " + blobDigest; } BlobChecker(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
DescriptorDigest blobDigest); @Override Optional<BlobDescriptor> handleResponse(Response response); @Override Optional<BlobDescriptor> handleHttpResponseException(ResponseException responseException); @Override URL getApiRoute(String apiRouteBase); @Nullable @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override String getHttpMethod(); @Override String getActionDescription(); }### Answer:
@Test public void testGetActionDescription() { Assert.assertEquals( "check BLOB exists for someServerUrl/someImageName with digest " + fakeDigest, testBlobChecker.getActionDescription()); } |
### Question:
BlobChecker implements RegistryEndpointProvider<Optional<BlobDescriptor>> { @Override public String getHttpMethod() { return HttpMethods.HEAD; } BlobChecker(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
DescriptorDigest blobDigest); @Override Optional<BlobDescriptor> handleResponse(Response response); @Override Optional<BlobDescriptor> handleHttpResponseException(ResponseException responseException); @Override URL getApiRoute(String apiRouteBase); @Nullable @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override String getHttpMethod(); @Override String getActionDescription(); }### Answer:
@Test public void testGetHttpMethod() { Assert.assertEquals("HEAD", testBlobChecker.getHttpMethod()); } |
### Question:
RegistryAliasGroup { public static List<String> getAliasesGroup(String registry) { for (ImmutableSet<String> aliasGroup : REGISTRY_ALIAS_GROUPS) { if (aliasGroup.contains(registry)) { Stream<String> self = Stream.of(registry); Stream<String> withoutSelf = aliasGroup.stream().filter(alias -> !registry.equals(alias)); return Stream.concat(self, withoutSelf).collect(Collectors.toList()); } } return Collections.singletonList(registry); } static List<String> getAliasesGroup(String registry); static String getHost(String registry); }### Answer:
@Test public void testGetAliasesGroup_noKnownAliases() { List<String> singleton = RegistryAliasGroup.getAliasesGroup("something.gcr.io"); Assert.assertEquals(1, singleton.size()); Assert.assertEquals("something.gcr.io", singleton.get(0)); }
@Test public void testGetAliasesGroup_dockerHub() { Set<String> aliases = Sets.newHashSet( "registry.hub.docker.com", "index.docker.io", "registry-1.docker.io", "docker.io"); for (String alias : aliases) { Assert.assertEquals(aliases, new HashSet<>(RegistryAliasGroup.getAliasesGroup(alias))); } } |
### Question:
RegistryAliasGroup { public static String getHost(String registry) { return REGISTRY_HOST_MAP.getOrDefault(registry, registry); } static List<String> getAliasesGroup(String registry); static String getHost(String registry); }### Answer:
@Test public void testGetHost_noAlias() { String host = RegistryAliasGroup.getHost("something.gcr.io"); Assert.assertEquals("something.gcr.io", host); }
@Test public void testGetHost_dockerIo() { String host = RegistryAliasGroup.getHost("docker.io"); Assert.assertEquals("registry-1.docker.io", host); } |
### Question:
AuthenticationMethodRetriever implements RegistryEndpointProvider<Optional<RegistryAuthenticator>> { @Nullable @Override public BlobHttpContent getContent() { return null; } AuthenticationMethodRetriever(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
@Nullable String userAgent,
FailoverHttpClient httpClient); @Nullable @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override Optional<RegistryAuthenticator> handleResponse(Response response); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); @Override Optional<RegistryAuthenticator> handleHttpResponseException(
ResponseException responseException); }### Answer:
@Test public void testGetContent() { Assert.assertNull(testAuthenticationMethodRetriever.getContent()); } |
### Question:
AuthenticationMethodRetriever implements RegistryEndpointProvider<Optional<RegistryAuthenticator>> { @Override public List<String> getAccept() { return Collections.emptyList(); } AuthenticationMethodRetriever(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
@Nullable String userAgent,
FailoverHttpClient httpClient); @Nullable @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override Optional<RegistryAuthenticator> handleResponse(Response response); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); @Override Optional<RegistryAuthenticator> handleHttpResponseException(
ResponseException responseException); }### Answer:
@Test public void testGetAccept() { Assert.assertEquals(0, testAuthenticationMethodRetriever.getAccept().size()); } |
### Question:
AuthenticationMethodRetriever implements RegistryEndpointProvider<Optional<RegistryAuthenticator>> { @Override public Optional<RegistryAuthenticator> handleResponse(Response response) { return Optional.empty(); } AuthenticationMethodRetriever(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
@Nullable String userAgent,
FailoverHttpClient httpClient); @Nullable @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override Optional<RegistryAuthenticator> handleResponse(Response response); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); @Override Optional<RegistryAuthenticator> handleHttpResponseException(
ResponseException responseException); }### Answer:
@Test public void testHandleResponse() { Assert.assertFalse( testAuthenticationMethodRetriever.handleResponse(Mockito.mock(Response.class)).isPresent()); } |
### Question:
AuthenticationMethodRetriever implements RegistryEndpointProvider<Optional<RegistryAuthenticator>> { @Override public URL getApiRoute(String apiRouteBase) throws MalformedURLException { return new URL(apiRouteBase); } AuthenticationMethodRetriever(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
@Nullable String userAgent,
FailoverHttpClient httpClient); @Nullable @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override Optional<RegistryAuthenticator> handleResponse(Response response); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); @Override Optional<RegistryAuthenticator> handleHttpResponseException(
ResponseException responseException); }### Answer:
@Test public void testGetApiRoute() throws MalformedURLException { Assert.assertEquals( new URL("http: testAuthenticationMethodRetriever.getApiRoute("http: } |
### Question:
AuthenticationMethodRetriever implements RegistryEndpointProvider<Optional<RegistryAuthenticator>> { @Override public String getHttpMethod() { return HttpMethods.GET; } AuthenticationMethodRetriever(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
@Nullable String userAgent,
FailoverHttpClient httpClient); @Nullable @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override Optional<RegistryAuthenticator> handleResponse(Response response); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); @Override Optional<RegistryAuthenticator> handleHttpResponseException(
ResponseException responseException); }### Answer:
@Test public void testGetHttpMethod() { Assert.assertEquals(HttpMethods.GET, testAuthenticationMethodRetriever.getHttpMethod()); } |
### Question:
AuthenticationMethodRetriever implements RegistryEndpointProvider<Optional<RegistryAuthenticator>> { @Override public String getActionDescription() { return "retrieve authentication method for " + registryEndpointRequestProperties.getServerUrl(); } AuthenticationMethodRetriever(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
@Nullable String userAgent,
FailoverHttpClient httpClient); @Nullable @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override Optional<RegistryAuthenticator> handleResponse(Response response); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); @Override Optional<RegistryAuthenticator> handleHttpResponseException(
ResponseException responseException); }### Answer:
@Test public void testGetActionDescription() { Assert.assertEquals( "retrieve authentication method for someServerUrl", testAuthenticationMethodRetriever.getActionDescription()); } |
### Question:
ManifestPusher implements RegistryEndpointProvider<DescriptorDigest> { @Override public BlobHttpContent getContent() { return new BlobHttpContent( Blobs.from(manifestTemplate), manifestTemplate.getManifestMediaType()); } ManifestPusher(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
ManifestTemplate manifestTemplate,
String imageTag,
EventHandlers eventHandlers); @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override DescriptorDigest handleHttpResponseException(ResponseException responseException); @Override DescriptorDigest handleResponse(Response response); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); }### Answer:
@Test public void testGetContent() throws IOException { BlobHttpContent body = testManifestPusher.getContent(); Assert.assertNotNull(body); Assert.assertEquals(V22ManifestTemplate.MANIFEST_MEDIA_TYPE, body.getType()); ByteArrayOutputStream bodyCaptureStream = new ByteArrayOutputStream(); body.writeTo(bodyCaptureStream); String v22manifestJson = new String(Files.readAllBytes(v22manifestJsonFile), StandardCharsets.UTF_8); Assert.assertEquals( v22manifestJson, new String(bodyCaptureStream.toByteArray(), StandardCharsets.UTF_8)); } |
### Question:
ManifestPusher implements RegistryEndpointProvider<DescriptorDigest> { @Override public URL getApiRoute(String apiRouteBase) throws MalformedURLException { return new URL( apiRouteBase + registryEndpointRequestProperties.getImageName() + "/manifests/" + imageTag); } ManifestPusher(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
ManifestTemplate manifestTemplate,
String imageTag,
EventHandlers eventHandlers); @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override DescriptorDigest handleHttpResponseException(ResponseException responseException); @Override DescriptorDigest handleResponse(Response response); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); }### Answer:
@Test public void testApiRoute() throws MalformedURLException { Assert.assertEquals( new URL("http: testManifestPusher.getApiRoute("http: } |
### Question:
ManifestPusher implements RegistryEndpointProvider<DescriptorDigest> { @Override public String getHttpMethod() { return HttpMethods.PUT; } ManifestPusher(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
ManifestTemplate manifestTemplate,
String imageTag,
EventHandlers eventHandlers); @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override DescriptorDigest handleHttpResponseException(ResponseException responseException); @Override DescriptorDigest handleResponse(Response response); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); }### Answer:
@Test public void testGetHttpMethod() { Assert.assertEquals("PUT", testManifestPusher.getHttpMethod()); } |
### Question:
ManifestPusher implements RegistryEndpointProvider<DescriptorDigest> { @Override public String getActionDescription() { return "push image manifest for " + registryEndpointRequestProperties.getServerUrl() + "/" + registryEndpointRequestProperties.getImageName() + ":" + imageTag; } ManifestPusher(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
ManifestTemplate manifestTemplate,
String imageTag,
EventHandlers eventHandlers); @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override DescriptorDigest handleHttpResponseException(ResponseException responseException); @Override DescriptorDigest handleResponse(Response response); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); }### Answer:
@Test public void testGetActionDescription() { Assert.assertEquals( "push image manifest for someServerUrl/someImageName:test-image-tag", testManifestPusher.getActionDescription()); } |
### Question:
ManifestPusher implements RegistryEndpointProvider<DescriptorDigest> { @Override public List<String> getAccept() { return Collections.emptyList(); } ManifestPusher(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
ManifestTemplate manifestTemplate,
String imageTag,
EventHandlers eventHandlers); @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override DescriptorDigest handleHttpResponseException(ResponseException responseException); @Override DescriptorDigest handleResponse(Response response); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); }### Answer:
@Test public void testGetAccept() { Assert.assertEquals(0, testManifestPusher.getAccept().size()); } |
### Question:
ManifestPusher implements RegistryEndpointProvider<DescriptorDigest> { @Override public DescriptorDigest handleHttpResponseException(ResponseException responseException) throws ResponseException, RegistryErrorException { if (responseException.getStatusCode() != HttpStatus.SC_BAD_REQUEST && responseException.getStatusCode() != HttpStatus.SC_UNSUPPORTED_MEDIA_TYPE) { throw responseException; } ErrorCodes errorCode = ErrorResponseUtil.getErrorCode(responseException); if (errorCode == ErrorCodes.MANIFEST_INVALID || errorCode == ErrorCodes.TAG_INVALID) { throw new RegistryErrorExceptionBuilder(getActionDescription(), responseException) .addReason( "Registry may not support pushing OCI Manifest or " + "Docker Image Manifest Version 2, Schema 2") .build(); } throw responseException; } ManifestPusher(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
ManifestTemplate manifestTemplate,
String imageTag,
EventHandlers eventHandlers); @Override BlobHttpContent getContent(); @Override List<String> getAccept(); @Override DescriptorDigest handleHttpResponseException(ResponseException responseException); @Override DescriptorDigest handleResponse(Response response); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); }### Answer:
@Test public void testHandleHttpResponseException_otherError() throws RegistryErrorException { ResponseException exception = Mockito.mock(ResponseException.class); Mockito.when(exception.getStatusCode()).thenReturn(HttpStatus.SC_UNAUTHORIZED); try { testManifestPusher.handleHttpResponseException(exception); Assert.fail(); } catch (ResponseException ex) { Assert.assertSame(exception, ex); } } |
### Question:
BlobPuller implements RegistryEndpointProvider<Void> { @Override public URL getApiRoute(String apiRouteBase) throws MalformedURLException { return new URL( apiRouteBase + registryEndpointRequestProperties.getImageName() + "/blobs/" + blobDigest); } BlobPuller(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
DescriptorDigest blobDigest,
OutputStream destinationOutputStream,
Consumer<Long> blobSizeListener,
Consumer<Long> writtenByteCountListener); @Override Void handleResponse(Response response); @Override @Nullable BlobHttpContent getContent(); @Override List<String> getAccept(); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); @Override Void handleHttpResponseException(ResponseException responseException); }### Answer:
@Test public void testGetApiRoute() throws MalformedURLException { Assert.assertEquals( new URL("http: testBlobPuller.getApiRoute("http: } |
### Question:
BlobPuller implements RegistryEndpointProvider<Void> { @Override public String getActionDescription() { return "pull BLOB for " + registryEndpointRequestProperties.getServerUrl() + "/" + registryEndpointRequestProperties.getImageName() + " with digest " + blobDigest; } BlobPuller(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
DescriptorDigest blobDigest,
OutputStream destinationOutputStream,
Consumer<Long> blobSizeListener,
Consumer<Long> writtenByteCountListener); @Override Void handleResponse(Response response); @Override @Nullable BlobHttpContent getContent(); @Override List<String> getAccept(); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); @Override Void handleHttpResponseException(ResponseException responseException); }### Answer:
@Test public void testGetActionDescription() { Assert.assertEquals( "pull BLOB for someServerUrl/someImageName with digest " + fakeDigest, testBlobPuller.getActionDescription()); } |
### Question:
BlobPuller implements RegistryEndpointProvider<Void> { @Override public String getHttpMethod() { return HttpMethods.GET; } BlobPuller(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
DescriptorDigest blobDigest,
OutputStream destinationOutputStream,
Consumer<Long> blobSizeListener,
Consumer<Long> writtenByteCountListener); @Override Void handleResponse(Response response); @Override @Nullable BlobHttpContent getContent(); @Override List<String> getAccept(); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); @Override Void handleHttpResponseException(ResponseException responseException); }### Answer:
@Test public void testGetHttpMethod() { Assert.assertEquals("GET", testBlobPuller.getHttpMethod()); } |
### Question:
BlobPuller implements RegistryEndpointProvider<Void> { @Override @Nullable public BlobHttpContent getContent() { return null; } BlobPuller(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
DescriptorDigest blobDigest,
OutputStream destinationOutputStream,
Consumer<Long> blobSizeListener,
Consumer<Long> writtenByteCountListener); @Override Void handleResponse(Response response); @Override @Nullable BlobHttpContent getContent(); @Override List<String> getAccept(); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); @Override Void handleHttpResponseException(ResponseException responseException); }### Answer:
@Test public void testGetContent() { Assert.assertNull(testBlobPuller.getContent()); } |
### Question:
BlobPuller implements RegistryEndpointProvider<Void> { @Override public List<String> getAccept() { return Collections.emptyList(); } BlobPuller(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
DescriptorDigest blobDigest,
OutputStream destinationOutputStream,
Consumer<Long> blobSizeListener,
Consumer<Long> writtenByteCountListener); @Override Void handleResponse(Response response); @Override @Nullable BlobHttpContent getContent(); @Override List<String> getAccept(); @Override URL getApiRoute(String apiRouteBase); @Override String getHttpMethod(); @Override String getActionDescription(); @Override Void handleHttpResponseException(ResponseException responseException); }### Answer:
@Test public void testGetAccept() { Assert.assertEquals(0, testBlobPuller.getAccept().size()); } |
### Question:
PluginConfigurationProcessor { static ContainerizingMode getContainerizingModeChecked( RawConfiguration rawConfiguration, ProjectProperties projectProperties) throws InvalidContainerizingModeException { ContainerizingMode mode = ContainerizingMode.from(rawConfiguration.getContainerizingMode()); if (mode == ContainerizingMode.PACKAGED && projectProperties.isWarProject()) { throw new UnsupportedOperationException( "packaged containerizing mode for WAR is not yet supported"); } return mode; } static JibBuildRunner createJibBuildRunnerForDockerDaemonImage(
RawConfiguration rawConfiguration,
InferredAuthProvider inferredAuthProvider,
ProjectProperties projectProperties,
HelpfulSuggestions helpfulSuggestions); static JibBuildRunner createJibBuildRunnerForTarImage(
RawConfiguration rawConfiguration,
InferredAuthProvider inferredAuthProvider,
ProjectProperties projectProperties,
HelpfulSuggestions helpfulSuggestions); static JibBuildRunner createJibBuildRunnerForRegistryImage(
RawConfiguration rawConfiguration,
InferredAuthProvider inferredAuthProvider,
ProjectProperties projectProperties,
HelpfulSuggestions helpfulSuggestions); static String getSkaffoldSyncMap(
RawConfiguration rawConfiguration, ProjectProperties projectProperties, Set<Path> excludes); }### Answer:
@Test public void testGetContainerizingModeChecked_packagedWithWar() throws InvalidContainerizingModeException { Mockito.when(rawConfiguration.getContainerizingMode()).thenReturn("packaged"); Mockito.when(projectProperties.isWarProject()).thenReturn(true); try { PluginConfigurationProcessor.getContainerizingModeChecked( rawConfiguration, projectProperties); Assert.fail(); } catch (UnsupportedOperationException ex) { Assert.assertEquals( "packaged containerizing mode for WAR is not yet supported", ex.getMessage()); } } |
### Question:
Port { public static Port tcp(int port) { return new Port(port, TCP_PROTOCOL); } private Port(int port, String protocol); static Port tcp(int port); static Port udp(int port); static Port parseProtocol(int port, String protocolString); int getPort(); String getProtocol(); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testTcp() { Port port = Port.tcp(5555); Assert.assertEquals(5555, port.getPort()); Assert.assertEquals("5555/tcp", port.toString()); } |
### Question:
BlobPusher { RegistryEndpointProvider<URL> writer(URL location, Consumer<Long> writtenByteCountListener) { return new Writer(location, writtenByteCountListener); } BlobPusher(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
DescriptorDigest blobDigest,
Blob blob,
@Nullable String sourceRepository); }### Answer:
@Test public void testWriter_getContent() throws IOException { LongAdder byteCount = new LongAdder(); BlobHttpContent body = testBlobPusher.writer(mockUrl, byteCount::add).getContent(); Assert.assertNotNull(body); Assert.assertEquals("application/octet-stream", body.getType()); ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); body.writeTo(byteArrayOutputStream); Assert.assertEquals( TEST_BLOB_CONTENT, new String(byteArrayOutputStream.toByteArray(), StandardCharsets.UTF_8)); Assert.assertEquals(TEST_BLOB_CONTENT.length(), byteCount.sum()); }
@Test public void testWriter_GetAccept() { Assert.assertEquals(0, testBlobPusher.writer(mockUrl, ignored -> {}).getAccept().size()); }
@Test public void testWriter_handleResponse() throws IOException, RegistryException { Mockito.when(mockResponse.getHeader("Location")) .thenReturn(Collections.singletonList("https: GenericUrl requestUrl = new GenericUrl("https: Mockito.when(mockResponse.getRequestUrl()).thenReturn(requestUrl); Assert.assertEquals( new URL("https: testBlobPusher.writer(mockUrl, ignored -> {}).handleResponse(mockResponse)); }
@Test public void testWriter_getApiRoute() throws MalformedURLException { URL fakeUrl = new URL("http: Assert.assertEquals(fakeUrl, testBlobPusher.writer(fakeUrl, ignored -> {}).getApiRoute("")); }
@Test public void testWriter_getHttpMethod() { Assert.assertEquals("PATCH", testBlobPusher.writer(mockUrl, ignored -> {}).getHttpMethod()); } |
### Question:
BlobPusher { RegistryEndpointProvider<Void> committer(URL location) { return new Committer(location); } BlobPusher(
RegistryEndpointRequestProperties registryEndpointRequestProperties,
DescriptorDigest blobDigest,
Blob blob,
@Nullable String sourceRepository); }### Answer:
@Test public void testCommitter_getContent() { Assert.assertNull(testBlobPusher.committer(mockUrl).getContent()); }
@Test public void testCommitter_GetAccept() { Assert.assertEquals(0, testBlobPusher.committer(mockUrl).getAccept().size()); }
@Test public void testCommitter_handleResponse() throws IOException, RegistryException { Assert.assertNull( testBlobPusher.committer(mockUrl).handleResponse(Mockito.mock(Response.class))); }
@Test public void testCommitter_getApiRoute() throws MalformedURLException { Assert.assertEquals( new URL("https: testBlobPusher.committer(new URL("https: }
@Test public void testCommitter_getHttpMethod() { Assert.assertEquals("PUT", testBlobPusher.committer(mockUrl).getHttpMethod()); } |
### Question:
ImageReference { public boolean isScratch() { return "".equals(registry) && "scratch".equals(repository) && Strings.isNullOrEmpty(tag) && Strings.isNullOrEmpty(digest); } private ImageReference(
String registry, String repository, @Nullable String tag, @Nullable String digest); static ImageReference parse(String reference); static ImageReference of(
@Nullable String registry, String repository, @Nullable String qualifier); static ImageReference of(
@Nullable String registry, String repository, @Nullable String tag, @Nullable String digest); static ImageReference scratch(); static boolean isValidRegistry(String registry); static boolean isValidRepository(String repository); static boolean isValidTag(String tag); static boolean isValidDigest(String digest); static boolean isDefaultTag(@Nullable String tag); String getRegistry(); String getRepository(); Optional<String> getTag(); Optional<String> getDigest(); String getQualifier(); boolean usesDefaultTag(); boolean isScratch(); ImageReference withQualifier(String newQualifier); @Override String toString(); String toStringWithQualifier(); @Override boolean equals(Object other); @Override int hashCode(); }### Answer:
@Test public void testIsScratch() throws InvalidImageReferenceException { Assert.assertTrue(ImageReference.parse("scratch").isScratch()); Assert.assertTrue(ImageReference.scratch().isScratch()); Assert.assertFalse(ImageReference.of("", "scratch", "").isScratch()); Assert.assertFalse(ImageReference.of(null, "scratch", null).isScratch()); } |
### Question:
ImageReference { public String getRegistry() { return registry; } private ImageReference(
String registry, String repository, @Nullable String tag, @Nullable String digest); static ImageReference parse(String reference); static ImageReference of(
@Nullable String registry, String repository, @Nullable String qualifier); static ImageReference of(
@Nullable String registry, String repository, @Nullable String tag, @Nullable String digest); static ImageReference scratch(); static boolean isValidRegistry(String registry); static boolean isValidRepository(String repository); static boolean isValidTag(String tag); static boolean isValidDigest(String digest); static boolean isDefaultTag(@Nullable String tag); String getRegistry(); String getRepository(); Optional<String> getTag(); Optional<String> getDigest(); String getQualifier(); boolean usesDefaultTag(); boolean isScratch(); ImageReference withQualifier(String newQualifier); @Override String toString(); String toStringWithQualifier(); @Override boolean equals(Object other); @Override int hashCode(); }### Answer:
@Test public void testGetRegistry() { Assert.assertEquals( "registry-1.docker.io", ImageReference.of(null, "someimage", null).getRegistry()); Assert.assertEquals( "registry-1.docker.io", ImageReference.of("docker.io", "someimage", null).getRegistry()); Assert.assertEquals( "index.docker.io", ImageReference.of("index.docker.io", "someimage", null).getRegistry()); Assert.assertEquals( "registry.hub.docker.com", ImageReference.of("registry.hub.docker.com", "someimage", null).getRegistry()); Assert.assertEquals("gcr.io", ImageReference.of("gcr.io", "someimage", null).getRegistry()); } |
### Question:
Containerizer { public static Containerizer to(RegistryImage registryImage) { ImageConfiguration imageConfiguration = ImageConfiguration.builder(registryImage.getImageReference()) .setCredentialRetrievers(registryImage.getCredentialRetrievers()) .build(); Function<BuildContext, StepsRunner> stepsRunnerFactory = buildContext -> StepsRunner.begin(buildContext).registryPushSteps(); return new Containerizer( DESCRIPTION_FOR_DOCKER_REGISTRY, imageConfiguration, stepsRunnerFactory, true); } private Containerizer(
String description,
ImageConfiguration imageConfiguration,
Function<BuildContext, StepsRunner> stepsRunnerFactory,
boolean mustBeOnline); static Containerizer to(RegistryImage registryImage); static Containerizer to(DockerDaemonImage dockerDaemonImage); static Containerizer to(TarImage tarImage); Containerizer withAdditionalTag(String tag); Containerizer setExecutorService(@Nullable ExecutorService executorService); Containerizer setBaseImageLayersCache(Path cacheDirectory); Containerizer setApplicationLayersCache(Path cacheDirectory); Containerizer addEventHandler(
Class<E> eventType, Consumer<? super E> eventConsumer); Containerizer addEventHandler(Consumer<JibEvent> eventConsumer); Containerizer setAllowInsecureRegistries(boolean allowInsecureRegistries); Containerizer setOfflineMode(boolean offline); Containerizer setToolName(String toolName); Containerizer setToolVersion(@Nullable String toolVersion); Containerizer setAlwaysCacheBaseImage(boolean alwaysCacheBaseImage); static final Path DEFAULT_BASE_CACHE_DIRECTORY; }### Answer:
@Test public void testTo() throws CacheDirectoryCreationException { RegistryImage registryImage = RegistryImage.named(ImageReference.of(null, "repository", null)); DockerDaemonImage dockerDaemonImage = DockerDaemonImage.named(ImageReference.of(null, "repository", null)); TarImage tarImage = TarImage.at(Paths.get("ignored")).named(ImageReference.of(null, "repository", null)); verifyTo(Containerizer.to(registryImage)); verifyTo(Containerizer.to(dockerDaemonImage)); verifyTo(Containerizer.to(tarImage)); } |
### Question:
Containerizer { public Containerizer withAdditionalTag(String tag) { Preconditions.checkArgument(ImageReference.isValidTag(tag), "invalid tag '%s'", tag); additionalTags.add(tag); return this; } private Containerizer(
String description,
ImageConfiguration imageConfiguration,
Function<BuildContext, StepsRunner> stepsRunnerFactory,
boolean mustBeOnline); static Containerizer to(RegistryImage registryImage); static Containerizer to(DockerDaemonImage dockerDaemonImage); static Containerizer to(TarImage tarImage); Containerizer withAdditionalTag(String tag); Containerizer setExecutorService(@Nullable ExecutorService executorService); Containerizer setBaseImageLayersCache(Path cacheDirectory); Containerizer setApplicationLayersCache(Path cacheDirectory); Containerizer addEventHandler(
Class<E> eventType, Consumer<? super E> eventConsumer); Containerizer addEventHandler(Consumer<JibEvent> eventConsumer); Containerizer setAllowInsecureRegistries(boolean allowInsecureRegistries); Containerizer setOfflineMode(boolean offline); Containerizer setToolName(String toolName); Containerizer setToolVersion(@Nullable String toolVersion); Containerizer setAlwaysCacheBaseImage(boolean alwaysCacheBaseImage); static final Path DEFAULT_BASE_CACHE_DIRECTORY; }### Answer:
@Test public void testWithAdditionalTag() { DockerDaemonImage dockerDaemonImage = DockerDaemonImage.named(ImageReference.of(null, "repository", null)); Containerizer containerizer = Containerizer.to(dockerDaemonImage); containerizer.withAdditionalTag("tag"); try { containerizer.withAdditionalTag("+invalid+"); Assert.fail(); } catch (IllegalArgumentException ex) { Assert.assertEquals("invalid tag '+invalid+'", ex.getMessage()); } } |
### Question:
Credential { public static Credential from(String username, String password) { return new Credential(username, password); } private Credential(String username, String password); static Credential from(String username, String password); String getUsername(); String getPassword(); boolean isOAuth2RefreshToken(); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static final String OAUTH2_TOKEN_USER_NAME; }### Answer:
@Test public void testCredentialsHash() { Credential credentialA1 = Credential.from("username", "password"); Credential credentialA2 = Credential.from("username", "password"); Credential credentialB1 = Credential.from("", ""); Credential credentialB2 = Credential.from("", ""); Assert.assertEquals(credentialA1, credentialA2); Assert.assertEquals(credentialB1, credentialB2); Assert.assertNotEquals(credentialA1, credentialB1); Assert.assertNotEquals(credentialA1, credentialB2); Set<Credential> credentialSet = new HashSet<>(Arrays.asList(credentialA1, credentialA2, credentialB1, credentialB2)); Assert.assertEquals(new HashSet<>(Arrays.asList(credentialA2, credentialB1)), credentialSet); } |
### Question:
DescriptorDigest { public static DescriptorDigest fromHash(String hash) throws DigestException { if (!hash.matches(HASH_REGEX)) { throw new DigestException("Invalid hash: " + hash); } return new DescriptorDigest(hash); } private DescriptorDigest(String hash); static DescriptorDigest fromHash(String hash); static DescriptorDigest fromDigest(String digest); String getHash(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static final int HASH_LENGTH; }### Answer:
@Test public void testCreateFromHash_fail() { String badHash = "not a valid hash"; try { DescriptorDigest.fromHash(badHash); Assert.fail("Invalid hash should have caused digest creation failure."); } catch (DigestException ex) { Assert.assertEquals("Invalid hash: " + badHash, ex.getMessage()); } }
@Test public void testCreateFromHash_failIncorrectLength() { String badHash = createGoodHash('a') + 'a'; try { DescriptorDigest.fromHash(badHash); Assert.fail("Invalid hash should have caused digest creation failure."); } catch (DigestException ex) { Assert.assertEquals("Invalid hash: " + badHash, ex.getMessage()); } } |
### Question:
DescriptorDigest { public static DescriptorDigest fromDigest(String digest) throws DigestException { if (!digest.matches(DIGEST_REGEX)) { throw new DigestException("Invalid digest: " + digest); } String hash = digest.substring(DIGEST_PREFIX.length()); return new DescriptorDigest(hash); } private DescriptorDigest(String hash); static DescriptorDigest fromHash(String hash); static DescriptorDigest fromDigest(String digest); String getHash(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static final int HASH_LENGTH; }### Answer:
@Test public void testCreateFromDigest_fail() { String badDigest = "sha256:not a valid digest"; try { DescriptorDigest.fromDigest(badDigest); Assert.fail("Invalid digest should have caused digest creation failure."); } catch (DigestException ex) { Assert.assertEquals("Invalid digest: " + badDigest, ex.getMessage()); } } |
### Question:
DockerClient { public static boolean isDockerInstalled(Path dockerExecutable) { try { new ProcessBuilder(dockerExecutable.toString()).start(); return true; } catch (IOException ex) { return false; } } DockerClient(Path dockerExecutable, Map<String, String> dockerEnvironment); @VisibleForTesting DockerClient(Function<List<String>, ProcessBuilder> processBuilderFactory); static boolean isDefaultDockerInstalled(); static boolean isDockerInstalled(Path dockerExecutable); String load(ImageTarball imageTarball, Consumer<Long> writtenByteCountListener); void save(
ImageReference imageReference, Path outputPath, Consumer<Long> writtenByteCountListener); DockerImageDetails inspect(ImageReference imageReference); static final Path DEFAULT_DOCKER_CLIENT; }### Answer:
@Test public void testIsDockerInstalled_fail() { Assert.assertFalse(DockerClient.isDockerInstalled(Paths.get("path/to/nonexistent/file"))); } |
### Question:
DockerClient { @VisibleForTesting static Function<List<String>, ProcessBuilder> defaultProcessBuilderFactory( String dockerExecutable, ImmutableMap<String, String> dockerEnvironment) { return dockerSubCommand -> { List<String> dockerCommand = new ArrayList<>(1 + dockerSubCommand.size()); dockerCommand.add(dockerExecutable); dockerCommand.addAll(dockerSubCommand); ProcessBuilder processBuilder = new ProcessBuilder(dockerCommand); Map<String, String> environment = processBuilder.environment(); environment.putAll(dockerEnvironment); return processBuilder; }; } DockerClient(Path dockerExecutable, Map<String, String> dockerEnvironment); @VisibleForTesting DockerClient(Function<List<String>, ProcessBuilder> processBuilderFactory); static boolean isDefaultDockerInstalled(); static boolean isDockerInstalled(Path dockerExecutable); String load(ImageTarball imageTarball, Consumer<Long> writtenByteCountListener); void save(
ImageReference imageReference, Path outputPath, Consumer<Long> writtenByteCountListener); DockerImageDetails inspect(ImageReference imageReference); static final Path DEFAULT_DOCKER_CLIENT; }### Answer:
@Test public void testDefaultProcessorBuilderFactory_customExecutable() { ProcessBuilder processBuilder = DockerClient.defaultProcessBuilderFactory("docker-executable", ImmutableMap.of()) .apply(Arrays.asList("sub", "command")); Assert.assertEquals( Arrays.asList("docker-executable", "sub", "command"), processBuilder.command()); Assert.assertEquals(System.getenv(), processBuilder.environment()); }
@Test public void testDefaultProcessorBuilderFactory_customEnvironment() { ImmutableMap<String, String> environment = ImmutableMap.of("Key1", "Value1"); Map<String, String> expectedEnvironment = new HashMap<>(System.getenv()); expectedEnvironment.putAll(environment); ProcessBuilder processBuilder = DockerClient.defaultProcessBuilderFactory("docker", environment) .apply(Collections.emptyList()); Assert.assertEquals(expectedEnvironment, processBuilder.environment()); } |
### Question:
DockerClient { public DockerImageDetails inspect(ImageReference imageReference) throws IOException, InterruptedException { Process inspectProcess = docker("inspect", "-f", "{{json .}}", "--type", "image", imageReference.toString()); if (inspectProcess.waitFor() != 0) { throw new IOException( "'docker inspect' command failed with error: " + getStderrOutput(inspectProcess)); } return JsonTemplateMapper.readJson(inspectProcess.getInputStream(), DockerImageDetails.class); } DockerClient(Path dockerExecutable, Map<String, String> dockerEnvironment); @VisibleForTesting DockerClient(Function<List<String>, ProcessBuilder> processBuilderFactory); static boolean isDefaultDockerInstalled(); static boolean isDockerInstalled(Path dockerExecutable); String load(ImageTarball imageTarball, Consumer<Long> writtenByteCountListener); void save(
ImageReference imageReference, Path outputPath, Consumer<Long> writtenByteCountListener); DockerImageDetails inspect(ImageReference imageReference); static final Path DEFAULT_DOCKER_CLIENT; }### Answer:
@Test public void testSize_fail() throws InterruptedException { DockerClient testDockerClient = new DockerClient( subcommand -> { Assert.assertEquals("inspect", subcommand.get(0)); return mockProcessBuilder; }); Mockito.when(mockProcess.waitFor()).thenReturn(1); Mockito.when(mockProcess.getErrorStream()) .thenReturn(new ByteArrayInputStream("error".getBytes(StandardCharsets.UTF_8))); try { testDockerClient.inspect(ImageReference.of(null, "image", null)); Assert.fail("docker inspect should have failed"); } catch (IOException ex) { Assert.assertEquals("'docker inspect' command failed with error: error", ex.getMessage()); } } |
### Question:
CacheStorageReader { Optional<ContainerConfigurationTemplate> retrieveLocalConfig(DescriptorDigest imageId) throws IOException { Path configPath = cacheStorageFiles.getLocalDirectory().resolve("config").resolve(imageId.getHash()); if (!Files.exists(configPath)) { return Optional.empty(); } ContainerConfigurationTemplate config = JsonTemplateMapper.readJsonFromFile(configPath, ContainerConfigurationTemplate.class); return Optional.of(config); } CacheStorageReader(CacheStorageFiles cacheStorageFiles); }### Answer:
@Test public void testRetrieveLocalConfig() throws IOException, URISyntaxException, DigestException { Path configDirectory = cacheDirectory.resolve("local").resolve("config"); Files.createDirectories(configDirectory); Files.copy( Paths.get(Resources.getResource("core/json/containerconfig.json").toURI()), configDirectory.resolve( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")); ContainerConfigurationTemplate configurationTemplate = cacheStorageReader .retrieveLocalConfig( DescriptorDigest.fromHash( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")) .get(); Assert.assertEquals("wasm", configurationTemplate.getArchitecture()); Assert.assertEquals("js", configurationTemplate.getOs()); Optional<ContainerConfigurationTemplate> missingConfigurationTemplate = cacheStorageReader.retrieveLocalConfig( DescriptorDigest.fromHash( "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")); Assert.assertFalse(missingConfigurationTemplate.isPresent()); } |
### Question:
CacheStorageReader { Optional<DescriptorDigest> select(DescriptorDigest selector) throws CacheCorruptedException, IOException { Path selectorFile = cacheStorageFiles.getSelectorFile(selector); if (!Files.exists(selectorFile)) { return Optional.empty(); } String selectorFileContents = new String(Files.readAllBytes(selectorFile), StandardCharsets.UTF_8); try { return Optional.of(DescriptorDigest.fromHash(selectorFileContents)); } catch (DigestException ex) { throw new CacheCorruptedException( cacheStorageFiles.getCacheDirectory(), "Expected valid layer digest as contents of selector file `" + selectorFile + "` for selector `" + selector.getHash() + "`, but got: " + selectorFileContents); } } CacheStorageReader(CacheStorageFiles cacheStorageFiles); }### Answer:
@Test public void testSelect_invalidLayerDigest() throws IOException { DescriptorDigest selector = layerDigest1; Path selectorFile = cacheStorageFiles.getSelectorFile(selector); Files.createDirectories(selectorFile.getParent()); Files.write(selectorFile, "not a valid layer digest".getBytes(StandardCharsets.UTF_8)); try { cacheStorageReader.select(selector); Assert.fail("Should have thrown CacheCorruptedException"); } catch (CacheCorruptedException ex) { MatcherAssert.assertThat( ex.getMessage(), CoreMatchers.startsWith( "Expected valid layer digest as contents of selector file `" + selectorFile + "` for selector `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`, but got: not a valid layer digest")); } }
@Test public void testSelect() throws IOException, CacheCorruptedException { DescriptorDigest selector = layerDigest1; Path selectorFile = cacheStorageFiles.getSelectorFile(selector); Files.createDirectories(selectorFile.getParent()); Files.write(selectorFile, layerDigest2.getHash().getBytes(StandardCharsets.UTF_8)); Optional<DescriptorDigest> selectedLayerDigest = cacheStorageReader.select(selector); Assert.assertTrue(selectedLayerDigest.isPresent()); Assert.assertEquals(layerDigest2, selectedLayerDigest.get()); } |
### Question:
CachedLayer implements Layer { public static Builder builder() { return new Builder(); } private CachedLayer(
DescriptorDigest layerDigest, DescriptorDigest layerDiffId, long layerSize, Blob layerBlob); static Builder builder(); DescriptorDigest getDigest(); long getSize(); @Override DescriptorDigest getDiffId(); @Override Blob getBlob(); @Override BlobDescriptor getBlobDescriptor(); }### Answer:
@Test public void testBuilder_fail() { try { CachedLayer.builder().build(); Assert.fail("missing required"); } catch (NullPointerException ex) { MatcherAssert.assertThat(ex.getMessage(), CoreMatchers.containsString("layerDigest")); } try { CachedLayer.builder().setLayerDigest(mockLayerDigest).build(); Assert.fail("missing required"); } catch (NullPointerException ex) { MatcherAssert.assertThat(ex.getMessage(), CoreMatchers.containsString("layerDiffId")); } try { CachedLayer.builder().setLayerDigest(mockLayerDigest).setLayerDiffId(mockLayerDiffId).build(); Assert.fail("missing required"); } catch (NullPointerException ex) { MatcherAssert.assertThat(ex.getMessage(), CoreMatchers.containsString("layerBlob")); } } |
### Question:
CacheStorageFiles { static boolean isLayerFile(Path file) { return file.getFileName().toString().length() == DescriptorDigest.HASH_LENGTH; } CacheStorageFiles(Path cacheDirectory); }### Answer:
@Test public void testIsLayerFile() { Assert.assertTrue( CacheStorageFiles.isLayerFile( Paths.get("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))); Assert.assertTrue( CacheStorageFiles.isLayerFile( Paths.get("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))); Assert.assertFalse(CacheStorageFiles.isLayerFile(Paths.get("is.not.layer.file"))); } |
### Question:
CacheStorageFiles { Path getLayerFile(DescriptorDigest layerDigest, DescriptorDigest layerDiffId) { return getLayerDirectory(layerDigest).resolve(getLayerFilename(layerDiffId)); } CacheStorageFiles(Path cacheDirectory); }### Answer:
@Test public void testGetLayerFile() throws DigestException { DescriptorDigest layerDigest = DescriptorDigest.fromHash( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); DescriptorDigest diffId = DescriptorDigest.fromHash( "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); Assert.assertEquals( Paths.get( "cache", "directory", "layers", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), TEST_CACHE_STORAGE_FILES.getLayerFile(layerDigest, diffId)); } |
### Question:
CacheStorageFiles { String getLayerFilename(DescriptorDigest layerDiffId) { return layerDiffId.getHash(); } CacheStorageFiles(Path cacheDirectory); }### Answer:
@Test public void testGetLayerFilename() throws DigestException { DescriptorDigest diffId = DescriptorDigest.fromHash( "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); Assert.assertEquals( "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", TEST_CACHE_STORAGE_FILES.getLayerFilename(diffId)); } |
### Question:
CacheStorageFiles { Path getSelectorFile(DescriptorDigest selector) { return cacheDirectory.resolve(SELECTORS_DIRECTORY).resolve(selector.getHash()); } CacheStorageFiles(Path cacheDirectory); }### Answer:
@Test public void testGetSelectorFile() throws DigestException { DescriptorDigest selector = DescriptorDigest.fromHash( "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"); Assert.assertEquals( Paths.get( "cache", "directory", "selectors", "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"), TEST_CACHE_STORAGE_FILES.getSelectorFile(selector)); } |
### Question:
CacheStorageFiles { Path getLayersDirectory() { return cacheDirectory.resolve(LAYERS_DIRECTORY); } CacheStorageFiles(Path cacheDirectory); }### Answer:
@Test public void testGetLayersDirectory() { Assert.assertEquals( Paths.get("cache", "directory", "layers"), TEST_CACHE_STORAGE_FILES.getLayersDirectory()); } |
### Question:
CacheStorageFiles { Path getLayerDirectory(DescriptorDigest layerDigest) { return getLayersDirectory().resolve(layerDigest.getHash()); } CacheStorageFiles(Path cacheDirectory); }### Answer:
@Test public void testGetLayerDirectory() throws DigestException { DescriptorDigest layerDigest = DescriptorDigest.fromHash( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); Assert.assertEquals( Paths.get( "cache", "directory", "layers", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), TEST_CACHE_STORAGE_FILES.getLayerDirectory(layerDigest)); } |
### Question:
CacheStorageFiles { Path getTemporaryDirectory() { return cacheDirectory.resolve(TEMPORARY_DIRECTORY); } CacheStorageFiles(Path cacheDirectory); }### Answer:
@Test public void testGetTemporaryDirectory() { Assert.assertEquals( Paths.get("cache/directory/tmp"), TEST_CACHE_STORAGE_FILES.getTemporaryDirectory()); } |
### Question:
CacheStorageFiles { Path getImagesDirectory() { return cacheDirectory.resolve(IMAGES_DIRECTORY); } CacheStorageFiles(Path cacheDirectory); }### Answer:
@Test public void testGetImagesDirectory() { Assert.assertEquals( Paths.get("cache/directory/images"), TEST_CACHE_STORAGE_FILES.getImagesDirectory()); } |
### Question:
CacheStorageFiles { Path getImageDirectory(ImageReference imageReference) { String replacedReference = imageReference.toStringWithQualifier().replace(':', '!').replace('@', '!'); Iterable<String> directories = Splitter.on('/').split(replacedReference); Path destination = getImagesDirectory(); for (String dir : directories) { destination = destination.resolve(dir); } return destination; } CacheStorageFiles(Path cacheDirectory); }### Answer:
@Test public void testGetImageDirectory() throws InvalidImageReferenceException { Path imagesDirectory = Paths.get("cache", "directory", "images"); Assert.assertEquals(imagesDirectory, TEST_CACHE_STORAGE_FILES.getImagesDirectory()); Assert.assertEquals( imagesDirectory.resolve("reg.istry/repo/sitory!tag"), TEST_CACHE_STORAGE_FILES.getImageDirectory( ImageReference.parse("reg.istry/repo/sitory:tag"))); Assert.assertEquals( imagesDirectory.resolve( "reg.istry/repo!sha256!aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), TEST_CACHE_STORAGE_FILES.getImageDirectory( ImageReference.parse( "reg.istry/repo@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))); Assert.assertEquals( imagesDirectory.resolve("reg.istry!5000/repo/sitory!tag"), TEST_CACHE_STORAGE_FILES.getImageDirectory( ImageReference.parse("reg.istry:5000/repo/sitory:tag"))); } |
### Question:
CacheStorageWriter { CachedLayer writeCompressed(Blob compressedLayerBlob) throws IOException { Files.createDirectories(cacheStorageFiles.getLayersDirectory()); Files.createDirectories(cacheStorageFiles.getTemporaryDirectory()); try (TempDirectoryProvider tempDirectoryProvider = new TempDirectoryProvider()) { Path temporaryLayerDirectory = tempDirectoryProvider.newDirectory(cacheStorageFiles.getTemporaryDirectory()); WrittenLayer writtenLayer = writeCompressedLayerBlobToDirectory(compressedLayerBlob, temporaryLayerDirectory); moveIfDoesNotExist( temporaryLayerDirectory, cacheStorageFiles.getLayerDirectory(writtenLayer.layerDigest)); Path layerFile = cacheStorageFiles.getLayerFile(writtenLayer.layerDigest, writtenLayer.layerDiffId); return CachedLayer.builder() .setLayerDigest(writtenLayer.layerDigest) .setLayerDiffId(writtenLayer.layerDiffId) .setLayerSize(writtenLayer.layerSize) .setLayerBlob(Blobs.from(layerFile)) .build(); } } CacheStorageWriter(CacheStorageFiles cacheStorageFiles); }### Answer:
@Test public void testWriteCompressed() throws IOException { Blob uncompressedLayerBlob = Blobs.from("uncompressedLayerBlob"); CachedLayer cachedLayer = cacheStorageWriter.writeCompressed(compress(uncompressedLayerBlob)); verifyCachedLayer(cachedLayer, uncompressedLayerBlob); } |
### Question:
CacheStorageWriter { CachedLayer writeUncompressed(Blob uncompressedLayerBlob, @Nullable DescriptorDigest selector) throws IOException { Files.createDirectories(cacheStorageFiles.getLayersDirectory()); Files.createDirectories(cacheStorageFiles.getTemporaryDirectory()); try (TempDirectoryProvider tempDirectoryProvider = new TempDirectoryProvider()) { Path temporaryLayerDirectory = tempDirectoryProvider.newDirectory(cacheStorageFiles.getTemporaryDirectory()); WrittenLayer writtenLayer = writeUncompressedLayerBlobToDirectory(uncompressedLayerBlob, temporaryLayerDirectory); moveIfDoesNotExist( temporaryLayerDirectory, cacheStorageFiles.getLayerDirectory(writtenLayer.layerDigest)); Path layerFile = cacheStorageFiles.getLayerFile(writtenLayer.layerDigest, writtenLayer.layerDiffId); CachedLayer.Builder cachedLayerBuilder = CachedLayer.builder() .setLayerDigest(writtenLayer.layerDigest) .setLayerDiffId(writtenLayer.layerDiffId) .setLayerSize(writtenLayer.layerSize) .setLayerBlob(Blobs.from(layerFile)); if (selector != null) { writeSelector(selector, writtenLayer.layerDigest); } return cachedLayerBuilder.build(); } } CacheStorageWriter(CacheStorageFiles cacheStorageFiles); }### Answer:
@Test public void testWriteUncompressed() throws IOException { Blob uncompressedLayerBlob = Blobs.from("uncompressedLayerBlob"); DescriptorDigest layerDigest = getDigest(compress(uncompressedLayerBlob)).getDigest(); DescriptorDigest selector = getDigest(Blobs.from("selector")).getDigest(); CachedLayer cachedLayer = cacheStorageWriter.writeUncompressed(uncompressedLayerBlob, selector); verifyCachedLayer(cachedLayer, uncompressedLayerBlob); Path selectorFile = cacheStorageFiles.getSelectorFile(selector); Assert.assertTrue(Files.exists(selectorFile)); Assert.assertEquals(layerDigest.getHash(), Blobs.writeToString(Blobs.from(selectorFile))); } |
### Question:
CacheStorageWriter { void writeLocalConfig( DescriptorDigest imageId, ContainerConfigurationTemplate containerConfiguration) throws IOException { Path configDirectory = cacheStorageFiles.getLocalDirectory().resolve("config"); Files.createDirectories(configDirectory); writeJsonTemplate(containerConfiguration, configDirectory.resolve(imageId.getHash())); } CacheStorageWriter(CacheStorageFiles cacheStorageFiles); }### Answer:
@Test public void testWriteLocalConfig() throws IOException, URISyntaxException, DigestException { ContainerConfigurationTemplate containerConfigurationTemplate = loadJsonResource("core/json/containerconfig.json", ContainerConfigurationTemplate.class); cacheStorageWriter.writeLocalConfig( DescriptorDigest.fromHash( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), containerConfigurationTemplate); Path savedConfigPath = cacheStorageFiles .getLocalDirectory() .resolve("config") .resolve("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); Assert.assertTrue(Files.exists(savedConfigPath)); ContainerConfigurationTemplate savedContainerConfig = JsonTemplateMapper.readJsonFromFile(savedConfigPath, ContainerConfigurationTemplate.class); Assert.assertEquals("wasm", savedContainerConfig.getArchitecture()); } |
### Question:
Cache { public static Cache withDirectory(Path cacheDirectory) throws CacheDirectoryCreationException { try { Files.createDirectories(cacheDirectory); } catch (IOException ex) { throw new CacheDirectoryCreationException(ex); } return new Cache(new CacheStorageFiles(cacheDirectory)); } private Cache(CacheStorageFiles cacheStorageFiles); static Cache withDirectory(Path cacheDirectory); void writeMetadata(ImageReference imageReference, ImageMetadataTemplate metadata); void writeMetadata(
ImageReference imageReference,
BuildableManifestTemplate manifest,
ContainerConfigurationTemplate containerConfiguration); void writeMetadata(ImageReference imageReference, V21ManifestTemplate manifestTemplate); CachedLayer writeCompressedLayer(Blob compressedLayerBlob); CachedLayer writeUncompressedLayer(
Blob uncompressedLayerBlob, ImmutableList<FileEntry> layerEntries); CachedLayer writeTarLayer(DescriptorDigest diffId, Blob compressedBlob); void writeLocalConfig(
DescriptorDigest imageId, ContainerConfigurationTemplate containerConfiguration); Optional<ImageMetadataTemplate> retrieveMetadata(ImageReference imageReference); Optional<CachedLayer> retrieve(ImmutableList<FileEntry> layerEntries); Optional<CachedLayer> retrieve(DescriptorDigest layerDigest); Optional<CachedLayer> retrieveTarLayer(DescriptorDigest diffId); Optional<ContainerConfigurationTemplate> retrieveLocalConfig(DescriptorDigest imageId); }### Answer:
@Test public void testWithDirectory_existsButNotDirectory() throws IOException { Path file = temporaryFolder.newFile().toPath(); try { Cache.withDirectory(file); Assert.fail(); } catch (CacheDirectoryCreationException ex) { MatcherAssert.assertThat( ex.getCause(), CoreMatchers.instanceOf(FileAlreadyExistsException.class)); } } |
### Question:
Port { public static Port udp(int port) { return new Port(port, UDP_PROTOCOL); } private Port(int port, String protocol); static Port tcp(int port); static Port udp(int port); static Port parseProtocol(int port, String protocolString); int getPort(); String getProtocol(); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testUdp() { Port port = Port.udp(6666); Assert.assertEquals(6666, port.getPort()); Assert.assertEquals("6666/udp", port.toString()); } |
### Question:
LayerEntriesSelector { @VisibleForTesting static List<LayerEntryTemplate> toSortedJsonTemplates(List<FileEntry> layerEntries) throws IOException { List<LayerEntryTemplate> jsonTemplates = new ArrayList<>(); for (FileEntry entry : layerEntries) { jsonTemplates.add(new LayerEntryTemplate(entry)); } Collections.sort(jsonTemplates); return jsonTemplates; } private LayerEntriesSelector(); }### Answer:
@Test public void testToSortedJsonTemplates() throws IOException { Assert.assertEquals( toLayerEntryTemplates(inOrderLayerEntries), LayerEntriesSelector.toSortedJsonTemplates(outOfOrderLayerEntries)); } |
### Question:
CredentialRetrieverFactory { public CredentialRetriever dockerCredentialHelper(String credentialHelper) { return dockerCredentialHelper(Paths.get(credentialHelper)); } @VisibleForTesting CredentialRetrieverFactory(
ImageReference imageReference,
Consumer<LogEvent> logger,
DockerCredentialHelperFactory dockerCredentialHelperFactory,
GoogleCredentialsProvider googleCredentialsProvider); static CredentialRetrieverFactory forImage(
ImageReference imageReference, Consumer<LogEvent> logger); CredentialRetriever known(Credential credential, String credentialSource); CredentialRetriever dockerCredentialHelper(String credentialHelper); CredentialRetriever dockerCredentialHelper(Path credentialHelper); CredentialRetriever wellKnownCredentialHelpers(); CredentialRetriever dockerConfig(); CredentialRetriever dockerConfig(Path dockerConfigFile); CredentialRetriever legacyDockerConfig(Path dockerConfigFile); CredentialRetriever googleApplicationDefaultCredentials(); }### Answer:
@Test public void testDockerCredentialHelper() throws CredentialRetrievalException { CredentialRetrieverFactory credentialRetrieverFactory = createCredentialRetrieverFactory("registry", "repo"); Assert.assertEquals( Optional.of(FAKE_CREDENTIALS), credentialRetrieverFactory .dockerCredentialHelper(Paths.get("docker-credential-foo")) .retrieve()); Mockito.verify(mockDockerCredentialHelperFactory) .create("registry", Paths.get("docker-credential-foo")); Mockito.verify(mockLogger) .accept( LogEvent.lifecycle("Using credential helper docker-credential-foo for registry/repo")); } |
### Question:
CredentialRetrieverFactory { public CredentialRetriever dockerConfig() { return dockerConfig( DockerConfigCredentialRetriever.create( imageReference.getRegistry(), Paths.get(System.getProperty("user.home"), ".docker", "config.json"))); } @VisibleForTesting CredentialRetrieverFactory(
ImageReference imageReference,
Consumer<LogEvent> logger,
DockerCredentialHelperFactory dockerCredentialHelperFactory,
GoogleCredentialsProvider googleCredentialsProvider); static CredentialRetrieverFactory forImage(
ImageReference imageReference, Consumer<LogEvent> logger); CredentialRetriever known(Credential credential, String credentialSource); CredentialRetriever dockerCredentialHelper(String credentialHelper); CredentialRetriever dockerCredentialHelper(Path credentialHelper); CredentialRetriever wellKnownCredentialHelpers(); CredentialRetriever dockerConfig(); CredentialRetriever dockerConfig(Path dockerConfigFile); CredentialRetriever legacyDockerConfig(Path dockerConfigFile); CredentialRetriever googleApplicationDefaultCredentials(); }### Answer:
@Test public void testDockerConfig() throws IOException, CredentialRetrievalException { CredentialRetrieverFactory credentialRetrieverFactory = createCredentialRetrieverFactory("registry", "repo"); Path dockerConfig = Paths.get("/foo/config.json"); DockerConfigCredentialRetriever dockerConfigCredentialRetriever = Mockito.mock(DockerConfigCredentialRetriever.class); Mockito.when(dockerConfigCredentialRetriever.retrieve(mockLogger)) .thenReturn(Optional.of(FAKE_CREDENTIALS)); Mockito.when(dockerConfigCredentialRetriever.getDockerConfigFile()).thenReturn(dockerConfig); Assert.assertEquals( Optional.of(FAKE_CREDENTIALS), credentialRetrieverFactory.dockerConfig(dockerConfigCredentialRetriever).retrieve()); Mockito.verify(mockLogger) .accept( LogEvent.lifecycle( "Using credentials from Docker config (" + dockerConfig + ") for registry/repo")); } |
### Question:
JibSystemProperties { public static void checkHttpTimeoutProperty() throws NumberFormatException { checkNumericSystemProperty(HTTP_TIMEOUT, Range.atLeast(0)); } private JibSystemProperties(); static int getHttpTimeout(); static boolean useCrossRepositoryBlobMounts(); static boolean serializeExecution(); static boolean sendCredentialsOverHttp(); static boolean isUserAgentEnabled(); static void checkHttpTimeoutProperty(); static void checkProxyPortProperty(); static boolean skipExistingImages(); static final String UPSTREAM_CLIENT; @VisibleForTesting static final String HTTP_TIMEOUT; @VisibleForTesting
static final String SEND_CREDENTIALS_OVER_HTTP; @VisibleForTesting static final String SKIP_EXISTING_IMAGES; }### Answer:
@Test public void testCheckHttpTimeoutProperty_okWhenUndefined() throws NumberFormatException { System.clearProperty(JibSystemProperties.HTTP_TIMEOUT); JibSystemProperties.checkHttpTimeoutProperty(); }
@Test public void testCheckHttpTimeoutProperty_stringValue() { System.setProperty(JibSystemProperties.HTTP_TIMEOUT, "random string"); try { JibSystemProperties.checkHttpTimeoutProperty(); Assert.fail(); } catch (NumberFormatException ex) { Assert.assertEquals("jib.httpTimeout must be an integer: random string", ex.getMessage()); } } |
### Question:
JibSystemProperties { public static boolean useCrossRepositoryBlobMounts() { return System.getProperty(CROSS_REPOSITORY_BLOB_MOUNTS) == null || Boolean.getBoolean(CROSS_REPOSITORY_BLOB_MOUNTS); } private JibSystemProperties(); static int getHttpTimeout(); static boolean useCrossRepositoryBlobMounts(); static boolean serializeExecution(); static boolean sendCredentialsOverHttp(); static boolean isUserAgentEnabled(); static void checkHttpTimeoutProperty(); static void checkProxyPortProperty(); static boolean skipExistingImages(); static final String UPSTREAM_CLIENT; @VisibleForTesting static final String HTTP_TIMEOUT; @VisibleForTesting
static final String SEND_CREDENTIALS_OVER_HTTP; @VisibleForTesting static final String SKIP_EXISTING_IMAGES; }### Answer:
@Test public void testUseBlobMounts_undefined() { System.clearProperty(JibSystemProperties.CROSS_REPOSITORY_BLOB_MOUNTS); Assert.assertTrue(JibSystemProperties.useCrossRepositoryBlobMounts()); }
@Test public void testUseBlobMounts_true() { System.setProperty(JibSystemProperties.CROSS_REPOSITORY_BLOB_MOUNTS, "true"); Assert.assertTrue(JibSystemProperties.useCrossRepositoryBlobMounts()); }
@Test public void testUseBlobMounts_false() { System.setProperty(JibSystemProperties.CROSS_REPOSITORY_BLOB_MOUNTS, "false"); Assert.assertFalse(JibSystemProperties.useCrossRepositoryBlobMounts()); }
@Test public void testUseBlobMounts_other() { System.setProperty(JibSystemProperties.CROSS_REPOSITORY_BLOB_MOUNTS, "nonbool"); Assert.assertFalse(JibSystemProperties.useCrossRepositoryBlobMounts()); } |
### Question:
JibSystemProperties { public static boolean skipExistingImages() { return Boolean.getBoolean(SKIP_EXISTING_IMAGES); } private JibSystemProperties(); static int getHttpTimeout(); static boolean useCrossRepositoryBlobMounts(); static boolean serializeExecution(); static boolean sendCredentialsOverHttp(); static boolean isUserAgentEnabled(); static void checkHttpTimeoutProperty(); static void checkProxyPortProperty(); static boolean skipExistingImages(); static final String UPSTREAM_CLIENT; @VisibleForTesting static final String HTTP_TIMEOUT; @VisibleForTesting
static final String SEND_CREDENTIALS_OVER_HTTP; @VisibleForTesting static final String SKIP_EXISTING_IMAGES; }### Answer:
@Test public void testSkipExistingImages_undefined() { System.clearProperty(JibSystemProperties.SKIP_EXISTING_IMAGES); Assert.assertFalse(JibSystemProperties.skipExistingImages()); } |
### Question:
BuildResult { @Override public int hashCode() { return Objects.hash(imageDigest, imageId); } BuildResult(DescriptorDigest imageDigest, DescriptorDigest imageId); DescriptorDigest getImageDigest(); DescriptorDigest getImageId(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer:
@Test public void testEquality() { BuildResult container1 = new BuildResult(digest1, id); BuildResult container2 = new BuildResult(digest1, id); BuildResult container3 = new BuildResult(digest2, id); Assert.assertEquals(container1, container2); Assert.assertEquals(container1.hashCode(), container2.hashCode()); Assert.assertNotEquals(container1, container3); } |
### Question:
BuildResult { static BuildResult fromImage(Image image, Class<? extends BuildableManifestTemplate> targetFormat) throws IOException { ImageToJsonTranslator imageToJsonTranslator = new ImageToJsonTranslator(image); BlobDescriptor containerConfigurationBlobDescriptor = Digests.computeDigest(imageToJsonTranslator.getContainerConfiguration()); BuildableManifestTemplate manifestTemplate = imageToJsonTranslator.getManifestTemplate( targetFormat, containerConfigurationBlobDescriptor); DescriptorDigest imageDigest = Digests.computeJsonDigest(manifestTemplate); DescriptorDigest imageId = containerConfigurationBlobDescriptor.getDigest(); return new BuildResult(imageDigest, imageId); } BuildResult(DescriptorDigest imageDigest, DescriptorDigest imageId); DescriptorDigest getImageDigest(); DescriptorDigest getImageId(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer:
@Test public void testFromImage() throws IOException { Image image1 = Image.builder(V22ManifestTemplate.class).setUser("user").build(); Image image2 = Image.builder(V22ManifestTemplate.class).setUser("user").build(); Image image3 = Image.builder(V22ManifestTemplate.class).setUser("anotherUser").build(); Assert.assertEquals( BuildResult.fromImage(image1, V22ManifestTemplate.class), BuildResult.fromImage(image2, V22ManifestTemplate.class)); Assert.assertNotEquals( BuildResult.fromImage(image1, V22ManifestTemplate.class), BuildResult.fromImage(image3, V22ManifestTemplate.class)); } |
### Question:
RegistryCredentialRetriever { static Optional<Credential> getBaseImageCredential(BuildContext buildContext) throws CredentialRetrievalException { return retrieve(buildContext.getBaseImageConfiguration(), buildContext.getEventHandlers()); } }### Answer:
@Test public void testCall_exception() throws CacheDirectoryCreationException { CredentialRetrievalException credentialRetrievalException = Mockito.mock(CredentialRetrievalException.class); BuildContext buildContext = makeFakeBuildContext( Collections.singletonList( () -> { throw credentialRetrievalException; }), Collections.emptyList()); try { RegistryCredentialRetriever.getBaseImageCredential(buildContext); Assert.fail("Should have thrown exception"); } catch (CredentialRetrievalException ex) { Assert.assertSame(credentialRetrievalException, ex); } } |
### Question:
LocalBaseImageSteps { @VisibleForTesting static boolean isGzipped(Path path) throws IOException { try (InputStream inputStream = Files.newInputStream(path)) { inputStream.mark(2); int magic = (inputStream.read() & 0xff) | ((inputStream.read() << 8) & 0xff00); return magic == GZIPInputStream.GZIP_MAGIC; } } }### Answer:
@Test public void testIsGzipped() throws URISyntaxException, IOException { Assert.assertTrue( LocalBaseImageSteps.isGzipped(getResource("core/extraction/compressed.tar.gz"))); Assert.assertFalse( LocalBaseImageSteps.isGzipped(getResource("core/extraction/not-compressed.tar"))); } |
### Question:
Timer implements TimerEvent.Timer { Duration lap() { Instant now = clock.instant(); Duration duration = Duration.between(lapStartTime, now); lapStartTime = now; return duration; } Timer(Clock clock, @Nullable Timer parentTimer); @Override Optional<? extends Timer> getParent(); }### Answer:
@Test public void testLap() { Mockito.when(mockClock.instant()).thenReturn(Instant.EPOCH); Timer parentTimer = new Timer(mockClock, null); Mockito.when(mockClock.instant()).thenReturn(Instant.EPOCH.plusMillis(5)); Duration parentDuration1 = parentTimer.lap(); Mockito.when(mockClock.instant()).thenReturn(Instant.EPOCH.plusMillis(15)); Duration parentDuration2 = parentTimer.lap(); Mockito.when(mockClock.instant()).thenReturn(Instant.EPOCH.plusMillis(16)); Timer childTimer = new Timer(mockClock, parentTimer); Mockito.when(mockClock.instant()).thenReturn(Instant.EPOCH.plusMillis(16).plusNanos(1)); Duration childDuration = childTimer.lap(); Mockito.when(mockClock.instant()).thenReturn(Instant.EPOCH.plusMillis(16).plusNanos(2)); Duration parentDuration3 = parentTimer.lap(); Assert.assertTrue(parentDuration2.compareTo(parentDuration1) > 0); Assert.assertTrue(parentDuration1.compareTo(parentDuration3) > 0); Assert.assertTrue(parentDuration3.compareTo(childDuration) > 0); } |
### Question:
CountingDigestOutputStream extends DigestOutputStream { public BlobDescriptor computeDigest() { try { byte[] hashedBytes = digest.digest(); StringBuilder stringBuilder = new StringBuilder(2 * hashedBytes.length); for (byte b : hashedBytes) { stringBuilder.append(String.format("%02x", b)); } String hash = stringBuilder.toString(); BlobDescriptor blobDescriptor = new BlobDescriptor(bytesSoFar, DescriptorDigest.fromHash(hash)); bytesSoFar = 0; return blobDescriptor; } catch (DigestException ex) { throw new RuntimeException("SHA-256 algorithm produced invalid hash: " + ex.getMessage(), ex); } } CountingDigestOutputStream(OutputStream outputStream); BlobDescriptor computeDigest(); @Override void write(byte[] data, int offset, int length); @Override void write(int singleByte); }### Answer:
@Test public void test_smokeTest() throws IOException, DigestException { for (Map.Entry<String, String> knownHash : KNOWN_SHA256_HASHES.entrySet()) { String toHash = knownHash.getKey(); String expectedHash = knownHash.getValue(); OutputStream underlyingOutputStream = new ByteArrayOutputStream(); CountingDigestOutputStream countingDigestOutputStream = new CountingDigestOutputStream(underlyingOutputStream); byte[] bytesToHash = toHash.getBytes(StandardCharsets.UTF_8); InputStream toHashInputStream = new ByteArrayInputStream(bytesToHash); ByteStreams.copy(toHashInputStream, countingDigestOutputStream); BlobDescriptor blobDescriptor = countingDigestOutputStream.computeDigest(); Assert.assertEquals(DescriptorDigest.fromHash(expectedHash), blobDescriptor.getDigest()); Assert.assertEquals(bytesToHash.length, blobDescriptor.getSize()); } } |
### Question:
AllocationCompletionTracker { ImmutableList<String> getUnfinishedLeafTasks() { List<Allocation> allUnfinished = getUnfinishedAllocations(); Set<Allocation> unfinishedLeaves = new LinkedHashSet<>(allUnfinished); for (Allocation allocation : allUnfinished) { Optional<Allocation> parent = allocation.getParent(); while (parent.isPresent()) { unfinishedLeaves.remove(parent.get()); parent = parent.get().getParent(); } } return ImmutableList.copyOf( unfinishedLeaves.stream().map(Allocation::getDescription).collect(Collectors.toList())); } }### Answer:
@Test public void testGetUnfinishedLeafTasks() { AllocationCompletionTracker tracker = new AllocationCompletionTracker(); tracker.updateProgress(AllocationTree.root, 0); Assert.assertEquals(Arrays.asList("root"), tracker.getUnfinishedLeafTasks()); tracker.updateProgress(AllocationTree.child1, 0); Assert.assertEquals(Arrays.asList("child1"), tracker.getUnfinishedLeafTasks()); tracker.updateProgress(AllocationTree.child2, 0); Assert.assertEquals(Arrays.asList("child1", "child2"), tracker.getUnfinishedLeafTasks()); tracker.updateProgress(AllocationTree.child1Child, 0); Assert.assertEquals(Arrays.asList("child2", "child1Child"), tracker.getUnfinishedLeafTasks()); tracker.updateProgress(AllocationTree.child1Child, 50); Assert.assertEquals(Arrays.asList("child2", "child1Child"), tracker.getUnfinishedLeafTasks()); tracker.updateProgress(AllocationTree.child2, 100); Assert.assertEquals(Arrays.asList("child2", "child1Child"), tracker.getUnfinishedLeafTasks()); tracker.updateProgress(AllocationTree.child2, 100); Assert.assertEquals(Arrays.asList("child1Child"), tracker.getUnfinishedLeafTasks()); tracker.updateProgress(AllocationTree.child1Child, 50); Assert.assertEquals(Collections.emptyList(), tracker.getUnfinishedLeafTasks()); } |
### Question:
EventHandlers { public void dispatch(JibEvent jibEvent) { if (handlers.isEmpty()) { return; } handlers.get(JibEvent.class).forEach(handler -> handler.handle(jibEvent)); handlers.get(jibEvent.getClass()).forEach(handler -> handler.handle(jibEvent)); } private EventHandlers(Multimap<Class<? extends JibEvent>, Handler<? extends JibEvent>> handlers); static Builder builder(); void dispatch(JibEvent jibEvent); static final EventHandlers NONE; }### Answer:
@Test public void testDispatch() { List<String> emissions = new ArrayList<>(); EventHandlers eventHandlers = EventHandlers.builder() .add(TestJibEvent2.class, testJibEvent2 -> emissions.add("handled 2 first")) .add(TestJibEvent2.class, testJibEvent2 -> emissions.add("handled 2 second")) .add(TestJibEvent3.class, testJibEvent3 -> emissions.add("handled 3")) .add(JibEvent.class, jibEvent -> emissions.add("handled generic")) .build(); TestJibEvent2 testJibEvent2 = new TestJibEvent2(); TestJibEvent3 testJibEvent3 = new TestJibEvent3(); eventHandlers.dispatch(testJibEvent2); eventHandlers.dispatch(testJibEvent3); Assert.assertEquals( Arrays.asList( "handled generic", "handled 2 first", "handled 2 second", "handled generic", "handled 3"), emissions); } |
### Question:
PluginConfigurationProcessor { @VisibleForTesting static Set<AbsoluteUnixPath> getVolumesSet(RawConfiguration rawConfiguration) throws InvalidContainerVolumeException { Set<AbsoluteUnixPath> volumes = new HashSet<>(); for (String path : rawConfiguration.getVolumes()) { try { AbsoluteUnixPath absoluteUnixPath = AbsoluteUnixPath.get(path); volumes.add(absoluteUnixPath); } catch (IllegalArgumentException exception) { throw new InvalidContainerVolumeException(path, path, exception); } } return volumes; } static JibBuildRunner createJibBuildRunnerForDockerDaemonImage(
RawConfiguration rawConfiguration,
InferredAuthProvider inferredAuthProvider,
ProjectProperties projectProperties,
HelpfulSuggestions helpfulSuggestions); static JibBuildRunner createJibBuildRunnerForTarImage(
RawConfiguration rawConfiguration,
InferredAuthProvider inferredAuthProvider,
ProjectProperties projectProperties,
HelpfulSuggestions helpfulSuggestions); static JibBuildRunner createJibBuildRunnerForRegistryImage(
RawConfiguration rawConfiguration,
InferredAuthProvider inferredAuthProvider,
ProjectProperties projectProperties,
HelpfulSuggestions helpfulSuggestions); static String getSkaffoldSyncMap(
RawConfiguration rawConfiguration, ProjectProperties projectProperties, Set<Path> excludes); }### Answer:
@Test public void testGetValidVolumesList() throws InvalidContainerVolumeException { Mockito.when(rawConfiguration.getVolumes()).thenReturn(Collections.singletonList("/some/root")); Assert.assertEquals( ImmutableSet.of(AbsoluteUnixPath.get("/some/root")), PluginConfigurationProcessor.getVolumesSet(rawConfiguration)); }
@Test public void testGetInvalidVolumesList() { Mockito.when(rawConfiguration.getVolumes()).thenReturn(Collections.singletonList("`some/root")); try { PluginConfigurationProcessor.getVolumesSet(rawConfiguration); Assert.fail(); } catch (InvalidContainerVolumeException ex) { Assert.assertEquals("`some/root", ex.getMessage()); Assert.assertEquals("`some/root", ex.getInvalidVolume()); } } |
### Question:
Port { public static Port parseProtocol(int port, String protocolString) { String protocol = UDP_PROTOCOL.equalsIgnoreCase(protocolString) ? UDP_PROTOCOL : TCP_PROTOCOL; return new Port(port, protocol); } private Port(int port, String protocol); static Port tcp(int port); static Port udp(int port); static Port parseProtocol(int port, String protocolString); int getPort(); String getProtocol(); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testParseProtocol() { Assert.assertEquals(Port.tcp(1111), Port.parseProtocol(1111, "tcp")); Assert.assertEquals(Port.udp(2222), Port.parseProtocol(2222, "udp")); Assert.assertEquals(Port.tcp(3333), Port.parseProtocol(3333, "")); } |
### Question:
JibPluginConfiguration extends AbstractMojo { Set<String> getTargetImageAdditionalTags() { String property = getProperty(PropertyNames.TO_TAGS); List<String> tags = property != null ? ConfigurationPropertyValidator.parseListProperty(property) : to.tags; if (tags.stream().anyMatch(Strings::isNullOrEmpty)) { String source = property != null ? PropertyNames.TO_TAGS : "<to><tags>"; throw new IllegalArgumentException(source + " has empty tag"); } return new HashSet<>(tags); } String getContainerizingMode(); }### Answer:
@Test public void testEmptyOrNullTags() { sessionProperties.put("jib.to.tags", "a,,b"); try { testPluginConfiguration.getTargetImageAdditionalTags(); Assert.fail(); } catch (IllegalArgumentException ex) { Assert.assertEquals("jib.to.tags has empty tag", ex.getMessage()); } } |
### Question:
PluginConfigurationProcessor { static Set<Path> getAllFiles(Set<Path> paths) throws IOException { Set<Path> expanded = new HashSet<>(); for (Path path : paths) { if (Files.isRegularFile(path)) { expanded.add(path); } else if (Files.isDirectory(path)) { try (Stream<Path> dirWalk = Files.walk(path)) { dirWalk.filter(Files::isRegularFile).forEach(expanded::add); } } } return expanded; } static JibBuildRunner createJibBuildRunnerForDockerDaemonImage(
RawConfiguration rawConfiguration,
InferredAuthProvider inferredAuthProvider,
ProjectProperties projectProperties,
HelpfulSuggestions helpfulSuggestions); static JibBuildRunner createJibBuildRunnerForTarImage(
RawConfiguration rawConfiguration,
InferredAuthProvider inferredAuthProvider,
ProjectProperties projectProperties,
HelpfulSuggestions helpfulSuggestions); static JibBuildRunner createJibBuildRunnerForRegistryImage(
RawConfiguration rawConfiguration,
InferredAuthProvider inferredAuthProvider,
ProjectProperties projectProperties,
HelpfulSuggestions helpfulSuggestions); static String getSkaffoldSyncMap(
RawConfiguration rawConfiguration, ProjectProperties projectProperties, Set<Path> excludes); }### Answer:
@Test public void getAllFiles_expandsDirectories() throws IOException { File rootFile = temporaryFolder.newFile("file"); File folder = temporaryFolder.newFolder("folder"); File folderFile = temporaryFolder.newFile("folder/file2"); Assert.assertEquals( ImmutableSet.of(rootFile.toPath().toAbsolutePath(), folderFile.toPath().toAbsolutePath()), PluginConfigurationProcessor.getAllFiles( ImmutableSet.of(rootFile.toPath(), folder.toPath()))); }
@Test public void getAllFiles_doesntBreakForNonExistentFiles() throws IOException { Path testPath = Paths.get("/a/file/that/doesnt/exist"); Assert.assertFalse(Files.exists(testPath)); Assert.assertEquals( ImmutableSet.of(), PluginConfigurationProcessor.getAllFiles(ImmutableSet.of(testPath))); } |
### Question:
TimerEventHandler implements Consumer<TimerEvent> { @Override public void accept(TimerEvent timerEvent) { logMessageConsumer.accept(buildLogMessage(timerEvent)); } TimerEventHandler(Consumer<String> logMessageConsumer); @Override void accept(TimerEvent timerEvent); }### Answer:
@Test public void testAccept() { TimerEventHandler timerEventHandler = new TimerEventHandler(logMessageQueue::add); timerEventHandler.accept( new TimerEvent(State.START, ROOT_TIMER, Duration.ZERO, Duration.ZERO, "description")); timerEventHandler.accept( new TimerEvent(State.LAP, ROOT_TIMER, Duration.ofMillis(10), Duration.ZERO, "description")); timerEventHandler.accept( new TimerEvent( State.FINISHED, ROOT_TIMER, Duration.ofMillis(100), Duration.ZERO, "description")); timerEventHandler.accept( new TimerEvent( State.LAP, () -> Optional.of(ROOT_TIMER), Duration.ZERO, Duration.ZERO, "child description")); String rootStartMessage = logMessageQueue.poll(); Assert.assertNotNull(rootStartMessage); Assert.assertEquals("TIMING\tdescription", rootStartMessage); String rootInProgressMessage = logMessageQueue.poll(); Assert.assertNotNull(rootInProgressMessage); Assert.assertEquals("TIMED\tdescription : 10.0 ms", rootInProgressMessage); String rootFinishedMessage = logMessageQueue.poll(); Assert.assertNotNull(rootFinishedMessage); Assert.assertEquals("TIMED\tdescription : 100.0 ms", rootFinishedMessage); String childMessage = logMessageQueue.poll(); Assert.assertNotNull(childMessage); Assert.assertEquals("\tTIMED\tchild description : 0.0 ms", childMessage); Assert.assertTrue(logMessageQueue.isEmpty()); } |
### Question:
UpdateChecker { public static Optional<String> finishUpdateCheck(Future<Optional<String>> updateMessageFuture) { if (updateMessageFuture.isDone()) { try { return updateMessageFuture.get(); } catch (InterruptedException | ExecutionException ignored) { } } updateMessageFuture.cancel(true); return Optional.empty(); } private UpdateChecker(); static Future<Optional<String>> checkForUpdate(
ExecutorService executorService,
Consumer<LogEvent> log,
String versionUrl,
String toolName,
String toolVersion); static Optional<String> finishUpdateCheck(Future<Optional<String>> updateMessageFuture); }### Answer:
@Test public void testFinishUpdateCheck_success() { Future<Optional<String>> updateCheckFuture = Futures.immediateFuture(Optional.of("Hello")); Optional<String> result = UpdateChecker.finishUpdateCheck(updateCheckFuture); Assert.assertTrue(result.isPresent()); Assert.assertEquals("Hello", result.get()); }
@Test public void testFinishUpdateCheck_notDone() { @SuppressWarnings("unchecked") Future<Optional<String>> updateCheckFuture = Mockito.mock(Future.class); Mockito.when(updateCheckFuture.isDone()).thenReturn(false); Optional<String> result = UpdateChecker.finishUpdateCheck(updateCheckFuture); Assert.assertFalse(result.isPresent()); } |
### Question:
VersionChecker { @VisibleForTesting static <T extends Comparable<? super T>> boolean lt(T a, T b) { return a.compareTo(b) < 0; } VersionChecker(Function<String, V> converter); @VisibleForTesting boolean compatibleVersion(String acceptableVersionRange, String actualVersion); }### Answer:
@Test public void testComparators_LT() { Assert.assertTrue(VersionChecker.lt(0, 1)); Assert.assertFalse(VersionChecker.lt(1, 1)); Assert.assertFalse(VersionChecker.lt(2, 1)); } |
### Question:
VersionChecker { @VisibleForTesting static <T extends Comparable<? super T>> boolean le(T a, T b) { return a.compareTo(b) <= 0; } VersionChecker(Function<String, V> converter); @VisibleForTesting boolean compatibleVersion(String acceptableVersionRange, String actualVersion); }### Answer:
@Test public void testComparators_LE() { Assert.assertTrue(VersionChecker.le(0, 1)); Assert.assertTrue(VersionChecker.le(1, 1)); Assert.assertFalse(VersionChecker.le(2, 1)); } |
### Question:
VersionChecker { @VisibleForTesting static <T extends Comparable<? super T>> boolean ge(T a, T b) { return a.compareTo(b) >= 0; } VersionChecker(Function<String, V> converter); @VisibleForTesting boolean compatibleVersion(String acceptableVersionRange, String actualVersion); }### Answer:
@Test public void testComparators_GE() { Assert.assertFalse(VersionChecker.ge(0, 1)); Assert.assertTrue(VersionChecker.ge(1, 1)); Assert.assertTrue(VersionChecker.ge(2, 1)); } |
### Question:
VersionChecker { @VisibleForTesting static <T extends Comparable<? super T>> boolean gt(T a, T b) { return a.compareTo(b) > 0; } VersionChecker(Function<String, V> converter); @VisibleForTesting boolean compatibleVersion(String acceptableVersionRange, String actualVersion); }### Answer:
@Test public void testComparators_GT() { Assert.assertFalse(VersionChecker.gt(0, 1)); Assert.assertFalse(VersionChecker.gt(1, 1)); Assert.assertTrue(VersionChecker.gt(2, 1)); } |
### Question:
FilePermissions { public static FilePermissions fromOctalString(String octalPermissions) { if (!octalPermissions.matches(OCTAL_PATTERN)) { throw new IllegalArgumentException( "octalPermissions must be a 3-digit octal number (000-777)"); } return new FilePermissions(Integer.parseInt(octalPermissions, 8)); } FilePermissions(int permissionBits); static FilePermissions fromOctalString(String octalPermissions); static FilePermissions fromPosixFilePermissions(
Set<PosixFilePermission> posixFilePermissions); int getPermissionBits(); String toOctalString(); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static final FilePermissions DEFAULT_FILE_PERMISSIONS; static final FilePermissions DEFAULT_FOLDER_PERMISSIONS; }### Answer:
@Test public void testFromOctalString() { Assert.assertEquals(new FilePermissions(0777), FilePermissions.fromOctalString("777")); Assert.assertEquals(new FilePermissions(0000), FilePermissions.fromOctalString("000")); Assert.assertEquals(new FilePermissions(0123), FilePermissions.fromOctalString("123")); Assert.assertEquals(new FilePermissions(0755), FilePermissions.fromOctalString("755")); Assert.assertEquals(new FilePermissions(0644), FilePermissions.fromOctalString("644")); ImmutableList<String> badStrings = ImmutableList.of("abc", "-123", "777444333", "987", "3"); for (String badString : badStrings) { try { FilePermissions.fromOctalString(badString); Assert.fail(); } catch (IllegalArgumentException ex) { Assert.assertEquals( "octalPermissions must be a 3-digit octal number (000-777)", ex.getMessage()); } } } |
### Question:
TokenUtil { public static String sanitizeTokenString(final String tokenString) { return tokenString.replaceAll("[^a-fA-F0-9]", ""); } private TokenUtil(); static String sanitizeTokenString(final String tokenString); }### Answer:
@Test void testSanitizeTokenString() { assertEquals("ffff1234", TokenUtil.sanitizeTokenString("<ffff 1234>")); }
@SuppressWarnings({"ResultOfMethodCallIgnored", "ConstantConditions"}) @Test void testSanitizeNullTokenString() { assertThrows(NullPointerException.class, () -> TokenUtil.sanitizeTokenString(null)); } |
### Question:
ApnsChannelPool { Future<Channel> acquire() { final Promise<Channel> acquirePromise = new DefaultPromise<>(this.executor); if (this.executor.inEventLoop()) { this.acquireWithinEventExecutor(acquirePromise); } else { this.executor.submit(() -> ApnsChannelPool.this.acquireWithinEventExecutor(acquirePromise)).addListener(future -> { if (!future.isSuccess()) { acquirePromise.tryFailure(future.cause()); } }); } return acquirePromise; } ApnsChannelPool(final PooledObjectFactory<Channel> channelFactory, final int capacity, final OrderedEventExecutor executor, final ApnsChannelPoolMetricsListener metricsListener); Future<Void> close(); }### Answer:
@SuppressWarnings("AnonymousInnerClassMayBeStatic") @Test void testAcquireConstructionFailure() throws Exception { final PooledObjectFactory<Channel> factory = new PooledObjectFactory<Channel>() { @Override public Future<Channel> create(final Promise<Channel> promise) { promise.tryFailure(new RuntimeException()); return promise; } @Override public Future<Void> destroy(final Channel channel, final Promise<Void> promise) { promise.trySuccess(null); return promise; } }; final ApnsChannelPool pool = new ApnsChannelPool(factory, 1, EVENT_EXECUTOR, this.metricsListener); assertFalse(pool.acquire().await().isSuccess()); assertEquals(0, this.metricsListener.getConnectionsAdded()); assertEquals(0, this.metricsListener.getConnectionsRemoved()); assertEquals(1, this.metricsListener.getConnectionsFailed()); } |
### Question:
ClientChannelClassUtil { static Class<? extends SocketChannel> getSocketChannelClass(final EventLoopGroup eventLoopGroup) { Objects.requireNonNull(eventLoopGroup); final String socketChannelClassName = SOCKET_CHANNEL_CLASSES.get(eventLoopGroup.getClass().getName()); if (socketChannelClassName == null) { throw new IllegalArgumentException("No socket channel class found for event loop group type: " + eventLoopGroup.getClass().getName()); } try { return Class.forName(socketChannelClassName).asSubclass(SocketChannel.class); } catch (final ClassNotFoundException e) { throw new IllegalArgumentException(e); } } }### Answer:
@Test void testGetCoreSocketChannelClass() { final NioEventLoopGroup nioEventLoopGroup = new NioEventLoopGroup(1); try { assertEquals(NioSocketChannel.class, ClientChannelClassUtil.getSocketChannelClass(nioEventLoopGroup)); } finally { nioEventLoopGroup.shutdownGracefully(); } }
@Test void testGetKqueueSocketChannelClass() { final String unavailabilityMessage = KQueue.unavailabilityCause() != null ? KQueue.unavailabilityCause().getMessage() : null; assumeTrue(KQueue.isAvailable(), "KQueue not available: " + unavailabilityMessage); final KQueueEventLoopGroup kQueueEventLoopGroup = new KQueueEventLoopGroup(1); try { assertEquals(KQueueSocketChannel.class, ClientChannelClassUtil.getSocketChannelClass(kQueueEventLoopGroup)); } finally { kQueueEventLoopGroup.shutdownGracefully(); } }
@Test void testGetEpollSocketChannelClass() { final String unavailabilityMessage = Epoll.unavailabilityCause() != null ? Epoll.unavailabilityCause().getMessage() : null; assumeTrue(Epoll.isAvailable(), "Epoll not available: " + unavailabilityMessage); final EpollEventLoopGroup epollEventLoopGroup = new EpollEventLoopGroup(1); try { assertEquals(EpollSocketChannel.class, ClientChannelClassUtil.getSocketChannelClass(epollEventLoopGroup)); } finally { epollEventLoopGroup.shutdownGracefully(); } } |
### Question:
ClientChannelClassUtil { static Class<? extends DatagramChannel> getDatagramChannelClass(final EventLoopGroup eventLoopGroup) { Objects.requireNonNull(eventLoopGroup); final String datagramChannelClassName = DATAGRAM_CHANNEL_CLASSES.get(eventLoopGroup.getClass().getName()); if (datagramChannelClassName == null) { throw new IllegalArgumentException("No datagram channel class found for event loop group type: " + eventLoopGroup.getClass().getName()); } try { return Class.forName(datagramChannelClassName).asSubclass(DatagramChannel.class); } catch (final ClassNotFoundException e) { throw new IllegalArgumentException(e); } } }### Answer:
@Test void testGetCoreDatagramChannelClass() { final NioEventLoopGroup nioEventLoopGroup = new NioEventLoopGroup(1); try { assertEquals(NioDatagramChannel.class, ClientChannelClassUtil.getDatagramChannelClass(nioEventLoopGroup)); } finally { nioEventLoopGroup.shutdownGracefully(); } }
@Test void testGetKqueueDatagramChannelClass() { final String unavailabilityMessage = KQueue.unavailabilityCause() != null ? KQueue.unavailabilityCause().getMessage() : null; assumeTrue(KQueue.isAvailable(), "KQueue not available: " + unavailabilityMessage); final KQueueEventLoopGroup kQueueEventLoopGroup = new KQueueEventLoopGroup(1); try { assertEquals(KQueueDatagramChannel.class, ClientChannelClassUtil.getDatagramChannelClass(kQueueEventLoopGroup)); } finally { kQueueEventLoopGroup.shutdownGracefully(); } }
@Test void testGetEpollDatagramChannelClass() { final String unavailabilityMessage = Epoll.unavailabilityCause() != null ? Epoll.unavailabilityCause().getMessage() : null; assumeTrue(Epoll.isAvailable(), "Epoll not available: " + unavailabilityMessage); final EpollEventLoopGroup epollEventLoopGroup = new EpollEventLoopGroup(1); try { assertEquals(EpollDatagramChannel.class, ClientChannelClassUtil.getDatagramChannelClass(epollEventLoopGroup)); } finally { epollEventLoopGroup.shutdownGracefully(); } } |
### Question:
ApnsClient { public CompletableFuture<Void> close() { log.info("Shutting down."); final CompletableFuture<Void> closeFuture; if (this.isClosed.compareAndSet(false, true)) { closeFuture = new CompletableFuture<>(); this.channelPool.close().addListener((GenericFutureListener<Future<Void>>) closePoolFuture -> { if (ApnsClient.this.shouldShutDownEventLoopGroup) { ApnsClient.this.eventLoopGroup.shutdownGracefully().addListener(future -> closeFuture.complete(null)); } else { closeFuture.complete(null); } }); } else { closeFuture = CompletableFuture.completedFuture(null); } return closeFuture; } protected ApnsClient(final InetSocketAddress apnsServerAddress, final SslContext sslContext,
final ApnsSigningKey signingKey, final Duration tokenExpiration,
final ProxyHandlerFactory proxyHandlerFactory, final Duration connectTimeout,
final Duration idlePingInterval, final Duration gracefulShutdownTimeout,
final int concurrentConnections, final ApnsClientMetricsListener metricsListener,
final Http2FrameLogger frameLogger, final EventLoopGroup eventLoopGroup); PushNotificationFuture<T, PushNotificationResponse<T>> sendNotification(final T notification); CompletableFuture<Void> close(); }### Answer:
@Test void testApnsClientWithManagedEventLoopGroup() throws Exception { final ApnsClient managedGroupClient = new ApnsClientBuilder() .setApnsServer(HOST, PORT) .setSigningKey(this.signingKey) .build(); assertDoesNotThrow(() -> managedGroupClient.close().get()); } |
### Question:
ErrorResponse { static ErrorResponse fromMap(final Map<String, Object> errorResponseMap) { String reason; try { reason = (String) errorResponseMap.get("reason"); } catch (final ClassCastException e) { reason = null; } Instant timestamp; if (errorResponseMap.containsKey("timestamp")) { try { timestamp = Instant.ofEpochMilli((Long) errorResponseMap.get("timestamp")); } catch (final ClassCastException e) { timestamp = null; } } else { timestamp = null; } return new ErrorResponse(reason, timestamp); } ErrorResponse(final String reason, final Instant timestamp); }### Answer:
@Test void fromMap() { { final ErrorResponse emptyError = ErrorResponse.fromMap(Collections.emptyMap()); assertNull(emptyError.getReason()); assertNull(emptyError.getTimestamp()); } { final String reason = "Badness"; final ErrorResponse reasonOnlyError = ErrorResponse.fromMap(Collections.singletonMap("reason", reason)); assertEquals(reason, reasonOnlyError.getReason()); assertNull(reasonOnlyError.getTimestamp()); } { final String reason = "Badness"; final Instant timestamp = Instant.now(); final Map<String, Object> errorResponseMap = new HashMap<>(); errorResponseMap.put("reason", reason); errorResponseMap.put("timestamp", timestamp.toEpochMilli()); final ErrorResponse errorResponse = ErrorResponse.fromMap(errorResponseMap); assertEquals(reason, errorResponse.getReason()); assertEquals(timestamp.toEpochMilli(), errorResponse.getTimestamp().toEpochMilli()); } { final Map<String, Object> wrongTypesErrorMap = new HashMap<>(); wrongTypesErrorMap.put("reason", 17); wrongTypesErrorMap.put("timestamp", false); final ErrorResponse errorResponse = ErrorResponse.fromMap(wrongTypesErrorMap); assertNull(errorResponse.getReason()); assertNull(errorResponse.getTimestamp()); } } |
### Question:
AugmentingReflectiveChannelFactory extends ReflectiveChannelFactory<T> { @Override public T newChannel() { final T channel = super.newChannel(); channel.attr(this.attributeKey).set(this.attributeValue); return channel; } AugmentingReflectiveChannelFactory(final Class<? extends T> channelClass, final AttributeKey<A> attributeKey, final A attributeValue); @Override T newChannel(); }### Answer:
@Test void testNewChannel() { final AttributeKey<String> attributeKey = AttributeKey.valueOf(getClass(), "attributeKey"); final AugmentingReflectiveChannelFactory<LocalChannel, String> factory = new AugmentingReflectiveChannelFactory<>(LocalChannel.class, attributeKey, "Test!"); final LocalChannel channel = factory.newChannel(); assertTrue(channel.hasAttr(attributeKey), "Newly-created channels should have attribute provided to factory."); } |
### Question:
MockApnsServerBuilder extends BaseHttp2ServerBuilder<MockApnsServer> { @Override public MockApnsServerBuilder setMaxConcurrentStreams(final int maxConcurrentStreams) { super.setMaxConcurrentStreams(maxConcurrentStreams); return this; } @Override MockApnsServerBuilder setServerCredentials(final File certificatePemFile, final File privateKeyPkcs8File, final String privateKeyPassword); @Override MockApnsServerBuilder setServerCredentials(final InputStream certificatePemInputStream, final InputStream privateKeyPkcs8InputStream, final String privateKeyPassword); @Override MockApnsServerBuilder setServerCredentials(final X509Certificate[] certificates, final PrivateKey privateKey, final String privateKeyPassword); @Override MockApnsServerBuilder setTrustedClientCertificateChain(final File certificatePemFile); @Override MockApnsServerBuilder setTrustedClientCertificateChain(final InputStream certificateInputStream); @Override MockApnsServerBuilder setTrustedServerCertificateChain(final X509Certificate... certificates); @Override MockApnsServerBuilder setEventLoopGroup(final EventLoopGroup eventLoopGroup); @Override MockApnsServerBuilder setMaxConcurrentStreams(final int maxConcurrentStreams); @Override MockApnsServerBuilder setUseAlpn(final boolean useAlpn); MockApnsServerBuilder setHandlerFactory(final PushNotificationHandlerFactory handlerFactory); MockApnsServerBuilder setListener(final MockApnsServerListener listener); @Override MockApnsServer build(); }### Answer:
@Test void testSetMaxConcurrentStreams() { new MockApnsServerBuilder().setMaxConcurrentStreams(1); }
@Test void testSetNegativeMaxConcurrentStreams() { assertThrows(IllegalArgumentException.class, () -> new MockApnsServerBuilder().setMaxConcurrentStreams(-7)); } |
### Question:
ServerChannelClassUtil { static Class<? extends ServerChannel> getServerSocketChannelClass(final EventLoopGroup eventLoopGroup) { Objects.requireNonNull(eventLoopGroup); final String serverSocketChannelClassName = SERVER_SOCKET_CHANNEL_CLASSES.get(eventLoopGroup.getClass().getName()); if (serverSocketChannelClassName == null) { throw new IllegalArgumentException("No server socket channel class found for event loop group type: " + eventLoopGroup.getClass().getName()); } try { return Class.forName(serverSocketChannelClassName).asSubclass(ServerChannel.class); } catch (final ClassNotFoundException e) { throw new IllegalArgumentException(e); } } }### Answer:
@Test void testGetCoreSocketChannelClass() { final NioEventLoopGroup nioEventLoopGroup = new NioEventLoopGroup(1); try { assertEquals(NioServerSocketChannel.class, ServerChannelClassUtil.getServerSocketChannelClass(nioEventLoopGroup)); } finally { nioEventLoopGroup.shutdownGracefully(); } }
@Test void testGetKqueueSocketChannelClass() { final String unavailabilityMessage = KQueue.unavailabilityCause() != null ? KQueue.unavailabilityCause().getMessage() : null; assumeTrue(KQueue.isAvailable(), "KQueue not available: " + unavailabilityMessage); final KQueueEventLoopGroup kQueueEventLoopGroup = new KQueueEventLoopGroup(1); try { assertEquals(KQueueServerSocketChannel.class, ServerChannelClassUtil.getServerSocketChannelClass(kQueueEventLoopGroup)); } finally { kQueueEventLoopGroup.shutdownGracefully(); } }
@Test void testGetEpollSocketChannelClass() { final String unavailabilityMessage = Epoll.unavailabilityCause() != null ? Epoll.unavailabilityCause().getMessage() : null; assumeTrue(Epoll.isAvailable(), "Epoll not available: " + unavailabilityMessage); final EpollEventLoopGroup epollEventLoopGroup = new EpollEventLoopGroup(1); try { assertEquals(EpollServerSocketChannel.class, ServerChannelClassUtil.getServerSocketChannelClass(epollEventLoopGroup)); } finally { epollEventLoopGroup.shutdownGracefully(); } } |
### Question:
ParsingMockApnsServerListenerAdapter implements MockApnsServerListener { public void handlePushNotificationRejected(final Http2Headers headers, final ByteBuf payload, final RejectionReason rejectionReason, final Instant deviceTokenExpirationTimestamp) { this.handlePushNotificationRejected(parsePushNotification(headers, payload), rejectionReason, deviceTokenExpirationTimestamp); } void handlePushNotificationAccepted(final Http2Headers headers, final ByteBuf payload); abstract void handlePushNotificationAccepted(final ApnsPushNotification pushNotification); void handlePushNotificationRejected(final Http2Headers headers, final ByteBuf payload, final RejectionReason rejectionReason, final Instant deviceTokenExpirationTimestamp); abstract void handlePushNotificationRejected(final ApnsPushNotification pushNotification, final RejectionReason rejectionReason, final Instant deviceTokenExpirationTimestamp); }### Answer:
@Test void testHandlePushNotificationRejected() { final TestParsingMockApnsServerListener listener = new TestParsingMockApnsServerListener(); { final RejectionReason rejectionReason = RejectionReason.BAD_DEVICE_TOKEN; listener.handlePushNotificationRejected(new DefaultHttp2Headers(), null, rejectionReason, null); assertEquals(rejectionReason, listener.mostRecentRejectionReason); assertNull(listener.mostRecentDeviceTokenExpiration); } { final RejectionReason rejectionReason = RejectionReason.BAD_PRIORITY; final Instant deviceTokenExpiration = Instant.now(); listener.handlePushNotificationRejected(new DefaultHttp2Headers(), null, rejectionReason, deviceTokenExpiration); assertEquals(rejectionReason, listener.mostRecentRejectionReason); assertEquals(deviceTokenExpiration, listener.mostRecentDeviceTokenExpiration); } } |
### Question:
AuthenticationToken { public String getKeyId() { return this.header.getKeyId(); } AuthenticationToken(final ApnsSigningKey signingKey, final Instant issuedAt); AuthenticationToken(final String base64EncodedToken); Instant getIssuedAt(); String getKeyId(); String getTeamId(); boolean verifySignature(final ApnsVerificationKey verificationKey); AsciiString getAuthorizationHeader(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }### Answer:
@Test void testHeaderFromMap() { assertThrows(IllegalArgumentException.class, () -> AuthenticationToken.AuthenticationTokenHeader.fromMap(Collections.emptyMap())); assertThrows(IllegalArgumentException.class, () -> AuthenticationToken.AuthenticationTokenHeader.fromMap( Collections.singletonMap("kid", false))); final String keyId = "test-key-id"; final Map<String, Object> headerMap = new HashMap<>(); headerMap.put("alg", "ES256"); headerMap.put("typ", "JWT"); headerMap.put("kid", keyId); final AuthenticationToken.AuthenticationTokenHeader authenticationTokenHeader = AuthenticationToken.AuthenticationTokenHeader.fromMap(headerMap); assertEquals(keyId, authenticationTokenHeader.getKeyId()); } |
### Question:
AuthenticationToken { @Override public String toString() { return this.base64EncodedToken; } AuthenticationToken(final ApnsSigningKey signingKey, final Instant issuedAt); AuthenticationToken(final String base64EncodedToken); Instant getIssuedAt(); String getKeyId(); String getTeamId(); boolean verifySignature(final ApnsVerificationKey verificationKey); AsciiString getAuthorizationHeader(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }### Answer:
@Test void testAuthenticationTokenFromString() throws Exception { final String base64EncodedToken = new AuthenticationToken(this.signingKey, Instant.now()).toString(); assertDoesNotThrow(() -> new AuthenticationToken(base64EncodedToken)); }
@Test void testToString() throws Exception { final AuthenticationToken token = new AuthenticationToken(this.signingKey, Instant.now()); assertTrue(Pattern.matches("^[a-zA-Z0-9_\\-]+\\.[a-zA-Z0-9_\\-]+\\.[a-zA-Z0-9_\\-]+$", token.toString())); } |
### Question:
ApnsKey implements ECKey { public String getKeyId() { return this.keyId; } ApnsKey(final String keyId, final String teamId, final ECKey key); String getKeyId(); String getTeamId(); @Override ECParameterSpec getParams(); static final String APNS_SIGNATURE_ALGORITHM; }### Answer:
@Test void testGetKeyId() throws Exception { assertNotNull(this.getApnsKey().getKeyId()); } |
### Question:
ApnsKey implements ECKey { public String getTeamId() { return this.teamId; } ApnsKey(final String keyId, final String teamId, final ECKey key); String getKeyId(); String getTeamId(); @Override ECParameterSpec getParams(); static final String APNS_SIGNATURE_ALGORITHM; }### Answer:
@Test void testGetTeamId() throws Exception { assertNotNull(this.getApnsKey().getTeamId()); } |
### Question:
ApnsKey implements ECKey { protected ECKey getKey() { return this.key; } ApnsKey(final String keyId, final String teamId, final ECKey key); String getKeyId(); String getTeamId(); @Override ECParameterSpec getParams(); static final String APNS_SIGNATURE_ALGORITHM; }### Answer:
@Test void testGetKey() throws Exception { assertNotNull(this.getApnsKey().getKey()); } |
### Question:
ApnsKey implements ECKey { @Override public ECParameterSpec getParams() { return this.key.getParams(); } ApnsKey(final String keyId, final String teamId, final ECKey key); String getKeyId(); String getTeamId(); @Override ECParameterSpec getParams(); static final String APNS_SIGNATURE_ALGORITHM; }### Answer:
@Test void testGetParams() throws Exception { assertNotNull(this.getApnsKey().getParams()); } |
### Question:
JsonParser { public Map<String, Object> parseJsonObject(final String jsonString) throws ParseException { this.jsonString = jsonString; this.position = findNextToken(jsonString, 0); if (jsonString.charAt(position) != '{') { throw new ParseException("JSON string does not represent a JSON object.", position); } return parseObject(); } JsonParser(); Map<String, Object> parseJsonObject(final String jsonString); }### Answer:
@Test void parseAsObject() throws ParseException { final JsonParser parser = new JsonParser(); assertThrows(ParseException.class, () -> parser.parseJsonObject("")); assertThrows(ParseException.class, () -> parser.parseJsonObject("[]")); assertEquals(Collections.singletonMap("moose", true), parser.parseJsonObject(" \t\r\n{ \"moose\"\t: true }\n\n")); } |
### Question:
JsonSerializer { JsonSerializer() throws InstantiationException { throw new InstantiationException("JsonSerializer must not be instantiated directly."); } JsonSerializer(); static void writeJsonText(final Map<?, ?> map, final Appendable out); static String writeJsonTextAsString(final Map<?, ?> map); static void writeJsonText(final Collection<?> collection, final Appendable out); static String writeJsonTextAsString(final Collection<?> collection); static void writeJsonText(final byte[] array, final Appendable out); static String writeJsonTextAsString(final byte[] array); static void writeJsonText(final short[] array, final Appendable out); static String writeJsonTextAsString(final short[] array); static void writeJsonText(final int[] array, final Appendable out); static String writeJsonTextAsString(final int[] array); static void writeJsonText(final long[] array, final Appendable out); static String writeJsonTextAsString(final long[] array); static void writeJsonText(final float[] array, final Appendable out); static String writeJsonTextAsString(final float[] array); static void writeJsonText(final double[] array, final Appendable out); static String writeJsonTextAsString(final double[] array); static void writeJsonText(final boolean[] array, final Appendable out); static String writeJsonTextAsString(final boolean[] array); static void writeJsonText(final char[] array, final Appendable out); static String writeJsonTextAsString(final char[] array); static void writeJsonText(final Object[] array, final Appendable out); static String writeJsonTextAsString(final Object[] array); }### Answer:
@Test void jsonSerializer() { assertThrows(InstantiationException.class, JsonSerializer::new); } |
### Question:
DropwizardApnsClientMetricsListener implements ApnsClientMetricsListener, MetricSet { @Override public void handleWriteFailure(final ApnsClient apnsClient, final long notificationId) { this.stopTimerForNotification(notificationId); this.writeFailures.mark(); } DropwizardApnsClientMetricsListener(); @Override void handleWriteFailure(final ApnsClient apnsClient, final long notificationId); @Override void handleNotificationSent(final ApnsClient apnsClient, final long notificationId); @Override void handleNotificationAccepted(final ApnsClient apnsClient, final long notificationId); @Override void handleNotificationRejected(final ApnsClient apnsClient, final long notificationId); @Override void handleConnectionAdded(final ApnsClient apnsClient); @Override void handleConnectionRemoved(final ApnsClient apnsClient); @Override void handleConnectionCreationFailed(final ApnsClient apnsClient); @Override Map<String, Metric> getMetrics(); static final String NOTIFICATION_TIMER_NAME; static final String WRITE_FAILURES_METER_NAME; static final String SENT_NOTIFICATIONS_METER_NAME; static final String ACCEPTED_NOTIFICATIONS_METER_NAME; static final String REJECTED_NOTIFICATIONS_METER_NAME; static final String OPEN_CONNECTIONS_GAUGE_NAME; static final String CONNECTION_FAILURES_METER_NAME; }### Answer:
@Test public void testHandleWriteFailure() { final Meter writeFailures = (Meter) this.listener.getMetrics().get(DropwizardApnsClientMetricsListener.WRITE_FAILURES_METER_NAME); assertEquals(0, writeFailures.getCount()); this.listener.handleWriteFailure(null, 1); assertEquals(1, writeFailures.getCount()); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.