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());
}
