Пример #1
0
        public void AttributesFail()
        {
            var mountfs = new MountFileSystem();

            Assert.Throws <FileNotFoundException>(() => mountfs.GetAttributes("/toto.txt"));
            Assert.Throws <FileNotFoundException>(() => mountfs.SetAttributes("/toto.txt", FileAttributes.Normal));
        }
Пример #2
0
        public void EnumerateDoesntExist()
        {
            var mountFs = new MountFileSystem();

            mountFs.Mount("/x", new MemoryFileSystem());
            Assert.Throws <DirectoryNotFoundException>(() => mountFs.EnumeratePaths("/y", "*", SearchOption.AllDirectories, SearchTarget.Both).ToList());
        }
Пример #3
0
        public void EnumerateMountsOverride()
        {
            var baseFs = new MemoryFileSystem();

            baseFs.CreateDirectory("/foo/bar");
            baseFs.WriteAllText("/base.txt", "test");
            baseFs.WriteAllText("/foo/base.txt", "test");
            baseFs.WriteAllText("/foo/bar/base.txt", "test");

            var mountedFs = new MemoryFileSystem();

            mountedFs.WriteAllText("/mounted.txt", "test");

            var deepMountedFs = new MemoryFileSystem();

            deepMountedFs.WriteAllText("/deep_mounted.txt", "test");

            var mountFs = new MountFileSystem(baseFs);

            mountFs.Mount("/foo", mountedFs);
            mountFs.Mount("/foo/bar", deepMountedFs);

            var expected = new List <UPath>
            {
                "/base.txt",
                "/foo",
                "/foo/bar",
                "/foo/mounted.txt",
                "/foo/bar/deep_mounted.txt"
            };

            var actual = mountFs.EnumeratePaths("/", "*", SearchOption.AllDirectories).ToList();

            Assert.Equal(expected, actual);
        }
Пример #4
0
        public void OpenFileFail()
        {
            var mountfs = new MountFileSystem();

            Assert.Throws <FileNotFoundException>(() => mountfs.OpenFile("/toto.txt", FileMode.Open, FileAccess.Read));
            Assert.Throws <UnauthorizedAccessException>(() => mountfs.OpenFile("/toto.txt", FileMode.Create, FileAccess.Read));
        }
Пример #5
0
        public void TimesFail()
        {
            var mountfs = new MountFileSystem();

            Assert.Throws <FileNotFoundException>(() => mountfs.SetCreationTime("/toto.txt", DateTime.Now));
            Assert.Throws <FileNotFoundException>(() => mountfs.SetLastAccessTime("/toto.txt", DateTime.Now));
            Assert.Throws <FileNotFoundException>(() => mountfs.SetLastWriteTime("/toto.txt", DateTime.Now));
        }
Пример #6
0
        public void CopyFileFail()
        {
            var mountfs = new MountFileSystem();

            mountfs.Mount("/dir1", new MemoryFileSystem());
            Assert.Throws <FileNotFoundException>(() => mountfs.CopyFile("/test", "/test2", true));
            Assert.Throws <DirectoryNotFoundException>(() => mountfs.CopyFile("/dir1/test.txt", "/test2", true));
        }
Пример #7
0
        public void EnumerateEmptyOnRoot()
        {
            var mountFs  = new MountFileSystem();
            var expected = Array.Empty <UPath>();
            var actual   = mountFs.EnumeratePaths("/", "*", SearchOption.AllDirectories, SearchTarget.Both).ToList();

            Assert.Equal(expected, actual);
        }
Пример #8
0
        public void Read()
        {
            // check the inputPath
            if (!Directory.Exists(InputPath))
            {
                throw new DirectoryNotFoundException("The input path is not a valid directory");
            }

            // change the (probably) relative path to an absolute one
            InputPath = Path.GetFullPath(InputPath);

            // again.. change the (probably) relative path to an absolute one
            OutputPath = Path.GetFullPath(OutputPath);

            _logger.Info($"Source path: '{InputPath}'");
            _logger.Info($"Output path: '{OutputPath}'");

            // check the project configuration file
            foreach (var extension in new[] { "yaml", "yml" })
            {
                var path = Path.Join(InputPath, $"project.{extension}");

                if (File.Exists(path))
                {
                    ProjectConfigurationPath = path;
                    break;
                }
            }

            if (string.IsNullOrWhiteSpace(ProjectConfigurationPath))
            {
                throw new FileNotFoundException("The project configuration file does not exist");
            }

            _logger.Info($"Reading the project file '{ProjectConfigurationPath}'");

            var yamlDeserializer = new Deserializer();
            var configStream     = File.OpenText(ProjectConfigurationPath);

            ProjectData = yamlDeserializer.Deserialize <ProjectData>(configStream);

            _fileSystem = new MountFileSystem(new SubFileSystem(new PhysicalFileSystem(), OsPathToUPath(InputPath)));

            foreach (var i in ProjectData.Includes)
            {
                i.Path = Path.GetFullPath(i.Path, InputPath);

                if (!Directory.Exists(i.Path))
                {
                    throw new DirectoryNotFoundException($"The include directory does not exist: '{i.Path}'");
                }

                _fileSystem.Mount(i.Mount, new SubFileSystem(new PhysicalFileSystem(), OsPathToUPath(i.Path)));
            }

            _logger.Info(ProjectData);
        }
Пример #9
0
        public TestMountFileSystemCompatSub()
        {
            // Check that MountFileSystem is working with a mount with the compat test
            var mountfs = new MountFileSystem();
            mountfs.Mount("/customMount", new MemoryFileSystem());

            // Use a SubFileSystem to fake the mount to a root folder
            fs = new SubFileSystem(mountfs, "/customMount");
        }
Пример #10
0
        public void DeleteDirectoryFail()
        {
            var mountfs = new MountFileSystem();

            mountfs.Mount("/dir1", new MemoryFileSystem());

            Assert.Throws <UnauthorizedAccessException>(() => mountfs.DeleteDirectory("/dir1", true));
            Assert.Throws <UnauthorizedAccessException>(() => mountfs.DeleteDirectory("/dir1", false));
            Assert.Throws <DirectoryNotFoundException>(() => mountfs.DeleteDirectory("/dir2", false));
        }
Пример #11
0
        protected MountFileSystem GetCommonMountFileSystemWithOnlyBackup()
        {
            // Check on MountFileSystem directly with backup mount
            var fs = new MemoryFileSystem();

            CreateFolderStructure(fs);
            var mountfs = new MountFileSystem(fs);

            return(mountfs);
        }
Пример #12
0
        public void MoveDirectoryFail()
        {
            var mountfs = new MountFileSystem();

            mountfs.Mount("/dir1", new MemoryFileSystem());
            mountfs.Mount("/dir2", new MemoryFileSystem());

            Assert.Throws <UnauthorizedAccessException>(() => mountfs.MoveDirectory("/dir1", "/dir2/yyy"));
            Assert.Throws <UnauthorizedAccessException>(() => mountfs.MoveDirectory("/dir1/xxx", "/dir2"));
            Assert.Throws <NotSupportedException>(() => mountfs.MoveDirectory("/dir1/xxx", "/dir2/yyy"));
        }
Пример #13
0
        public void DirectoryExistsPartialMountName()
        {
            var fs      = new MemoryFileSystem();
            var mountFs = new MountFileSystem();

            mountFs.Mount("/x/y/z", fs);

            Assert.True(mountFs.DirectoryExists("/x"));
            Assert.True(mountFs.DirectoryExists("/x/y"));
            Assert.True(mountFs.DirectoryExists("/x/y/z"));
            Assert.False(mountFs.DirectoryExists("/z"));
        }
Пример #14
0
        public void DirectoryEntryPartialMountName()
        {
            var fs = new MemoryFileSystem();

            fs.CreateDirectory("/w");

            var mountFs = new MountFileSystem();

            mountFs.Mount("/x/y/z", fs);

            Assert.NotNull(mountFs.GetDirectoryEntry("/x"));
            Assert.NotNull(mountFs.GetDirectoryEntry("/x/y"));
            Assert.NotNull(mountFs.GetDirectoryEntry("/x/y/z"));
            Assert.NotNull(mountFs.GetDirectoryEntry("/x/y/z/w"));
        }
Пример #15
0
        public void TestMount()
        {
            var fs    = new MountFileSystem();
            var memfs = new MemoryFileSystem();

            Assert.Throws <ArgumentNullException>(() => fs.Mount(null, memfs));
            Assert.Throws <ArgumentNullException>(() => fs.Mount("/test", null));
            Assert.Throws <ArgumentException>(() => fs.Mount("test", memfs));
            Assert.Throws <ArgumentException>(() => fs.Mount("/", memfs));

            Assert.False(fs.IsMounted("/test"));
            fs.Mount("/test", memfs);
            Assert.True(fs.IsMounted("/test"));
            Assert.Throws <ArgumentException>(() => fs.Mount("/test", memfs));
            Assert.Throws <ArgumentException>(() => fs.Mount("/test", fs));

            Assert.Throws <ArgumentNullException>(() => fs.Unmount(null));
            Assert.Throws <ArgumentException>(() => fs.Unmount("test"));
            Assert.Throws <ArgumentException>(() => fs.Unmount("/"));
            Assert.Throws <ArgumentException>(() => fs.Unmount("/test/a"));
            Assert.Throws <ArgumentException>(() => fs.Unmount("/test/a/b"));
            Assert.Throws <ArgumentException>(() => fs.Unmount("/test2"));

            fs.Mount("/test2", memfs);
            Assert.True(fs.IsMounted("/test"));
            Assert.True(fs.IsMounted("/test2"));

            Assert.Equal(new Dictionary <UPath, IFileSystem>()
            {
                { "/test", memfs },
                { "/test2", memfs },
            }, fs.GetMounts());

            fs.Unmount("/test");
            Assert.False(fs.IsMounted("/test"));
            Assert.True(fs.IsMounted("/test2"));

            fs.Unmount("/test2");

            Assert.Equal(0, fs.GetMounts().Count);

            var innerFs = GetCommonMemoryFileSystem();

            fs.Mount("/x/y", innerFs);
            fs.Mount("/x/y/b", innerFs);
            Assert.True(fs.FileExists("/x/y/A.txt"));
            Assert.True(fs.FileExists("/x/y/b/A.txt"));
        }
Пример #16
0
        public void ReplaceFileFail()
        {
            var mountfs = new MountFileSystem();
            var memfs1  = new MemoryFileSystem();

            memfs1.WriteAllText("/file.txt", "content1");

            var memfs2 = new MemoryFileSystem();

            memfs2.WriteAllText("/file2.txt", "content1");

            mountfs.Mount("/dir1", memfs1);
            mountfs.Mount("/dir2", memfs2);
            Assert.Throws <FileNotFoundException>(() => mountfs.ReplaceFile("/dir1/file.txt", "/dir1/to.txt", "/dir1/to.bak", true));
            Assert.Throws <FileNotFoundException>(() => mountfs.ReplaceFile("/dir1/to.txt", "/dir1/file.txt", "/dir1/to.bak", true));
            Assert.Throws <NotSupportedException>(() => mountfs.ReplaceFile("/dir1/file.txt", "/dir2/file2.txt", null, true));
        }
Пример #17
0
        public void MoveFileFail()
        {
            var mountfs = new MountFileSystem();
            var memfs1  = new MemoryFileSystem();

            memfs1.WriteAllText("/file.txt", "content1");

            var memfs2 = new MemoryFileSystem();

            memfs2.WriteAllText("/file2.txt", "content1");

            mountfs.Mount("/dir1", memfs1);
            mountfs.Mount("/dir2", memfs2);
            Assert.Throws <DirectoryNotFoundException>(() => mountfs.MoveFile("/dir1/file.txt", "/xxx/yyy.txt"));
            Assert.Throws <FileNotFoundException>(() => mountfs.MoveFile("/dir1/xxx", "/dir1/file1.txt"));
            Assert.Throws <FileNotFoundException>(() => mountfs.MoveFile("/xxx", "/dir1/file1.txt"));
        }
Пример #18
0
        protected MountFileSystem GetCommonMountFileSystemWithMounts()
        {
            // Check on MountFileSystem
            // with real mount
            var fs = new MemoryFileSystem();

            CreateFolderStructure(fs);
            fs.DeleteDirectory("/b", true);
            fs.DeleteDirectory("/C", true);

            var fs1 = new MemoryFileSystem();

            fs1.WriteAllText("/b.i", "content");

            var mountfs = new MountFileSystem(fs);

            mountfs.Mount("/b", fs1);
            mountfs.Mount("/C", new MemoryFileSystem());

            return(mountfs);
        }
Пример #19
0
        public void EnumerateDeepMountPartial()
        {
            var fs      = GetCommonMemoryFileSystem();
            var mountFs = new MountFileSystem();

            mountFs.Mount("/x/y/z", fs);
            Assert.True(mountFs.FileExists("/x/y/z/A.txt"));

            var expected = new List <UPath>
            {
                "/x/y",
                "/x/y/z",
                "/x/y/z/a",
                "/x/y/z/A.txt"
            };

            // only concerned with the first few because it should list the mount parts first
            var actual = mountFs.EnumeratePaths("/x", "*", SearchOption.AllDirectories).Take(4).ToList();

            Assert.Equal(expected, actual);
        }
Пример #20
0
        public void CopyAndMoveFileCross()
        {
            var mountfs = new MountFileSystem();
            var memfs1  = new MemoryFileSystem();

            memfs1.WriteAllText("/file1.txt", "content1");
            var memfs2 = new MemoryFileSystem();

            mountfs.Mount("/dir1", memfs1);
            mountfs.Mount("/dir2", memfs2);

            mountfs.CopyFile("/dir1/file1.txt", "/dir2/file2.txt", true);

            Assert.True(memfs2.FileExists("/file2.txt"));
            Assert.Equal("content1", memfs2.ReadAllText("/file2.txt"));

            mountfs.MoveFile("/dir1/file1.txt", "/dir2/file1.txt");

            Assert.False(memfs1.FileExists("/file1.txt"));
            Assert.True(memfs2.FileExists("/file1.txt"));
            Assert.Equal("content1", memfs2.ReadAllText("/file1.txt"));
        }
Пример #21
0
        public void GetFileLengthFail()
        {
            var mountfs = new MountFileSystem();

            Assert.Throws <FileNotFoundException>(() => mountfs.GetFileLength("/toto.txt"));
        }
Пример #22
0
        public void CreateDirectoryFail()
        {
            var mountfs = new MountFileSystem();

            Assert.Throws <UnauthorizedAccessException>(() => mountfs.CreateDirectory("/test"));
        }
Пример #23
0
 public TestMountFileSystemCompat()
 {
     // Check that the MountFileSystem is working with only a plain backup MemoryFileSystem with the compat test
     fs = new MountFileSystem(new MemoryFileSystem());
 }
Пример #24
0
        public void EnumerateFail()
        {
            var mountfs = new MountFileSystem();

            Assert.Throws <DirectoryNotFoundException>(() => mountfs.EnumeratePaths("/dir").ToList());
        }