Пример #1
0
class StorageTest(unittest.TestCase):
    def setUp(self):
        self.tmpdir = tempfile.mkdtemp()
        self.storage_manager = StorageManager(self.tmpdir, chunk_size=128)

    def tearDown(self):
        shutil.rmtree(self.tmpdir)

    def test_chunks_storage(self):
        ## todo: check deduplication
        for chunk_hash, chunk_data in DUMMY_CHUNKS.iteritems():
            ## Test storage
            chunk_id = self.storage_manager.store_chunk(chunk_data)
            self.assertEqual(chunk_id, chunk_hash)

        for chunk_hash, chunk_data in DUMMY_CHUNKS.iteritems():
            ## Test retrieval
            self.assertTrue(self.storage_manager.has_chunk(chunk_hash))
            new_chunk = self.storage_manager.get_chunk(chunk_hash)
            self.assertEqual(chunk_data, new_chunk)

        for chunk_hash in DUMMY_CHUNKS.iterkeys():
            ## Test deletion
            self.storage_manager.delete_chunk(chunk_hash)
            self.assertFalse(self.storage_manager.has_chunk(chunk_hash))
            with self.assertRaises(Exception):
                self.storage_manager.get_chunk(chunk_hash)

    def test_blobs_storage(self):
        ## todo: test refcount of chunks
        from io import BytesIO
        for blob_hash, blob_data in DUMMY_BLOBS.iteritems():
            ## Test storage
            b = BytesIO(blob_data)
            blob_id = self.storage_manager.store_blob(b)
            self.assertEqual(blob_id, blob_hash)

        for blob_hash, blob_data in DUMMY_BLOBS.iteritems():
            ## Test retrieval
            self.assertTrue(self.storage_manager.has_blob(blob_hash))
            b2 = BytesIO()
            self.storage_manager.retrieve_blob(blob_hash, b2)
            b2.seek(0)
            blob2 = b2.read()
            self.assertEqual(blob_data, blob2)

        for blob_hash, blob_data in DUMMY_BLOBS.iteritems():
            ## Test deletion
            self.storage_manager.delete_blob_info(blob_hash)
            self.assertFalse(self.storage_manager.has_blob(blob_hash))

            ## Test retrieval of non-existent blobs
            b2 = BytesIO()
            with self.assertRaises(Exception):
                self.storage_manager.retrieve_blob(blob_hash, b2)

    def test_table_storage(self):
        ## todo: test refcount of blobs + chunks
        ## todo: check refcounts / deletion / cleanup / etc.
        ## todo: test table metadata storage + indexing etc.
        for fs_name, fs_tree in DUMMY_FS.iteritems():
            self.storage_manager.store_table(fs_name, {
                'hostname': fs_name,
            }, fs_tree)

        self.assertListEqual(
            sorted(list(self.storage_manager.list_tables())),
            sorted(list(DUMMY_FS.iterkeys())))

        for fs_name, fs_tree in DUMMY_FS.iteritems():
            self.assertTrue(self.storage_manager.has_table(fs_name))
            retr_tree = self.storage_manager.get_table_data(fs_name)
            self.assertDictEqual(retr_tree, fs_tree)

        for fs_name, fs_tree in DUMMY_FS.iteritems():
            self.storage_manager.delete_table(fs_name)
            self.assertFalse(self.storage_manager.has_table(fs_name))
            with self.assertRaises(Exception):
                self.storage_manager.get_table_data(fs_name)