REF: use the new mixins for the storage tests

- update tests to use the new mixins
- some flaking
- remove duplicated commented code

encore/storage/tests/dict_memory_store_test.py

@@ -5,11 +5,13 @@
 # This file is open source software distributed according to the terms in LICENSE.txt
 #
 import time
+from unittest import TestCase
 
-import encore.storage.tests.abstract_test as abstract_test
+from .abstract_test import StoreReadTestMixin, StoreWriteTestMixin
 from ..dict_memory_store import DictMemoryStore
 
-class DictMemoryStoreReadTest(abstract_test.AbstractStoreReadTest):
+
+class DictMemoryStoreReadTest(TestCase, StoreReadTestMixin):
 
     def setUp(self):
         """ Set up a data store for the test case
@@ -32,7 +34,7 @@ def setUp(self):
         self.store = DictMemoryStore()
         t = time.time()
         self.store._store['test1'] = (
-            'test2\n', {
+            b'test2\n', {
                 'a_str': 'test3',
                 'an_int': 1,
                 'a_float': 2.0,
@@ -43,13 +45,13 @@ def setUp(self):
         for i in range(10):
             t = time.time()
             self.store._store['key%d'%i] = (
-                'value%d' % i, {'query_test1': 'value', 'query_test2': i},
+                b'value%d' % i, {'query_test1': 'value', 'query_test2': i},
                 t, t)
             if i % 2 == 0:
                 self.store._store['key%d'%i][1]['optional'] = True
 
 
-class DictMemoryStoreWriteTest(abstract_test.AbstractStoreWriteTest):
+class DictMemoryStoreWriteTest(TestCase, StoreWriteTestMixin):
 
     def setUp(self):
         """ Set up a data store for the test case

encore/storage/tests/dynamic_url_store_test.py

@@ -1,10 +1,10 @@
-import os
-from tempfile import mkdtemp
 from unittest import TestCase
 from ..dynamic_url_store import DynamicURLStore
 
+
 class DynamicURLStoreTest(TestCase):
     ''' TODO: This should be a full test suite. '''
+
     def setUp(self):
         self.store = DynamicURLStore('http://localhost',
                                      None,

encore/storage/tests/filesystem_store_test.py

@@ -6,18 +6,21 @@
 #
 
 import os
-import threading
 from tempfile import mkdtemp
 from shutil import rmtree
 import json
-import time
-import random
+from unittest import TestCase
 
-import encore.storage.tests.abstract_test as abstract_test
+from .abstract_test import StoreReadTestMixin, StoreWriteTestMixin
 from ..filesystem_store import FileSystemStore, init_shared_store
 
-class FileSystemStoreMixin(object):
-
+class BaseFileSystemStoreTestCase(TestCase):
+
+    resolution = 'second'
+
+    def tearDown(self):
+        rmtree(self.path)
+
     def utils_large(self):
         self._write_data('test3', 'test4'*10000000)
         self._write_metadata('test3', {})
@@ -31,9 +34,7 @@ def _write_metadata(self, filename, metadata):
             json.dump(metadata, fp)
 
 
-class FileSystemStoreReadTest(abstract_test.AbstractStoreReadTest, FileSystemStoreMixin):
-    resolution = 'second'
-
+class FileSystemStoreReadTest(BaseFileSystemStoreTestCase, StoreReadTestMixin):
     def setUp(self):
         """ Set up a data store for the test case
         
@@ -76,30 +77,27 @@ def setUp(self):
         self.store = FileSystemStore(self.path)
         self.store.connect()
 
-    def tearDown(self):
-        rmtree(self.path)
-
     def utils_large(self):
         self._write_data('test3', 'test4'*10000000)
         self._write_metadata('test3', {})
 
-class FileSystemStoreWriteTest(abstract_test.AbstractStoreWriteTest, FileSystemStoreMixin):
-    resolution = 'second'
+
+class FileSystemStoreWriteTest(BaseFileSystemStoreTestCase, StoreWriteTestMixin):
 
     def setUp(self):
         """ Set up a data store for the test case
-        
+
         The store should have:
-            
+
             * a key 'test1' with a file-like data object containing the
               bytes 'test2\n' and metadata {'a_str': 'test3', 'an_int': 1,
               'a_float': 2.0, 'a_bool': True, 'a_list': ['one', 'two', 'three'],
               'a_dict': {'one': 1, 'two': 2, 'three': 3}}
-             
+
             * a series of keys 'existing_key0' through 'existing_key9' with
               data containing 'existing_value0' through 'existing_value9' and
               metadata {'meta': True, 'meta1': 0} through {'meta': True, 'meta1': -9}
-       
+
         and set into 'self.store'.
         """
         super(FileSystemStoreWriteTest, self).setUp()
@@ -115,7 +113,7 @@ def setUp(self):
             'a_list': ['one', 'two', 'three'],
             'a_dict': {'one': 1, 'two': 2, 'three': 3}
         })
-        
+
         for i in range(10):
             key = 'existing_key'+str(i)
             data = 'existing_value'+str(i)
@@ -126,5 +124,3 @@ def setUp(self):
         self.store = FileSystemStore(self.path)
         self.store.connect()
 
-    def tearDown(self):
-        rmtree(self.path)

encore/storage/tests/joined_store_test.py

@@ -6,12 +6,13 @@
 #
 
 import time
+from unittest import TestCase
 
-import encore.storage.tests.abstract_test as abstract_test
+from .abstract_test import StoreReadTestMixin, StoreWriteTestMixin
 from ..joined_store import JoinedStore
 from ..dict_memory_store import DictMemoryStore
 
-class JoinedStoreReadTest(abstract_test.AbstractStoreReadTest):
+class JoinedStoreReadTest(TestCase, StoreReadTestMixin):
 
     def setUp(self):
         """ Set up a data store for the test case
@@ -36,7 +37,7 @@ def setUp(self):
         self.store3 = DictMemoryStore()
         t = time.time()
         self.store2._store['test1'] = (
-            'test2\n',
+            b'test2\n',
             {
                 'a_str': 'test3',
                 'an_int': 1,
@@ -53,13 +54,10 @@ def setUp(self):
             if i % 2 == 0:
                 metadata['optional'] = True
             t = time.time()
-            stores[i%3]._store['key%d'%i] = ('value%d' % i, metadata, t, t)
+            stores[i%3]._store['key%d'%i] = (b'value%d' % i, metadata, t, t)
         self.store = JoinedStore(stores)
 
-    #def utils_large(self):
-    #    self.store2.from_bytes('test3', '')#'test4'*10000000)
-
-class JoinedStoreWriteTest(abstract_test.AbstractStoreWriteTest):
+class JoinedStoreWriteTest(TestCase, StoreWriteTestMixin):
 
     def setUp(self):
         """ Set up a data store for the test case
@@ -108,149 +106,4 @@ def test_multiset_metadata(self):
         metadatas = [{'meta1': i, 'meta2': True} for i in range(10)]
         for i in range(10):
             self.assertTrue(self.store1.exists(keys[i]))
-            self.assertEquals(self.store1.get_metadata(keys[i]), metadatas[i])
-
-    """
-    def test_set(self):
-        super(DictMemoryStoreWriteTest, self).test_set()
-        self.assertEqual(self.store._data['test3'], 'test4')
-        self.assertEqual(self.store._metadata['test3'], {
-            'a_str': 'test5',
-            'an_int': 2,
-            'a_float_1': 3.0,
-            'a_bool_1': True,
-            'a_list_1': ['one', 'two', 'three'],
-            'a_dict_1': {'one': 1, 'two': 2, 'three': 3}
-        })
-
-    def test_set_copies(self):
-        super(DictMemoryStoreWriteTest, self).test_set_copies()
-        self.assertEqual(self.store._metadata['test3'], {
-            'a_str': 'test5',
-            'an_int': 2,
-            'a_float_1': 3.0,
-            'a_bool_1': True,
-            'a_list_1': ['one', 'two', 'three'],
-            'a_dict_1': {'one': 1, 'two': 2, 'three': 3}
-        })
-
-    def test_set_large(self):
-        super(DictMemoryStoreWriteTest, self).test_set_large()
-        self.assertEqual(self.store._data['test3'], 'test4'*10000000)
-        self.assertEqual(self.store._metadata['test3'], {
-            'a_str': 'test5',
-            'an_int': 2,
-            'a_float_1': 3.0,
-            'a_bool_1': True,
-            'a_list_1': ['one', 'two', 'three'],
-            'a_dict_1': {'one': 1, 'two': 2, 'three': 3}
-        })
-
-    def test_set_buffer(self):
-        super(DictMemoryStoreWriteTest, self).test_set_buffer()
-        self.assertEqual(self.store._data['test3'], 'test4'*8000)
-        self.assertEqual(self.store._metadata['test3'], {
-            'a_str': 'test5',
-            'an_int': 2,
-            'a_float_1': 3.0,
-            'a_bool_1': True,
-            'a_list_1': ['one', 'two', 'three'],
-            'a_dict_1': {'one': 1, 'two': 2, 'three': 3}
-        })
-
-    def test_set_data(self):
-        super(DictMemoryStoreWriteTest, self).test_set_data()
-        self.assertEqual(self.store._data['test1'], 'test4')
-
-    def test_set_data_large(self):
-        super(DictMemoryStoreWriteTest, self).test_set_data_large()
-        self.assertEqual(self.store._data['test3'], 'test4'*10000000)
-
-    def test_set_data_buffer(self):
-        super(DictMemoryStoreWriteTest, self).test_set_data_buffer()
-        self.assertEqual(self.store._data['test1'], 'test4'*8000)
-
-    def test_set_metadata(self):
-        super(DictMemoryStoreWriteTest, self).test_set_metadata()
-        self.assertEqual(self.store._metadata['test1'], {
-            'a_str': 'test5',
-            'an_int': 2,
-            'a_float_1': 3.0,
-            'a_bool_1': True,
-            'a_list_1': ['one', 'two', 'three'],
-            'a_dict_1': {'one': 1, 'two': 2, 'three': 3}
-        })
-
-    def test_update_metadata(self):
-        super(DictMemoryStoreWriteTest, self).test_update_metadata()
-        self.assertEqual(self.store._metadata['test1'], {
-            'a_float': 2.0,
-            'a_list': ['one', 'two', 'three'],
-            'a_dict': {'one': 1, 'two': 2, 'three': 3},
-            'a_str': 'test5',
-            'a_bool': True,
-            'an_int': 2,
-            'a_float_1': 3.0,
-            'a_bool_1': True,
-            'a_list_1': ['one', 'two', 'three'],
-            'a_dict_1': {'one': 1, 'two': 2, 'three': 3}
-        })
-    
-    def test_delete(self):
-        super(DictMemoryStoreWriteTest, self).test_delete()
-        self.assertFalse('test1' in self.store._data)
-        self.assertFalse('test1' in self.store._metadata)
-
-    def test_multiset(self):
-        super(DictMemoryStoreWriteTest, self).test_multiset()
-        keys = ['set_key'+str(i) for i in range(10)]
-        values = ['set_value'+str(i) for i in range(10)]
-        metadatas = [{'meta1': i, 'meta2': True} for i in range(10)]
-        for i in range(10):
-            self.assertEquals(self.store._data[keys[i]], values[i])
-            self.assertEquals(self.store._metadata[keys[i]], metadatas[i])
-
-    def test_multiset_overwrite(self):
-        super(DictMemoryStoreWriteTest, self).test_multiset_overwrite()
-        keys = ['existing_key'+str(i) for i in range(10)]
-        values = ['set_value'+str(i) for i in range(10)]
-        metadatas = [{'meta1': i, 'meta2': True} for i in range(10)]
-        for i in range(10):
-            self.assertEquals(self.store._data[keys[i]], values[i])
-            self.assertEquals(self.store._metadata[keys[i]], metadatas[i])
-
-    def test_multiset_data(self):
-        super(DictMemoryStoreWriteTest, self).test_multiset_data()
-        keys = ['existing_key'+str(i) for i in range(10)]
-        values = ['set_value'+str(i) for i in range(10)]
-        for i in range(10):
-            self.assertEquals(self.store._data[keys[i]], values[i])
-
-    def test_multiset_metadata(self):
-        super(DictMemoryStoreWriteTest, self).test_multiset_metadata()
-        keys = ['existing_key'+str(i) for i in range(10)]
-        metadatas = [{'meta1': i, 'meta2': True} for i in range(10)]
-        for i in range(10):
-            self.assertEquals(self.store._metadata[keys[i]], metadatas[i])
-
-    def test_multiupdate_metadata(self):
-        super(DictMemoryStoreWriteTest, self).test_multiupdate_metadata()
-        keys = ['existing_key'+str(i) for i in range(10)]
-        metadatas = [{'meta1': i, 'meta2': True} for i in range(10)]
-        for i in range(10):
-            expected = {'meta': True}
-            expected.update(metadatas[i])
-            self.assertEquals(self.store._metadata[keys[i]], metadatas[i])
-
-    def test_from_file(self):
-        super(DictMemoryStoreWriteTest, self).test_from_file()
-        self.assertEqual(self.store._data['test3'], 'test4')
-
-    def test_from_file_large(self):
-        super(DictMemoryStoreWriteTest, self).test_from_file_large()
-        self.assertEqual(self.store._data['test3'], 'test4'*10000000)
-
-    def test_from_bytes(self):
-        super(DictMemoryStoreWriteTest, self).test_from_bytes()
-        self.assertEqual(self.store._data['test3'], 'test4')
-    """
+            self.assertEquals(self.store1.get_metadata(keys[i]), metadatas[i])

encore/storage/tests/mounted_store_test.py

@@ -5,10 +5,10 @@
 # This file is open source software distributed according to the terms in LICENSE.txt
 #
 
-from unittest import TestCase
 import time
+from unittest import TestCase
 
-import encore.storage.tests.abstract_test as abstract_test
+from .abstract_test import StoreReadTestMixin, StoreWriteTestMixin
 from ..mounted_store import MountedStore
 from ..dict_memory_store import DictMemoryStore
 from ..string_value import StringValue
@@ -126,7 +126,7 @@ def test_push(self):
         self.assertEqual(value.metadata, {"metakey": "mounted"})
 
 
-class MountedStoreReadTest(abstract_test.AbstractStoreReadTest):
+class MountedStoreReadTest(TestCase, StoreReadTestMixin):
 
     def setUp(self):
         """ Set up a data store for the test case
@@ -170,10 +170,7 @@ def setUp(self):
             stores[i%2]._store['key%d'%i] = ('value%d' % i, metadata, t, t)
         self.store = MountedStore('', self.mounted_store, self.backing_store)
 
-    #def utils_large(self):
-    #    self.store2.from_bytes('test3', '')#'test4'*10000000)
-
-class MountedStoreWriteTest(abstract_test.AbstractStoreWriteTest):
+class MountedStoreWriteTest(TestCase, StoreWriteTestMixin):
 
     def setUp(self):
         """ Set up a data store for the test case