| import py |
| import sys |
| |
| class CommonFSTests(object): |
| def test_constructor_equality(self, path1): |
| p = path1.__class__(path1) |
| assert p == path1 |
| |
| def test_eq_nonstring(self, path1): |
| p1 = path1.join('sampledir') |
| p2 = path1.join('sampledir') |
| assert p1 == p2 |
| |
| def test_new_identical(self, path1): |
| assert path1 == path1.new() |
| |
| def test_join(self, path1): |
| p = path1.join('sampledir') |
| strp = str(p) |
| assert strp.endswith('sampledir') |
| assert strp.startswith(str(path1)) |
| |
| def test_join_normalized(self, path1): |
| newpath = path1.join(path1.sep+'sampledir') |
| strp = str(newpath) |
| assert strp.endswith('sampledir') |
| assert strp.startswith(str(path1)) |
| newpath = path1.join((path1.sep*2) + 'sampledir') |
| strp = str(newpath) |
| assert strp.endswith('sampledir') |
| assert strp.startswith(str(path1)) |
| |
| def test_join_noargs(self, path1): |
| newpath = path1.join() |
| assert path1 == newpath |
| |
| def test_add_something(self, path1): |
| p = path1.join('sample') |
| p = p + 'dir' |
| assert p.check() |
| assert p.exists() |
| assert p.isdir() |
| assert not p.isfile() |
| |
| def test_parts(self, path1): |
| newpath = path1.join('sampledir', 'otherfile') |
| par = newpath.parts()[-3:] |
| assert par == [path1, path1.join('sampledir'), newpath] |
| |
| revpar = newpath.parts(reverse=True)[:3] |
| assert revpar == [newpath, path1.join('sampledir'), path1] |
| |
| def test_common(self, path1): |
| other = path1.join('sampledir') |
| x = other.common(path1) |
| assert x == path1 |
| |
| #def test_parents_nonexisting_file(self, path1): |
| # newpath = path1 / 'dirnoexist' / 'nonexisting file' |
| # par = list(newpath.parents()) |
| # assert par[:2] == [path1 / 'dirnoexist', path1] |
| |
| def test_basename_checks(self, path1): |
| newpath = path1.join('sampledir') |
| assert newpath.check(basename='sampledir') |
| assert newpath.check(notbasename='xyz') |
| assert newpath.basename == 'sampledir' |
| |
| def test_basename(self, path1): |
| newpath = path1.join('sampledir') |
| assert newpath.check(basename='sampledir') |
| assert newpath.basename, 'sampledir' |
| |
| def test_dirname(self, path1): |
| newpath = path1.join('sampledir') |
| assert newpath.dirname == str(path1) |
| |
| def test_dirpath(self, path1): |
| newpath = path1.join('sampledir') |
| assert newpath.dirpath() == path1 |
| |
| def test_dirpath_with_args(self, path1): |
| newpath = path1.join('sampledir') |
| assert newpath.dirpath('x') == path1.join('x') |
| |
| def test_newbasename(self, path1): |
| newpath = path1.join('samplefile') |
| newbase = newpath.new(basename="samplefile2") |
| assert newbase.basename == "samplefile2" |
| assert newbase.dirpath() == newpath.dirpath() |
| |
| def test_not_exists(self, path1): |
| assert not path1.join('does_not_exist').check() |
| assert path1.join('does_not_exist').check(exists=0) |
| |
| def test_exists(self, path1): |
| assert path1.join("samplefile").check() |
| assert path1.join("samplefile").check(exists=1) |
| assert path1.join("samplefile").exists() |
| assert path1.join("samplefile").isfile() |
| assert not path1.join("samplefile").isdir() |
| |
| def test_dir(self, path1): |
| #print repr(path1.join("sampledir")) |
| assert path1.join("sampledir").check(dir=1) |
| assert path1.join('samplefile').check(notdir=1) |
| assert not path1.join("samplefile").check(dir=1) |
| assert path1.join("samplefile").exists() |
| assert not path1.join("samplefile").isdir() |
| assert path1.join("samplefile").isfile() |
| |
| def test_fnmatch_file(self, path1): |
| assert path1.join("samplefile").check(fnmatch='s*e') |
| assert path1.join("samplefile").fnmatch('s*e') |
| assert not path1.join("samplefile").fnmatch('s*x') |
| assert not path1.join("samplefile").check(fnmatch='s*x') |
| |
| #def test_fnmatch_dir(self, path1): |
| |
| # pattern = path1.sep.join(['s*file']) |
| # sfile = path1.join("samplefile") |
| # assert sfile.check(fnmatch=pattern) |
| |
| def test_relto(self, path1): |
| l=path1.join("sampledir", "otherfile") |
| assert l.relto(path1) == l.sep.join(["sampledir", "otherfile"]) |
| assert l.check(relto=path1) |
| assert path1.check(notrelto=l) |
| assert not path1.check(relto=l) |
| |
| def test_bestrelpath(self, path1): |
| curdir = path1 |
| sep = curdir.sep |
| s = curdir.bestrelpath(curdir) |
| assert s == "." |
| s = curdir.bestrelpath(curdir.join("hello", "world")) |
| assert s == "hello" + sep + "world" |
| |
| s = curdir.bestrelpath(curdir.dirpath().join("sister")) |
| assert s == ".." + sep + "sister" |
| assert curdir.bestrelpath(curdir.dirpath()) == ".." |
| |
| assert curdir.bestrelpath("hello") == "hello" |
| |
| def test_relto_not_relative(self, path1): |
| l1=path1.join("bcde") |
| l2=path1.join("b") |
| assert not l1.relto(l2) |
| assert not l2.relto(l1) |
| |
| @py.test.mark.xfail("sys.platform.startswith('java')") |
| def test_listdir(self, path1): |
| l = path1.listdir() |
| assert path1.join('sampledir') in l |
| assert path1.join('samplefile') in l |
| py.test.raises(py.error.ENOTDIR, |
| "path1.join('samplefile').listdir()") |
| |
| def test_listdir_fnmatchstring(self, path1): |
| l = path1.listdir('s*dir') |
| assert len(l) |
| assert l[0], path1.join('sampledir') |
| |
| def test_listdir_filter(self, path1): |
| l = path1.listdir(lambda x: x.check(dir=1)) |
| assert path1.join('sampledir') in l |
| assert not path1.join('samplefile') in l |
| |
| def test_listdir_sorted(self, path1): |
| l = path1.listdir(lambda x: x.check(basestarts="sample"), sort=True) |
| assert path1.join('sampledir') == l[0] |
| assert path1.join('samplefile') == l[1] |
| assert path1.join('samplepickle') == l[2] |
| |
| def test_visit_nofilter(self, path1): |
| l = [] |
| for i in path1.visit(): |
| l.append(i.relto(path1)) |
| assert "sampledir" in l |
| assert path1.sep.join(["sampledir", "otherfile"]) in l |
| |
| def test_visit_norecurse(self, path1): |
| l = [] |
| for i in path1.visit(None, lambda x: x.basename != "sampledir"): |
| l.append(i.relto(path1)) |
| assert "sampledir" in l |
| assert not path1.sep.join(["sampledir", "otherfile"]) in l |
| |
| def test_visit_filterfunc_is_string(self, path1): |
| l = [] |
| for i in path1.visit('*dir'): |
| l.append(i.relto(path1)) |
| assert len(l), 2 |
| assert "sampledir" in l |
| assert "otherdir" in l |
| |
| @py.test.mark.xfail("sys.platform.startswith('java')") |
| def test_visit_ignore(self, path1): |
| p = path1.join('nonexisting') |
| assert list(p.visit(ignore=py.error.ENOENT)) == [] |
| |
| def test_visit_endswith(self, path1): |
| l = [] |
| for i in path1.visit(lambda x: x.check(endswith="file")): |
| l.append(i.relto(path1)) |
| assert path1.sep.join(["sampledir", "otherfile"]) in l |
| assert "samplefile" in l |
| |
| def test_endswith(self, path1): |
| assert path1.check(notendswith='.py') |
| x = path1.join('samplefile') |
| assert x.check(endswith='file') |
| |
| def test_cmp(self, path1): |
| path1 = path1.join('samplefile') |
| path2 = path1.join('samplefile2') |
| assert (path1 < path2) == ('samplefile' < 'samplefile2') |
| assert not (path1 < path1) |
| |
| def test_simple_read(self, path1): |
| x = path1.join('samplefile').read('r') |
| assert x == 'samplefile\n' |
| |
| def test_join_div_operator(self, path1): |
| newpath = path1 / '/sampledir' / '/test//' |
| newpath2 = path1.join('sampledir', 'test') |
| assert newpath == newpath2 |
| |
| def test_ext(self, path1): |
| newpath = path1.join('sampledir.ext') |
| assert newpath.ext == '.ext' |
| newpath = path1.join('sampledir') |
| assert not newpath.ext |
| |
| def test_purebasename(self, path1): |
| newpath = path1.join('samplefile.py') |
| assert newpath.purebasename == 'samplefile' |
| |
| def test_multiple_parts(self, path1): |
| newpath = path1.join('samplefile.py') |
| dirname, purebasename, basename, ext = newpath._getbyspec( |
| 'dirname,purebasename,basename,ext') |
| assert str(path1).endswith(dirname) # be careful with win32 'drive' |
| assert purebasename == 'samplefile' |
| assert basename == 'samplefile.py' |
| assert ext == '.py' |
| |
| def test_dotted_name_ext(self, path1): |
| newpath = path1.join('a.b.c') |
| ext = newpath.ext |
| assert ext == '.c' |
| assert newpath.ext == '.c' |
| |
| def test_newext(self, path1): |
| newpath = path1.join('samplefile.py') |
| newext = newpath.new(ext='.txt') |
| assert newext.basename == "samplefile.txt" |
| assert newext.purebasename == "samplefile" |
| |
| def test_readlines(self, path1): |
| fn = path1.join('samplefile') |
| contents = fn.readlines() |
| assert contents == ['samplefile\n'] |
| |
| def test_readlines_nocr(self, path1): |
| fn = path1.join('samplefile') |
| contents = fn.readlines(cr=0) |
| assert contents == ['samplefile', ''] |
| |
| def test_file(self, path1): |
| assert path1.join('samplefile').check(file=1) |
| |
| def test_not_file(self, path1): |
| assert not path1.join("sampledir").check(file=1) |
| assert path1.join("sampledir").check(file=0) |
| |
| def test_non_existent(self, path1): |
| assert path1.join("sampledir.nothere").check(dir=0) |
| assert path1.join("sampledir.nothere").check(file=0) |
| assert path1.join("sampledir.nothere").check(notfile=1) |
| assert path1.join("sampledir.nothere").check(notdir=1) |
| assert path1.join("sampledir.nothere").check(notexists=1) |
| assert not path1.join("sampledir.nothere").check(notfile=0) |
| |
| # pattern = path1.sep.join(['s*file']) |
| # sfile = path1.join("samplefile") |
| # assert sfile.check(fnmatch=pattern) |
| |
| def test_size(self, path1): |
| url = path1.join("samplefile") |
| assert url.size() > len("samplefile") |
| |
| def test_mtime(self, path1): |
| url = path1.join("samplefile") |
| assert url.mtime() > 0 |
| |
| def test_relto_wrong_type(self, path1): |
| py.test.raises(TypeError, "path1.relto(42)") |
| |
| def test_load(self, path1): |
| p = path1.join('samplepickle') |
| obj = p.load() |
| assert type(obj) is dict |
| assert obj.get('answer',None) == 42 |
| |
| def test_visit_filesonly(self, path1): |
| l = [] |
| for i in path1.visit(lambda x: x.check(file=1)): |
| l.append(i.relto(path1)) |
| assert not "sampledir" in l |
| assert path1.sep.join(["sampledir", "otherfile"]) in l |
| |
| def test_visit_nodotfiles(self, path1): |
| l = [] |
| for i in path1.visit(lambda x: x.check(dotfile=0)): |
| l.append(i.relto(path1)) |
| assert "sampledir" in l |
| assert path1.sep.join(["sampledir", "otherfile"]) in l |
| assert not ".dotfile" in l |
| |
| def test_visit_breadthfirst(self, path1): |
| l = [] |
| for i in path1.visit(bf=True): |
| l.append(i.relto(path1)) |
| for i, p in enumerate(l): |
| if path1.sep in p: |
| for j in range(i, len(l)): |
| assert path1.sep in l[j] |
| break |
| else: |
| py.test.fail("huh") |
| |
| def test_visit_sort(self, path1): |
| l = [] |
| for i in path1.visit(bf=True, sort=True): |
| l.append(i.relto(path1)) |
| for i, p in enumerate(l): |
| if path1.sep in p: |
| break |
| assert l[:i] == sorted(l[:i]) |
| assert l[i:] == sorted(l[i:]) |
| |
| def test_endswith(self, path1): |
| def chk(p): |
| return p.check(endswith="pickle") |
| assert not chk(path1) |
| assert not chk(path1.join('samplefile')) |
| assert chk(path1.join('somepickle')) |
| |
| def test_copy_file(self, path1): |
| otherdir = path1.join('otherdir') |
| initpy = otherdir.join('__init__.py') |
| copied = otherdir.join('copied') |
| initpy.copy(copied) |
| try: |
| assert copied.check() |
| s1 = initpy.read() |
| s2 = copied.read() |
| assert s1 == s2 |
| finally: |
| if copied.check(): |
| copied.remove() |
| |
| def test_copy_dir(self, path1): |
| otherdir = path1.join('otherdir') |
| copied = path1.join('newdir') |
| try: |
| otherdir.copy(copied) |
| assert copied.check(dir=1) |
| assert copied.join('__init__.py').check(file=1) |
| s1 = otherdir.join('__init__.py').read() |
| s2 = copied.join('__init__.py').read() |
| assert s1 == s2 |
| finally: |
| if copied.check(dir=1): |
| copied.remove(rec=1) |
| |
| def test_remove_file(self, path1): |
| d = path1.ensure('todeleted') |
| assert d.check() |
| d.remove() |
| assert not d.check() |
| |
| def test_remove_dir_recursive_by_default(self, path1): |
| d = path1.ensure('to', 'be', 'deleted') |
| assert d.check() |
| p = path1.join('to') |
| p.remove() |
| assert not p.check() |
| |
| def test_ensure_dir(self, path1): |
| b = path1.ensure_dir("001", "002") |
| assert b.basename == "002" |
| assert b.isdir() |
| |
| def test_mkdir_and_remove(self, path1): |
| tmpdir = path1 |
| py.test.raises(py.error.EEXIST, tmpdir.mkdir, 'sampledir') |
| new = tmpdir.join('mktest1') |
| new.mkdir() |
| assert new.check(dir=1) |
| new.remove() |
| |
| new = tmpdir.mkdir('mktest') |
| assert new.check(dir=1) |
| new.remove() |
| assert tmpdir.join('mktest') == new |
| |
| def test_move_file(self, path1): |
| p = path1.join('samplefile') |
| newp = p.dirpath('moved_samplefile') |
| p.move(newp) |
| try: |
| assert newp.check(file=1) |
| assert not p.check() |
| finally: |
| dp = newp.dirpath() |
| if hasattr(dp, 'revert'): |
| dp.revert() |
| else: |
| newp.move(p) |
| assert p.check() |
| |
| def test_move_dir(self, path1): |
| source = path1.join('sampledir') |
| dest = path1.join('moveddir') |
| source.move(dest) |
| assert dest.check(dir=1) |
| assert dest.join('otherfile').check(file=1) |
| assert not source.join('sampledir').check() |
| |
| def setuptestfs(path): |
| if path.join('samplefile').check(): |
| return |
| #print "setting up test fs for", repr(path) |
| samplefile = path.ensure('samplefile') |
| samplefile.write('samplefile\n') |
| |
| execfile = path.ensure('execfile') |
| execfile.write('x=42') |
| |
| execfilepy = path.ensure('execfile.py') |
| execfilepy.write('x=42') |
| |
| d = {1:2, 'hello': 'world', 'answer': 42} |
| path.ensure('samplepickle').dump(d) |
| |
| sampledir = path.ensure('sampledir', dir=1) |
| sampledir.ensure('otherfile') |
| |
| otherdir = path.ensure('otherdir', dir=1) |
| otherdir.ensure('__init__.py') |
| |
| module_a = otherdir.ensure('a.py') |
| if sys.version_info >= (2,6): |
| module_a.write('from .b import stuff as result\n') |
| else: |
| module_a.write('from b import stuff as result\n') |
| module_b = otherdir.ensure('b.py') |
| module_b.write('stuff="got it"\n') |
| module_c = otherdir.ensure('c.py') |
| module_c.write('''import py; |
| import otherdir.a |
| value = otherdir.a.result |
| ''') |
| module_d = otherdir.ensure('d.py') |
| module_d.write('''import py; |
| from otherdir import a |
| value2 = a.result |
| ''') |
