public void GetManifestDigestSha(string tag, ManifestMediaType mediaType, string expectedDigestSha, Type expectedExceptionType = null)
        {
            Mock <IManifestToolService> manifestToolService = new Mock <IManifestToolService>();

            manifestToolService
            .Setup(o => o.Inspect("tag1", false))
            .Returns(ManifestToolServiceHelper.CreateTagManifest(ManifestToolService.ManifestMediaType, ManifestDigest));
            manifestToolService
            .Setup(o => o.Inspect("tag2", false))
            .Returns(ManifestToolServiceHelper.CreateTagManifest(ManifestToolService.ManifestListMediaType, ManifestListDigest));

            if (expectedExceptionType is null)
            {
                string digestSha = ManifestToolServiceExtensions.GetManifestDigestSha(
                    manifestToolService.Object,
                    mediaType,
                    tag,
                    false);
                Assert.Equal(expectedDigestSha, digestSha);
            }
            else
            {
                Assert.Throws(expectedExceptionType, () =>
                {
                    ManifestToolServiceExtensions.GetManifestDigestSha(
                        manifestToolService.Object,
                        mediaType,
                        tag,
                        false);
                });
            }
        }
Example #2
0
        public async Task SyndicatedTag()
        {
            string expectedManifest1 =
                @"image: mcr.microsoft.com/repo:sharedtag2
tags: [sharedtag1]
manifests:
- image: mcr.microsoft.com/repo:tag1
  platform:
    architecture: amd64
    os: linux
";

            string expectedManifest2 =
                @"image: mcr.microsoft.com/repo2:sharedtag2a
tags: [sharedtag2b]
manifests:
- image: mcr.microsoft.com/repo2:tag2
  platform:
    architecture: amd64
    os: linux
";

            bool manifest1Found = false;
            bool manifest2Found = false;

            Mock <IManifestToolService> manifestToolService = new Mock <IManifestToolService>();

            manifestToolService
            .Setup(o => o.PushFromSpec(It.IsAny <string>(), false))
            .Callback((string manifestFile, bool isDryRun) =>
            {
                string manifestContents = File.ReadAllText(manifestFile);

                if (manifestContents == expectedManifest1)
                {
                    manifest1Found = true;
                }
                else if (manifestContents == expectedManifest2)
                {
                    manifest2Found = true;
                }
            });

            manifestToolService
            .Setup(o => o.Inspect(It.IsAny <string>(), false))
            .Returns(ManifestToolServiceHelper.CreateTagManifest(ManifestToolService.ManifestListMediaType, "digest"));

            PublishManifestCommand command = new PublishManifestCommand(
                manifestToolService.Object, Mock.Of <ILoggerService>());

            using TempFolderContext tempFolderContext = new TempFolderContext();

            command.Options.Manifest      = Path.Combine(tempFolderContext.Path, "manifest.json");
            command.Options.ImageInfoPath = Path.Combine(tempFolderContext.Path, "image-info.json");

            string dockerfile = CreateDockerfile("1.0/repo/os", tempFolderContext);

            ImageArtifactDetails imageArtifactDetails = new ImageArtifactDetails
            {
                Repos =
                {
                    new RepoData
                    {
                        Repo   = "repo",
                        Images =
                        {
                            new ImageData
                            {
                                Platforms =
                                {
                                    CreatePlatform(dockerfile,
                                                   simpleTags: new List <string>
                                    {
                                        "tag1",
                                        "tag2"
                                    })
                                },
                                Manifest = new ManifestData
                                {
                                    SharedTags =
                                    {
                                        "sharedtag1",
                                        "sharedtag2"
                                    }
                                }
                            }
                        }
                    }
                }
            };

            File.WriteAllText(command.Options.ImageInfoPath, JsonHelper.SerializeObject(imageArtifactDetails));

            const string syndicatedRepo2 = "repo2";

            Platform platform;

            Manifest manifest = CreateManifest(
                CreateRepo("repo",
                           CreateImage(
                               new Platform[]
            {
                platform = CreatePlatform(dockerfile, Array.Empty <string>())
            },
                               new Dictionary <string, Tag>
            {
                {
                    "sharedtag2",
                    new Tag
                    {
                        Syndication = new TagSyndication
                        {
                            Repo            = syndicatedRepo2,
                            DestinationTags = new string[]
                            {
                                "sharedtag2a",
                                "sharedtag2b"
                            }
                        }
                    }
                },
                { "sharedtag1", new Tag() }
            }))
                );

            manifest.Registry = "mcr.microsoft.com";
            platform.Tags     = new Dictionary <string, Tag>
            {
                { "tag1", new Tag() },
                { "tag2", new Tag
                  {
                      Syndication = new TagSyndication
                      {
                          Repo            = syndicatedRepo2,
                          DestinationTags = new string[]
                          {
                              "tag2"
                          }
                      }
                  } },
            };

            File.WriteAllText(command.Options.Manifest, JsonHelper.SerializeObject(manifest));

            command.LoadManifest();
            await command.ExecuteAsync();

            Assert.True(manifest1Found);
            Assert.True(manifest2Found);
            manifestToolService
            .Verify(o => o.PushFromSpec(It.IsAny <string>(), false), Times.Exactly(2));
        }
Example #3
0
        public async Task ImageInfoTagOutput()
        {
            Mock <IManifestToolService> manifestToolService = new Mock <IManifestToolService>();

            manifestToolService
            .Setup(o => o.Inspect("repo1:sharedtag2", false))
            .Returns(ManifestToolServiceHelper.CreateTagManifest(ManifestToolService.ManifestListMediaType, "digest1"));
            manifestToolService
            .Setup(o => o.Inspect("repo2:sharedtag3", false))
            .Returns(ManifestToolServiceHelper.CreateTagManifest(ManifestToolService.ManifestListMediaType, "digest2"));

            PublishManifestCommand command = new PublishManifestCommand(
                manifestToolService.Object, Mock.Of <ILoggerService>());

            using TempFolderContext tempFolderContext = new TempFolderContext();

            command.Options.Manifest      = Path.Combine(tempFolderContext.Path, "manifest.json");
            command.Options.ImageInfoPath = Path.Combine(tempFolderContext.Path, "image-info.json");

            string dockerfile1 = CreateDockerfile("1.0/repo1/os", tempFolderContext);
            string dockerfile2 = CreateDockerfile("1.0/repo2/os", tempFolderContext);
            string dockerfile3 = CreateDockerfile("1.0/repo3/os", tempFolderContext);

            ImageArtifactDetails imageArtifactDetails = new ImageArtifactDetails
            {
                Repos =
                {
                    new RepoData
                    {
                        Repo   = "repo1",
                        Images =
                        {
                            new ImageData
                            {
                                Platforms =
                                {
                                    CreatePlatform(dockerfile1),
                                    new PlatformData
                                    {
                                    }
                                },
                                Manifest = new ManifestData
                                {
                                    SharedTags =
                                    {
                                        "sharedtag1",
                                        "sharedtag2"
                                    }
                                }
                            }
                        }
                    },
                    new RepoData
                    {
                        Repo   = "repo2",
                        Images =
                        {
                            new ImageData
                            {
                                Platforms =
                                {
                                    CreatePlatform(dockerfile2)
                                },
                                Manifest = new ManifestData
                                {
                                    SharedTags =
                                    {
                                        "sharedtag1",
                                        "sharedtag3"
                                    }
                                }
                            }
                        }
                    },
                    new RepoData
                    {
                        Repo   = "repo3",
                        Images =
                        {
                            new ImageData
                            {
                                Platforms =
                                {
                                    CreatePlatform(dockerfile3)
                                }
                            }
                        }
                    }
                }
            };

            File.WriteAllText(command.Options.ImageInfoPath, JsonHelper.SerializeObject(imageArtifactDetails));

            Manifest manifest = CreateManifest(
                CreateRepo("repo1",
                           CreateImage(
                               new Platform[]
            {
                CreatePlatform(dockerfile1, new string[] { "tag1" })
            },
                               new Dictionary <string, Tag>
            {
                { "sharedtag2", new Tag() },
                { "sharedtag1", new Tag() }
            })),
                CreateRepo("repo2",
                           CreateImage(
                               new Platform[]
            {
                CreatePlatform(dockerfile2, new string[] { "tag2" })
            },
                               new Dictionary <string, Tag>
            {
                { "sharedtag3", new Tag() },
                { "sharedtag1", new Tag() }
            })),
                CreateRepo("repo3",
                           CreateImage(
                               new Platform[]
            {
                CreatePlatform(dockerfile3, new string[] { "tag3" })
            })),
                CreateRepo("unpublishedrepo",
                           CreateImage(
                               new Platform[]
            {
                CreatePlatform(
                    CreateDockerfile("1.0/unpublishedrepo/os", tempFolderContext),
                    new string[] { "tag" })
            },
                               new Dictionary <string, Tag>
            {
                { "sharedtag", new Tag() }
            }))
                );

            File.WriteAllText(command.Options.Manifest, JsonHelper.SerializeObject(manifest));

            command.LoadManifest();
            await command.ExecuteAsync();

            string actualOutput = File.ReadAllText(command.Options.ImageInfoPath);

            ImageArtifactDetails actualImageArtifactDetails = JsonConvert.DeserializeObject <ImageArtifactDetails>(actualOutput);

            // Since we don't know what the exact Created time will be that the command has calculated, we're going to
            // pull it from the data, verify that it's recent and then use it for constructing our expected data value.
            DateTime actualCreatedDate = actualImageArtifactDetails.Repos[0].Images[0].Manifest.Created;

            Assert.True(actualCreatedDate > (DateTime.Now.ToUniversalTime() - TimeSpan.FromMinutes(1)));
            Assert.True(actualCreatedDate < (DateTime.Now.ToUniversalTime() + TimeSpan.FromMinutes(1)));

            imageArtifactDetails.Repos[0].Images[0].Manifest.Digest  = "repo1@digest1";
            imageArtifactDetails.Repos[0].Images[0].Manifest.Created = actualCreatedDate;
            imageArtifactDetails.Repos[1].Images[0].Manifest.Digest  = "repo2@digest2";
            imageArtifactDetails.Repos[1].Images[0].Manifest.Created = actualCreatedDate;

            string expectedOutput = JsonHelper.SerializeObject(imageArtifactDetails);

            Assert.Equal(expectedOutput, actualOutput);
        }