示例#1
0
        public void Test_PathEquality()
        {
            //
            // RelativeDirectoryPath
            //
            IRelativeDirectoryPath relativeRelativeDirectoryPath1 = @"..\Dir1\Dir2".ToRelativeDirectoryPath();
            IRelativeDirectoryPath relativeRelativeDirectoryPath2 = @"..\\dir1//DIR2/".ToRelativeDirectoryPath();

            Assert.IsTrue(relativeRelativeDirectoryPath1.Equals(relativeRelativeDirectoryPath2));

            relativeRelativeDirectoryPath1 = @"..\Dir1\Dir2".ToRelativeDirectoryPath();
            relativeRelativeDirectoryPath2 = @".\Dir1\Dir2".ToRelativeDirectoryPath();
            Assert.IsFalse(relativeRelativeDirectoryPath1.Equals(relativeRelativeDirectoryPath2));

            relativeRelativeDirectoryPath1 = @"..\Dir1\Dir2".ToRelativeDirectoryPath();
            relativeRelativeDirectoryPath2 = @"..\Dir1\Dir2\Dir3".ToRelativeDirectoryPath();
            Assert.IsFalse(relativeRelativeDirectoryPath1.Equals(relativeRelativeDirectoryPath2));

            relativeRelativeDirectoryPath1 = @"..\Dir1\Dir2".ToRelativeDirectoryPath();
            relativeRelativeDirectoryPath2 = @"..\Dir1\Dir".ToRelativeDirectoryPath();
            Assert.IsFalse(relativeRelativeDirectoryPath1.Equals(relativeRelativeDirectoryPath2));

            //
            // AbsoluteDirectoryPath
            //
            IAbsoluteDirectoryPath absoluteAbsoluteDirectoryPath1 = @"C:\Dir1\Dir2".ToAbsoluteDirectoryPath();
            IAbsoluteDirectoryPath absoluteAbsoluteDirectoryPath2 = @"C:\\dir1//Dir2\\".ToAbsoluteDirectoryPath();

            Assert.IsTrue(absoluteAbsoluteDirectoryPath1.Equals(absoluteAbsoluteDirectoryPath2));

            absoluteAbsoluteDirectoryPath1 = @"C:\Dir1\Dir2".ToAbsoluteDirectoryPath();
            absoluteAbsoluteDirectoryPath2 = @"D:\Dir1\Dir2".ToAbsoluteDirectoryPath();
            Assert.IsFalse(absoluteAbsoluteDirectoryPath1.Equals(absoluteAbsoluteDirectoryPath2));

            absoluteAbsoluteDirectoryPath1 = @"C:\Dir1\Dir2".ToAbsoluteDirectoryPath();
            absoluteAbsoluteDirectoryPath2 = @"C:\Dir1\Dir2\Dir2".ToAbsoluteDirectoryPath();
            Assert.IsFalse(absoluteAbsoluteDirectoryPath1.Equals(absoluteAbsoluteDirectoryPath2));

            absoluteAbsoluteDirectoryPath1 = @"C:\Dir1\Dir2".ToAbsoluteDirectoryPath();
            absoluteAbsoluteDirectoryPath2 = @"C:\Dir1\Dir".ToAbsoluteDirectoryPath();
            Assert.IsFalse(absoluteAbsoluteDirectoryPath1.Equals(absoluteAbsoluteDirectoryPath2));

            //
            // Mix between AbsoluteDirectoryPath and RelativeDirectoryPath
            //
            relativeRelativeDirectoryPath1 = @"..\Dir1\Dir2".ToRelativeDirectoryPath();
            absoluteAbsoluteDirectoryPath1 = @"C:\Dir1\Dir2".ToAbsoluteDirectoryPath();
            Assert.IsFalse(absoluteAbsoluteDirectoryPath1.Equals(relativeRelativeDirectoryPath1));
        }
示例#2
0
        public async Task <bool> IsFolderWhitelisted(IAbsoluteDirectoryPath path)
        {
            if (_folders.Any(path.Equals))
            {
                return(true);
            }
            var ctx = _locator.GetContentLinkContext();

            return((await ctx.GetFolderLink().ConfigureAwait(false)).Infos.Any(x => path.Equals(x.Path)));
        }
示例#3
0
        public static string GetRelativeDirectory(this IAbsoluteDirectoryPath path,
                                                  IAbsoluteDirectoryPath possibleRoot)
        {
            if (path.Equals(possibleRoot) || !path.CanGetRelativePathFrom(possibleRoot) ||
                !path.IsRootedIn(possibleRoot))
            {
                return(path.ToString());
            }

            return(path.GetRelativePathFrom(possibleRoot).Join());
        }
示例#4
0
        public void Test_PathEquality()
        {
            //
            // RelativeFilePath
            //
            IRelativeFilePath relativeFilePath1 = @"..\Dir1\File.txt".ToRelativeFilePath();
            IRelativeFilePath relativeFilePath2 = @"..\\dir1//file.TXT".ToRelativeFilePath();

            Assert.IsTrue(relativeFilePath1.Equals(relativeFilePath2));

            relativeFilePath1 = @"..\Dir1\File.txt".ToRelativeFilePath();
            relativeFilePath2 = @".\Dir1\File.txt".ToRelativeFilePath();
            Assert.IsFalse(relativeFilePath1.Equals(relativeFilePath2));

            relativeFilePath1 = @"..\Dir1\File.txt".ToRelativeFilePath();
            relativeFilePath2 = @"..\Dir1\Dir2\File.txt".ToRelativeFilePath();
            Assert.IsFalse(relativeFilePath1.Equals(relativeFilePath2));

            relativeFilePath1 = @"..\Dir1\File.txt".ToRelativeFilePath();
            relativeFilePath2 = @"..\Dir1\File.tx".ToRelativeFilePath();
            Assert.IsFalse(relativeFilePath1.Equals(relativeFilePath2));

            //
            // AbsoluteFilePath
            //
            IAbsoluteFilePath absoluteAbsoluteFilePath1 = @"C:\Dir1\File.txt".ToAbsoluteFilePath();
            IAbsoluteFilePath absoluteAbsoluteFilePath2 = @"C:\\dir1//file.TXT".ToAbsoluteFilePath();

            Assert.IsTrue(absoluteAbsoluteFilePath1.Equals(absoluteAbsoluteFilePath2));

            absoluteAbsoluteFilePath1 = @"C:\Dir1\File.txt".ToAbsoluteFilePath();
            absoluteAbsoluteFilePath2 = @"D:\Dir1\File.txt".ToAbsoluteFilePath();
            Assert.IsFalse(absoluteAbsoluteFilePath1.Equals(absoluteAbsoluteFilePath2));

            absoluteAbsoluteFilePath1 = @"C:\Dir1\File.txt".ToAbsoluteFilePath();
            absoluteAbsoluteFilePath2 = @"C:\Dir1\Dir2\File.txt".ToAbsoluteFilePath();
            Assert.IsFalse(absoluteAbsoluteFilePath1.Equals(absoluteAbsoluteFilePath2));

            absoluteAbsoluteFilePath1 = @"C:\Dir1\File.txt".ToAbsoluteFilePath();
            absoluteAbsoluteFilePath2 = @"C:\Dir1\File.tx".ToAbsoluteFilePath();
            Assert.IsFalse(absoluteAbsoluteFilePath1.Equals(absoluteAbsoluteFilePath2));

            //
            // Mix between AbsoluteFilePath and RelativeFilePath
            //
            relativeFilePath1         = @"..\Dir1\File.txt".ToRelativeFilePath();
            absoluteAbsoluteFilePath1 = @"C:\Dir1\File.txt".ToAbsoluteFilePath();
            Assert.IsFalse(absoluteAbsoluteFilePath1.Equals(relativeFilePath1));

            //
            // Mix between absoluteDirectoryPath and filePath
            //
            IAbsoluteDirectoryPath absoluteAbsoluteDirectoryPath1 = @"C:\Dir1\File".ToAbsoluteDirectoryPath();

            absoluteAbsoluteFilePath1 = @"C:\Dir1\File".ToAbsoluteFilePath();
            Assert.IsFalse(absoluteAbsoluteDirectoryPath1.Equals(absoluteAbsoluteFilePath1));
            Assert.IsFalse(absoluteAbsoluteFilePath1.Equals(absoluteAbsoluteDirectoryPath1));

            IRelativeDirectoryPath relativeRelativeDirectoryPath1 = @"..\Dir1\File".ToRelativeDirectoryPath();

            relativeFilePath1 = @"..\Dir1\File".ToRelativeFilePath();
            Assert.IsFalse(relativeRelativeDirectoryPath1.Equals(relativeFilePath1));
            Assert.IsFalse(relativeFilePath1.Equals(relativeRelativeDirectoryPath1));
        }
 public async Task<bool> IsFolderWhitelisted(IAbsoluteDirectoryPath path) {
     if (_folders.Any(path.Equals))
         return true;
     var ctx = _locator.GetContentLinkContext();
     return (await ctx.GetFolderLink().ConfigureAwait(false)).Infos.Any(x => path.Equals(x.Path));
 }