def test_split_windows(self):
path = URI(r'C:\some\path\on\windows', sep='\\')
pth, tail = path.split()
self.assertEqual(pth.uri, 'file:///C/some/path/on')
self.assertEqual(pth.path, r'C:\some\path\on')
self.assertEqual(pth, URI(r'C:\some\path\on', sep='\\'))
self.assertEqual(tail, 'windows')
class TestWritingZip(ZipTestCase):
def setUp(self):
super(TestWritingZip, self).setUp()
self.zip_uri = 'file://./file.zip'
self.zip_path = URI(self.zip_uri)
def tearDown(self):
# reset the connection registry, otherwise the zip file cannot
# be deleted on windows since it is still opened by the
# backend
CONNECTION_REGISTRY.cleanup(force=True)
if self.zip_path.exists():
self.zip_path.remove()
def test_write_file_to_non_existing_zip(self):
foo = URI('zip://((%s))/foo.txt' % self.zip_uri)
with foo.open('wb') as fd:
fd.write(b'bar')
def test_write_file_to_non_existing_zip_2(self):
foo = URI('zip://((%s))/deeper/foo.txt' % self.zip_uri)
with foo.open('wb') as fd:
fd.write(b'bar')
def test_write_two_files(self):
foo = URI('zip://((%s))/foo.txt' % self.zip_uri)
with foo.open('wb') as fd:
fd.write(b'bar')
bar = URI('zip://((%s))/bar.txt' % self.zip_uri)
with bar.open('wb') as fd:
fd.write(b'foo')
def test_dirname(self):
pth = URI("/this/is/a/path")
self.assertEqual(pth.dirname(), URI("/this/is/a"))
self.assertEqual(pth.dirname(level=2), URI("/this/is"))
self.assertEqual(pth.dirname(level=3), URI("/this"))
self.assertEqual(pth.dirname(level=4), URI("/"))
self.assertEqual(pth.dirname(level=5), URI("/"))
class TestAdvancedZip(ZipTestCase):
def setUp(self):
super(TestAdvancedZip, self).setUp()
self.zip_path = URI('memory:///file.zip')
zip_handle = self.zip_path.open('wb')
try:
self.fp_zip = ZipFile(zip_handle, 'w')
self.fp_zip.writestr('/dir1/foo.txt', 'bar')
self.fp_zip.writestr('/dir1/bar.txt', 'bar')
self.fp_zip.writestr('/bar.txt', 'bar')
self.fp_zip.close()
finally:
zip_handle.close()
def tearDown(self):
self.zip_path.remove()
def test_walk(self):
root = URI('zip://((%s))/' % self.zip_path.uri)
self.assertEqual(len(root.listdir()), 2)
rlist = []
for base, dirs, files in root.walk():
rlist.append((base, dirs, files))
self.assertEqual(rlist,
[(root, ['dir1'], ['bar.txt']),
((root / 'dir1'), [], ['bar.txt', 'foo.txt'])])
def tearDown(self):
p = URI(self.foo_dir)
if p.isdir():
p.remove(recursive=True)
b = URI(self.bar_dir)
if b.isdir():
b.remove(recursive=True)
def tearDown(self):
p = URI("test.txt")
if p.exists():
p.remove()
l = URI("test_link")
if l.islink():
l.remove()
def test_dirname(self):
pth = URI("/this/is/a/path")
self.assertEqual(pth.dirname(), URI("/this/is/a"))
self.assertEqual(pth.dirname(level=2), URI("/this/is"))
self.assertEqual(pth.dirname(level=3), URI("/this"))
self.assertEqual(pth.dirname(level=4), URI("/"))
self.assertEqual(pth.dirname(level=5), URI("/"))
class TestAdvancedZip(ZipTestCase):
def setUp(self):
super(TestAdvancedZip, self).setUp()
self.zip_path = URI('memory:///file.zip')
zip_handle = self.zip_path.open('wb')
try:
self.fp_zip = ZipFile(zip_handle, 'w')
self.fp_zip.writestr('/dir1/foo.txt', 'bar')
self.fp_zip.writestr('/dir1/bar.txt', 'bar')
self.fp_zip.writestr('/bar.txt', 'bar')
self.fp_zip.close()
finally:
zip_handle.close()
def tearDown(self):
self.zip_path.remove()
def test_walk(self):
root = URI('zip://((%s))/' % self.zip_path.uri)
self.assertEqual(len(root.listdir()), 2)
rlist = []
for base, dirs, files in root.walk():
rlist.append((base, dirs, files))
self.assertEqual(rlist,
[(root, ['dir1'], ['bar.txt']),
((root / 'dir1'), [], ['bar.txt', 'foo.txt'])])
class TestWritingZip(ZipTestCase):
def setUp(self):
super(TestWritingZip, self).setUp()
self.zip_uri = 'file://./file.zip'
self.zip_path = URI(self.zip_uri)
def tearDown(self):
# reset the connection registry, otherwise the zip file cannot
# be deleted on windows since it is still opened by the
# backend
CONNECTION_REGISTRY.cleanup(force=True)
if self.zip_path.exists():
self.zip_path.remove()
def test_write_file_to_non_existing_zip(self):
foo = URI('zip://((%s))/foo.txt' % self.zip_uri)
with foo.open('wb') as fd:
fd.write(b'bar')
def test_write_file_to_non_existing_zip_2(self):
foo = URI('zip://((%s))/deeper/foo.txt' % self.zip_uri)
with foo.open('wb') as fd:
fd.write(b'bar')
def test_write_two_files(self):
foo = URI('zip://((%s))/foo.txt' % self.zip_uri)
with foo.open('wb') as fd:
fd.write(b'bar')
bar = URI('zip://((%s))/bar.txt' % self.zip_uri)
with bar.open('wb') as fd:
fd.write(b'foo')
def test_write_two_files(self):
foo = URI('zip://((%s))/foo.txt' % self.zip_uri)
with foo.open('wb') as fd:
fd.write(b'bar')
bar = URI('zip://((%s))/bar.txt' % self.zip_uri)
with bar.open('wb') as fd:
fd.write(b'foo')
def test_split_windows(self):
path = URI(r'C:\some\path\on\windows', sep='\\')
pth, tail = path.split()
self.assertEqual(pth.uri, 'file:///C/some/path/on')
self.assertEqual(pth.path, r'C:\some\path\on')
self.assertEqual(pth, URI(r'C:\some\path\on', sep='\\'))
self.assertEqual(tail, 'windows')
def test_dont_mix_unicode_and_bytes(self):
p = URI("Vögel")
p2 = p / "no_ünicode"
self.assertTrue(type(p2.uri) is str)
p3 = URI("Vögel")
p4 = p3 / "ünicode"
self.assertTrue(type(p4.uri) is str)
def test_walk(self):
root = URI('zip://((%s))/' % self.zip_path.uri)
self.assertEqual(len(root.listdir()), 2)
rlist = []
for base, dirs, files in root.walk():
rlist.append((base, dirs, files))
self.assertEqual(rlist,
[(root, ['dir1'], ['bar.txt']),
((root / 'dir1'), [], ['bar.txt', 'foo.txt'])])
def test_walk(self):
root = URI('zip://((%s))/' % self.zip_path.uri)
self.assertEqual(len(root.listdir()), 2)
rlist = []
for base, dirs, files in root.walk():
rlist.append((base, dirs, files))
self.assertEqual(rlist,
[(root, ['dir1'], ['bar.txt']),
((root / 'dir1'), [], ['bar.txt', 'foo.txt'])])
def setUp(self):
super(TestReadingZip, self).setUp()
self.zip_path = URI('memory:///file.zip')
zip_handle = self.zip_path.open('wb')
try:
self.fp_zip = ZipFile(zip_handle, 'w')
self.fp_zip.writestr('/foo.txt', 'bar')
self.fp_zip.close()
finally:
zip_handle.close()
def test_globbing_by_suffix(self):
base = URI("memory:///")
a = base / "a.foo"
b = base / "b.bar"
for f in [a, b]:
with f.open("w") as outf:
outf.write("foo")
self.assertEqual([a], base.glob("a.*"))
def test_globbing_by_suffix(self):
base = URI("memory:///")
a = base / "a.foo"
b = base / "b.bar"
for f in [a, b]:
with f.open("w") as outf:
outf.write("foo")
self.assertEqual([a], base.glob("a.*"))
def test_creation(self):
local_path = URI('/tmp/this')
self.assertEqual(local_path.path.split(os.sep), ['', 'tmp', 'this'])
self.assertEqual(local_path.scheme, 'file')
path = URI('localpath', sep='/')
self.assertEqual(path.path, './localpath', path.path)
path = URI('trailing/slash/', sep='/')
self.assertEqual(path.path, './trailing/slash/')
def test_split(self):
local_path = URI('/some/long/dir/structure')
pth, tail = local_path.split()
self.assertEqual(pth, URI('/some/long/dir'))
self.assertEqual(tail, 'structure')
local_path = URI('somedir')
pth, tail = local_path.split()
self.assertEqual(pth, URI('.'))
self.assertEqual(tail, 'somedir')
def test_globbing_by_prefix_in_subdir(self):
base = URI("memory:///") / "dir"
base.mkdir()
a = base / "a.foo"
b = base / "b.bar"
for f in [a, b]:
with f.open("w") as outf:
outf.write("foo")
self.assertEqual([a], base.glob("*.foo"))
def test_globbing_by_prefix_in_subdir(self):
base = URI("memory:///") / "dir"
base.mkdir()
a = base / "a.foo"
b = base / "b.bar"
for f in [a, b]:
with f.open("w") as outf:
outf.write("foo")
self.assertEqual([a], base.glob("*.foo"))
def test_setting_mode(self):
# setting the permission flags are not supported on windows
if sys.platform != "win32":
p = URI("test.txt")
mode = p.info().mode
new_mode = mode | stat.S_IXUSR
p.info(dict(mode=new_mode))
self.assertEqual(
p.info().mode,
new_mode,
)
class TestReadingZip(ZipTestCase):
def setUp(self):
super(TestReadingZip, self).setUp()
self.zip_path = URI('memory:///file.zip')
zip_handle = self.zip_path.open('wb')
try:
self.fp_zip = ZipFile(zip_handle, 'w')
self.fp_zip.writestr('/foo.txt', 'bar')
self.fp_zip.close()
finally:
zip_handle.close()
def tearDown(self):
if self.zip_path.exists():
self.zip_path.remove()
def test_read_a_file(self):
p = URI('zip://((memory:///file.zip))/foo.txt')
with p.open('rb') as fd:
self.assertEqual(fd.read(), b'bar')
def test_write_a_file(self):
p = URI('zip://((memory:///file.zip))/bar.txt')
with p.open('wb') as fd:
fd.write(b'foo')
with p.open() as fd:
self.assertEqual(fd.read(), b'foo')
def test_exists(self):
p = URI('zip://((memory:///file.zip))/foo.txt')
with p.open('wb') as fd:
fd.write(b'foo')
self.assertTrue(p.exists())
def test_isfile(self):
p = URI('zip://((memory:///file.zip))/foo.txt')
with p.open('wb') as fd:
fd.write(b'foo')
self.assertTrue(p.isfile())
def test_isdir(self):
dir_path = URI('zip://((memory:///file.zip))/somedir')
p = dir_path / 'foo.txt'
with p.open('wb') as fd:
fd.write(b'foo')
self.assertTrue(dir_path.isdir())
def test_path(self):
dir_path = URI('zip://((memory:///file.zip))/somedir')
self.assertEqual(dir_path.path, '/somedir')
new_path = dir_path / 'other'
self.assertEqual(new_path.path, '/somedir/other')
def test_backend(self):
foo_path = URI(self.baseurl) / 'foo'
bar_path = URI(foo_path.path + '?arg1=value1')
foo_2_path = foo_path / 'some_dir'
self.assertTrue(
foo_path.get_connection() is foo_2_path.get_connection())
self.assertTrue(
bar_path.get_connection() is not foo_path.get_connection())
foo_path_connection = foo_path.get_connection()
foo_path.query['arg'] = 'value'
self.assertTrue(foo_path_connection is not foo_path.get_connection())
def test_copy_empty_dirs_recursive(self):
root = URI(self.baseurl)
root.makedirs()
gaz_path = root / 'gaz'
gaz_path.makedirs()
moo_path = root / 'moo'
gaz_path.copy(moo_path, recursive=True)
self.assertTrue((moo_path).isdir())
def test_copy_empty_dirs_recursive(self):
root = URI(self.baseurl)
root.makedirs()
gaz_path = root / 'gaz'
gaz_path.makedirs()
moo_path = root / 'moo'
gaz_path.copy(moo_path, recursive=True)
self.assertTrue((moo_path).isdir())
class TestReadingZip(ZipTestCase):
def setUp(self):
super(TestReadingZip, self).setUp()
self.zip_path = URI('memory:///file.zip')
zip_handle = self.zip_path.open('wb')
try:
self.fp_zip = ZipFile(zip_handle, 'w')
self.fp_zip.writestr('/foo.txt', 'bar')
self.fp_zip.close()
finally:
zip_handle.close()
def tearDown(self):
if self.zip_path.exists():
self.zip_path.remove()
def test_read_a_file(self):
p = URI('zip://((memory:///file.zip))/foo.txt')
with p.open('rb') as fd:
self.assertEqual(fd.read(), b'bar')
def test_write_a_file(self):
p = URI('zip://((memory:///file.zip))/bar.txt')
with p.open('wb') as fd:
fd.write(b'foo')
with p.open() as fd:
self.assertEqual(fd.read(), b'foo')
def test_exists(self):
p = URI('zip://((memory:///file.zip))/foo.txt')
with p.open('wb') as fd:
fd.write(b'foo')
self.assertTrue(p.exists())
def test_isfile(self):
p = URI('zip://((memory:///file.zip))/foo.txt')
with p.open('wb') as fd:
fd.write(b'foo')
self.assertTrue(p.isfile())
def test_isdir(self):
dir_path = URI('zip://((memory:///file.zip))/somedir')
p = dir_path / 'foo.txt'
with p.open('wb') as fd:
fd.write(b'foo')
self.assertTrue(dir_path.isdir())
def test_path(self):
dir_path = URI('zip://((memory:///file.zip))/somedir')
self.assertEqual(dir_path.path, '/somedir')
new_path = dir_path / 'other'
self.assertEqual(new_path.path, '/somedir/other')
def tearDown(self):
p = URI(self.foo_dir)
if p.isdir():
p.remove(recursive=True)
b = URI(self.bar_dir)
if b.isdir():
b.remove(recursive=True)
def test_remove_recursive_with_readonly_file(self):
foo_path = URI(self.baseurl) / 'foo'
bar_path = foo_path / 'bar'
bar_path.makedirs()
gaz_path = bar_path / 'ghaz.txt'
create_file(gaz_path)
mode = gaz_path.info().mode
gaz_path.info(set_info=dict(mode=mode & ~stat.S_IWUSR))
foo_path.remove(recursive=True)
self.assertTrue(not foo_path.exists())
def test_remove_recursive_with_readonly_file(self):
foo_path = URI(self.baseurl) / 'foo'
bar_path = foo_path / 'bar'
bar_path.makedirs()
gaz_path = bar_path / 'ghaz.txt'
create_file(gaz_path)
mode = gaz_path.info().mode
gaz_path.info(set_info=dict(mode=mode & ~stat.S_IWUSR))
foo_path.remove(recursive=True)
self.assertTrue(not foo_path.exists())
def setUp(self):
self.starttime = datetime.datetime.now()
p = URI("test.txt")
with p.open("w") as fs:
fs.write('test')
a_link = URI("test_link")
if p.connection.supports_symlinks() and not a_link.islink():
p.symlink(a_link)
def test_copy_dirsymlink_to_dirsymlink_preservelinks(self):
root = URI(self.baseurl)
bar_path = root / 'foo' / 'bar'
bar_path.makedirs()
gaz_path = bar_path / 'gaz.txt'
create_file(gaz_path, content='foobar')
moo_path = root / 'moo'
moo_path.makedirs()
tee_path = root / 'helloworld'
bar_path.symlink(tee_path)
tee2_path = root / 'helloworld2'
moo_path.symlink(tee2_path)
tee_path.copy(tee2_path, recursive=True, followlinks=False)
helloworld_path = tee2_path / 'helloworld'
self.assertTrue(tee2_path.islink()) # still a link?
self.assertTrue(tee_path.islink()) # still a link?
self.assertTrue(helloworld_path.islink())
self.assertTrue(helloworld_path.isdir())
self.assertTrue((helloworld_path / 'gaz.txt').isfile())
self.assertEqual(helloworld_path.readlink(), bar_path)
self.assertEqual(helloworld_path.readlink(), tee_path.readlink())
def test_symlink_file(self):
root = URI(self.baseurl)
bar_path = root / 'foo' / 'bar'
bar_path.makedirs()
gaz_path = bar_path / 'gaz.txt'
create_file(gaz_path, content='foobar')
tee_path = root / 'helloworld'
self.assertTrue(not tee_path.exists())
self.assertTrue(not tee_path.islink())
gaz_path.symlink(tee_path)
self.assertTrue(tee_path.exists())
self.assertTrue(tee_path.islink())
# a symlink to a file is a file
self.assertTrue(tee_path.isfile())
link = tee_path.readlink()
self.assertEqual(link, gaz_path)
# check that gaz.txt is accessible through the symlink
self.assertEqual(load_file(tee_path), 'foobar')
def test_copy_filesymlink_to_dirsymlink_followlinks(self):
root = URI(self.baseurl)
bar_path = root / 'foo' / 'bar'
bar_path.makedirs()
gaz_path = bar_path / 'gaz.txt'
create_file(gaz_path, content='foobar')
moo_path = root / 'moo'
moo_path.makedirs()
tee_path = root / 'helloworld'
gaz_path.symlink(tee_path)
tee2_path = root / 'helloworld2'
moo_path.symlink(tee2_path)
tee_path.copy(tee2_path, followlinks=True)
helloworld_path = tee2_path / 'helloworld'
self.assertTrue(tee2_path.islink()) # still a link?
self.assertTrue(tee_path.islink()) # still a link?
self.assertTrue(not helloworld_path.islink())
self.assertTrue(helloworld_path.isfile())
self.assertEqual(load_file(helloworld_path), 'foobar')
self.assertTrue((moo_path / 'helloworld').isfile())
def _setup_hierarchy(self):
"""Walk the following tree:
foo/
test.py
bar/
file1a.txt
file1b.png
gaz/
file2a.jpg
file2b.html
"""
path = URI(self.baseurl)
foo_path = path / 'foo'
bar_path = foo_path / 'bar'
bar_path.makedirs()
gaz_path = foo_path / 'gaz'
gaz_path.makedirs()
create_file(bar_path / 'file1a.txt')
create_file(bar_path / 'file1b.png')
create_file(foo_path / 'file2a.jpg')
create_file(foo_path / 'file2b.html')
create_file(foo_path / 'test.py')
return foo_path
def test_walk_very_deep_hierarchies(self):
root = URI(self.baseurl)
foo_path = root / 'foo'
expected = []
def expected_root_str(path):
return 'ROOT: .%s' % path.path[len(foo_path.path):].replace(
'\\', '/')
d_path = foo_path
for i in range(0, 49):
nm = 'f%d' % i
expected.append('DIR: %s' % nm)
expected.append(expected_root_str(d_path))
d_path = d_path / nm
d_path.makedirs()
expected.append(expected_root_str(d_path))
expected.reverse()
actual = self._walk(foo_path, topdown=False, followlinks=False)
self.assertEqual(expected, actual)
# expect the right amount of output. For 64 level with 2 lines per
# level (1 x ROOT:, 1x DIR:) + 1 for the iinermost ('f63')
self.assertEqual(len(actual), 99)
def setUp(self):
super(CommonFileSystemTest, self).setUp()
self.local_setup()
self.foo_path = URI(self.baseurl) / 'foo'
self.existing_dir = ujoin(self.baseurl, 'foo')
self.existing_file = ujoin(self.baseurl, 'foo', 'foo.txt')
self.non_existing_file = ujoin(self.baseurl, 'bar.txt')
def test_remove_recursive_with_symlinks(self):
root = URI(self.baseurl)
hw_path = root / 'doo' / 'helloworld'
hw_path.makedirs()
humpty_path = hw_path / 'humpty.txt'
create_file(humpty_path)
raz_path = root / 'raz'
mam_path = raz_path / 'mam'
mam_path.makedirs()
create_file(mam_path / 'x')
foo_path = root / 'foo'
bar_path = foo_path / 'bar'
bar_path.makedirs()
gaz_path = bar_path / 'gaz.txt'
create_file(gaz_path, content='foobar')
# a symlink to a dir outside of foo
tee_path = bar_path / 'tee'
mam_path.symlink(tee_path)
# a symlink to a file outside of foo
moo_path = bar_path / 'moo.txt'
humpty_path.symlink(moo_path)
foo_path.remove(recursive=True)
self.assertTrue(not foo_path.isdir())
# followlinks: the pointed to files should not been deleted
self.assertTrue(humpty_path.isfile())
self.assertTrue(mam_path.isdir())
self.assertTrue(raz_path.isdir())
def test_copy_filesymlink_to_filesymlink_followlinks(self):
root = URI(self.baseurl)
bar_path = root / 'foo' / 'bar'
bar_path.makedirs()
gaz_path = bar_path / 'gaz.txt'
create_file(gaz_path, content='foobar')
gaz2_path = bar_path / 'gaz2.txt'
create_file(gaz2_path, content='foobar2')
tee_path = root / 'helloworld'
gaz_path.symlink(tee_path)
tee2_path = root / 'helloworld2'
gaz2_path.symlink(tee2_path)
tee_path.copy(tee2_path, followlinks=True)
# when following links copying to a symlink->file modifies the
# referenced file!
self.assertTrue(tee2_path.islink())
self.assertEqual(load_file(tee2_path), 'foobar')
self.assertEqual(load_file(gaz2_path), 'foobar')
self.assertTrue((bar_path / 'gaz2.txt').isfile())
self.assertTrue((bar_path / 'gaz.txt').isfile())
def test_unipath_windows(self):
path = URI('C:\\some?extra=arg', sep='\\')
self.assertEqual(path.path, 'C:\\some')
self.assertEqual(path.unipath, '/C/some')
self.assertEqual(path.uri, 'file:///C/some?extra=arg')
new_path = path / 'other'
self.assertEqual(new_path.unipath, '/C/some/other')
self.assertEqual(new_path.uri, 'file:///C/some/other?extra=arg')
def test_selfpointing_symlink(self):
root = URI(self.baseurl)
tee_path = root / 'helloworld'
tee_path.symlink(tee_path)
self.assertTrue(tee_path.islink())
self.assertEqual(tee_path.readlink(), tee_path)
def test_open_unknown_file_fails(self):
"""Check that both backends fail with a proper exception when trying to
open a path for loading, which does not exist.
"""
root = URI(self.baseurl)
notexisting_path = root / 'ma' / 'moo'
self.assertRaises(IOError, load_file, notexisting_path)
self.assertRaises(IOError, create_file, notexisting_path)
def test_exists_doesnt_fail_on_deadlink(self):
root = URI(self.baseurl)
notexisting_path = root / 'foo' / 'bar'
tee_path = root / 'helloworld'
notexisting_path.symlink(tee_path)
self.assertTrue(not tee_path.exists())
def test_isexec_fails_on_deadlink(self):
root = URI(self.baseurl)
notexisting_path = root / 'foo' / 'bar'
tee_path = root / 'helloworld'
notexisting_path.symlink(tee_path)
self.assertRaises(OSError, tee_path.isexec)
def test_backend(self):
foo_path = URI(self.baseurl) / 'foo'
bar_path = URI(foo_path.path + '?arg1=value1')
foo_2_path = foo_path / 'some_dir'
self.assertTrue(foo_path.get_connection() is foo_2_path.get_connection())
self.assertTrue(bar_path.get_connection() is not foo_path.get_connection())
foo_path_connection = foo_path.get_connection()
foo_path.query['arg'] = 'value'
self.assertTrue(foo_path_connection is not foo_path.get_connection())
def test_copy_recursive_with_preservelinks(self):
src_path = URI(self.baseurl) / 'folder'
base_path = src_path / 'gaz'
foo_path = base_path / 'foo'
bar_path = foo_path / 'tmp'
bar_path.makedirs()
mee_path = foo_path / 'mee.txt'
create_file(mee_path)
mee2_path = bar_path / 'mee2.txt'
create_file(mee2_path)
dest_path = URI(self.baseurl) / 'helloworld'
src_path.copy(dest_path, recursive=True, followlinks=False)
self.assertTrue((dest_path / 'gaz' / 'foo' / 'mee.txt').isfile())
self.assertTrue((dest_path / 'gaz' / 'foo' / 'tmp').isdir())
def test_listdir(self):
base_path = URI('zip://((%s))/' % self.zip_path.uri)
self.assertEqual(base_path.listdir(), [])
p1 = URI('zip://((%s))/foo.txt' % self.zip_path.uri)
with p1.open('wb') as fd:
fd.write(b'foo')
self.assertEqual(base_path.listdir(), ['foo.txt'])
p2 = URI('zip://((%s))/dir/foo.txt' % self.zip_path.uri)
with p2.open('w') as fd:
fd.write(b'foo')
self.assertEqual(set(base_path.listdir()), set(['foo.txt', 'dir']))
def setUp(self):
super(TestReadingZip, self).setUp()
self.zip_path = URI('memory:///file.zip')
zip_handle = self.zip_path.open('wb')
try:
self.fp_zip = ZipFile(zip_handle, 'w')
self.fp_zip.writestr('/foo.txt', 'bar')
self.fp_zip.close()
finally:
zip_handle.close()
class TestListDir(ZipTestCase):
def setUp(self):
super(TestListDir, self).setUp()
self.zip_path = URI('memory:///file.zip')
def tearDown(self):
if self.zip_path.exists():
self.zip_path.remove()
def test_listdir(self):
base_path = URI('zip://((%s))/' % self.zip_path.uri)
self.assertEqual(base_path.listdir(), [])
p1 = URI('zip://((%s))/foo.txt' % self.zip_path.uri)
with p1.open('wb') as fd:
fd.write(b'foo')
self.assertEqual(base_path.listdir(), ['foo.txt'])
p2 = URI('zip://((%s))/dir/foo.txt' % self.zip_path.uri)
with p2.open('w') as fd:
fd.write(b'foo')
self.assertEqual(set(base_path.listdir()), set(['foo.txt', 'dir']))
def test_file(self):
path = URI(self.baseurl) / 'testfile.txt'
create_file(path, content='hallo')
content = load_file(path)
self.assertEqual(content, 'hallo')
self.assertTrue(path.exists())
self.assertTrue(path.isfile())
path.remove()
self.assertTrue(not path.exists())
path = URI(self.existing_file)
self.assertTrue(path.exists())
self.assertTrue(path.isfile())
content = load_file(path)
self.assertTrue(content)
def test_info_mtime(self):
p = URI("test.txt")
now = datetime.datetime.now()
size = p.info().size
with p.open('a') as fs:
fs.write(' again')
self.assertTrue(p.info().mtime >= p.info().ctime)
self.assertTrue( p.info().size > size)
# due to now's millisecond resolution, we must ignore milliseconds
self.assertTrue(p.info().mtime.timetuple()[:6] >= now.timetuple()[:6])
def test_manipulation_api(self):
p = self.root_path / "test.txt"
p._manipulate(lock=True)
mfile = p.open("w")
assert not mfile.lock.acquire(False)
p._manipulate(unlock=True)
try:
assert mfile.lock.acquire(False)
finally:
mfile.lock.release()
with p.open("w") as outf:
outf.write("foo")
old_mtime = p.mtime()
new_mtime = old_mtime + 100
p._manipulate(mtime=new_mtime)
self.assertEqual(p.mtime(), new_mtime)
error_file = self.root_path / "error"
with error_file.open("wb") as outf:
outf.write(b"foobarbaz")
error_dir = self.root_path / "error.dir"
error_dir.mkdir()
def next_op_callback(_path, _func):
raise OSError(13, "Permission denied")
for error in (error_file, error_dir):
error._manipulate(next_op_callback=next_op_callback)
clone = URI(error)
try:
clone.remove()
except OSError as e:
self.assertEqual(e.errno, 13)
else:
assert False, "Shouldn't be here"
def test_locking(self):
try:
p = URI("lock.txt")
content = "I'm something written into a locked file"
with p.lock() as inf:
inf.write(content)
self.assertEqual(p.open().read(), content)
finally:
if p.exists():
p.remove()
def test_info_on_symlinks(self):
a_file = URI("test.txt")
a_link = URI("test_link")
with a_file.open('w') as f:
f.write("a" * 800)
if not a_file.connection.supports_symlinks():
return
self.assertEqual(a_file.info().size, 800)
self.assertEqual(a_link.info().size, 800)
self.assertNotEqual(a_link.info(followlinks=False).size, 800)
def setUp(self):
super(TestRemovalOfFilesAndDirs, self).setUp()
self.root_path = URI('memory:///')
def setUp(self):
super(MemoryFSTests, self).setUp()
self.temp_path = URI(tempfile.mktemp())
self.temp_path.mkdir()
self.root = URI("memory:///")
class MemoryFSTests(CleanupMemoryBeforeTestMixin, TestCase):
def setUp(self):
super(MemoryFSTests, self).setUp()
self.temp_path = URI(tempfile.mktemp())
self.temp_path.mkdir()
self.root = URI("memory:///")
def tearDown(self):
if self.temp_path.isdir():
self.temp_path.remove(recursive=True)
super(MemoryFSTests, self).tearDown()
def test_all(self):
root = self.root
assert root.isdir()
subdir = root / "foo"
subdir.mkdir()
assert subdir.isdir()
assert not subdir.isfile()
out = subdir / "bar"
with out.open("w") as outf:
outf.write("foobar")
assert not out.isdir()
assert out.isfile()
with out.open() as inf:
content = inf.read()
self.assertEqual(content, "foobar")
assert subdir == root / "foo"
time.sleep(.5)
assert out.info().mtime < time.time()
connection = subdir.connection
out = StringIO()
connection.dump(out)
print((out.getvalue()))
def test_write_text_read_binary(self):
test_file = self.root / 'foo'
with test_file.open('w') as text_proxy:
text_proxy.write("spam & eggs")
with test_file.open('rb') as binary_proxy:
self.assertEqual(binary_proxy.read(), b"spam & eggs")
def test_write_binary_read_text(self):
test_file = self.root / 'foo'
with test_file.open('wb') as binary_proxy:
binary_proxy.write(b"spam & eggs")
with test_file.open('r') as text_proxy:
self.assertEqual(text_proxy.read(), "spam & eggs")
def test_info_on_symlinks(self):
root = self.root
a_file = root / "a_file"
a_link = root / "a_link"
with a_file.open('w') as f:
f.write("a" * 800)
a_file.symlink(a_link)
self.assertEqual(a_file.info().size, 800)
self.assertEqual(a_link.info().size, 800)
self.assertNotEqual(a_link.info(followlinks=False).size, 800)
orig_info = a_file.info()
new_info = a_file.info()
new_info.mtime = new_info.mtime + 100
a_link.info(new_info, followlinks=False)
self.assertEqual(a_file.info().mtime, orig_info.mtime)
self.assertEqual(a_link.info().mtime, orig_info.mtime)
self.assertEqual(a_link.info(followlinks=False).mtime, new_info.mtime)
def test_listdir_empty_root(self):
root = self.root
files = root.listdir()
assert not files
def test_listdir_empty_dir(self):
root = self.root
foo = root / 'foo'
foo.mkdir()
rootfiles = root.listdir()
assert 'foo' in rootfiles
foofiles = foo.listdir()
assert not foofiles
def test_walk(self):
root = self.root
foo = root / 'foo'
foo.mkdir()
bar = root / 'bar'
bar.mkdir()
foofile = foo / 'foocontent.txt'
with foofile.open('w') as fd:
fd.write('foocontent')
results = []
for root, dirs, files in root.walk():
results.append((root, dirs, files))
assert len(results) == 3
def test_next(self):
root = self.root
subdir = root / "foo"
with subdir.open("w") as outf:
outf.write("foo\nbar")
with subdir.open() as inf:
content = next(inf)
self.assertEqual(content, "foo\n")
content = next(inf)
self.assertEqual(content, "bar")
with subdir.open() as inf:
for line in inf:
self.assertIn(line, ["foo\n", "bar"])
def test_exists_on_root(self):
root = self.root
assert root.exists()
def test_root_of_non_existing_dir_exists(self):
dir_path = URI("memory:///foo")
assert dir_path.dirname().exists()
def test_directory_cant_be_overwritten_by_file(self):
base = URI("memory:///")
d = base / "foo"
d.mkdir()
assert d.exists()
try:
with d.open("w") as outf:
outf.write("foo")
except IOError as e:
self.assertEqual(e.errno, errno.EISDIR)
else:
assert False, "You shouldn't be able to ovewrite a directory like this"
def test_copy_into_fs(self):
root = self.root
for item in ["foo", "bar"]:
with (root/item).open("wb") as fd:
fd.write(item.encode('utf-8'))
root.copy(self.temp_path, recursive=True)
content = self.temp_path.listdir()
self.assertEqual(set(content), set(["foo", "bar"]))
def test_cleanup_removes_lingering_locks(self):
lockfile = self.root / "lockfile"
with lockfile.open("w") as outf:
outf.write(" ")
lockfile._manipulate(mtime=lockfile.mtime() + 3, lock=True)
CONNECTION_REGISTRY.cleanup(force=True)
with lockfile.lock(fail_on_lock=True):
pass
class TestRemovalOfFilesAndDirs(CleanupMemoryBeforeTestMixin, TestCase):
def setUp(self):
super(TestRemovalOfFilesAndDirs, self).setUp()
self.root_path = URI('memory:///')
def test_first(self):
self.assertEqual(self.root_path.listdir(),[])
def test_removedir(self):
dir_path = self.root_path / 'foo'
self.assertTrue(not dir_path.exists())
dir_path.mkdir()
self.assertTrue(dir_path.exists())
self.assertTrue(dir_path.isdir())
dir_path.remove()
self.assertTrue(not dir_path.exists())
def test_remove_not_existing_dir(self):
dir_path = self.root_path / 'foo'
self.assertRaises(FileDoesNotExistError, dir_path.remove, ())
def test_removefile(self):
file_path = self.root_path / 'foo.txt'
self.assertTrue(not file_path.exists())
with file_path.open('w') as fd:
fd.write('bar')
self.assertTrue(file_path.isfile())
file_path.remove()
self.assertTrue(not file_path.exists())
def test_removefile_not_existing(self):
file_path = self.root_path / 'foo.txt'
self.assertRaises(FileDoesNotExistError, file_path.remove, ())
def test_remove_recursive(self):
dir_path = self.root_path / 'foo'
file_path = dir_path / 'bar.txt'
dir_path.mkdir()
with file_path.open('w') as fd:
fd.write('info')
self.assertTrue(dir_path.exists())
self.assertTrue(file_path.exists())
dir_path.remove(recursive=True)
self.assertTrue(not dir_path.exists())
self.assertTrue(not file_path.exists())
def test_locking(self):
p = self.root_path / "test.txt"
try:
content = "I'm something written into a locked file"
with p.lock() as inf:
inf.write(content)
self.assertEqual(p.open().read(), content)
finally:
if p.exists():
p.remove()
mfile = p.open("w")
lock_a = mfile.lock
mfile.close()
mfile = p.open("w")
assert lock_a is mfile.lock
# artificially lock the file
mfile.lock.acquire()
try:
with p.lock(fail_on_lock=True):
assert False, "we shouldn't be allowed here!"
except LockFileObtainException:
pass
finally:
mfile.lock.release()
def test_manipulation_api(self):
p = self.root_path / "test.txt"
p._manipulate(lock=True)
mfile = p.open("w")
assert not mfile.lock.acquire(False)
p._manipulate(unlock=True)
try:
assert mfile.lock.acquire(False)
finally:
mfile.lock.release()
with p.open("w") as outf:
outf.write("foo")
old_mtime = p.mtime()
new_mtime = old_mtime + 100
p._manipulate(mtime=new_mtime)
self.assertEqual(p.mtime(), new_mtime)
error_file = self.root_path / "error"
with error_file.open("wb") as outf:
outf.write(b"foobarbaz")
error_dir = self.root_path / "error.dir"
error_dir.mkdir()
def next_op_callback(_path, _func):
raise OSError(13, "Permission denied")
for error in (error_file, error_dir):
error._manipulate(next_op_callback=next_op_callback)
clone = URI(error)
try:
clone.remove()
except OSError as e:
self.assertEqual(e.errno, 13)
else:
assert False, "Shouldn't be here"
def test_reading_from_write_only_files_not_working(self):
p = self.root_path / "test.txt"
with p.open("w") as outf:
self.assertRaises(IOError, outf.read)
def test_lockfile_cleanup(self):
p = self.root_path / "test.txt"
if p.exists():
p.remove()
with p.lock(cleanup=True):
assert p.exists()
assert not p.exists()
def test_file_name_comparison(self):
a = self.root_path / "a"
b = self.root_path / "b"
assert a == a
assert b == b
assert a != b
assert b != a
assert not a != a
assert not b != b
def test_double_dir_creation_fails(self):
a = self.root_path / "a"
a.mkdir()
self.assertRaises(OSError, a.mkdir)
def test_setting_mode(self):
p = self.root_path / "test.txt"
if p.exists():
p.remove()
create_file(p, content="foo")
mode = p.info().mode
new_mode = mode | stat.S_IXUSR
p.info(set_info=dict(mode=new_mode))
self.assertEqual(p.info().mode,
new_mode)
def test_removing_non_empty_dirs(self):
p = self.root_path / "test-dir"
assert not p.exists()
p.mkdir()
create_file(p / "some-file.txt", content="foobar")
self.assertRaises(OSError, p.remove)
(p / "some-file.txt").remove()
p.remove()
assert not p.exists()
p.mkdir()
create_file(p / "some-file.txt", content="foobar")
p.remove(recursive=True)
