prevent duplicate loading of test data

Author: Luke Bakken

riak/tests/test_btypes.py

@@ -151,13 +151,18 @@ def test_multiget_bucket_types(self):
             self.assertEqual(btype, mobj.bucket.bucket_type)
 
     def test_write_once_bucket_type(self):
-        btype = self.client.bucket_type('write_once')
-        bucket = btype.bucket(self.bucket_name)
-
-        for i in range(100):
-            obj = bucket.new(self.key_name + str(i))
-            obj.data = {'id': i}
-            obj.store()
+        bt = 'write_once'
+        skey = 'write_once-init'
+        btype = self.client.bucket_type(bt)
+        bucket = btype.bucket(bt)
+        sobj = bucket.get(skey)
+        if not sobj.exists:
+            for i in range(100):
+                o = bucket.new(self.key_name + str(i))
+                o.data = {'id': i}
+                o.store()
+            o = bucket.new(skey, data={'id': skey})
+            o.store()
 
         mget = bucket.multiget([self.key_name + str(i) for i in range(100)])
         for mobj in mget:

riak/tests/test_kv.py

@@ -180,17 +180,29 @@ def test_string_bucket_name(self):
     def test_generate_key(self):
         # Ensure that Riak generates a random key when
         # the key passed to bucket.new() is None.
-        bucket = self.client.bucket('random_key_bucket')
-        existing_keys = bucket.get_keys()
+        bucket = self.client.bucket(self.bucket_name)
         o = bucket.new(None, data={})
         self.assertIsNone(o.key)
         o.store()
         self.assertIsNotNone(o.key)
         self.assertNotIn('/', o.key)
-        self.assertNotIn(o.key, existing_keys)
-        self.assertEqual(len(bucket.get_keys()), len(existing_keys) + 1)
+        existing_keys = bucket.get_keys()
+        self.assertEqual(len(existing_keys), 1)
+
+    def maybe_store_keys(self):
+        skey = 'rkb-init'
+        bucket = self.client.bucket('random_key_bucket')
+        sobj = bucket.get(skey)
+        if sobj.exists:
+            return
+        for key in range(1, 1000):
+            o = bucket.new(None, data={})
+            o.store()
+        o = bucket.new(skey, data={})
+        o.store()
 
     def test_stream_keys(self):
+        self.maybe_store_keys()
         bucket = self.client.bucket('random_key_bucket')
         regular_keys = bucket.get_keys()
         self.assertNotEqual(len(regular_keys), 0)
@@ -203,10 +215,8 @@ def test_stream_keys(self):
         self.assertEqual(sorted(regular_keys), sorted(streamed_keys))
 
     def test_stream_keys_timeout(self):
+        self.maybe_store_keys()
         bucket = self.client.bucket('random_key_bucket')
-        for key in range(1, 1000):
-            o = bucket.new(None, data={})
-            o.store()
         streamed_keys = []
         with self.assertRaises(RiakError):
             for keylist in self.client.stream_keys(bucket, timeout=1):
@@ -216,6 +226,7 @@ def test_stream_keys_timeout(self):
                 streamed_keys += keylist
 
     def test_stream_keys_abort(self):
+        self.maybe_store_keys()
         bucket = self.client.bucket('random_key_bucket')
         regular_keys = bucket.get_keys()
         self.assertNotEqual(len(regular_keys), 0)