Python URI.isdir方法代码示例

# 需要导入模块: from abl.vpath.base import URI [as 别名]
# 或者: from abl.vpath.base.URI import isdir [as 别名]
 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)

# 需要导入模块: from abl.vpath.base import URI [as 别名]
# 或者: from abl.vpath.base.URI import isdir [as 别名]
    def test_dir(self):
        testdir = URI('testdir')
        testdir.makedirs()
        self.assertTrue(testdir.exists())
        self.assertTrue(testdir.isdir())
        self.assertTrue(not testdir.isfile())
        testfile = URI('testdir/somefile')
        create_file(testfile, content='test')
        testdir.remove(recursive=True)
        self.assertTrue(not testdir.exists())
        self.assertTrue(not testfile.exists())

        testdir = URI(self.existing_dir)
        self.assertTrue(testdir.exists())
        self.assertTrue(testdir.isdir())

# 需要导入模块: from abl.vpath.base import URI [as 别名]
# 或者: from abl.vpath.base.URI import isdir [as 别名]
    def test_copy_and_move_dir(self):
        folder = URI(self.baseurl) / 'folder'
        folder.makedirs()

        self.assertTrue(folder.isdir())
        afile = folder / 'afile.txt'
        create_file(afile)

        target = URI(self.baseurl) / 'target'
        self.assertTrue(not target.exists())
        folder.copy(target, recursive=True)
        self.assertTrue(target.exists())

        target_file = target / 'afile.txt'
        self.assertTrue(target_file.exists())
        self.assertEqual(load_file(target_file), 'content')

        target.remove(recursive=True)
        self.assertTrue(not target.exists())
        target.makedirs()
        folder.copy(target, recursive=True)

        newtarget = target / 'folder'
        self.assertTrue(newtarget.exists())
        self.assertTrue(newtarget.isdir())

        newtarget_file = newtarget / 'afile.txt'
        self.assertTrue(newtarget_file.exists())
        self.assertTrue(newtarget_file.isfile())
        target.remove(recursive=True)

        folder.move(target)
        self.assertTrue(not folder.exists())
        self.assertTrue(target.exists())
        self.assertTrue(target.isdir())
        self.assertTrue(target_file.exists())
        self.assertTrue(target_file.isfile())
        target.remove(recursive=True)

# 需要导入模块: from abl.vpath.base import URI [as 别名]
# 或者: from abl.vpath.base.URI import isdir [as 别名]
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
#.........这里部分代码省略.........

# 需要导入模块: from abl.vpath.base import URI [as 别名]
# 或者: from abl.vpath.base.URI import isdir [as 别名]
 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())