public void CanReadNamedRootWithGraftInsideLocation()
{
var builder = ReadConfiguration(@"
<element>
<add name=""root"" path=""c:\caber-root"">
<location path=""subdir\"">
<location path=""leaf\"" graft=""c:\grafted-leaf"" />
</location>
</add>
</element>");
var hierarchies = builder.BuildHierarchies();
Assert.That(FindRoot(hierarchies, @"C:\caber-root\"), Is.Not.Null);
Assert.That(FindRoot(hierarchies, @"C:\caber-root\subdir\"), Is.Not.Null);
Assert.That(FindRoot(hierarchies, @"C:\grafted-leaf\"), Is.Not.Null);
Assert.That(hierarchies.Grafts,
Is.EqualTo(new [] {
new Graft(
new QualifiedPath(
FindRoot(hierarchies, @"C:\caber-root\"),
RelativePath.CreateFromSegments("subdir").AsContainer()),
FindRoot(hierarchies, @"C:\caber-root\subdir\")),
new Graft(
new QualifiedPath(
FindRoot(hierarchies, @"C:\caber-root\subdir\"),
RelativePath.CreateFromSegments("leaf").AsContainer()),
FindRoot(hierarchies, @"C:\grafted-leaf\"))
}).Using(default(Graft.DefaultEqualityComparer)));
}
public void DefaultMatcher_IncludesAllPaths()
{
var matcher = default(RelativePathMatcher);
Assert.That(matcher.Matches(RelativePath.CreateFromSegments("some", "arbitrary", "path", Guid.NewGuid().ToString())), Is.True);
Assert.That(matcher.Rule, Is.EqualTo(FilterRule.Include));
}
public RelativePath GetCanonicalRelativePath(string rootPath, IEnumerable <string> relativePathParts)
{
var parts = relativePathParts.ToArray();
new WindowsPathCanonicaliser().TryCanonicaliseRelative(new Internal(), rootPath, parts);
return(RelativePath.CreateFromSegments(parts));
}
public void QualifiedPathsWithSameCaseInsensitiveRoot_AndDifferingCase_AreEqual()
{
var root = new LocalRoot(new Uri(@"C:\"), FileSystemCasing.CasePreservingInsensitive);
var a = new QualifiedPath(root, RelativePath.CreateFromSegments("a", "b", "c"));
var b = new QualifiedPath(root, RelativePath.CreateFromSegments("A", "B", "C"));
Assert.That(a, Is.EqualTo(b).Using(default(QualifiedPath.DefaultEqualityComparer)));
}
public void PathIsContainedByDifferingCaseParent_WhenPolicyIsCaseInsensitive()
{
var comparer = new PathEqualityComparer(FileSystemCasing.CasePreservingInsensitive);
var path = RelativePath.CreateFromSegments("A", "B", "c");
var parentPath = RelativePath.CreateFromSegments("a", "b").AsContainer();
Assert.That(parentPath.Contains(path, comparer), Is.True);
}
public void PathIsContainedByParent([ValueSource(nameof(ValidFileSystemCasings))] FileSystemCasing casing)
{
var comparer = new PathEqualityComparer(casing);
var path = RelativePath.CreateFromSegments("a", "b", "c");
var parentPath = RelativePath.CreateFromSegments("a", "b").AsContainer();
Assert.That(parentPath.Contains(path, comparer), Is.True);
}
public void PathIsEqualToDifferentCasePath_WhenPolicyIsCaseInsensitive()
{
var comparer = new PathEqualityComparer(FileSystemCasing.CasePreservingInsensitive);
var pathA = RelativePath.CreateFromSegments("a", "b", "c");
var pathB = RelativePath.CreateFromSegments("A", "B", "c");
Assert.That(pathA, Is.EqualTo(pathB).Using <RelativePath>(comparer));
}
public void PathIsEqualToIdenticalCasePath([ValueSource(nameof(ValidFileSystemCasings))] FileSystemCasing casing)
{
var comparer = new PathEqualityComparer(casing);
var pathA = RelativePath.CreateFromSegments("a", "b", "c");
var pathB = RelativePath.CreateFromSegments("a", "b", "c");
Assert.That(pathA, Is.EqualTo(pathB).Using <RelativePath>(comparer));
}
public void QualifiedPathsWithDifferentRoots_AreNotEqual([ValueSource(nameof(ValidFileSystemCasings))] FileSystemCasing casing)
{
var relativePath = RelativePath.CreateFromSegments("a", "b", "c");
var a = new QualifiedPath(new LocalRoot(new Uri(@"C:\"), casing), relativePath);
var b = new QualifiedPath(new LocalRoot(new Uri(@"E:\"), casing), relativePath);
Assert.That(a, Is.Not.EqualTo(b).Using(default(QualifiedPath.DefaultEqualityComparer)));
}
public void PathDoesNotContainSibling([ValueSource(nameof(ValidFileSystemCasings))] FileSystemCasing casing)
{
var comparer = new PathEqualityComparer(casing);
var path = RelativePath.CreateFromSegments("a", "b", "c");
var siblingPath = RelativePath.CreateFromSegments("a", "b", "d");
Assert.That(path.Contains(siblingPath, comparer), Is.False);
Assert.That(path.AsContainer().Contains(siblingPath, comparer), Is.False);
}
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 CanReadRootWithRegexFilter()
{
var builder = ReadConfiguration(@"
<element>
<add name=""root"" path=""c:\caber-root"">
<filters>
<match regex=""test.*"" rule=""exclude"" />
</filters>
</add>
</element>");
var hierarchies = builder.BuildHierarchies();
var root = FindRoot(hierarchies, @"c:\caber-root\");
var filter = hierarchies.GetFilterFor(root);
Assert.That(filter.Exists, Is.True);
Assert.That(filter.Evaluate(RelativePath.CreateFromSegments("test")).Description, Is.EqualTo("Regex(test.*)"));
}
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)));
}
public void CannotCreatePathWithNoSegments()
{
Assert.Throws <ArgumentException>(() => RelativePath.CreateFromSegments());
}
public RelativePath GetCanonicalRelativePath(string rootPath, IEnumerable <string> relativePathParts)
{
return(RelativePath.CreateFromSegments(relativePathParts.ToArray()));
}
public void FilePathIsNotContainer()
{
var path = RelativePath.CreateFromSegments("a", "b", "c");
Assert.That(path.IsContainer(), Is.False);
}
public void ContainerPathIsContainer()
{
var path = RelativePath.CreateFromSegments("a", "b", "c").AsContainer();
Assert.That(path.IsContainer(), Is.True);
}
public void PathUsesNormalSeparator()
{
var path = RelativePath.CreateFromSegments("a", "b", "c");
Assert.That(path.ToString(), Is.EqualTo("a/b/c"));
}
