Python platform.open_file函数代码示例

    def _create_paths(self):
        """Create the paths for the tests.

        The following structure will be created:

            self.basedir/
            |-> self.testfile
            |-> dir0/
                |-> file0
                |-> link
            |-> dir1/
                |-> file1
                |-> dir11/
            |-> dir2/
                |-> file2
            |-> dir3/

        """
        open_file(self.testfile, 'w').close()

        for i in xrange(3):
            dir_name = 'dir%i' % i
            dir_path = os.path.join(self.basedir, dir_name)
            make_dir(dir_path, recursive=True)

            file_name = 'file%i' % i
            file_path = os.path.join(dir_path, file_name)
            open_file(file_path, "w").close()

        make_link(os.path.devnull,
                  os.path.join(self.basedir, 'dir0', 'link'))
        make_dir(os.path.join(self.basedir, 'dir1', 'dir11'))
        make_dir(os.path.join(self.basedir, 'dir3'), recursive=True)

    def test_broken_metadata_with_backup(self):
        """test that each time a metadata file is updated a .old is kept"""
        self.shelf['bad_file'] = {'value': 'old'}
        path = self.shelf.key_file('bad_file')
        self.assertFalse(path_exists(path+'.old'))
        self.assertEqual({'value': 'old'}, self.shelf['bad_file'])
        # force the creation of the .old file
        self.shelf['bad_file'] = {'value': 'new'}
        self.assertTrue(path_exists(path+'.old'))
        # check that the new value is there
        self.assertEqual({'value': 'new'}, self.shelf['bad_file'])
        # write the current md file fwith 0 bytes
        open_file(path, 'w').close()
        # test that the old value is retrieved
        self.assertEqual({'value': 'old'}, self.shelf['bad_file'])

        self.shelf['broken_pickle'] = {'value': 'old'}
        path = self.shelf.key_file('broken_pickle')
        # check that .old don't exist
        self.assertFalse(path_exists(path+'.old'))
        # force the creation of the .old file
        self.shelf['broken_pickle'] = {'value': 'new'}
        # check that .old exists
        self.assertTrue(path_exists(path+'.old'))
        # check that the new value is there
        self.assertEqual({'value': 'new'}, self.shelf['broken_pickle'])
        # write random bytes to the md file
        with open_file(path, 'w') as f:
            f.write(BROKEN_PICKLE)
        # check that the old value is retrieved
        self.assertEqual({'value': 'old'}, self.shelf['broken_pickle'])

    def test_open_file_write(self):
        """Open a file, and write."""
        fh = open_file(self.testfile, 'w')
        fh.write("foo")
        fh.close()

        f = open_file(self.testfile)
        self.assertTrue(f.read(), "foo")

    def test_set_file_readwrite(self):
        """Test for set_file_readwrite."""
        set_file_readonly(self.testfile)
        self.addCleanup(set_dir_readwrite, self.testfile)

        set_file_readwrite(self.testfile)
        open_file(self.testfile, 'w')
        self.assertTrue(can_write(self.testfile))

 def setUp(self, test_dir_name=None, test_file_name=None,
           valid_file_path_builder=None):
     """Setup for the tests."""
     yield super(OSWrapperTests, self).setUp(
         test_dir_name=test_dir_name, test_file_name=test_file_name,
         valid_file_path_builder=valid_file_path_builder)
     # make sure the file exists
     open_file(self.testfile, 'w').close()

 def test_bad_path(self):
     """Test that the shelf removes the previous shelve file and create a
     directory for the new file based shelf at creation time.
     """
     path = os.path.join(self.path, 'shelf_file')
     open_file(path, 'w').close()
     self.fileshelf_class(path)
     self.assertTrue(os.path.isdir(path))

 def _check_move_file(self, src, dst, real_dst):
     """Check that a file was indeed moved."""
     with open_file(src, "rb") as f:
         contents = f.read()
     recursive_move(src, dst)
     with open_file(real_dst, "rb") as f:
         self.assertEqual(contents, f.read())
     self.assertFalse(path_exists(src))

 def test_movetotrash_file_bad(self):
     """Something bad happen when moving to trash, removed anyway."""
     path = os.path.join(self.basedir, 'foo')
     open_file(path, 'w').close()
     move_to_trash(path)
     self.assertFalse(os.path.exists(path))
     self.assertTrue(self.handler.check_warning("Problems moving to trash!",
                                                "Removing anyway", "foo"))

 def test_corrupted_backup(self):
     """test getitem if also the .old file is corrupted"""
     self.shelf["foo"] = "bar"
     # create the .old backup
     self.shelf["foo"] = "bar1"
     # write 0 bytes to both
     open_file(self.shelf.key_file('foo')+'.old', 'w').close()
     open_file(self.shelf.key_file('foo'), 'w').close()
     self.assertRaises(KeyError, self.shelf.__getitem__, 'foo')

 def test_endless_borken_backups(self):
     """test getitem  with a lot of files named .old.old.....old"""
     self.shelf["foo"] = "bar"
     path = self.shelf.key_file('foo')
     open_file(self.shelf.key_file('foo'), 'w').close()
     for _ in xrange(20):
         open_file(path + '.old', 'w').close()
         path += '.old'
     self.assertRaises(KeyError, self.shelf.__getitem__, 'foo')

 def test_movetotrash_file_systemnotcapable(self):
     """The system is not capable of moving into trash."""
     FakeGIOFile._bad_trash_call = GIO_NOT_SUPPORTED
     self.patch(gio, "File", FakeGIOFile)
     path = os.path.join(self.basedir, 'foo')
     open_file(path, 'w').close()
     move_to_trash(path)
     self.assertFalse(os.path.exists(path))
     self.assertTrue(self.handler.check_warning("Problems moving to trash!",
                                                "Removing anyway", "foo",
                                                "ERROR_NOT_SUPPORTED"))

 def test_movetotrash_dir_bad(self):
     """Something bad happen when moving to trash, removed anyway."""
     FakeGIOFile._bad_trash_call = False   # error
     self.patch(gio, "File", FakeGIOFile)
     path = os.path.join(self.basedir, 'foo')
     os.mkdir(path)
     open_file(os.path.join(path, 'file inside directory'), 'w').close()
     move_to_trash(path)
     self.assertFalse(os.path.exists(path))
     self.assertTrue(self.handler.check_warning("Problems moving to trash!",
                                                "Removing anyway", "foo"))

 def __init__(self, path):
     """Create the instance."""
     self.path = path
     self.tempfile = None
     if path_exists(self.path) and stat_path(self.path).st_size > 0:
         # if it's there and size > 0, open only for read
         self.fd = open_file(self.path, "rb")
     else:
         # this is a new hint file, lets create it as a tempfile.
         self.tempfile = tempfile.mktemp(dir=os.path.dirname(self.path))
         self.fd = open_file(self.tempfile, "w+b")

 def test_delete_backups_too(self):
     """test that delitem also deletes the .old/.new files left around"""
     self.shelf["foo"] = "bar"
     # create the .old backup
     self.shelf["foo"] = "bar1"
     path = self.shelf.key_file('foo')
     # create a .new file (a hard reboot during the rename dance)
     open_file(path+'.new', 'w').close()
     # write 0 bytes to both
     del self.shelf['foo']
     self.assertFalse(path_exists(path))
     self.assertFalse(path_exists(path+'.old'), 'there is a .old file!')
     self.assertFalse(path_exists(path+'.new'), 'there is a .new file!')

    def test_broken_metadata_without_backup(self):
        """test the shelf behavior when it hit a broken metadata file without
        backup.
        """
        self.shelf['bad_file'] = {}
        path = self.shelf.key_file('bad_file')
        open_file(path, 'w').close()
        self.assertRaises(KeyError, self.shelf.__getitem__, 'bad_file')

        self.shelf['broken_pickle'] = {}
        path = self.shelf.key_file('broken_pickle')
        with open_file(path, 'w') as f:
            f.write(BROKEN_PICKLE)
        self.assertRaises(KeyError, self.shelf.__getitem__, 'broken_pickle')