public void Read(StorageElementCollection element, StorageHierarchiesBuilder builder)
{
foreach (var add in element.Items)
{
Read(add, builder);
}
}
public void Read(StorageElementCollection.AddElement add, StorageHierarchiesBuilder builder)
{
var context = TryCreateNamedHierarchyAndContext(add, builder);
ReadFiltersElement(add.Filters, context);
ReadChildLocations(add, context);
}
public void GraftingOntoUndeclaredParent_ThrowsInvalidOperationException()
{
var builder = new StorageHierarchiesBuilder(new StubFileSystemApi());
var root = builder.CreateNode(@"C:\Root", FileSystemCasing.CasePreservingInsensitive);
Assert.Throws <InvalidOperationException>(() =>
builder.AddGraftPoint(root, "Child", builder.CreateNode(@"C:\Other\A", FileSystemCasing.CasePreservingInsensitive)));
}
private StorageHierarchiesBuilder ReadConfiguration(string xml)
{
var element = new TestConfigurationProvider <StorageElementCollection>().GetAsElement(xml);
var builder = new StorageHierarchiesBuilder(new StubFileSystemApi(FileSystemCasing.CasePreservingInsensitive));
var reader = new StorageConfigurationReader();
reader.Read(element, builder);
return(builder);
}
public void DoesNotResolveQualifiedPathNotInRoot()
{
var builder = new StorageHierarchiesBuilder(new StubFileSystemApi());
var root = builder.CreateNode(@"C:\Root", FileSystemCasing.CasePreservingInsensitive);
builder.AddNamedRoot("SimpleRoot", root);
var storage = builder.BuildHierarchies();
Assert.That(storage.TryResolveQualifiedPath(@"C:\Outside\some\filepath.txt", out _), Is.False);
}
public void CreatingDuplicateNamedRootLocation_DifferingByCase_RecordsDuplicateLocalRoot()
{
var builder = new StorageHierarchiesBuilder(new StubFileSystemApi());
builder.AddNamedRoot("RootA", builder.CreateNode(@"C:\Root\A", FileSystemCasing.CaseSensitive));
var error = builder.AddNamedRoot("RootB", builder.CreateNode(@"C:\root\a", FileSystemCasing.CaseSensitive));
Assert.That(error, Is.InstanceOf <DuplicateLocalRootDeclaration>());
Assert.That(builder.Errors, Is.EquivalentTo(new [] { error }));
}
public void CreatingNamedRoot_ContainingExistingNamedRoot_RecordsOverlappingLocalRoot()
{
var builder = new StorageHierarchiesBuilder(new StubFileSystemApi());
builder.AddNamedRoot("RootA", builder.CreateNode(@"C:\Root\Child", FileSystemCasing.CasePreservingInsensitive));
var error = builder.AddNamedRoot("RootB", builder.CreateNode(@"C:\Root", FileSystemCasing.CasePreservingInsensitive));
Assert.That(error, Is.InstanceOf <OverlappingLocalRootDeclaration>());
Assert.That(builder.Errors, Is.EquivalentTo(new [] { error }));
}
public void DoesNotResolveQualifiedPathInRoot_UnderGraftPoint()
{
var builder = new StorageHierarchiesBuilder(new StubFileSystemApi());
var root = builder.CreateNode(@"C:\Root", FileSystemCasing.CasePreservingInsensitive);
builder.AddNamedRoot("Root", root);
builder.AddGraftPoint(root, "Graft", builder.CreateNode(@"C:\Other", FileSystemCasing.CasePreservingInsensitive));
var storage = builder.BuildHierarchies();
Assert.That(storage.TryResolveQualifiedPath(@"C:\root\Graft\some\filepath.txt", out _), Is.False);
}
public void MultipleNamesForTheSameRoot_RecordsDuplicateLocalRoot()
{
var builder = new StorageHierarchiesBuilder(new StubFileSystemApi());
var root = builder.CreateNode(@"C:\Root", FileSystemCasing.CasePreservingInsensitive);
builder.AddNamedRoot("RootA", root);
var error = builder.AddNamedRoot("RootB", root);
Assert.That(error, Is.InstanceOf <DuplicateLocalRootDeclaration>());
Assert.That(builder.Errors, Is.EquivalentTo(new [] { error }));
}
public void GraftingLocalRoot_OntoParentWithDifferingCasingRules_RecordsFileSystemCasingConflict()
{
var builder = new StorageHierarchiesBuilder(new StubFileSystemApi());
var root = builder.CreateNode(@"C:\Root", FileSystemCasing.CasePreservingInsensitive);
builder.AddNamedRoot("Root", root);
var error = builder.AddGraftPoint(root, "Child", builder.CreateNode(@"C:\Other", FileSystemCasing.CaseSensitive));
Assert.That(error, Is.InstanceOf <FileSystemCasingConflict>());
Assert.That(builder.Errors, Is.EquivalentTo(new [] { error }));
}
public void GraftingDuplicateQualifiedPath_RecordsDuplicateGraft()
{
var builder = new StorageHierarchiesBuilder(new StubFileSystemApi());
var root = builder.CreateNode(@"C:\Root", FileSystemCasing.CasePreservingInsensitive);
builder.AddNamedRoot("Root", root);
builder.AddGraftPoint(root, "Child", builder.CreateNode(@"C:\Other\A", FileSystemCasing.CasePreservingInsensitive));
var error = builder.AddGraftPoint(root, "Child", builder.CreateNode(@"C:\Other\B", FileSystemCasing.CasePreservingInsensitive));
Assert.That(error, Is.InstanceOf <DuplicateGraftDeclaration>());
Assert.That(builder.Errors, Is.EquivalentTo(new [] { error }));
}
public void AddingLocation_AddsOverlappingGraft_WithoutError()
{
var builder = new StorageHierarchiesBuilder(new StubFileSystemApi());
var root = builder.CreateNode(@"C:\Root", FileSystemCasing.CasePreservingInsensitive);
builder.AddNamedRoot("Root", root);
var error = builder.AddLocation(root, "Child", out var child);
Assert.That(error, Is.Null);
Assert.That(builder.Errors, Is.Empty);
Assert.That(child.RootUri, Is.EqualTo(new Uri(root.RootUri, @"Child\")));
}
private static void ValidateStorageConfiguration(XElement storageElement)
{
var element = new TestConfigurationProvider <StorageElementCollection>()
.GetAsElement(CreateDummyElementFromInnerXml(storageElement));
var builder = new StorageHierarchiesBuilder(new StubFileSystemApi(FileSystemCasing.CasePreservingInsensitive));
var reader = new StorageConfigurationReader();
reader.Read(element, builder);
builder.BuildHierarchies();
Assert.That(reader.Errors, Is.Empty);
Assert.That(builder.Errors, Is.Empty);
}
public void RoundtripsQualifiedPathInRootWithNoGrafts()
{
var builder = new StorageHierarchiesBuilder(new StubFileSystemApi());
var root = builder.CreateNode(@"C:\Root", FileSystemCasing.CasePreservingInsensitive);
builder.AddNamedRoot("SimpleRoot", root);
var storage = builder.BuildHierarchies();
Assert.That(storage.TryResolveQualifiedPath(@"C:\root\some\filepath.txt", out var qualifiedPath), Is.True);
Assert.That(qualifiedPath,
Is.EqualTo(new QualifiedPath(root, RelativePath.CreateFromSegments("some", "filepath.txt")))
.Using(default(QualifiedPath.DefaultEqualityComparer)));
Assert.That(storage.ResolveToFile(qualifiedPath)?.FullName, Is.EqualTo(@"C:\Root\some\filepath.txt"));
}
public void DoesNotMapExcludedPath()
{
var builder = new StorageHierarchiesBuilder(new StubFileSystemApi());
var root = builder.CreateNode(@"C:\Root", FileSystemCasing.CasePreservingInsensitive);
builder.AddNamedRoot("Root", root);
var regex = new GlobToRegexCompiler().CompileRegex("**/.caber/**", FileSystemCasing.CaseSensitive);
builder.AddFilter(root, new RelativePathMatcher(regex, FilterRule.Exclude));
var storage = builder.BuildHierarchies();
var qualifiedPath = new QualifiedPath(root, RelativePath.CreateFromSegments(".caber", "tempfile"));
Assert.That(storage.MapToAbstractPath(qualifiedPath), Is.Null);
}
public void RoundtripsAbstractPathInRootWithNoGrafts()
{
var builder = new StorageHierarchiesBuilder(new StubFileSystemApi());
var root = builder.CreateNode(@"C:\Root", FileSystemCasing.CasePreservingInsensitive);
builder.AddNamedRoot("SimpleRoot", root);
var storage = builder.BuildHierarchies();
var qualifiedPath = new QualifiedPath(root, RelativePath.CreateFromSegments("some", "filepath.txt"));
var expectedAbstractPath = new AbstractPath(storage.NamedRoots.Single(), RelativePath.CreateFromSegments("some", "filepath.txt"));
var abstractPath = storage.MapToAbstractPath(qualifiedPath);
Assert.That(abstractPath, Is.EqualTo(expectedAbstractPath).Using(default(AbstractPath.DefaultEqualityComparer)));
Assert.That(storage.MapFromAbstractPath(abstractPath),
Is.EqualTo(qualifiedPath)
.Using(default(QualifiedPath.DefaultEqualityComparer)));
}
private Context TryCreateNamedHierarchyAndContext(StorageElementCollection.AddElement add, StorageHierarchiesBuilder builder)
{
var watch = builder.Errors.Watch() + Errors.Watch();
VerifyAbsolutePath(add.Path)?.SetLocation(add.ElementInformation);
if (watch.HasNewErrors)
{
return(default);
