public async Task SetUpAsync()
{
SystemPath directory = temporaryFolder.NewFolder().ToPath();
Files.CreateDirectory(directory.Resolve("source"));
Files.CreateFile(directory.Resolve("source/file"));
Files.CreateDirectories(directory.Resolve("another/source"));
Files.CreateFile(directory.Resolve("another/source/file"));
layerBlob1 = Blobs.From("layerBlob1");
layerDigest1 = await DigestOfAsync(Compress(layerBlob1)).ConfigureAwait(false);
layerDiffId1 = await DigestOfAsync(layerBlob1).ConfigureAwait(false);
layerSize1 = await SizeOfAsync(Compress(layerBlob1)).ConfigureAwait(false);
layerEntries1 =
ImmutableArray.Create(
DefaultLayerEntry(
directory.Resolve("source/file"), AbsoluteUnixPath.Get("/extraction/path")),
DefaultLayerEntry(
directory.Resolve("another/source/file"),
AbsoluteUnixPath.Get("/another/extraction/path")));
layerBlob2 = Blobs.From("layerBlob2");
layerDigest2 = await DigestOfAsync(Compress(layerBlob2)).ConfigureAwait(false);
layerDiffId2 = await DigestOfAsync(layerBlob2).ConfigureAwait(false);
layerSize2 = await SizeOfAsync(Compress(layerBlob2)).ConfigureAwait(false);
layerEntries2 = ImmutableArray.Create <LayerEntry>();
}
public void TestClose_directoryDeleted()
{
using (TemporaryDirectory temporaryDirectory =
new TemporaryDirectory(temporaryFolder.NewFolder().ToPath()))
{
CreateFilesInDirectory(temporaryDirectory.GetDirectory());
temporaryDirectory.Dispose();
Assert.IsFalse(Files.Exists(temporaryDirectory.GetDirectory()));
}
}
public void SetUp()
{
fakeDependenciesLayerConfiguration =
MakeLayerConfiguration(
"core/application/dependencies", EXTRACTION_PATH_ROOT.Resolve("libs"));
fakeSnapshotDependenciesLayerConfiguration =
MakeLayerConfiguration(
"core/application/snapshot-dependencies", EXTRACTION_PATH_ROOT.Resolve("libs"));
fakeResourcesLayerConfiguration =
MakeLayerConfiguration(
"core/application/resources", EXTRACTION_PATH_ROOT.Resolve("resources"));
fakeClassesLayerConfiguration =
MakeLayerConfiguration("core/application/classes", EXTRACTION_PATH_ROOT.Resolve("classes"));
fakeExtraFilesLayerConfiguration =
LayerConfiguration.CreateBuilder()
.AddEntry(
Paths.Get(TestResources.GetResource("core/fileA").ToURI()),
EXTRA_FILES_LAYER_EXTRACTION_PATH.Resolve("fileA"))
.AddEntry(
Paths.Get(TestResources.GetResource("core/fileB").ToURI()),
EXTRA_FILES_LAYER_EXTRACTION_PATH.Resolve("fileB"))
.Build();
emptyLayerConfiguration = LayerConfiguration.CreateBuilder().Build();
cache = LayersCache.WithDirectory(temporaryFolder.NewFolder().ToPath());
Mock.Get(mockBuildConfiguration).Setup(m => m.GetEventHandlers()).Returns(mockEventHandlers);
Mock.Get(mockBuildConfiguration).Setup(m => m.GetApplicationLayersCache()).Returns(cache);
}
public async Task TestBuildTarballAsync()
{
SystemPath outputPath = temporaryFolder.NewFolder().ToPath().Resolve("test.tar");
await BuildTarImageAsync(
ImageReference.Of("gcr.io", "distroless/java", DISTROLESS_DIGEST),
ImageReference.Of(null, "testtar", null),
outputPath,
new List <string>()).ConfigureAwait(false);
progressChecker.CheckCompletion();
new Command("docker", "load", "--input", outputPath.ToString()).Run();
AssertLayerSizer(7, "testtar");
Assert.AreEqual(
"Hello, world. An argument.\n", new Command("docker", "run", "--rm", "testtar").Run());
}
public void TestListDigests()
{
CacheStorageFiles cacheStorageFiles =
new CacheStorageFiles(temporaryFolder.NewFolder().ToPath());
CacheStorageReader cacheStorageReader = new CacheStorageReader(cacheStorageFiles);
// Creates test layer directories.
Files.CreateDirectories(cacheStorageFiles.GetLayersDirectory().Resolve(layerDigest1.GetHash()));
Files.CreateDirectories(cacheStorageFiles.GetLayersDirectory().Resolve(layerDigest2.GetHash()));
// Checks that layer directories created are all listed.
Assert.AreEqual(
new HashSet <DescriptorDigest>(new[] { layerDigest1, layerDigest2 }),
cacheStorageReader.FetchDigests());
// Checks that non-digest directories means the cache is corrupted.
Files.CreateDirectory(cacheStorageFiles.GetLayersDirectory().Resolve("not a hash"));
try
{
cacheStorageReader.FetchDigests();
Assert.Fail("Listing digests should have failed");
}
catch (CacheCorruptedException ex)
{
Assert.That(
ex.Message, Does.StartWith("Found non-digest file in layers directory"));
Assert.IsInstanceOf <DigestException>(ex.InnerException);
}
}
public void SetUp()
{
SystemPath folder = temporaryFolder.NewFolder().ToPath();
SystemPath file1 = Files.CreateDirectory(folder.Resolve("files"));
SystemPath file2 = Files.CreateFile(folder.Resolve("files").Resolve("two"));
SystemPath file3 = Files.CreateFile(folder.Resolve("gile"));
LayerEntry testLayerEntry1 = DefaultLayerEntry(file1, AbsoluteUnixPath.Get("/extraction/path"));
LayerEntry testLayerEntry2 = DefaultLayerEntry(file2, AbsoluteUnixPath.Get("/extraction/path"));
LayerEntry testLayerEntry3 = DefaultLayerEntry(file3, AbsoluteUnixPath.Get("/extraction/path"));
LayerEntry testLayerEntry4 =
new LayerEntry(
file3,
AbsoluteUnixPath.Get("/extraction/path"),
FilePermissions.FromOctalString("755"),
LayerConfiguration.DefaultModifiedTime);
LayerEntry testLayerEntry5 =
DefaultLayerEntry(file3, AbsoluteUnixPath.Get("/extraction/patha"));
LayerEntry testLayerEntry6 =
new LayerEntry(
file3,
AbsoluteUnixPath.Get("/extraction/patha"),
FilePermissions.FromOctalString("755"),
LayerConfiguration.DefaultModifiedTime);
outOfOrderLayerEntries =
ImmutableArray.Create(
testLayerEntry4,
testLayerEntry2,
testLayerEntry6,
testLayerEntry3,
testLayerEntry1,
testLayerEntry5);
inOrderLayerEntries =
ImmutableArray.Create(
testLayerEntry1,
testLayerEntry2,
testLayerEntry3,
testLayerEntry4,
testLayerEntry5,
testLayerEntry6);
}
public void TestCopy()
{
SystemPath destDir = temporaryFolder.NewFolder().ToPath();
SystemPath libraryA =
Paths.Get(TestResources.GetResource("core/application/dependencies/libraryA.jar").ToURI());
SystemPath libraryB =
Paths.Get(TestResources.GetResource("core/application/dependencies/libraryB.jar").ToURI());
SystemPath dirLayer = Paths.Get(TestResources.GetResource("core/layer").ToURI());
FileOperations.Copy(ImmutableArray.Create(libraryA, libraryB, dirLayer), destDir);
AssertFilesEqual(libraryA, destDir.Resolve("libraryA.jar"));
AssertFilesEqual(libraryB, destDir.Resolve("libraryB.jar"));
Assert.IsTrue(Files.Exists(destDir.Resolve("layer").Resolve("a").Resolve("b")));
Assert.IsTrue(Files.Exists(destDir.Resolve("layer").Resolve("c")));
AssertFilesEqual(
dirLayer.Resolve("a").Resolve("b").Resolve("bar"),
destDir.Resolve("layer").Resolve("a").Resolve("b").Resolve("bar"));
AssertFilesEqual(
dirLayer.Resolve("c").Resolve("cat"), destDir.Resolve("layer").Resolve("c").Resolve("cat"));
AssertFilesEqual(dirLayer.Resolve("foo"), destDir.Resolve("layer").Resolve("foo"));
}
public void SetUp()
{
cacheRoot = temporaryFolder.NewFolder().ToPath();
cacheStorageFiles = new CacheStorageFiles(cacheRoot);
}
public void SetUp()
{
fakeCacheHome = temporaryFolder.NewFolder().FullName;
mockEnvironment = Mock.Of <IEnvironment>();
Mock.Get(mockEnvironment).Setup(e => e.IsOsx()).Returns(false);
}