public void TestPortMapToList() { ImmutableSortedDictionary <string, IDictionary <object, object> > input = new Dictionary <string, IDictionary <object, object> > { ["1000"] = ImmutableDictionary.Create <object, object>(), ["2000/tcp"] = ImmutableDictionary.Create <object, object>(), ["3000/udp"] = ImmutableDictionary.Create <object, object>() }.ToImmutableSortedDictionary(); ImmutableHashSet <Port> expected = ImmutableHashSet.Create(Port.Tcp(1000), Port.Tcp(2000), Port.Udp(3000)); Assert.AreEqual(expected, JsonToImageTranslator.PortMapToSet(input)); ImmutableArray <IDictionary <string, IDictionary <object, object> > > badInputs = ImmutableArray.Create <IDictionary <string, IDictionary <object, object> > >( ImmutableDic.Of <string, IDictionary <object, object> >("abc", ImmutableDictionary.Create <object, object>()), ImmutableDic.Of <string, IDictionary <object, object> >("1000-2000", ImmutableDictionary.Create <object, object>()), ImmutableDic.Of <string, IDictionary <object, object> >("/udp", ImmutableDictionary.Create <object, object>()), ImmutableDic.Of <string, IDictionary <object, object> >("123/xxx", ImmutableDictionary.Create <object, object>())); foreach (IDictionary <string, IDictionary <object, object> > badInput in badInputs) { try { JsonToImageTranslator.PortMapToSet(badInput); Assert.Fail(); } catch (BadContainerConfigurationFormatException) { } } }
public void TestVolumeMapToList() { ImmutableSortedDictionary <string, IDictionary <object, object> > input = new Dictionary <string, IDictionary <object, object> > { ["/var/job-result-data"] = ImmutableDictionary.Create <object, object>(), ["/var/log/my-app-logs"] = ImmutableDictionary.Create <object, object>() }.ToImmutableSortedDictionary(); ImmutableHashSet <AbsoluteUnixPath> expected = ImmutableHashSet.Create( AbsoluteUnixPath.Get("/var/job-result-data"), AbsoluteUnixPath.Get("/var/log/my-app-logs")); Assert.AreEqual(expected, JsonToImageTranslator.VolumeMapToSet(input)); ImmutableArray <IDictionary <string, IDictionary <object, object> > > badInputs = ImmutableArray.Create <IDictionary <string, IDictionary <object, object> > >( ImmutableDic.Of <string, IDictionary <object, object> >("var/job-result-data", ImmutableDictionary.Create <object, object>()), ImmutableDic.Of <string, IDictionary <object, object> >("log", ImmutableDictionary.Create <object, object>()), ImmutableDic.Of <string, IDictionary <object, object> >("C:/udp", ImmutableDictionary.Create <object, object>())); foreach (IDictionary <string, IDictionary <object, object> > badInput in badInputs) { try { JsonToImageTranslator.VolumeMapToSet(badInput); Assert.Fail(); } catch (BadContainerConfigurationFormatException) { } } }
public void TestEnvironmentMapToList() { ImmutableDictionary <string, string> input = ImmutableDic.Of("NAME1", "VALUE1", "NAME2", "VALUE2"); ImmutableArray <string> expected = ImmutableArray.Create("NAME1=VALUE1", "NAME2=VALUE2"); CollectionAssert.AreEqual(expected, ImageToJsonTranslator.EnvironmentMapToList(input)); }
public void TestToBuildConfiguration_containerConfigurationAdd() { FibContainerBuilder fibContainerBuilder = new FibContainerBuilder(RegistryImage.Named("base/image"), buildConfigurationBuilder) .SetEntrypoint("entry", "point") .SetEnvironment(ImmutableDic.Of("name", "value")) .AddEnvironmentVariable("environment", "variable") .SetExposedPorts(Port.Tcp(1234), Port.Udp(5678)) .AddExposedPort(Port.Tcp(1337)) .SetLabels(ImmutableDic.Of("key", "value")) .AddLabel("added", "label") .SetProgramArguments("program", "arguments"); BuildConfiguration buildConfiguration = fibContainerBuilder.ToBuildConfiguration( Containerizer.To(RegistryImage.Named("target/image"))); IContainerConfiguration containerConfiguration = buildConfiguration.GetContainerConfiguration(); Assert.AreEqual(new[] { "entry", "point" }, containerConfiguration.GetEntrypoint()); Assert.AreEqual( ImmutableDic.Of("name", "value", "environment", "variable"), containerConfiguration.GetEnvironmentMap()); Assert.AreEqual( ImmutableHashSet.Create(Port.Tcp(1234), Port.Udp(5678), Port.Tcp(1337)), containerConfiguration.GetExposedPorts()); Assert.AreEqual( ImmutableDic.Of("key", "value", "added", "label"), containerConfiguration.GetLabels()); Assert.AreEqual( new[] { "program", "arguments" }, containerConfiguration.GetProgramArguments()); Assert.AreEqual(Instant.FromUnixTimeSeconds(0), containerConfiguration.GetCreationTime()); }
private async Task <FibContainer> BuildImageAsync( ImageReference baseImage, Containerizer containerizer, IList <string> additionalTags) { FibContainerBuilder containerBuilder = FibContainerBuilder.From(baseImage) .SetEntrypoint(new[] { "java", "-cp", "/app/resources:/app/classes:/app/libs/*", "HelloWorld" }) .SetProgramArguments(new List <string> { "An argument." }) .SetEnvironment(ImmutableDic.Of("env1", "envvalue1", "env2", "envvalue2")) .SetExposedPorts(Port.Parse(new[] { "1000", "2000-2002/tcp", "3000/udp" })) .SetLabels(ImmutableDic.Of("key1", "value1", "key2", "value2")) .SetLayers(fakeLayerConfigurations); SystemPath cacheDirectory = temporaryFolder.NewFolder().ToPath(); containerizer .SetBaseImageLayersCache(cacheDirectory) .SetApplicationLayersCache(cacheDirectory) .SetAllowInsecureRegistries(true) .SetToolName("fib-integration-test") .AddEventHandler <ProgressEvent>(progressChecker.progressEventHandler.Accept); foreach (string i in additionalTags) { containerizer.WithAdditionalTag(i); } return(await containerBuilder.ContainerizeAsync(containerizer).ConfigureAwait(false)); }
public void Test_smokeTest() { Image image = Image.CreateBuilder(ManifestFormat.V22) .SetCreated(Instant.FromUnixTimeSeconds(10000)) .AddEnvironmentVariable("crepecake", "is great") .AddEnvironmentVariable("VARIABLE", "VALUE") .SetEntrypoint(new[] { "some", "command" }) .SetProgramArguments(new[] { "arg1", "arg2" }) .AddExposedPorts(ImmutableHashSet.Create(Port.Tcp(1000), Port.Tcp(2000))) .AddVolumes( ImmutableHashSet.Create( AbsoluteUnixPath.Get("/a/path"), AbsoluteUnixPath.Get("/another/path"))) .SetUser("john") .AddLayer(mockLayer) .Build(); Assert.AreEqual(ManifestFormat.V22, image.GetImageFormat()); Assert.AreEqual( mockDescriptorDigest, image.GetLayers()[0].GetBlobDescriptor().GetDigest()); Assert.AreEqual(Instant.FromUnixTimeSeconds(10000), image.GetCreated()); Assert.AreEqual( ImmutableDic.Of("crepecake", "is great", "VARIABLE", "VALUE"), image.GetEnvironment()); Assert.AreEqual(new[] { "some", "command" }, image.GetEntrypoint()); Assert.AreEqual(new[] { "arg1", "arg2" }, image.GetProgramArguments()); Assert.AreEqual(ImmutableHashSet.Create(Port.Tcp(1000), Port.Tcp(2000)), image.GetExposedPorts()); Assert.AreEqual( ImmutableHashSet.Create(AbsoluteUnixPath.Get("/a/path"), AbsoluteUnixPath.Get("/another/path")), image.GetVolumes()); Assert.AreEqual("john", image.GetUser()); }
public void TestToJson() { // Loads the expected JSON string. SystemPath jsonFile = Paths.Get(TestResources.GetResource("core/json/containerconfig.json").ToURI()); string expectedJson = Encoding.UTF8.GetString(Files.ReadAllBytes(jsonFile)); // Creates the JSON object to serialize. ContainerConfigurationTemplate containerConfigJson = new ContainerConfigurationTemplate { Created = "1970-01-01T00:00:20Z", Architecture = "wasm", Os = "js" }; containerConfigJson.SetContainerEnvironment(new[] { "VAR1=VAL1", "VAR2=VAL2" }); containerConfigJson.SetContainerEntrypoint(new[] { "some", "entrypoint", "command" }); containerConfigJson.SetContainerCmd(new[] { "arg1", "arg2" }); containerConfigJson.SetContainerHealthCheckTest(new[] { "CMD-SHELL", "/checkhealth" }); containerConfigJson.SetContainerHealthCheckInterval(3000000000L); containerConfigJson.SetContainerHealthCheckTimeout(1000000000L); containerConfigJson.SetContainerHealthCheckStartPeriod(2000000000L); containerConfigJson.SetContainerHealthCheckRetries(3); containerConfigJson.SetContainerExposedPorts( new Dictionary <string, IDictionary <object, object> > { ["1000/tcp"] = ImmutableDictionary.Create <object, object>(), ["2000/tcp"] = ImmutableDictionary.Create <object, object>(), ["3000/udp"] = ImmutableDictionary.Create <object, object>() }.ToImmutableSortedDictionary()); containerConfigJson.SetContainerLabels(ImmutableDic.Of("key1", "value1", "key2", "value2")); containerConfigJson.SetContainerVolumes( ImmutableDic.Of <string, IDictionary <object, object> >( "/var/job-result-data", ImmutableDictionary.Create <object, object>(), "/var/log/my-app-logs", ImmutableDictionary.Create <object, object>())); containerConfigJson.SetContainerWorkingDir("/some/workspace"); containerConfigJson.SetContainerUser("tomcat"); containerConfigJson.AddLayerDiffId( DescriptorDigest.FromDigest( "sha256:8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad")); containerConfigJson.AddHistoryEntry( HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(0)) .SetAuthor("Bazel") .SetCreatedBy("bazel build ...") .SetEmptyLayer(true) .Build()); containerConfigJson.AddHistoryEntry( HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(20)) .SetAuthor("Fib") .SetCreatedBy("fib") .Build()); // Serializes the JSON object. Assert.AreEqual(expectedJson, JsonTemplateMapper.ToUtf8String(containerConfigJson)); }
public void TestFromJson() { // Loads the JSON string. SystemPath jsonFile = Paths.Get(TestResources.GetResource("core/json/containerconfig.json").ToURI()); // Deserializes into a manifest JSON object. ContainerConfigurationTemplate containerConfigJson = JsonTemplateMapper.ReadJsonFromFile <ContainerConfigurationTemplate>(jsonFile); Assert.AreEqual("1970-01-01T00:00:20Z", containerConfigJson.Created); Assert.AreEqual("wasm", containerConfigJson.Architecture); Assert.AreEqual("js", containerConfigJson.Os); Assert.AreEqual( new[] { "VAR1=VAL1", "VAR2=VAL2" }, containerConfigJson.GetContainerEnvironment()); Assert.AreEqual( new[] { "some", "entrypoint", "command" }, containerConfigJson.GetContainerEntrypoint()); Assert.AreEqual(new[] { "arg1", "arg2" }, containerConfigJson.GetContainerCmd()); Assert.AreEqual( new[] { "CMD-SHELL", "/checkhealth" }, containerConfigJson.GetContainerHealthTest()); Assert.IsNotNull(containerConfigJson.GetContainerHealthInterval()); Assert.AreEqual(3000000000L, containerConfigJson.GetContainerHealthInterval().GetValueOrDefault()); Assert.IsNotNull(containerConfigJson.GetContainerHealthTimeout()); Assert.AreEqual(1000000000L, containerConfigJson.GetContainerHealthTimeout().GetValueOrDefault()); Assert.IsNotNull(containerConfigJson.GetContainerHealthStartPeriod()); Assert.AreEqual( 2000000000L, containerConfigJson.GetContainerHealthStartPeriod().GetValueOrDefault()); Assert.IsNotNull(containerConfigJson.GetContainerHealthRetries()); Assert.AreEqual(3, containerConfigJson.GetContainerHealthRetries().GetValueOrDefault()); Assert.AreEqual( ImmutableDic.Of("key1", "value1", "key2", "value2"), containerConfigJson.GetContainerLabels()); Assert.AreEqual("/some/workspace", containerConfigJson.GetContainerWorkingDir()); Assert.AreEqual( DescriptorDigest.FromDigest( "sha256:8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad"), containerConfigJson.GetLayerDiffId(0)); Assert.AreEqual( ImmutableArray.Create( HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(0)) .SetAuthor("Bazel") .SetCreatedBy("bazel build ...") .SetEmptyLayer(true) .Build(), HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(20)) .SetAuthor("Fib") .SetCreatedBy("fib") .Build()), containerConfigJson.History); }
//private static DescriptorDigest fakeDigest = DescriptorDigest.fromHash(new string('a', 64)); private void SetUp(ManifestFormat imageFormat) { Image.Builder testImageBuilder = Image.CreateBuilder(imageFormat) .SetCreated(Instant.FromUnixTimeSeconds(20)) .SetArchitecture("wasm") .SetOs("js") .AddEnvironmentVariable("VAR1", "VAL1") .AddEnvironmentVariable("VAR2", "VAL2") .SetEntrypoint(new[] { "some", "entrypoint", "command" }) .SetProgramArguments(new[] { "arg1", "arg2" }) .SetHealthCheck( DockerHealthCheck.FromCommand(ImmutableArray.Create("CMD-SHELL", "/checkhealth")) .SetInterval(Duration.FromSeconds(3)) .SetTimeout(Duration.FromSeconds(1)) .SetStartPeriod(Duration.FromSeconds(2)) .SetRetries(3) .Build()) .AddExposedPorts(ImmutableHashSet.Create(Port.Tcp(1000), Port.Tcp(2000), Port.Udp(3000))) .AddVolumes( ImmutableHashSet.Create( AbsoluteUnixPath.Get("/var/job-result-data"), AbsoluteUnixPath.Get("/var/log/my-app-logs"))) .AddLabels(ImmutableDic.Of("key1", "value1", "key2", "value2")) .SetWorkingDirectory("/some/workspace") .SetUser("tomcat"); DescriptorDigest fakeDigest = DescriptorDigest.FromDigest( "sha256:8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad"); testImageBuilder.AddLayer( new FakeLayer(fakeDigest)); testImageBuilder.AddHistory( HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(0)) .SetAuthor("Bazel") .SetCreatedBy("bazel build ...") .SetEmptyLayer(true) .Build()); testImageBuilder.AddHistory( HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(20)) .SetAuthor("Fib") .SetCreatedBy("fib") .Build()); imageToJsonTranslator = new ImageToJsonTranslator(testImageBuilder.Build()); }
public async Task TestContainerize_configuredExecutorAsync() { FibContainerBuilder fibContainerBuilder = new FibContainerBuilder(RegistryImage.Named("base/image"), buildConfigurationBuilder) .SetEntrypoint(new[] { "entry", "point" }) .SetEnvironment(ImmutableDic.Of("name", "value")) .SetExposedPorts(ImmutableHashSet.Create(Port.Tcp(1234), Port.Udp(5678))) .SetLabels(ImmutableDic.Of("key", "value")) .SetProgramArguments(new[] { "program", "arguments" }) .SetCreationTime(DateTimeOffset.FromUnixTimeMilliseconds(1000)) .SetUser("user") .SetWorkingDirectory(AbsoluteUnixPath.Get("/working/directory")); IContainerizer mockContainerizer = CreateMockContainerizer(); await fibContainerBuilder.ContainerizeAsync(mockContainerizer).ConfigureAwait(false); }
public void TestDefaultProcessorBuilderFactory_customEnvironment() { ImmutableDictionary <string, string> environment = ImmutableDic.Of("Key1", "Value1"); var expectedEnvironment = new Dictionary <string, string>( Environment.GetEnvironmentVariables() .Cast <DictionaryEntry>() .Select(e => new KeyValuePair <string, string>(e.Key?.ToString(), e.Value?.ToString()))) { ["Key1"] = "Value1" }; ProcessBuilder processBuilder = DockerClient.DefaultProcessBuilderFactory("docker", environment)(new List <string>()); CollectionAssert.AreEquivalent(expectedEnvironment, processBuilder.GetEnvironment()); }
public void TestBuilder() { const string expectedBaseImageServerUrl = "someserver"; const string expectedBaseImageName = "baseimage"; const string expectedBaseImageTag = "baseimagetag"; const string expectedTargetServerUrl = "someotherserver"; const string expectedTargetImageName = "targetimage"; const string expectedTargetTag = "targettag"; ISet <string> additionalTargetImageTags = ImmutableHashSet.Create("tag1", "tag2", "tag3"); ISet <string> expectedTargetImageTags = ImmutableHashSet.Create("targettag", "tag1", "tag2", "tag3"); IList <CredentialRetriever> credentialRetrievers = new List <CredentialRetriever> { () => Maybe.Of(Credential.From("username", "password")) }; Instant expectedCreationTime = Instant.FromUnixTimeSeconds(10000); IList <string> expectedEntrypoint = new[] { "some", "entrypoint" }; IList <string> expectedProgramArguments = new[] { "arg1", "arg2" }; IDictionary <string, string> expectedEnvironment = ImmutableDic.Of("key", "value"); ImmutableHashSet <Port> expectedExposedPorts = ImmutableHashSet.Create(Port.Tcp(1000), Port.Tcp(2000)); IDictionary <string, string> expectedLabels = ImmutableDic.Of("key1", "value1", "key2", "value2"); const ManifestFormat expectedTargetFormat = ManifestFormat.OCI; SystemPath expectedApplicationLayersCacheDirectory = Paths.Get("application/layers"); SystemPath expectedBaseImageLayersCacheDirectory = Paths.Get("base/image/layers"); IList <ILayerConfiguration> expectedLayerConfigurations = new List <ILayerConfiguration> { LayerConfiguration.CreateBuilder() .AddEntry(Paths.Get("sourceFile"), AbsoluteUnixPath.Get("/path/in/container")) .Build() }; const string expectedCreatedBy = "createdBy"; ImageConfiguration baseImageConfiguration = ImageConfiguration.CreateBuilder( ImageReference.Of( expectedBaseImageServerUrl, expectedBaseImageName, expectedBaseImageTag)) .Build(); ImageConfiguration targetImageConfiguration = ImageConfiguration.CreateBuilder( ImageReference.Of( expectedTargetServerUrl, expectedTargetImageName, expectedTargetTag)) .SetCredentialRetrievers(credentialRetrievers) .Build(); ContainerConfiguration containerConfiguration = ContainerConfiguration.CreateBuilder() .SetCreationTime(expectedCreationTime) .SetEntrypoint(expectedEntrypoint) .SetProgramArguments(expectedProgramArguments) .SetEnvironment(expectedEnvironment) .SetExposedPorts(expectedExposedPorts) .SetLabels(expectedLabels) .Build(); BuildConfiguration.Builder buildConfigurationBuilder = BuildConfiguration.CreateBuilder() .SetBaseImageConfiguration(baseImageConfiguration) .SetTargetImageConfiguration(targetImageConfiguration) .SetAdditionalTargetImageTags(additionalTargetImageTags) .SetContainerConfiguration(containerConfiguration) .SetApplicationLayersCacheDirectory(expectedApplicationLayersCacheDirectory) .SetBaseImageLayersCacheDirectory(expectedBaseImageLayersCacheDirectory) .SetTargetFormat(ImageFormat.OCI) .SetAllowInsecureRegistries(true) .SetLayerConfigurations(expectedLayerConfigurations) .SetToolName(expectedCreatedBy); BuildConfiguration buildConfiguration = buildConfigurationBuilder.Build(); Assert.IsNotNull(buildConfiguration.GetContainerConfiguration()); Assert.AreEqual( expectedCreationTime, buildConfiguration.GetContainerConfiguration().GetCreationTime()); Assert.AreEqual( expectedBaseImageServerUrl, buildConfiguration.GetBaseImageConfiguration().GetImageRegistry()); Assert.AreEqual( expectedBaseImageName, buildConfiguration.GetBaseImageConfiguration().GetImageRepository()); Assert.AreEqual( expectedBaseImageTag, buildConfiguration.GetBaseImageConfiguration().GetImageTag()); Assert.AreEqual( expectedTargetServerUrl, buildConfiguration.GetTargetImageConfiguration().GetImageRegistry()); Assert.AreEqual( expectedTargetImageName, buildConfiguration.GetTargetImageConfiguration().GetImageRepository()); Assert.AreEqual( expectedTargetTag, buildConfiguration.GetTargetImageConfiguration().GetImageTag()); Assert.AreEqual(expectedTargetImageTags, buildConfiguration.GetAllTargetImageTags()); Assert.AreEqual( Credential.From("username", "password"), buildConfiguration .GetTargetImageConfiguration() .GetCredentialRetrievers() [0] .Retrieve() .OrElseThrow(() => new AssertionException(""))); Assert.AreEqual( expectedProgramArguments, buildConfiguration.GetContainerConfiguration().GetProgramArguments()); Assert.AreEqual( expectedEnvironment, buildConfiguration.GetContainerConfiguration().GetEnvironmentMap()); Assert.AreEqual( expectedExposedPorts, buildConfiguration.GetContainerConfiguration().GetExposedPorts()); Assert.AreEqual(expectedLabels, buildConfiguration.GetContainerConfiguration().GetLabels()); Assert.AreEqual(expectedTargetFormat, buildConfiguration.GetTargetFormat()); Assert.AreEqual( expectedApplicationLayersCacheDirectory, buildConfigurationBuilder.GetApplicationLayersCacheDirectory()); Assert.AreEqual( expectedBaseImageLayersCacheDirectory, buildConfigurationBuilder.GetBaseImageLayersCacheDirectory()); Assert.IsTrue(buildConfiguration.GetAllowInsecureRegistries()); Assert.AreEqual(expectedLayerConfigurations, buildConfiguration.GetLayerConfigurations()); Assert.AreEqual( expectedEntrypoint, buildConfiguration.GetContainerConfiguration().GetEntrypoint()); Assert.AreEqual(expectedCreatedBy, buildConfiguration.GetToolName()); }
private void TestToImage_buildable <T>( string jsonFilename) where T : IBuildableManifestTemplate { // Loads the container configuration JSON. SystemPath containerConfigurationJsonFile = Paths.Get( TestResources.GetResource("core/json/containerconfig.json").ToURI()); ContainerConfigurationTemplate containerConfigurationTemplate = JsonTemplateMapper.ReadJsonFromFile <ContainerConfigurationTemplate>( containerConfigurationJsonFile); // Loads the manifest JSON. SystemPath manifestJsonFile = Paths.Get(TestResources.GetResource(jsonFilename).ToURI()); T manifestTemplate = JsonTemplateMapper.ReadJsonFromFile <T>(manifestJsonFile); Image image = JsonToImageTranslator.ToImage(manifestTemplate, containerConfigurationTemplate); IList <ILayer> layers = image.GetLayers(); Assert.AreEqual(1, layers.Count); Assert.AreEqual( new BlobDescriptor( 1000000, DescriptorDigest.FromDigest( "sha256:4945ba5011739b0b98c4a41afe224e417f47c7c99b2ce76830999c9a0861b236")), layers[0].GetBlobDescriptor()); Assert.AreEqual( DescriptorDigest.FromDigest( "sha256:8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad"), layers[0].GetDiffId()); CollectionAssert.AreEqual( ImmutableArray.Create( HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(0)) .SetAuthor("Bazel") .SetCreatedBy("bazel build ...") .SetEmptyLayer(true) .Build(), HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(20)) .SetAuthor("Fib") .SetCreatedBy("fib") .Build()), image.GetHistory()); Assert.AreEqual(Instant.FromUnixTimeSeconds(20), image.GetCreated()); Assert.AreEqual(new[] { "some", "entrypoint", "command" }, image.GetEntrypoint()); Assert.AreEqual(ImmutableDic.Of("VAR1", "VAL1", "VAR2", "VAL2"), image.GetEnvironment()); Assert.AreEqual("/some/workspace", image.GetWorkingDirectory()); Assert.AreEqual( ImmutableHashSet.Create(Port.Tcp(1000), Port.Tcp(2000), Port.Udp(3000)), image.GetExposedPorts()); Assert.AreEqual( ImmutableHashSet.Create( AbsoluteUnixPath.Get("/var/job-result-data"), AbsoluteUnixPath.Get("/var/log/my-app-logs")), image.GetVolumes()); Assert.AreEqual("tomcat", image.GetUser()); Assert.AreEqual("value1", image.GetLabels()["key1"]); Assert.AreEqual("value2", image.GetLabels()["key2"]); Assert.AreEqual(2, image.GetLabels().Count); }
public void SetUp() { testDescriptorDigest = DescriptorDigest.FromHash( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); Mock.Get(mockBuildConfiguration).Setup(m => m.GetEventHandlers()).Returns(mockEventHandlers); Mock.Get(mockBuildConfiguration).Setup(m => m.GetContainerConfiguration()).Returns(mockContainerConfiguration); Mock.Get(mockBuildConfiguration).Setup(m => m.GetToolName()).Returns(() => null); Mock.Get(mockContainerConfiguration).Setup(m => m.GetCreationTime()).Returns(Instant.FromUnixTimeSeconds(0)); Mock.Get(mockContainerConfiguration).Setup(m => m.GetEnvironmentMap()).Returns(ImmutableDictionary.Create <string, string>()); Mock.Get(mockContainerConfiguration).Setup(m => m.GetProgramArguments()).Returns(ImmutableArray.Create <string>()); Mock.Get(mockContainerConfiguration).Setup(m => m.GetExposedPorts()).Returns(ImmutableHashSet.Create <Port>()); Mock.Get(mockContainerConfiguration).Setup(m => m.GetEntrypoint()).Returns(ImmutableArray.Create <string>()); Mock.Get(mockContainerConfiguration).Setup(m => m.GetUser()).Returns("root"); Mock.Get(mockCachedLayer).Setup(m => m.GetBlobDescriptor()).Returns(new BlobDescriptor(0, testDescriptorDigest)); nonEmptyLayerHistory = HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(0)) .SetAuthor("FibBase") .SetCreatedBy("fib-test") .Build(); emptyLayerHistory = HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(0)) .SetAuthor("FibBase") .SetCreatedBy("fib-test") .SetEmptyLayer(true) .Build(); Image baseImage = Image.CreateBuilder(ManifestFormat.V22) .SetArchitecture("wasm") .SetOs("js") .AddEnvironment(ImmutableDic.Of("BASE_ENV", "BASE_ENV_VALUE", "BASE_ENV_2", "DEFAULT")) .AddLabel("base.label", "base.label.value") .AddLabel("base.label.2", "default") .SetWorkingDirectory("/base/working/directory") .SetEntrypoint(ImmutableArray.Create("baseImageEntrypoint")) .SetProgramArguments(ImmutableArray.Create("catalina.sh", "run")) .SetHealthCheck( DockerHealthCheck.FromCommand(ImmutableArray.Create("CMD-SHELL", "echo hi")) .SetInterval(Duration.FromSeconds(3)) .SetTimeout(Duration.FromSeconds(2)) .SetStartPeriod(Duration.FromSeconds(1)) .SetRetries(20) .Build()) .AddExposedPorts(ImmutableHashSet.Create(Port.Tcp(1000), Port.Udp(2000))) .AddVolumes( ImmutableHashSet.Create( AbsoluteUnixPath.Get("/base/path1"), AbsoluteUnixPath.Get("/base/path2"))) .AddHistory(nonEmptyLayerHistory) .AddHistory(emptyLayerHistory) .AddHistory(emptyLayerHistory) .Build(); Mock.Get(mockPullAndCacheBaseImageLayerStep).Setup(m => m.GetFuture()).Returns(Futures.ImmediateFutureAsync(mockCachedLayer)); Mock.Get(mockPullAndCacheBaseImageLayersStep).Setup(m => m.GetFuture()).Returns( Futures.ImmediateFutureAsync <IReadOnlyList <ICachedLayer> >( ImmutableArray.Create( mockCachedLayer, mockCachedLayer, mockCachedLayer))); Mock.Get(mockPullBaseImageStep).Setup(m => m.GetFuture()).Returns( Futures.ImmediateFutureAsync( new BaseImageWithAuthorization(baseImage, null))); mockClassesLayer = new CachedLayerWithType(mockCachedLayer, "classes"); mockDependenciesLayer = new CachedLayerWithType(mockCachedLayer, "dependencies"); mockExtraFilesLayer = new CachedLayerWithType(mockCachedLayer, "extra files"); mockResourcesLayer = new CachedLayerWithType(mockCachedLayer, "resources"); }
public async Task Test_propagateBaseImageConfigurationAsync() { Mock.Get(mockContainerConfiguration).Setup(m => m.GetEnvironmentMap()).Returns(ImmutableDic.Of("MY_ENV", "MY_ENV_VALUE", "BASE_ENV_2", "NEW_VALUE")); Mock.Get(mockContainerConfiguration).Setup(m => m.GetLabels()).Returns(ImmutableDic.Of("my.label", "my.label.value", "base.label.2", "new.value")); Mock.Get(mockContainerConfiguration).Setup(m => m.GetExposedPorts()).Returns(ImmutableHashSet.Create(Port.Tcp(3000), Port.Udp(4000))); Mock.Get(mockContainerConfiguration).Setup(m => m.GetVolumes()).Returns( ImmutableHashSet.Create( AbsoluteUnixPath.Get("/new/path1"), AbsoluteUnixPath.Get("/new/path2"))); Mock.Get(mockBuildAndCacheApplicationLayersStep).Setup(s => s.GetFuture()).Returns(Task.FromResult <IReadOnlyList <ICachedLayer> >(ImmutableArray.Create( mockDependenciesLayer, mockResourcesLayer, mockClassesLayer))); BuildImageStep buildImageStep = new BuildImageStep( mockBuildConfiguration, ProgressEventDispatcher.NewRoot(mockEventHandlers, "ignored", 1).NewChildProducer(), mockPullBaseImageStep, mockPullAndCacheBaseImageLayersStep, mockBuildAndCacheApplicationLayersStep); Image image = await buildImageStep.GetFuture().ConfigureAwait(false); Assert.AreEqual("wasm", image.GetArchitecture()); Assert.AreEqual("js", image.GetOs()); Assert.AreEqual( new Dictionary <string, string> { ["BASE_ENV"] = "BASE_ENV_VALUE", ["MY_ENV"] = "MY_ENV_VALUE", ["BASE_ENV_2"] = "NEW_VALUE" }.ToImmutableDictionary(), image.GetEnvironment()); Assert.AreEqual( new Dictionary <string, string> { ["base.label"] = "base.label.value", ["my.label"] = "my.label.value", ["base.label.2"] = "new.value" }.ToImmutableDictionary(), image.GetLabels()); Assert.IsNotNull(image.GetHealthCheck()); CollectionAssert.AreEqual( ImmutableArray.Create("CMD-SHELL", "echo hi"), image.GetHealthCheck().GetCommand()); Assert.IsTrue(image.GetHealthCheck().GetInterval().IsPresent()); Assert.AreEqual(Duration.FromSeconds(3), image.GetHealthCheck().GetInterval().Get()); Assert.IsTrue(image.GetHealthCheck().GetTimeout().IsPresent()); Assert.AreEqual(Duration.FromSeconds(2), image.GetHealthCheck().GetTimeout().Get()); Assert.IsTrue(image.GetHealthCheck().GetStartPeriod().IsPresent()); Assert.AreEqual(Duration.FromSeconds(1), image.GetHealthCheck().GetStartPeriod().Get()); Assert.IsTrue(image.GetHealthCheck().GetRetries().IsPresent()); Assert.AreEqual(20, image.GetHealthCheck().GetRetries().Get()); Assert.AreEqual( ImmutableHashSet.Create(Port.Tcp(1000), Port.Udp(2000), Port.Tcp(3000), Port.Udp(4000)), image.GetExposedPorts()); Assert.AreEqual( ImmutableHashSet.Create( AbsoluteUnixPath.Get("/base/path1"), AbsoluteUnixPath.Get("/base/path2"), AbsoluteUnixPath.Get("/new/path1"), AbsoluteUnixPath.Get("/new/path2")), image.GetVolumes()); Assert.AreEqual("/base/working/directory", image.GetWorkingDirectory()); Assert.AreEqual("root", image.GetUser()); Assert.AreEqual(image.GetHistory()[0], nonEmptyLayerHistory); Assert.AreEqual(image.GetHistory()[1], emptyLayerHistory); Assert.AreEqual(image.GetHistory()[2], emptyLayerHistory); Assert.AreEqual(ImmutableArray.Create <string>(), image.GetEntrypoint()); Assert.AreEqual(ImmutableArray.Create <string>(), image.GetProgramArguments()); }