def test__when_copying_to_non_pyfilesystem__should_raise_runtime_error(): target_fs = NonPyFilesystemBasedFilesystem() origin_fs = MemoryFS() origin_fs.create(SOURCE) sut = _TestFilesystemImpl(origin_fs) with pytest.raises(RuntimeError): sut.copy(SOURCE, TARGET, filesystem=target_fs)
def test__when_copying__but_file_exists__should_raise_file_exists_error(): mem_fs = MemoryFS() mem_fs.create(SOURCE) mem_fs.create(TARGET) sut = _TestFilesystemImpl(mem_fs) with pytest.raises(FileExistsError): sut.copy(SOURCE, TARGET)
def test__when_copying_to_other_filesystem__but_file_exists__should_raise_file_exists_error( ): origin_fs = MemoryFS() origin_fs.create(SOURCE) target_fs = MemoryFS() target_fs.create(TARGET) sut = _TestFilesystemImpl(origin_fs) with pytest.raises(FileExistsError): sut.copy(SOURCE, TARGET, filesystem=_TestFilesystemImpl(target_fs))
def test__when_deleting_with_glob_pattern__it_deletes_matching_files(): mem_fs = MemoryFS() mem_fs.create("hello.txt") mem_fs.create("world.txt") mem_fs.create("nope.gif") sut = _TestFilesystemImpl(mem_fs) sut.delete("*.txt") assert not mem_fs.exists("hello.txt") assert not mem_fs.exists("world.txt") assert mem_fs.exists("nope.gif")
def test__when_copying_files_with_glob_pattern__it_copies_matching_files(): mem_fs = MemoryFS() mem_fs.create("hello.txt") mem_fs.create("world.txt") mem_fs.create("nope.gif") sut = _TestFilesystemImpl(mem_fs) sut.copy("*.txt", "newdir/") assert mem_fs.exists("newdir/hello.txt") assert mem_fs.exists("newdir/world.txt") assert not mem_fs.exists("newdir/nope.gif")
def test__when_globbing__it_returns_matching_paths(): mem_fs = MemoryFS() mem_fs.create("hello.txt") mem_fs.create("world.txt") mem_fs.create("nope.gif") subfs = mem_fs.makedir("sub") subfs.create("nomatch.gif") subfs.create("match.txt") sut = _TestFilesystemImpl(mem_fs) actual = sut.glob("**/**.txt") assert actual == ["hello.txt", "world.txt", "sub/match.txt"]
def test__when_copying_file_to_other_filesystem__and_parent_dir_exists__should_not_try_to_create_dirs( ): target_parent_dir = "another/folder" target_fs = MemoryFS() target_fs.makedirs(target_parent_dir) target_fs_wrapping_mock = MagicMock(spec=MemoryFS, wraps=target_fs) origin_fs = MemoryFS() origin_fs.create(SOURCE) sut = _TestFilesystemImpl(origin_fs) complete_path = f"{target_parent_dir}/{TARGET}" sut.copy(SOURCE, complete_path, filesystem=_TestFilesystemImpl(target_fs_wrapping_mock)) target_fs_wrapping_mock.makedirs.assert_not_called()
class TestBoundWalkerBase(unittest.TestCase): def setUp(self): """ Sets up the following file system with empty files: / -foo1/ - -top1.txt - -top2.txt -foo2/ - -bar1/ - -bar2/ - - -bar3/ - - - -test.txt - -top3.bin -foo3/ """ self.fs = MemoryFS() self.fs.makedir("foo1") self.fs.makedir("foo2") self.fs.makedir("foo3") self.fs.create("foo1/top1.txt") self.fs.create("foo1/top2.txt") self.fs.makedir("foo1/bar1") self.fs.makedir("foo2/bar2") self.fs.makedir("foo2/bar2/bar3") self.fs.create("foo2/bar2/bar3/test.txt") self.fs.create("foo2/top3.bin")
class TestWalk(unittest.TestCase): def setUp(self): self.fs = MemoryFS() self.fs.makedir('foo1') self.fs.makedir('foo2') self.fs.makedir('foo3') self.fs.create('foo1/top1.txt') self.fs.create('foo1/top2.txt') self.fs.makedir('foo1/bar1') self.fs.makedir('foo2/bar2') self.fs.makedir('foo2/bar2/bar3') self.fs.create('foo2/bar2/bar3/test.txt') self.fs.create('foo2/top3.txt') def test_invalid(self): with self.assertRaises(ValueError): self.fs.walk(search='random') def test_repr(self): repr(self.fs.walk) def test_walk(self): walk = [] for path, dirs, files in self.fs.walk(): walk.append( (path, [info.name for info in dirs], [info.name for info in files])) expected = [(u'/', [u'foo1', u'foo2', u'foo3'], []), (u'/foo1', [u'bar1'], [u'top1.txt', u'top2.txt']), (u'/foo2', [u'bar2'], [u'top3.txt']), (u'/foo3', [], []), (u'/foo1/bar1', [], []), (u'/foo2/bar2', [u'bar3'], []), (u'/foo2/bar2/bar3', [], [u'test.txt'])] self.assertEqual(walk, expected) def test_walk_files(self): files = list(self.fs.walk.files()) self.assertEqual(files, [ '/foo1/top1.txt', '/foo1/top2.txt', '/foo2/top3.txt', '/foo2/bar2/bar3/test.txt', ]) files = list(self.fs.walk.files(search="depth")) self.assertEqual(files, [ '/foo1/top1.txt', '/foo1/top2.txt', '/foo2/bar2/bar3/test.txt', '/foo2/top3.txt', ]) def test_walk_dirs(self): dirs = list(self.fs.walk.dirs()) self.assertEqual(dirs, [ '/foo1', '/foo2', '/foo3', '/foo1/bar1', '/foo2/bar2', '/foo2/bar2/bar3' ]) dirs = list(self.fs.walk.dirs(search="depth")) self.assertEqual(dirs, [ '/foo1/bar1', '/foo2/bar2/bar3', '/foo2/bar2', '/foo1', '/foo2', '/foo3' ]) dirs = list(self.fs.walk.dirs(search="depth", exclude_dirs=['foo2'])) self.assertEqual(dirs, ['/foo1/bar1', '/foo1', '/foo3']) def test_walk_info(self): walk = [] for path, info in self.fs.walk.info(): walk.append((path, info.is_dir, info.name)) expected = [(u'/foo1', True, u'foo1'), (u'/foo2', True, u'foo2'), (u'/foo3', True, u'foo3'), (u'/foo1/bar1', True, u'bar1'), (u'/foo1/top1.txt', False, u'top1.txt'), (u'/foo1/top2.txt', False, u'top2.txt'), (u'/foo2/bar2', True, u'bar2'), (u'/foo2/top3.txt', False, u'top3.txt'), (u'/foo2/bar2/bar3', True, u'bar3'), (u'/foo2/bar2/bar3/test.txt', False, u'test.txt')] self.assertEqual(walk, expected) def test_broken(self): original_scandir = self.fs.scandir def broken_scandir(path, namespaces=None): if path == '/foo2': raise FSError("can't read dir") return original_scandir(path, namespaces=namespaces) self.fs.scandir = broken_scandir files = list(self.fs.walk.files(search="depth", ignore_errors=True)) self.assertEqual(files, ['/foo1/top1.txt', '/foo1/top2.txt']) with self.assertRaises(FSError): list(self.fs.walk.files(on_error=lambda path, error: False)) def test_on_error_invalid(self): with self.assertRaises(TypeError): walk.Walker(on_error='nope')
class TestWalk(unittest.TestCase): def setUp(self): self.fs = MemoryFS() self.fs.makedir('foo1') self.fs.makedir('foo2') self.fs.makedir('foo3') self.fs.create('foo1/top1.txt') self.fs.create('foo1/top2.txt') self.fs.makedir('foo1/bar1') self.fs.makedir('foo2/bar2') self.fs.makedir('foo2/bar2/bar3') self.fs.create('foo2/bar2/bar3/test.txt') self.fs.create('foo2/top3.bin') def test_invalid(self): with self.assertRaises(ValueError): self.fs.walk(search='random') def test_repr(self): repr(self.fs.walk) def test_walk(self): _walk = [] for step in self.fs.walk(): self.assertIsInstance(step, walk.Step) path, dirs, files = step _walk.append( (path, [info.name for info in dirs], [info.name for info in files])) expected = [(u'/', [u'foo1', u'foo2', u'foo3'], []), (u'/foo1', [u'bar1'], [u'top1.txt', u'top2.txt']), (u'/foo2', [u'bar2'], [u'top3.bin']), (u'/foo3', [], []), (u'/foo1/bar1', [], []), (u'/foo2/bar2', [u'bar3'], []), (u'/foo2/bar2/bar3', [], [u'test.txt'])] self.assertEqual(_walk, expected) def test_walk_depth(self): _walk = [] for step in self.fs.walk(search='depth'): self.assertIsInstance(step, walk.Step) path, dirs, files = step _walk.append( (path, [info.name for info in dirs], [info.name for info in files])) expected = [(u'/foo1/bar1', [], []), (u'/foo1', [u'bar1'], [u'top1.txt', u'top2.txt']), (u'/foo2/bar2/bar3', [], [u'test.txt']), (u'/foo2/bar2', [u'bar3'], []), (u'/foo2', [u'bar2'], [u'top3.bin']), (u'/foo3', [], []), (u'/', [u'foo1', u'foo2', u'foo3'], [])] self.assertEqual(_walk, expected) def test_walk_directory(self): _walk = [] for step in self.fs.walk('foo2'): self.assertIsInstance(step, walk.Step) path, dirs, files = step _walk.append( (path, [info.name for info in dirs], [info.name for info in files])) expected = [(u'/foo2', [u'bar2'], [u'top3.bin']), (u'/foo2/bar2', [u'bar3'], []), (u'/foo2/bar2/bar3', [], [u'test.txt'])] self.assertEqual(_walk, expected) def test_walk_levels_1(self): results = list(self.fs.walk(max_depth=1)) self.assertEqual(len(results), 1) dirs = sorted(info.name for info in results[0].dirs) self.assertEqual(dirs, ['foo1', 'foo2', 'foo3']) files = sorted(info.name for info in results[0].files) self.assertEqual(files, []) def test_walk_levels_1_depth(self): results = list(self.fs.walk(max_depth=1, search='depth')) self.assertEqual(len(results), 1) dirs = sorted(info.name for info in results[0].dirs) self.assertEqual(dirs, ['foo1', 'foo2', 'foo3']) files = sorted(info.name for info in results[0].files) self.assertEqual(files, []) def test_walk_levels_2(self): _walk = [] for step in self.fs.walk(max_depth=2): self.assertIsInstance(step, walk.Step) path, dirs, files = step _walk.append((path, sorted(info.name for info in dirs), sorted(info.name for info in files))) expected = [(u'/', [u'foo1', u'foo2', u'foo3'], []), (u'/foo1', [u'bar1'], [u'top1.txt', u'top2.txt']), (u'/foo2', [u'bar2'], [u'top3.bin']), (u'/foo3', [], [])] self.assertEqual(_walk, expected) def test_walk_files(self): files = list(self.fs.walk.files()) self.assertEqual(files, [ '/foo1/top1.txt', '/foo1/top2.txt', '/foo2/top3.bin', '/foo2/bar2/bar3/test.txt', ]) files = list(self.fs.walk.files(search="depth")) self.assertEqual(files, [ '/foo1/top1.txt', '/foo1/top2.txt', '/foo2/bar2/bar3/test.txt', '/foo2/top3.bin', ]) def test_walk_dirs(self): dirs = list(self.fs.walk.dirs()) self.assertEqual(dirs, [ '/foo1', '/foo2', '/foo3', '/foo1/bar1', '/foo2/bar2', '/foo2/bar2/bar3' ]) dirs = list(self.fs.walk.dirs(search="depth")) self.assertEqual(dirs, [ '/foo1/bar1', '/foo1', '/foo2/bar2/bar3', '/foo2/bar2', '/foo2', '/foo3' ]) dirs = list(self.fs.walk.dirs(search="depth", exclude_dirs=['foo2'])) self.assertEqual(dirs, ['/foo1/bar1', '/foo1', '/foo3']) def test_walk_files_filter(self): files = list(self.fs.walk.files(filter=['*.txt'])) self.assertEqual(files, [ '/foo1/top1.txt', '/foo1/top2.txt', '/foo2/bar2/bar3/test.txt', ]) files = list(self.fs.walk.files(search="depth", filter=['*.txt'])) self.assertEqual(files, [ '/foo1/top1.txt', '/foo1/top2.txt', '/foo2/bar2/bar3/test.txt', ]) files = list(self.fs.walk.files(filter=['*.bin'])) self.assertEqual(files, ['/foo2/top3.bin']) files = list(self.fs.walk.files(filter=['*.nope'])) self.assertEqual(files, []) def test_walk_info(self): walk = [] for path, info in self.fs.walk.info(): walk.append((path, info.is_dir, info.name)) expected = [(u'/foo1', True, u'foo1'), (u'/foo2', True, u'foo2'), (u'/foo3', True, u'foo3'), (u'/foo1/top1.txt', False, u'top1.txt'), (u'/foo1/top2.txt', False, u'top2.txt'), (u'/foo1/bar1', True, u'bar1'), (u'/foo2/bar2', True, u'bar2'), (u'/foo2/top3.bin', False, u'top3.bin'), (u'/foo2/bar2/bar3', True, u'bar3'), (u'/foo2/bar2/bar3/test.txt', False, u'test.txt')] self.assertEqual(walk, expected) def test_broken(self): original_scandir = self.fs.scandir def broken_scandir(path, namespaces=None): if path == '/foo2': raise FSError("can't read dir") return original_scandir(path, namespaces=namespaces) self.fs.scandir = broken_scandir files = list(self.fs.walk.files(search="depth", ignore_errors=True)) self.assertEqual(files, ['/foo1/top1.txt', '/foo1/top2.txt']) with self.assertRaises(FSError): list(self.fs.walk.files(on_error=lambda path, error: False)) def test_on_error_invalid(self): with self.assertRaises(TypeError): walk.Walker(on_error='nope') def test_subdir_uses_same_walker(self): class CustomWalker(walk.Walker): @classmethod def bind(cls, fs): return walk.BoundWalker(fs, walker_class=CustomWalker) class CustomizedMemoryFS(MemoryFS): walker_class = CustomWalker base_fs = CustomizedMemoryFS() base_fs.settext("a", "a") base_fs.makedirs("b") base_fs.settext("b/c", "c") base_fs.settext("b/d", "d") base_walker = base_fs.walk self.assertEqual(base_walker.walker_class, CustomWalker) six.assertCountEqual(self, ["/a", "/b/c", "/b/d"], base_walker.files()) sub_fs = base_fs.opendir("b") sub_walker = sub_fs.walk self.assertEqual(sub_walker.walker_class, CustomWalker) six.assertCountEqual(self, ["/c", "/d"], sub_walker.files()) def test_readonly_wrapper_uses_same_walker(self): class CustomWalker(walk.Walker): @classmethod def bind(cls, fs): return walk.BoundWalker(fs, walker_class=CustomWalker) class CustomizedMemoryFS(MemoryFS): walker_class = CustomWalker base_fs = CustomizedMemoryFS() base_walker = base_fs.walk self.assertEqual(base_walker.walker_class, CustomWalker) readonly_fs = read_only(CustomizedMemoryFS()) readonly_walker = readonly_fs.walk self.assertEqual(readonly_walker.walker_class, CustomWalker)
import dokanmount import os.path import tempfile from fs.osfs import OSFS from fs.memoryfs import MemoryFS from shutil import rmtree from six import b path = tempfile.mkdtemp() try: #fs = OSFS(path) fs = MemoryFS() fs.create('test.txt') fs.appendtext('test.txt', 'This is a test file', encoding=u'utf-8', errors=None, newline=u'') fs.makedir("TestDir") fs.create('TestDir/subtest.txt') fs.appendtext('TestDir/subtest.txt', 'This is a test file in a subfolder', encoding=u'utf-8', errors=None, newline=u'') flags = dokanmount.DOKAN_OPTION_DEBUG | dokanmount.DOKAN_OPTION_STDERR | dokanmount.DOKAN_OPTION_REMOVABLE a = dokanmount.mount(fs, "Q:\\", foreground=True, numthreads=2, flags=flags) #fs.close()
class TestWalk(unittest.TestCase): def setUp(self): self.fs = MemoryFS() self.fs.makedir("foo1") self.fs.makedir("foo2") self.fs.makedir("foo3") self.fs.create("foo1/top1.txt") self.fs.create("foo1/top2.txt") self.fs.makedir("foo1/bar1") self.fs.makedir("foo2/bar2") self.fs.makedir("foo2/bar2/bar3") self.fs.create("foo2/bar2/bar3/test.txt") self.fs.create("foo2/top3.bin") def test_invalid(self): with self.assertRaises(ValueError): self.fs.walk(search="random") def test_repr(self): repr(self.fs.walk) def test_walk(self): _walk = [] for step in self.fs.walk(): self.assertIsInstance(step, walk.Step) path, dirs, files = step _walk.append( (path, [info.name for info in dirs], [info.name for info in files]) ) expected = [ ("/", ["foo1", "foo2", "foo3"], []), ("/foo1", ["bar1"], ["top1.txt", "top2.txt"]), ("/foo2", ["bar2"], ["top3.bin"]), ("/foo3", [], []), ("/foo1/bar1", [], []), ("/foo2/bar2", ["bar3"], []), ("/foo2/bar2/bar3", [], ["test.txt"]), ] self.assertEqual(_walk, expected) def test_walk_filter_dirs(self): _walk = [] for step in self.fs.walk(filter_dirs=["foo*"]): self.assertIsInstance(step, walk.Step) path, dirs, files = step _walk.append( (path, [info.name for info in dirs], [info.name for info in files]) ) expected = [ ("/", ["foo1", "foo2", "foo3"], []), ("/foo1", [], ["top1.txt", "top2.txt"]), ("/foo2", [], ["top3.bin"]), ("/foo3", [], []), ] self.assertEqual(_walk, expected) def test_walk_depth(self): _walk = [] for step in self.fs.walk(search="depth"): self.assertIsInstance(step, walk.Step) path, dirs, files = step _walk.append( (path, [info.name for info in dirs], [info.name for info in files]) ) expected = [ ("/foo1/bar1", [], []), ("/foo1", ["bar1"], ["top1.txt", "top2.txt"]), ("/foo2/bar2/bar3", [], ["test.txt"]), ("/foo2/bar2", ["bar3"], []), ("/foo2", ["bar2"], ["top3.bin"]), ("/foo3", [], []), ("/", ["foo1", "foo2", "foo3"], []), ] self.assertEqual(_walk, expected) def test_walk_directory(self): _walk = [] for step in self.fs.walk("foo2"): self.assertIsInstance(step, walk.Step) path, dirs, files = step _walk.append( (path, [info.name for info in dirs], [info.name for info in files]) ) expected = [ ("/foo2", ["bar2"], ["top3.bin"]), ("/foo2/bar2", ["bar3"], []), ("/foo2/bar2/bar3", [], ["test.txt"]), ] self.assertEqual(_walk, expected) def test_walk_levels_1(self): results = list(self.fs.walk(max_depth=1)) self.assertEqual(len(results), 1) dirs = sorted(info.name for info in results[0].dirs) self.assertEqual(dirs, ["foo1", "foo2", "foo3"]) files = sorted(info.name for info in results[0].files) self.assertEqual(files, []) def test_walk_levels_1_depth(self): results = list(self.fs.walk(max_depth=1, search="depth")) self.assertEqual(len(results), 1) dirs = sorted(info.name for info in results[0].dirs) self.assertEqual(dirs, ["foo1", "foo2", "foo3"]) files = sorted(info.name for info in results[0].files) self.assertEqual(files, []) def test_walk_levels_2(self): _walk = [] for step in self.fs.walk(max_depth=2): self.assertIsInstance(step, walk.Step) path, dirs, files = step _walk.append( ( path, sorted(info.name for info in dirs), sorted(info.name for info in files), ) ) expected = [ ("/", ["foo1", "foo2", "foo3"], []), ("/foo1", ["bar1"], ["top1.txt", "top2.txt"]), ("/foo2", ["bar2"], ["top3.bin"]), ("/foo3", [], []), ] self.assertEqual(_walk, expected) def test_walk_files(self): files = list(self.fs.walk.files()) self.assertEqual( files, [ "/foo1/top1.txt", "/foo1/top2.txt", "/foo2/top3.bin", "/foo2/bar2/bar3/test.txt", ], ) files = list(self.fs.walk.files(search="depth")) self.assertEqual( files, [ "/foo1/top1.txt", "/foo1/top2.txt", "/foo2/bar2/bar3/test.txt", "/foo2/top3.bin", ], ) def test_walk_dirs(self): dirs = list(self.fs.walk.dirs()) self.assertEqual( dirs, ["/foo1", "/foo2", "/foo3", "/foo1/bar1", "/foo2/bar2", "/foo2/bar2/bar3"], ) dirs = list(self.fs.walk.dirs(search="depth")) self.assertEqual( dirs, ["/foo1/bar1", "/foo1", "/foo2/bar2/bar3", "/foo2/bar2", "/foo2", "/foo3"], ) dirs = list(self.fs.walk.dirs(search="depth", exclude_dirs=["foo2"])) self.assertEqual(dirs, ["/foo1/bar1", "/foo1", "/foo3"]) def test_walk_files_filter(self): files = list(self.fs.walk.files(filter=["*.txt"])) self.assertEqual( files, ["/foo1/top1.txt", "/foo1/top2.txt", "/foo2/bar2/bar3/test.txt"] ) files = list(self.fs.walk.files(search="depth", filter=["*.txt"])) self.assertEqual( files, ["/foo1/top1.txt", "/foo1/top2.txt", "/foo2/bar2/bar3/test.txt"] ) files = list(self.fs.walk.files(filter=["*.bin"])) self.assertEqual(files, ["/foo2/top3.bin"]) files = list(self.fs.walk.files(filter=["*.nope"])) self.assertEqual(files, []) def test_walk_files_exclude(self): # Test exclude argument works files = list(self.fs.walk.files(exclude=["*.txt"])) self.assertEqual(files, ["/foo2/top3.bin"]) # Test exclude doesn't break filter files = list(self.fs.walk.files(filter=["*.bin"], exclude=["*.txt"])) self.assertEqual(files, ["/foo2/top3.bin"]) # Test excluding everything files = list(self.fs.walk.files(exclude=["*"])) self.assertEqual(files, []) def test_walk_info(self): walk = [] for path, info in self.fs.walk.info(): walk.append((path, info.is_dir, info.name)) expected = [ ("/foo1", True, "foo1"), ("/foo2", True, "foo2"), ("/foo3", True, "foo3"), ("/foo1/top1.txt", False, "top1.txt"), ("/foo1/top2.txt", False, "top2.txt"), ("/foo1/bar1", True, "bar1"), ("/foo2/bar2", True, "bar2"), ("/foo2/top3.bin", False, "top3.bin"), ("/foo2/bar2/bar3", True, "bar3"), ("/foo2/bar2/bar3/test.txt", False, "test.txt"), ] self.assertEqual(walk, expected) def test_broken(self): original_scandir = self.fs.scandir def broken_scandir(path, namespaces=None): if path == "/foo2": raise FSError("can't read dir") return original_scandir(path, namespaces=namespaces) self.fs.scandir = broken_scandir files = list(self.fs.walk.files(search="depth", ignore_errors=True)) self.assertEqual(files, ["/foo1/top1.txt", "/foo1/top2.txt"]) with self.assertRaises(FSError): list(self.fs.walk.files(on_error=lambda path, error: False)) def test_on_error_invalid(self): with self.assertRaises(TypeError): walk.Walker(on_error="nope") def test_subdir_uses_same_walker(self): class CustomWalker(walk.Walker): @classmethod def bind(cls, fs): return walk.BoundWalker(fs, walker_class=CustomWalker) class CustomizedMemoryFS(MemoryFS): walker_class = CustomWalker base_fs = CustomizedMemoryFS() base_fs.writetext("a", "a") base_fs.makedirs("b") base_fs.writetext("b/c", "c") base_fs.writetext("b/d", "d") base_walker = base_fs.walk self.assertEqual(base_walker.walker_class, CustomWalker) six.assertCountEqual(self, ["/a", "/b/c", "/b/d"], base_walker.files()) sub_fs = base_fs.opendir("b") sub_walker = sub_fs.walk self.assertEqual(sub_walker.walker_class, CustomWalker) six.assertCountEqual(self, ["/c", "/d"], sub_walker.files()) def test_readonly_wrapper_uses_same_walker(self): class CustomWalker(walk.Walker): @classmethod def bind(cls, fs): return walk.BoundWalker(fs, walker_class=CustomWalker) class CustomizedMemoryFS(MemoryFS): walker_class = CustomWalker base_fs = CustomizedMemoryFS() base_walker = base_fs.walk self.assertEqual(base_walker.walker_class, CustomWalker) readonly_fs = read_only(CustomizedMemoryFS()) readonly_walker = readonly_fs.walk self.assertEqual(readonly_walker.walker_class, CustomWalker)
class TestInfo(unittest.TestCase): def setUp(self): self.fs = MemoryFS() self.fs.makedir("foo") self.fs.makedir("bar") self.fs.makedir("baz") self.fs.makedirs("foo/egg1") self.fs.makedirs("foo/egg2") self.fs.create("/root1") self.fs.create("/root2") self.fs.create("/foo/test.txt") self.fs.create("/foo/test2.txt") self.fs.create("/foo/.hidden") self.fs.makedirs("/deep/deep1/deep2/deep3/deep4/deep5/deep6") def test_tree(self): output_file = io.StringIO() tree.render(self.fs, file=output_file) expected = "|-- bar\n|-- baz\n|-- deep\n| `-- deep1\n| `-- deep2\n| `-- deep3\n| `-- deep4\n| `-- deep5\n|-- foo\n| |-- egg1\n| |-- egg2\n| |-- .hidden\n| |-- test.txt\n| `-- test2.txt\n|-- root1\n`-- root2\n" self.assertEqual(output_file.getvalue(), expected) def test_tree_encoding(self): output_file = io.StringIO() tree.render(self.fs, file=output_file, with_color=True) print(repr(output_file.getvalue())) expected = "\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mbar\x1b[0m\n\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mbaz\x1b[0m\n\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mdeep\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[1;34mdeep1\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[1;34mdeep2\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[1;34mdeep3\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[1;34mdeep4\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[1;34mdeep5\x1b[0m\n\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mfoo\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m \x1b[1;34megg1\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m \x1b[1;34megg2\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m \x1b[33m.hidden\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m test.txt\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m test2.txt\n\x1b[32m\u251c\u2500\u2500\x1b[0m root1\n\x1b[32m\u2514\u2500\u2500\x1b[0m root2\n" self.assertEqual(output_file.getvalue(), expected) def test_tree_bytes_no_dirs_first(self): output_file = io.StringIO() tree.render(self.fs, file=output_file, dirs_first=False) expected = "|-- bar\n|-- baz\n|-- deep\n| `-- deep1\n| `-- deep2\n| `-- deep3\n| `-- deep4\n| `-- deep5\n|-- foo\n| |-- .hidden\n| |-- egg1\n| |-- egg2\n| |-- test.txt\n| `-- test2.txt\n|-- root1\n`-- root2\n" self.assertEqual(output_file.getvalue(), expected) def test_error(self): output_file = io.StringIO() filterdir = self.fs.filterdir def broken_filterdir(path, **kwargs): if path.startswith("/deep/deep1/"): # Because error messages differ accross Python versions raise Exception("integer division or modulo by zero") return filterdir(path, **kwargs) self.fs.filterdir = broken_filterdir tree.render(self.fs, file=output_file, with_color=True) expected = "\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mbar\x1b[0m\n\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mbaz\x1b[0m\n\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mdeep\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[1;34mdeep1\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[1;34mdeep2\x1b[0m\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m \x1b[31merror (integer division or modulo by zero)\x1b[0m\n\x1b[32m\u251c\u2500\u2500\x1b[0m \x1b[1;34mfoo\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m \x1b[1;34megg1\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m \x1b[1;34megg2\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m \x1b[33m.hidden\x1b[0m\n\x1b[32m\u2502 \u251c\u2500\u2500\x1b[0m test.txt\n\x1b[32m\u2502 \u2514\u2500\u2500\x1b[0m test2.txt\n\x1b[32m\u251c\u2500\u2500\x1b[0m root1\n\x1b[32m\u2514\u2500\u2500\x1b[0m root2\n" tree_output = output_file.getvalue() print(repr(tree_output)) self.assertEqual(expected, tree_output) output_file = io.StringIO() tree.render(self.fs, file=output_file, with_color=False) expected = "|-- bar\n|-- baz\n|-- deep\n| `-- deep1\n| `-- deep2\n| `-- error (integer division or modulo by zero)\n|-- foo\n| |-- egg1\n| |-- egg2\n| |-- .hidden\n| |-- test.txt\n| `-- test2.txt\n|-- root1\n`-- root2\n" self.assertEqual(expected, output_file.getvalue())
import dokanmount import os.path import tempfile from fs.osfs import OSFS from fs.memoryfs import MemoryFS from shutil import rmtree from six import b fs = MemoryFS() fs.create('test.txt') fs.appendtext('test.txt', 'This is a test file', encoding=u'utf-8', errors=None, newline=u'') fs.makedir("TestDir") fs.create('TestDir/subtest.txt') fs.appendtext('TestDir/subtest.txt', 'This is a test file in a subfolder', encoding=u'utf-8', errors=None, newline=u'') #flags = dokanmount.DOKAN_OPTION_DEBUG | dokanmount.DOKAN_OPTION_STDERR | dokanmount.DOKAN_OPTION_REMOVABLE flags = dokanmount.DOKAN_OPTION_REMOVABLE dm = dokanmount.mount(fs, "Q:\\", foreground=False, numthreads=2, flags=flags) print("Memory FS is now mounted!") input("Press any key to create file...") fs.create('PostMountCreatedFile.txt') fs.appendtext('PostMountCreatedFile.txt', 'This is a file was populated after Dokan mounted', encoding=u'utf-8',
import csv import json import tempfile from fs.memoryfs import MemoryFS import numpy as np fsys = MemoryFS() fsys.makedir('raw_data') fsys.makedir('result_data') fsys.makedir('result_data/dataset_200_step/') pure_path = 'result_data/dataset_200_step/' fsys.create(pure_path + 'a.tfrecord') fsys.create(pure_path + 'b.tfrecord') fsys.create(pure_path + 'log.log') fsys.tree() fsys.removetree(pure_path) fsys.tree()
path = relpath(normpath(path)) path = path.replace("__colon__", ":") if not self.allow_autorun: if path.lower().startswith("autorun."): path = "_" + path return path if __name__ == "__main__": import os.path import tempfile from fs.osfs import OSFS from fs.memoryfs import MemoryFS from shutil import rmtree from six import b path = tempfile.mkdtemp() try: #fs = OSFS(path) fs = MemoryFS() fs.create('test.txt') fs.appendtext('test.txt', 'this is a test', encoding=u'utf-8', errors=None, newline=u'') flags = DOKAN_OPTION_DEBUG | DOKAN_OPTION_STDERR | DOKAN_OPTION_REMOVABLE mount(fs, "Q:\\", foreground=True, numthreads=1, flags=flags) fs.close() finally: rmtree(path)
from fs.memoryfs import MemoryFS mem_fs = MemoryFS() mem_fs.makedirs("HelloMem") mem_fs.create("./hello.mem") print(mem_fs.listdir("./"))