private IContainerizer CreateMockContainerizer() { ImageReference targetImage = ImageReference.Parse("target-image"); IContainerizer mockContainerizer = Mock.Of <IContainerizer>(); IStepsRunner stepsRunner = Mock.Of <IStepsRunner>(); IBuildResult mockBuildResult = Mock.Of <IBuildResult>(); Mock.Get(mockContainerizer).Setup(m => m.GetImageConfiguration()).Returns(ImageConfiguration.CreateBuilder(targetImage).Build()); Mock.Get(mockContainerizer).Setup(m => m.CreateStepsRunner(It.IsAny <BuildConfiguration>())).Returns(stepsRunner); Mock.Get(stepsRunner).Setup(s => s.RunAsync()).Returns(Task.FromResult(mockBuildResult)); Mock.Get(mockBuildResult).Setup(m => m.GetImageDigest()).Returns( DescriptorDigest.FromHash( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")); Mock.Get(mockBuildResult).Setup(m => m.GetImageId()).Returns( DescriptorDigest.FromHash( "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")); Mock.Get(mockContainerizer).Setup(m => m.GetAdditionalTags()).Returns(new HashSet <string>()); Mock.Get(mockContainerizer).Setup(m => m.GetBaseImageLayersCacheDirectory()).Returns(Paths.Get("/")); Mock.Get(mockContainerizer).Setup(m => m.GetApplicationLayersCacheDirectory()).Returns(Paths.Get("/")); Mock.Get(mockContainerizer).Setup(m => m.GetAllowInsecureRegistries()).Returns(false); Mock.Get(mockContainerizer).Setup(m => m.GetToolName()).Returns("mocktool"); Mock.Get(mockContainerizer).Setup(m => m.BuildEventHandlers()).Returns(EventHandlers.NONE); return(mockContainerizer); }
public async Task TestTag_fail() { DockerClient testDockerClient = new DockerClient( subcommand => { Assert.AreEqual(new[] { "tag", "original", "new" }, subcommand); return(mockProcessBuilder); }); Mock.Get(mockProcess).Setup(m => m.WaitFor()).Returns(1); Mock.Get(mockProcess).Setup(m => m.GetErrorStream()).Returns(new MemoryStream(Encoding.UTF8.GetBytes("error"))); try { ImageReference originalImageReference = ImageReference.Of(null, "original", null); ImageReference newImageReference = ImageReference.Parse("new"); await testDockerClient.TagAsync(originalImageReference, newImageReference).ConfigureAwait(false); Assert.Fail("docker tag should have failed"); } catch (IOException ex) { Assert.AreEqual("'docker tag' command failed with error: error", ex.Message); } }
public void TestToString() { Assert.AreEqual("someimage", ImageReference.Of(null, "someimage", null).ToString()); Assert.AreEqual("someimage", ImageReference.Of("", "someimage", "").ToString()); Assert.AreEqual( "someotherimage", ImageReference.Of(null, "library/someotherimage", null).ToString()); Assert.AreEqual( "someregistry/someotherimage", ImageReference.Of("someregistry", "someotherimage", null).ToString()); Assert.AreEqual( "anotherregistry/anotherimage:sometag", ImageReference.Of("anotherregistry", "anotherimage", "sometag").ToString()); Assert.AreEqual( "someimage@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", ImageReference.Of( null, "someimage", "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").ToString()); Assert.AreEqual( "gcr.io/distroless/java@sha256:b430543bea1d8326e767058bdab3a2482ea45f59d7af5c5c61334cd29ede88a1", ImageReference.Parse( "gcr.io/distroless/java@sha256:b430543bea1d8326e767058bdab3a2482ea45f59d7af5c5c61334cd29ede88a1") .ToString()); }
public void TestParse_dockerHub_official() { const string imageReferenceString = "busybox"; ImageReference imageReference = ImageReference.Parse(imageReferenceString); Assert.AreEqual("registry-1.docker.io", imageReference.GetRegistry()); Assert.AreEqual("library/busybox", imageReference.GetRepository()); Assert.AreEqual("latest", imageReference.GetTag()); }
public void TestParse_dockerHub_user() { const string imageReferenceString = "someuser/someimage"; ImageReference imageReference = ImageReference.Parse(imageReferenceString); Assert.AreEqual("registry-1.docker.io", imageReference.GetRegistry()); Assert.AreEqual("someuser/someimage", imageReference.GetRepository()); Assert.AreEqual("latest", imageReference.GetTag()); }
public void TestCreateContainerizer_CreatesForDockerClient() { var result = new TestableTarCommand { OutputFile = "OutputFile" } .CreateContainerizer(ImageReference.Parse("image-reference")); Assert.AreEqual(Containerizer.DescriptionForImageTarFile, result.GetDescription()); }
public ImageReference GetTargetImageReference() { var targetImageReference = ImageReference.Parse(TargetImage); if (TargetTags?.Count > 0) { targetImageReference = targetImageReference.WithTag(TargetTags[0]); } return(targetImageReference); }
public async Task TestBuildToDockerRegistry_DockerHubBaseImageAsync() { await BuildRegistryImageAsync( ImageReference.Parse("openjdk:8-jre-alpine"), ImageReference.Of("localhost:5000", "testimage", "testtag"), new List <string>()).ConfigureAwait(false); progressChecker.CheckCompletion(); const string imageReference = "localhost:5000/testimage:testtag"; new Command("docker", "pull", imageReference).Run(); Assert.AreEqual( "Hello, world. An argument.\n", new Command("docker", "run", "--rm", imageReference).Run()); }
public void TestIsTagDigest() { Assert.IsFalse(ImageReference.Of(null, "someimage", null).IsTagDigest()); Assert.IsFalse(ImageReference.Of(null, "someimage", "latest").IsTagDigest()); Assert.IsTrue( ImageReference.Of( null, "someimage", "sha256:b430543bea1d8326e767058bdab3a2482ea45f59d7af5c5c61334cd29ede88a1") .IsTagDigest()); Assert.IsTrue( ImageReference.Parse( "someimage@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") .IsTagDigest()); }
public async Task TestTag() { DockerClient testDockerClient = new DockerClient( subcommand => { Assert.AreEqual(new[] { "tag", "original", "new" }, subcommand); return(mockProcessBuilder); }); Mock.Get(mockProcess).Setup(m => m.WaitFor()).Returns(0); ImageReference originalImageReference = ImageReference.Of(null, "original", null); ImageReference newImageReference = ImageReference.Parse("new"); await testDockerClient.TagAsync(originalImageReference, newImageReference).ConfigureAwait(false); }
public void TestParse_invalid() { foreach (string badImageReference in badImageReferences) { try { ImageReference.Parse(badImageReference); Assert.Fail(badImageReference + " should not be a valid image reference"); } catch (InvalidImageReferenceException ex) { Assert.That(ex.Message, Does.Contain(badImageReference)) ; } } }
public async Task TestAuthenticateAsync() { ImageReference dockerHubImageReference = ImageReference.Parse("library/busybox"); RegistryAuthenticator registryAuthenticator = await RegistryClient.CreateFactory( EventHandlers.NONE, dockerHubImageReference.GetRegistry(), dockerHubImageReference.GetRepository()) .NewRegistryClient() .GetRegistryAuthenticatorAsync().ConfigureAwait(false); Assert.IsNotNull(registryAuthenticator); Authorization authorization = await registryAuthenticator.AuthenticatePullAsync(null).ConfigureAwait(false); // Checks that some token was received. Assert.IsTrue(0 < authorization.GetToken().Length); }
public async Task TestWriteMetadata_v21Async() { SystemPath manifestJsonFile = Paths.Get(TestResources.GetResource("core/json/v21manifest.json").ToURI()); V21ManifestTemplate manifestTemplate = JsonTemplateMapper.ReadJsonFromFile <V21ManifestTemplate>(manifestJsonFile); ImageReference imageReference = ImageReference.Parse("image.reference/project/thing:tag"); await new CacheStorageWriter(cacheStorageFiles).WriteMetadataAsync(imageReference, manifestTemplate).ConfigureAwait(false); SystemPath savedManifestPath = cacheRoot.Resolve("images/image.reference/project/thing!tag/manifest.json"); Assert.IsTrue(Files.Exists(savedManifestPath)); V21ManifestTemplate savedManifest = JsonTemplateMapper.ReadJsonFromFile <V21ManifestTemplate>(savedManifestPath); Assert.AreEqual("amd64", savedManifest.GetContainerConfiguration().Get().Architecture); }
private void VerifyParse(string registry, string repository, string tagSeparator, string tag) { // Gets the expected parsed components. string expectedRegistry = registry; if (string.IsNullOrEmpty(expectedRegistry)) { expectedRegistry = "registry-1.docker.io"; } string expectedRepository = repository; if ("registry-1.docker.io" == expectedRegistry && repository.IndexOf('/', StringComparison.Ordinal) < 0) { expectedRepository = "library/" + expectedRepository; } string expectedTag = tag; if (string.IsNullOrEmpty(expectedTag)) { expectedTag = "latest"; } // Builds the image reference to parse. StringBuilder imageReferenceBuilder = new StringBuilder(); if (!string.IsNullOrEmpty(registry)) { imageReferenceBuilder.Append(registry).Append('/'); } imageReferenceBuilder.Append(repository); if (!string.IsNullOrEmpty(tag)) { imageReferenceBuilder.Append(tagSeparator).Append(tag); } ImageReference imageReference = ImageReference.Parse(imageReferenceBuilder.ToString()); Assert.AreEqual(expectedRegistry, imageReference.GetRegistry()); Assert.AreEqual(expectedRepository, imageReference.GetRepository()); Assert.AreEqual(expectedTag, imageReference.GetTag()); }
public void TestGetImageDirectory() { SystemPath imagesDirectory = Paths.Get("cache", "directory", "images"); Assert.AreEqual(imagesDirectory, TEST_CACHE_STORAGE_FILES.GetImagesDirectory()); Assert.AreEqual( imagesDirectory.Resolve("reg.istry/repo/sitory!tag"), TEST_CACHE_STORAGE_FILES.GetImageDirectory( ImageReference.Parse("reg.istry/repo/sitory:tag"))); Assert.AreEqual( imagesDirectory.Resolve( "reg.istry/repo!sha256!aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), TEST_CACHE_STORAGE_FILES.GetImageDirectory( ImageReference.Parse( "reg.istry/repo@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))); Assert.AreEqual( imagesDirectory.Resolve("reg.istry!5000/repo/sitory!tag"), TEST_CACHE_STORAGE_FILES.GetImageDirectory( ImageReference.Parse("reg.istry:5000/repo/sitory:tag"))); }
public async Task TestWriteMetadata_v22Async() { SystemPath containerConfigurationJsonFile = Paths.Get( TestResources.GetResource("core/json/containerconfig.json").ToURI()); ContainerConfigurationTemplate containerConfigurationTemplate = JsonTemplateMapper.ReadJsonFromFile <ContainerConfigurationTemplate>( containerConfigurationJsonFile); SystemPath manifestJsonFile = Paths.Get(TestResources.GetResource("core/json/v22manifest.json").ToURI()); IBuildableManifestTemplate manifestTemplate = JsonTemplateMapper.ReadJsonFromFile <V22ManifestTemplate>(manifestJsonFile); ImageReference imageReference = ImageReference.Parse("image.reference/project/thing:tag"); await new CacheStorageWriter(cacheStorageFiles) .WriteMetadataAsync(imageReference, manifestTemplate, containerConfigurationTemplate).ConfigureAwait(false); SystemPath savedManifestPath = cacheRoot.Resolve("images/image.reference/project/thing!tag/manifest.json"); SystemPath savedConfigPath = cacheRoot.Resolve("images/image.reference/project/thing!tag/config.json"); Assert.IsTrue(Files.Exists(savedManifestPath)); Assert.IsTrue(Files.Exists(savedConfigPath)); V22ManifestTemplate savedManifest = JsonTemplateMapper.ReadJsonFromFile <V22ManifestTemplate>(savedManifestPath); Assert.AreEqual( "8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad", savedManifest.GetContainerConfiguration().Digest.GetHash()); ContainerConfigurationTemplate savedContainerConfig = JsonTemplateMapper.ReadJsonFromFile <ContainerConfigurationTemplate>(savedConfigPath); Assert.AreEqual("wasm", savedContainerConfig.Architecture); }
public async Task TestWriteToAsync() { SystemPath fileA = Paths.Get(TestResources.GetResource("core/fileA").ToURI()); SystemPath fileB = Paths.Get(TestResources.GetResource("core/fileB").ToURI()); long fileASize = Files.Size(fileA); long fileBSize = Files.Size(fileB); DescriptorDigest fakeDigestA = DescriptorDigest.FromHash( "5994471abb01112afcc18159f6cc74b4f511b99806da59b3caf5a9c173cacfc5"); DescriptorDigest fakeDigestB = DescriptorDigest.FromHash( "5994471abb01112afcc18159f6cc74b4f511b99806da59b3caf5a9c173cacfc6"); Mock.Get(mockLayer1).Setup(m => m.GetBlob()).Returns(Blobs.From(fileA)); Mock.Get(mockLayer1).Setup(m => m.GetBlobDescriptor()).Returns(new BlobDescriptor(fileASize, fakeDigestA)); Mock.Get(mockLayer1).Setup(m => m.GetDiffId()).Returns(fakeDigestA); Mock.Get(mockLayer2).Setup(m => m.GetBlob()).Returns(Blobs.From(fileB)); Mock.Get(mockLayer2).Setup(m => m.GetBlobDescriptor()).Returns(new BlobDescriptor(fileBSize, fakeDigestB)); Mock.Get(mockLayer2).Setup(m => m.GetDiffId()).Returns(fakeDigestB); Image testImage = Image.CreateBuilder(ManifestFormat.V22).AddLayer(mockLayer1).AddLayer(mockLayer2).Build(); ImageTarball imageToTarball = new ImageTarball(testImage, ImageReference.Parse("my/image:tag")); MemoryStream @out = new MemoryStream(); await imageToTarball.WriteToAsync(@out).ConfigureAwait(false); MemoryStream @in = new MemoryStream(@out.ToArray()); using (TarInputStream tarArchiveInputStream = new TarInputStream(@in)) { // Verifies layer with fileA was added. TarEntry headerFileALayer = tarArchiveInputStream.GetNextEntry(); Assert.AreEqual(fakeDigestA.GetHash() + ".tar.gz", headerFileALayer.Name); string fileAString = await new StreamReader(tarArchiveInputStream).ReadToEndAsync().ConfigureAwait(false); Assert.AreEqual(await Blobs.WriteToStringAsync(Blobs.From(fileA)).ConfigureAwait(false), fileAString); // Verifies layer with fileB was added. TarEntry headerFileBLayer = tarArchiveInputStream.GetNextEntry(); Assert.AreEqual(fakeDigestB.GetHash() + ".tar.gz", headerFileBLayer.Name); string fileBString = await new StreamReader(tarArchiveInputStream).ReadToEndAsync().ConfigureAwait(false); Assert.AreEqual(await Blobs.WriteToStringAsync(Blobs.From(fileB)).ConfigureAwait(false), fileBString); // Verifies container configuration was added. TarEntry headerContainerConfiguration = tarArchiveInputStream.GetNextEntry(); Assert.AreEqual("config.json", headerContainerConfiguration.Name); string containerConfigJson = await new StreamReader(tarArchiveInputStream).ReadToEndAsync().ConfigureAwait(false); JsonTemplateMapper.ReadJson <ContainerConfigurationTemplate>(containerConfigJson); // Verifies manifest was added. TarEntry headerManifest = tarArchiveInputStream.GetNextEntry(); Assert.AreEqual("manifest.json", headerManifest.Name); string manifestJson = await new StreamReader(tarArchiveInputStream).ReadToEndAsync().ConfigureAwait(false); JsonTemplateMapper.ReadListOfJson <DockerLoadManifestEntryTemplate>(manifestJson); } }
public void TestCreateContainerizer_CreatesForDockerClient() { var result = new TestableDaemonCommand().CreateContainerizer(ImageReference.Parse("image-reference")); Assert.AreEqual(Containerizer.DescriptionForDockerDaemon, result.GetDescription()); }