def test_listdir_duplicates(self):
m1 = MemoryFS()
m2 = MemoryFS()
m1.touch('foo')
m2.touch('foo')
multi_fs = MultiFS()
multi_fs.add_fs('m1', m1)
multi_fs.add_fs('m2', m2)
self.assertEqual(multi_fs.listdir(u'/'), ['foo'])
def test_listdir_duplicates(self):
m1 = MemoryFS()
m2 = MemoryFS()
m1.touch("foo")
m2.touch("foo")
multi_fs = MultiFS()
multi_fs.add_fs("m1", m1)
multi_fs.add_fs("m2", m2)
self.assertEqual(multi_fs.listdir("/"), ["foo"])
def test_target(self):
from fs.memoryfs import MemoryFS
from dxl.fs import Directory
from pygate.routine.base import RoutineOnDirectory
from pygate.routine.merger import OpMerge
import rx
mfs = MemoryFS()
d = Directory('.', mfs)
mfs.makedir('sub1')
mfs.makedir('sub2')
mfs.touch('test.txt')
r = RoutineOnDirectory(d)
o = OperationOnFile('test.txt')
self.assertEqual(o.target(r).path.s, 'test.txt')
def test_match(self):
from fs.memoryfs import MemoryFS
from dxl.fs import Directory
mfs = MemoryFS()
d = Directory('.', mfs)
r = RoutineOnDirectory(d)
for i in range(2):
mfs.makedir('sub{}'.format(i))
mfs.makedir('testdir')
mfs.touch('sub.txt')
o = OperationOnSubdirectories(['sub*'])
sub_dirs = (o.subdirectories(r).to_list().to_blocking().first())
self.assertEqual(len(sub_dirs), 2)
paths = [d.path.s for d in sub_dirs]
self.assertIn('sub0', paths)
self.assertIn('sub1', paths)
def test_list_only_matched_dirs(self):
mfs = MemoryFS()
mfs.touch('test.txt')
for i in range(2):
mfs.makedir('sub{}'.format(i))
mfs.makedir('foo')
d = Directory('.', mfs)
result = (d.listdir_as_observable().filter(
lambda o: isinstance(o, Directory)).filter(
lambda d: d.match(['sub*'])).to_list().to_blocking().first())
self.assertEqual(len(result), 2)
for o in result:
self.assertIsInstance(o, Directory)
paths = [o.path.s for o in result]
self.assertIn('sub0', paths)
self.assertIn('sub1', paths)
def test_listdir(self):
mfs = MemoryFS()
mfs.touch('test_file.txt')
mfs.makedir('test_dir')
d = Directory('.', mfs)
result = d.listdir()
self.assertEqual(len(result), 2)
cdir = None
cfile = None
for o in result:
if isinstance(o, Directory):
cdir = o
else:
cfile = o
self.assertIsNotNone(cdir)
self.assertIsNotNone(cfile)
self.assertEqual(cdir.path.n, 'test_dir')
self.assertEqual(cfile.path.n, 'test_file.txt')
def _my_fs(module):
"""Create a mock filesystem to be used in examples."""
my_fs = MemoryFS()
if module == "fs.base":
my_fs.makedir("Desktop")
my_fs.makedir("Videos")
my_fs.touch("Videos/starwars.mov")
my_fs.touch("file.txt")
elif module == "fs.info":
my_fs.touch("foo.tar.gz")
my_fs.settext("foo.py", "print('Hello, world!')")
my_fs.makedir("bar")
elif module in {"fs.walk", "fs.glob"}:
my_fs.makedir("dir1")
my_fs.makedir("dir2")
my_fs.settext("foo.py", "print('Hello, world!')")
my_fs.touch("foo.pyc")
my_fs.settext("bar.py", "print('ok')\n\n# this is a comment\n")
my_fs.touch("bar.pyc")
return my_fs
def test_apply(self):
mfs = MemoryFS()
subs = ['sub.{}'.format(i) for i in range(3)]
for d in subs:
mfs.makedir(d)
d = Directory('.', mfs)
mfs.touch('test1.txt')
mfs.touch('test2.txt')
o0 = ini.OpAddToBroadcastFile('test1.txt')
o1 = ini.OpAddToBroadcastFile('test2.txt')
obc = ini.OpBroadcastFile(['sub*'])
r = RoutineOnDirectory(d, [o0, o1, obc])
r.work()
target_files = []
for d in subs:
for f in ['test1.txt', 'test2.txt']:
target_files.append(d + '/' + f)
for i, t in enumerate(target_files):
with self.subTest(i):
self.assertTrue(mfs.exists(t))
class TestFilesFilter(unittest.TestCase):
def setUp(self):
self.fs = MemoryFS()
for i in range(5):
self.fs.makedir('sub.{0}'.format(i))
with self.fs.opendir('sub.{0}'.format(i)) as d:
d.touch('result.txt')
for i in range(5):
self.fs.makedir('child.{0}'.format(i))
with self.fs.opendir('child.{0}'.format(i)) as d:
d.touch('result.txt')
for i in range(5):
self.fs.touch('result.{}.txt'.format(i))
self.fs.touch('errors.{}.txt'.format(i))
def tearDown(self):
self.fs.close()
def test_basic(self):
ff = batch.FilesFilter(include_filters=['result*'])
results = set(ff.lst(self.fs))
expected = {'result.{}.txt'.format(i) for i in range(5)}
self.assertEqual(results, expected)
def test_multi_filters(self):
ff = batch.FilesFilter(include_filters=['result*', 'errors*'])
results = set(ff.lst(self.fs))
expected = {'result.{}.txt'.format(i)
for i in range(5)
}.union({'errors.{}.txt'.format(i)
for i in range(5)})
self.assertEqual(results, expected)
def test_with_directory_filter(self):
results = set()
(batch.DirectoriesFilter(['sub*']).obv(
self.fs).flat_map(lambda p: batch.FilesFilter(['result*']).obv(
self.fs, p)).subscribe(results.add))
expected = {'sub.{}/result.txt'.format(i) for i in range(5)}
self.assertEqual(results, expected)
def test_copy_files(self):
mfs = MemoryFS()
mfs.touch('txt1.txt')
mfs.touch('txt2.txt')
mfs.makedir('sub1')
mfs.makedir('sub2')
new_files = [
'sub1/txt1.txt', 'sub1/txt2.txt', 'sub2/txt1.txt', 'sub2/txt2.txt'
]
for n in new_files:
self.assertFalse(mfs.exists(n))
d = Directory('.', mfs)
targets = d.listdir_as_observable().filter(match_directory(['sub*']))
sources = d.listdir_as_observable().filter(match_file(['txt*']))
sources.subscribe(lambda f: print(f.path.s))
sources_list = []
sources.subscribe(sources_list.append)
results = (targets.flat_map(
lambda d: d.sync(sources)).to_list().to_blocking().first())
self.assertEqual(len(results), 4)
for n in new_files:
self.assertTrue(mfs.exists(n))
def test_exist(self):
mfs = MemoryFS()
mfs.touch('test.txt')
f = File('test.txt', mfs)
self.assertTrue(f.exists())
def test_exist(self):
mfs = MemoryFS()
mfs.touch('test.txt')
afs = FileSystem(mfs)
o = ObjectOnFileSystem(afs, 'test.txt')
self.assertTrue(o.exists())
def test_not_a_directory(self):
mfs = MemoryFS()
mfs.touch('test')
d = Directory('test', mfs)
with self.assertRaises(NotADirectoryError):
d.exists()
