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());
}
public void TestGetters_default()
{
RegistryImage image = RegistryImage.Named("registry/image");
Assert.AreEqual("registry/image", image.GetImageReference().ToString());
Assert.AreEqual(0, image.GetCredentialRetrievers().Count);
}
protected override IContainerizer CreateContainerizer(FibCliConfiguration configuration)
{
var toImage = RegistryImage.Named(configuration.GetTargetImageReference());
if (configuration.TargetImageCredential != null && !string.IsNullOrEmpty(configuration.TargetImageCredential.UserName) &&
!string.IsNullOrEmpty(configuration.TargetImageCredential.Password))
{
toImage.AddCredential(configuration.TargetImageCredential.UserName, configuration.TargetImageCredential.Password);
}
return(Containerizer.To(toImage));
}
public void TestTo()
{
RegistryImage registryImage = RegistryImage.Named(ImageReference.Of(null, "repository", null));
DockerDaemonImage dockerDaemonImage =
DockerDaemonImage.Named(ImageReference.Of(null, "repository", null));
TarImage tarImage =
TarImage.Named(ImageReference.Of(null, "repository", null)).SaveTo(Paths.Get("ignored"));
VerifyTo(Containerizer.To(registryImage));
VerifyTo(Containerizer.To(dockerDaemonImage));
VerifyTo(Containerizer.To(tarImage));
}
public void TestGetters()
{
RegistryImage image =
RegistryImage.Named("registry/image")
.AddCredentialRetriever(mockCredentialRetriever)
.AddCredential("username", "password");
Assert.AreEqual(2, image.GetCredentialRetrievers().Count);
Assert.AreSame(mockCredentialRetriever, image.GetCredentialRetrievers()[0]);
Assert.AreEqual(
Credential.From("username", "password"),
image.GetCredentialRetrievers()[1].Retrieve().Get());
}
public void TestGetImageConfiguration_registryImage()
{
CredentialRetriever credentialRetriever = Mock.Of <CredentialRetriever>();
Containerizer containerizer =
Containerizer.To(
RegistryImage.Named("registry/image").AddCredentialRetriever(credentialRetriever));
ImageConfiguration imageConfiguration = containerizer.GetImageConfiguration();
Assert.AreEqual("registry/image", imageConfiguration.GetImage().ToString());
Assert.AreEqual(
new[] { credentialRetriever }, imageConfiguration.GetCredentialRetrievers());
}
public void TestConfigureContainerizer_SetsBaseImageLayersCache()
{
var config = new FibCliConfiguration
{
BaseLayersCacheDirectory = "BaseCacheDirectory"
};
var containerizer = Containerizer.To(RegistryImage.Named("target-image:tag3"));
config.ConfigureContainerizer(containerizer);
Assert.AreEqual("BaseCacheDirectory", containerizer.GetBaseImageLayersCacheDirectory());
}
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 async Task TestScratchAsync()
{
ImageReference targetImageReference =
ImageReference.Of("localhost:5002", "fibdotnet-core", "basic-scratch");
await FibContainerBuilder.FromScratch()
.ContainerizeAsync(
Containerizer.To(
RegistryImage.Named(targetImageReference)
.AddCredentialRetriever(
() => Maybe.Of(Credential.From("username", "password"))))
.SetAllowInsecureRegistries(true)).ConfigureAwait(false);
// Check that resulting image has no layers
localRegistry.Pull(targetImageReference.ToString());
string inspectOutput = new Command("docker", "inspect", targetImageReference.ToString()).Run();
Assert.That(inspectOutput, Does.Not.Contain("\"Layers\": ["), "docker inspect output contained layers: " + inspectOutput);
}
public async Task TestBasic_HelloWorldAsync()
{
ImageReference targetImageReference =
ImageReference.Of("localhost:5002", "fibdotnet-core", "basic-helloworld");
FibContainer fibContainer =
await FibContainerBuilder.From("busybox")
.SetEntrypoint("echo", "Hello World")
.ContainerizeAsync(
Containerizer.To(
RegistryImage.Named(targetImageReference)
.AddCredentialRetriever(
() => Maybe.Of(Credential.From("username", "password"))))
.SetAllowInsecureRegistries(true)
.AddEventHandler <IFibEvent>(e => TestContext.Out.WriteLine(e))).ConfigureAwait(false);
Assert.AreEqual("Hello World\n", PullAndRunBuiltImage(targetImageReference.ToString()));
Assert.AreEqual(
"Hello World\n",
PullAndRunBuiltImage(
targetImageReference.WithTag(fibContainer.GetDigest().ToString()).ToString()));
}
public void TestToBuildConfiguration_containerConfigurationSet()
{
FibContainerBuilder fibContainerBuilder =
new FibContainerBuilder(RegistryImage.Named("base/image"), buildConfigurationBuilder)
.SetEntrypoint(new[] { "entry", "point" })
.SetEnvironment(ImmutableDictionary.CreateRange(new Dictionary <string, string> {
["name"] = "value"
}))
.SetExposedPorts(ImmutableHashSet.Create(Port.Tcp(1234), Port.Udp(5678)))
.SetLabels(ImmutableDictionary.CreateRange(new Dictionary <string, string> {
["key"] = "value"
}))
.SetProgramArguments(new[] { "program", "arguments" })
.SetCreationTime(DateTimeOffset.FromUnixTimeMilliseconds(1000))
.SetUser("user")
.SetWorkingDirectory(AbsoluteUnixPath.Get("/working/directory"));
BuildConfiguration buildConfiguration =
fibContainerBuilder.ToBuildConfiguration(
Containerizer.To(RegistryImage.Named("target/image")));
IContainerConfiguration containerConfiguration = buildConfiguration.GetContainerConfiguration();
Assert.AreEqual(new[] { "entry", "point" }, containerConfiguration.GetEntrypoint());
Assert.AreEqual(
ImmutableDictionary.CreateRange(new Dictionary <string, string> {
["name"] = "value"
}), containerConfiguration.GetEnvironmentMap());
Assert.AreEqual(
ImmutableHashSet.Create(Port.Tcp(1234), Port.Udp(5678)), containerConfiguration.GetExposedPorts());
Assert.AreEqual(ImmutableDictionary.CreateRange(new Dictionary <string, string> {
["key"] = "value"
}), containerConfiguration.GetLabels());
Assert.AreEqual(
new[] { "program", "arguments" }, containerConfiguration.GetProgramArguments());
Assert.AreEqual(Instant.FromUnixTimeMilliseconds(1000), containerConfiguration.GetCreationTime());
Assert.AreEqual("user", containerConfiguration.GetUser());
Assert.AreEqual(
AbsoluteUnixPath.Get("/working/directory"), containerConfiguration.GetWorkingDirectory());
}
protected override IContainerizer CreateContainerizer(ImageReference imageReference)
{
return(Containerizer.To(RegistryImage.Named(imageReference)));
}
public async Task TestOfflineAsync()
{
SystemPath cacheDirectory = cacheFolder.GetRoot().ToPath();
ImageReference targetImageReferenceOnline =
ImageReference.Of("localhost:5001", "fibdotnet-core", "basic-online");
ImageReference targetImageReferenceOffline =
ImageReference.Of("localhost:5001", "fibdotnet-core", "basic-offline");
FibContainerBuilder fibContainerBuilder =
FibContainerBuilder.From("localhost:5001/busybox").SetEntrypoint("echo", "Hello World");
// Should fail since Fib can't build to registry offline
try
{
await fibContainerBuilder.ContainerizeAsync(
Containerizer.To(RegistryImage.Named(targetImageReferenceOffline)).SetOfflineMode(true)).ConfigureAwait(false);
Assert.Fail();
}
catch (InvalidOperationException ex)
{
Assert.AreEqual("Cannot build to a container registry in offline mode", ex.Message);
}
// Should fail since Fib hasn't cached the base image yet
try
{
await fibContainerBuilder.ContainerizeAsync(
Containerizer.To(DockerDaemonImage.Named(targetImageReferenceOffline))
.SetBaseImageLayersCache(cacheDirectory)
.SetOfflineMode(true)).ConfigureAwait(false);
Assert.Fail();
}
catch (IOException ex)
{
Assert.AreEqual(
"Cannot run Fib in offline mode; localhost:5001/busybox not found in local Fib cache",
ex.Message);
}
using (LocalRegistry tempRegistry = new LocalRegistry(5001))
{
await tempRegistry.StartAsync().ConfigureAwait(false);
tempRegistry.PullAndPushToLocal("busybox", "busybox");
// Run online to cache the base image
await fibContainerBuilder.ContainerizeAsync(
Containerizer.To(DockerDaemonImage.Named(targetImageReferenceOnline))
.SetBaseImageLayersCache(cacheDirectory)
.SetAllowInsecureRegistries(true)).ConfigureAwait(false);
}
// Run again in offline mode, should succeed this time
await fibContainerBuilder.ContainerizeAsync(
Containerizer.To(DockerDaemonImage.Named(targetImageReferenceOffline))
.SetBaseImageLayersCache(cacheDirectory)
.SetOfflineMode(true)).ConfigureAwait(false);
// Verify output
Assert.AreEqual(
"Hello World\n",
new Command("docker", "run", "--rm", targetImageReferenceOffline.ToString()).Run());
}
public void TestToBuildConfiguration()
{
RegistryImage targetImage =
RegistryImage.Named(ImageReference.Of("gcr.io", "my-project/my-app", null))
.AddCredential("username", "password");
IContainerizer containerizer =
Containerizer.To(targetImage)
.SetBaseImageLayersCache(Paths.Get("base/image/layers"))
.SetApplicationLayersCache(Paths.Get("application/layers"))
.AddEventHandler(mockFibEventConsumer);
RegistryImage baseImage =
RegistryImage.Named("base/image").AddCredentialRetriever(mockCredentialRetriever);
FibContainerBuilder fibContainerBuilder =
new FibContainerBuilder(baseImage, buildConfigurationBuilder)
.SetLayers(new[] { mockLayerConfiguration1, mockLayerConfiguration2 });
BuildConfiguration buildConfiguration =
fibContainerBuilder.ToBuildConfiguration(
containerizer);
Assert.AreEqual(
buildConfigurationBuilder.Build().GetContainerConfiguration(),
buildConfiguration.GetContainerConfiguration());
Assert.AreEqual(
"base/image", buildConfiguration.GetBaseImageConfiguration().GetImage().ToString());
Assert.AreEqual(
new[] { mockCredentialRetriever },
buildConfiguration.GetBaseImageConfiguration().GetCredentialRetrievers());
Assert.AreEqual(
"gcr.io/my-project/my-app",
buildConfiguration.GetTargetImageConfiguration().GetImage().ToString());
Assert.AreEqual(
1, buildConfiguration.GetTargetImageConfiguration().GetCredentialRetrievers().Length);
Assert.AreEqual(
Credential.From("username", "password"),
buildConfiguration
.GetTargetImageConfiguration()
.GetCredentialRetrievers()
[0]
.Retrieve()
.OrElseThrow(() => new AssertionException("")));
Assert.AreEqual(ImmutableHashSet.Create("latest"), buildConfiguration.GetAllTargetImageTags());
Assert.AreEqual(
new[] { mockLayerConfiguration1, mockLayerConfiguration2 },
buildConfiguration.GetLayerConfigurations());
buildConfiguration.GetEventHandlers().Dispatch(mockFibEvent);
Mock.Get(mockFibEventConsumer).Verify(m => m(mockFibEvent));
Assert.AreEqual("fibdotnet-core", buildConfiguration.GetToolName());
Assert.AreEqual(ManifestFormat.V22, buildConfiguration.GetTargetFormat());
Assert.AreEqual("fibdotnet-core", buildConfiguration.GetToolName());
// Changes fibContainerBuilder.
buildConfiguration =
fibContainerBuilder
.SetFormat(ImageFormat.OCI)
.ToBuildConfiguration(
containerizer
.WithAdditionalTag("tag1")
.WithAdditionalTag("tag2")
.SetToolName("toolName"));
Assert.AreEqual(ManifestFormat.OCI, buildConfiguration.GetTargetFormat());
Assert.AreEqual(
ImmutableHashSet.Create("latest", "tag1", "tag2"), buildConfiguration.GetAllTargetImageTags());
Assert.AreEqual("toolName", buildConfiguration.GetToolName());
}
private async Task <FibContainer> BuildRegistryImageAsync(
ImageReference baseImage, ImageReference targetImage, IList <string> additionalTags)
{
return(await BuildImageAsync(
baseImage, Containerizer.To(RegistryImage.Named(targetImage)), additionalTags).ConfigureAwait(false));
}
