public void TestAddRemoveFileSystem()
{
var fs = new AggregateFileSystem();
Assert.Throws <ArgumentNullException>(() => fs.AddFileSystem(null));
Assert.Throws <ArgumentException>(() => fs.AddFileSystem(fs));
var memfs = new MemoryFileSystem();
fs.AddFileSystem(memfs);
Assert.Throws <ArgumentException>(() => fs.AddFileSystem(memfs));
Assert.Throws <ArgumentNullException>(() => fs.RemoveFileSystem(null));
var memfs2 = new MemoryFileSystem();
Assert.Throws <ArgumentException>(() => fs.RemoveFileSystem(memfs2));
var list = fs.GetFileSystems();
Assert.Equal(1, list.Count);
Assert.Equal(memfs, list[0]);
fs.RemoveFileSystem(memfs);
list = fs.GetFileSystems();
Assert.Equal(0, list.Count);
}
protected AggregateFileSystem GetCommonAggregateFileSystem(out MemoryFileSystem fs1, out MemoryFileSystem fs2, out MemoryFileSystem fs3)
{
// ----------------------------------------------
// This creates the following AggregateFileSystem
// ----------------------------------------------
// /a -> fs2
// /a -> fs1
// a.txt -> fs1
// /b -> fs1
// b.i -> fs1
// /C -> fs2
// /d -> fs2
// a.txt -> fs2
// A.txt -> fs2
// b.txt -> fs2
// c.txt1 -> fs2
// d.i -> fs2
// f.i1 -> fs2
// E -> fs2
// /b -> fs1
// b.i -> fs1
// /C -> fs2
// /d -> fs3
// A.txt -> fs3
// b.txt -> fs2
// c.txt1 -> fs3
// d.i -> fs3
// f.i1 -> fs3
// E -> fs2
fs1 = new MemoryFileSystem()
{
Name = "mem0"
};
CreateFolderStructure(fs1);
fs2 = fs1.Clone();
fs2.Name = "mem1";
fs3 = fs2.Clone();
fs3.Name = "mem2";
// Delete part of fs2 so that it will fallback to fs1
fs2.DeleteDirectory("/a/a", true);
fs2.DeleteDirectory("/a/b", true);
fs2.DeleteDirectory("/b", true);
// Delete on fs3 to fallback to fs2 and fs1
fs3.DeleteDirectory("/a", true);
fs3.DeleteDirectory("/C", true);
fs3.DeleteFile("/b.txt");
fs3.DeleteFile("/E");
var aggfs = new AggregateFileSystem(fs1);
aggfs.AddFileSystem(fs2);
aggfs.AddFileSystem(fs3);
return(aggfs);
}
protected override IFileSystem GetTemplateFileSystem()
{
// GitHubRelease template is based on the "Default" template
// => create aggregate file system with the files of both the "Default" and "GitHubRelease" templates
var templateFileSystem = new AggregateFileSystem();
templateFileSystem.AddFileSystem(base.GetTemplateFileSystem());
templateFileSystem.AddFileSystem(CreateEmbeddedResourcesFileSystem("/templates/GitHubRelease"));
return(templateFileSystem);
}
public void TestFallback()
{
// aggregate_fs (fs)
// => aggregate_fs (subFs)
// => memory_fs (subFsMemFs)
// => memory_fs (subMemFs)
// => memory_fs (root)
var root = new MemoryFileSystem();
var fs = new AggregateFileSystem(root);
var subFsMemFs = new MemoryFileSystem();
var subFs = new AggregateFileSystem(subFsMemFs);
fs.AddFileSystem(subFs);
var subMemFs = new MemoryFileSystem();
fs.AddFileSystem(subMemFs);
root.CreateDirectory("/a");
root.CreateDirectory("/b");
root.CreateDirectory("/c");
{
using var a = root.OpenFile("/a.txt", FileMode.Create, FileAccess.Write);
using var b = root.OpenFile("/b.txt", FileMode.Create, FileAccess.Write);
using var c = root.OpenFile("/c.txt", FileMode.Create, FileAccess.Write);
}
subFsMemFs.CreateDirectory("/b");
{
using var b = subFsMemFs.OpenFile("/b.txt", FileMode.Create, FileAccess.Write);
}
subMemFs.CreateDirectory("/a");
{
using var a = subMemFs.OpenFile("/a.txt", FileMode.Create, FileAccess.Write);
}
var findA = fs.FindFirstFileSystemEntry("/a");
Assert.Equal(subMemFs, findA?.FileSystem);
var findB = fs.FindFirstFileSystemEntry("/b");
Assert.Equal(subFsMemFs, findB?.FileSystem);
var findC = fs.FindFirstFileSystemEntry("/c");
Assert.Equal(root, findC?.FileSystem);
Assert.True(fs.DirectoryExists("/c"));
Assert.True(fs.DirectoryExists("/b"));
Assert.True(fs.DirectoryExists("/a"));
Assert.True(fs.FileExists("/c.txt"));
Assert.True(fs.FileExists("/b.txt"));
Assert.True(fs.FileExists("/a.txt"));
}
public void TestFindFileSystemEntries()
{
var fs = new AggregateFileSystem();
var memfs1 = new MemoryFileSystem();
memfs1.WriteAllText("/a.txt", "content1");
memfs1.WriteAllText("/b", "notused");
fs.AddFileSystem(memfs1);
var memfs2 = new MemoryFileSystem();
memfs2.WriteAllText("/a.txt", "content2");
memfs2.CreateDirectory("/b");
fs.AddFileSystem(memfs2);
{
var entries = fs.FindFileSystemEntries("/a.txt");
Assert.Equal(2, entries.Count);
Assert.IsType <FileEntry>(entries[0]);
Assert.IsType <FileEntry>(entries[1]);
Assert.Equal(memfs2, entries[0].FileSystem);
Assert.Equal(memfs1, entries[1].FileSystem);
Assert.Equal("/a.txt", entries[0].Path.FullName);
Assert.Equal("/a.txt", entries[1].Path.FullName);
}
{
var entries = fs.FindFileSystemEntries("/b");
Assert.Single(entries);
Assert.IsType <DirectoryEntry>(entries[0]);
Assert.Equal(memfs2, entries[0].FileSystem);
Assert.Equal("/b", entries[0].Path.FullName);
}
{
var entry = fs.FindFirstFileSystemEntry("/a.txt");
Assert.NotNull(entry);
Assert.IsType <FileEntry>(entry);
Assert.Equal(memfs2, entry.FileSystem);
Assert.Equal("/a.txt", entry.Path.FullName);
}
}
public ScribanBaseTemplate(ChangeLogConfiguration configuration)
{
m_Configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
m_Filesystem = new Lazy <IFileSystem>(() =>
{
var fileSystem = GetTemplateFileSystem();
if (!String.IsNullOrEmpty(TemplateSettings.CustomDirectory))
{
var physicalFileSystem = new PhysicalFileSystem();
var path = physicalFileSystem.ConvertPathFromInternal(TemplateSettings.CustomDirectory);
var aggregateFileSystem = new AggregateFileSystem(fileSystem);
aggregateFileSystem.AddFileSystem(physicalFileSystem.GetOrCreateSubFileSystem(path));
fileSystem = aggregateFileSystem;
}
return(fileSystem);
});
}