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