From 802dd924545b52ce9ffcf752e54656bafa515b69 Mon Sep 17 00:00:00 2001 From: evan Date: Sat, 17 Nov 2012 10:55:51 -0800 Subject: [PATCH 1/6] temp commit --- riak/tests/test_all.py | 76 +++++++++++++++++------------- riak/tests/test_kv.py | 97 ++++++++++++++++++++------------------- riak/tests/test_pool.py | 4 +- riak/tests/test_search.py | 66 +++++++++++++------------- 4 files changed, 128 insertions(+), 115 deletions(-) diff --git a/riak/tests/test_all.py b/riak/tests/test_all.py index 97044ead..43a4e343 100644 --- a/riak/tests/test_all.py +++ b/riak/tests/test_all.py @@ -59,24 +59,33 @@ class BaseTestCase(object): def randint(): return random.randint(1, 999999) + @staticmethod + def randname(length = 12): + out = '' + for i in range(length): + out += chr(random.randint(ord('a'), ord('z'))) + return out + def create_client(self, host=None, port=None, transport_class=None): host = host or self.host port = port or self.port transport_class = transport_class or self.transport_class - return RiakClient(self.host, self.port, - transport_class=self.transport_class) + return RiakClient(host, port, + transport_class=transport_class) def setUp(self): - self.client = self.create_client() - - # make sure these are not left over from a previous, failed run - bucket = self.client.bucket('bucket') - o = bucket.get('nonexistent_key_json') - o.delete() - o = bucket.get('nonexistent_key_binary') - o.delete() - + self.bucket_name = self.randname() + self.key_name = self.randname() + if not getattr(self, 'search_bucket', None): + print repr(self), 'creating search bucket' + self.search_bucket = self.randname() + c = self.create_client(HTTP_HOST, HTTP_PORT, + RiakHttpTransport) + b = c.bucket(self.search_bucket) + b.enable_search() + self.client = self.create_client() + class RiakPbcTransportTestCase(BasicKVTests, KVFileTests, TwoITests, @@ -94,6 +103,8 @@ def setUp(self): self.host = PB_HOST self.port = PB_PORT self.transport_class = RiakPbcTransport + self.http_client = self.create_client(HTTP_HOST, HTTP_PORT, + RiakHttpTransport) super(RiakPbcTransportTestCase, self).setUp() def test_uses_client_id_if_given(self): @@ -107,15 +118,14 @@ def test_uses_client_id_if_given(self): def test_close_underlying_socket_fails(self): c = RiakClient(PB_HOST, PB_PORT, transport_class=RiakPbcTransport) - - bucket = c.bucket('bucket_test_close') + bucket = c.bucket(self.bucket_name) rand = self.randint() - obj = bucket.new('foo', rand) + obj = bucket.new(self.key_name, rand) obj.store() - obj = bucket.get('foo') + obj = bucket.get(self.key_name) self.assertTrue(obj.exists()) - self.assertEqual(obj.get_bucket().get_name(), 'bucket_test_close') - self.assertEqual(obj.get_key(), 'foo') + self.assertEqual(obj.get_bucket().get_name(), self.bucket_name) + self.assertEqual(obj.get_key(), self.key_name) self.assertEqual(obj.get_data(), rand) # Close the underlying socket. This gets a bit sketchy, @@ -130,15 +140,15 @@ def test_close_underlying_socket_fails(self): def test_close_underlying_socket_retry(self): c = RiakClient(PB_HOST, PB_PORT, transport_class=RiakPbcTransport, transport_options={"max_attempts": 2}) - - bucket = c.bucket('bucket_test_close') + bucket = c.bucket(self.bucket_name) rand = self.randint() - obj = bucket.new('barbaz', rand) + obj = bucket.new(self.key_name, rand) obj.store() - obj = bucket.get('barbaz') + + obj = bucket.get(self.key_name) self.assertTrue(obj.exists()) - self.assertEqual(obj.get_bucket().get_name(), 'bucket_test_close') - self.assertEqual(obj.get_key(), 'barbaz') + self.assertEqual(obj.get_bucket().get_name(), self.bucket_name) + self.assertEqual(obj.get_key(), self.key_name) self.assertEqual(obj.get_data(), rand) # Close the underlying socket. This gets a bit sketchy, @@ -148,20 +158,20 @@ def test_close_underlying_socket_retry(self): conns[0].sock.close() # This should work, since we have a retry - obj = bucket.get('barbaz') + obj = bucket.get(self.key_name) self.assertTrue(obj.exists()) - self.assertEqual(obj.get_bucket().get_name(), 'bucket_test_close') - self.assertEqual(obj.get_key(), 'barbaz') + self.assertEqual(obj.get_bucket().get_name(), self.bucket_name) + self.assertEqual(obj.get_key(), self.key_name) self.assertEqual(obj.get_data(), rand) def test_bucket_search_enabled(self): - bucket = self.client.bucket("unsearch_bucket") + bucket = self.client.bucket(self.bucket_name) self.assertRaises(NotImplementedError) def test_enable_search_commit_hook(self): - bucket = self.client.bucket("search_bucket") - bucket.enable_search() - self.assertRaises(NotImplementedError) + bucket = self.client.bucket(self.bucket_name) + bucket.enable_search() + self.assertRaises(NotImplementedError) class RiakHttpTransportTestCase(BasicKVTests, @@ -184,12 +194,12 @@ def setUp(self): super(RiakHttpTransportTestCase, self).setUp() def test_no_returnbody(self): - bucket = self.client.bucket("bucket") - o = bucket.new("foo", "bar").store(return_body=False) + bucket = self.client.bucket(self.bucket_name) + o = bucket.new(self.key_name, "bar").store(return_body=False) self.assertEqual(o.vclock(), None) def test_too_many_link_headers_shouldnt_break_http(self): - bucket = self.client.bucket("bucket") + bucket = self.client.bucket(self.bucket_name) o = bucket.new("lots_of_links", "My god, it's full of links!") for i in range(0, 400): link = RiakLink("other", "key%d" % i, "next") diff --git a/riak/tests/test_kv.py b/riak/tests/test_kv.py index 943f6ef0..54eeef08 100644 --- a/riak/tests/test_kv.py +++ b/riak/tests/test_kv.py @@ -37,19 +37,19 @@ def test_is_alive(self): self.assertTrue(self.client.is_alive()) def test_store_and_get(self): - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) rand = self.randint() obj = bucket.new('foo', rand) obj.store() obj = bucket.get('foo') self.assertTrue(obj.exists()) - self.assertEqual(obj.get_bucket().get_name(), 'bucket') + self.assertEqual(obj.get_bucket().get_name(), self.bucket_name) self.assertEqual(obj.get_key(), 'foo') self.assertEqual(obj.get_data(), rand) # unicode objects are fine, as long as they don't # contain any non-ASCII chars - self.client.bucket(u'bucket') + self.client.bucket(unicode(self.bucket_name)) self.assertRaises(TypeError, self.client.bucket, u'búcket') self.assertRaises(TypeError, self.client.bucket, 'búcket') @@ -65,7 +65,7 @@ def test_store_and_get(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') + bucket = self.client.bucket(self.bucket_name) existing_keys = bucket.get_keys() o = bucket.new(None, data={}) self.assertIsNone(o.get_key()) @@ -76,71 +76,72 @@ def test_generate_key(self): self.assertEqual(len(bucket.get_keys()), len(existing_keys) + 1) def test_binary_store_and_get(self): - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) # Store as binary, retrieve as binary, then compare... rand = str(self.randint()) - obj = bucket.new_binary('foo1', rand) + obj = bucket.new_binary(self.key_name, rand) obj.store() - obj = bucket.get_binary('foo1') + obj = bucket.get_binary(self.key_name) self.assertTrue(obj.exists()) self.assertEqual(obj.get_data(), rand) # Store as JSON, retrieve as binary, JSON-decode, then compare... data = [self.randint(), self.randint(), self.randint()] - obj = bucket.new('foo2', data) + key2 = self.randname() + obj = bucket.new(key2, data) obj.store() - obj = bucket.get_binary('foo2') + obj = bucket.get_binary(key2) self.assertEqual(data, json.loads(obj.get_data())) def test_custom_bucket_encoder_decoder(self): # Teach the bucket how to pickle - bucket = self.client.bucket("picklin_bucket") + bucket = self.client.bucket(self.bucket_name) bucket.set_encoder('application/x-pickle', cPickle.dumps) bucket.set_decoder('application/x-pickle', cPickle.loads) data = {'array': [1, 2, 3], 'badforjson': NotJsonSerializable(1, 3)} - obj = bucket.new("foo", data, 'application/x-pickle').store() + obj = bucket.new(self.key_name, data, 'application/x-pickle').store() obj.store() - obj2 = bucket.get("foo") + obj2 = bucket.get(self.key_name) self.assertEqual(data, obj2.get_data()) def test_custom_client_encoder_decoder(self): # Teach the bucket how to pickle - bucket = self.client.bucket("picklin_client") + bucket = self.client.bucket(self.bucket_name) self.client.set_encoder('application/x-pickle', cPickle.dumps) self.client.set_decoder('application/x-pickle', cPickle.loads) data = {'array': [1, 2, 3], 'badforjson': NotJsonSerializable(1, 3)} - obj = bucket.new("foo", data, 'application/x-pickle').store() + obj = bucket.new(self.key_name, data, 'application/x-pickle').store() obj.store() - obj2 = bucket.get("foo") + obj2 = bucket.get(self.key_name) self.assertEqual(data, obj2.get_data()) def test_unknown_content_type_encoder_decoder(self): # Teach the bucket how to pickle - bucket = self.client.bucket("unknown_contenttype") + bucket = self.client.bucket(self.bucket_name) data = "some funny data" - obj = bucket.new("foo", data, 'application/x-frobnicator').store() + obj = bucket.new(self.key_name, data, 'application/x-frobnicator').store() obj.store() - obj2 = bucket.get("foo") + obj2 = bucket.get(self.key_name) self.assertEqual(data, obj2.get_data()) def test_missing_object(self): - bucket = self.client.bucket('bucket') - obj = bucket.get("missing") + bucket = self.client.bucket(self.bucket_name) + obj = bucket.get(self.key_name) self.assertFalse(obj.exists()) self.assertEqual(obj.get_data(), None) def test_delete(self): - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) rand = self.randint() - obj = bucket.new('foo', rand) + obj = bucket.new(self.key_name, rand) obj.store() - obj = bucket.get('foo') + obj = bucket.get(self.key_name) self.assertTrue(obj.exists()) obj.delete() obj.reload() self.assertFalse(obj.exists()) def test_set_bucket_properties(self): - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) # Test setting allow mult... bucket.set_allow_multiples(True) self.assertTrue(bucket.get_allow_multiples()) @@ -153,7 +154,7 @@ def test_set_bucket_properties(self): self.assertEqual(bucket.get_n_val(), 2) def test_rw_settings(self): - bucket = self.client.bucket('rwsettings') + bucket = self.client.bucket(self.bucket_name) self.assertEqual(bucket.get_r(), "default") self.assertEqual(bucket.get_w(), "default") self.assertEqual(bucket.get_dw(), "default") @@ -172,7 +173,7 @@ def test_rw_settings(self): self.assertEqual(bucket.get_rw(), "one") def test_primary_quora(self): - bucket = self.client.bucket('primary_quora') + bucket = self.client.bucket(self.bucket_name) self.assertEqual(bucket.get_pr(), "default") self.assertEqual(bucket.get_pw(), "default") @@ -183,8 +184,8 @@ def test_primary_quora(self): self.assertEqual(bucket.get_pw(), "quorum") def test_if_none_match(self): - bucket = self.client.bucket('if_none_match_test') - obj = bucket.get('obj') + bucket = self.client.bucket(self.bucket_name) + obj = bucket.get(self.key_name) obj.delete() obj.reload() @@ -198,9 +199,9 @@ def test_if_none_match(self): def test_siblings(self): # Set up the bucket, clear any existing object... - bucket = self.client.bucket('multiBucket') - bucket.set_allow_multiples(True) - obj = bucket.get_binary('foo') + self.create_client().bucket(self.bucket_name).set_allow_multiples(True) + bucket = self.client.bucket(self.bucket_name) + obj = bucket.get_binary(self.key_name) # Even if it previously existed, let's store a base resolved version # from which we can diverge by sending a stale vclock. obj.set_data('start') @@ -210,13 +211,13 @@ def test_siblings(self): vals = set() for i in range(5): other_client = self.create_client() - other_bucket = other_client.bucket('multiBucket') + other_bucket = other_client.bucket(self.bucket_name) while True: randval = self.randint() if randval not in vals: break - other_obj = other_bucket.new_binary('foo', str(randval)) + other_obj = other_bucket.new_binary(self.key_name, str(randval)) other_obj._vclock = obj._vclock other_obj.store() vals.add(str(randval)) @@ -241,9 +242,9 @@ def test_siblings(self): self.assertEqual(obj.get_data(), obj3.get_data()) def test_store_of_missing_object(self): - bucket = self.client.bucket("bucket") + bucket = self.client.bucket(self.bucket_name) # for json objects - o = bucket.get("nonexistent_key_json") + o = bucket.get(self.key_name) self.assertEqual(o.exists(), False) o.set_data({"foo": "bar"}) o = o.store() @@ -251,7 +252,7 @@ def test_store_of_missing_object(self): self.assertEqual(o.get_content_type(), "application/json") o.delete() # for binary objects - o = bucket.get_binary("nonexistent_key_binary") + o = bucket.get_binary(self.randname()) self.assertEqual(o.exists(), False) o.set_data("1234567890") o = o.store() @@ -260,44 +261,44 @@ def test_store_of_missing_object(self): o.delete() def test_store_metadata(self): - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) rand = self.randint() - obj = bucket.new('fooster', rand) + obj = bucket.new(self.key_name, rand) obj.set_usermeta({'custom': 'some metadata'}) obj.store() - obj = bucket.get('fooster') + obj = bucket.get(self.key_name) self.assertEqual('some metadata', obj.get_usermeta()['custom']) def test_list_buckets(self): - bucket = self.client.bucket("list_bucket") + bucket = self.client.bucket(self.bucket_name) bucket.new("one", {"foo": "one", "bar": "red"}).store() buckets = self.client.get_buckets() - self.assertTrue("list_bucket" in buckets) + self.assertTrue(self.bucket_name in buckets) class KVFileTests(object): def test_store_binary_object_from_file(self): - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) rand = str(self.randint()) filepath = os.path.join(os.path.dirname(__file__), 'test_all.py') - obj = bucket.new_binary_from_file('foo_from_file', filepath) + obj = bucket.new_binary_from_file(self.key_name, filepath) obj.store() - obj = bucket.get_binary('foo_from_file') + obj = bucket.get_binary(self.key_name) self.assertNotEqual(obj.get_data(), None) self.assertEqual(obj.get_content_type(), "text/x-python") def test_store_binary_object_from_file_should_use_default_mimetype(self): - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) rand = str(self.randint()) filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir, 'THANKS') - obj = bucket.new_binary_from_file('foo_from_file', filepath) + obj = bucket.new_binary_from_file(self.key_name, filepath) obj.store() - obj = bucket.get_binary('foo_from_file') + obj = bucket.get_binary(self.key_name) self.assertEqual(obj.get_content_type(), 'application/octet-stream') def test_store_binary_object_from_file_should_fail_if_file_not_found(self): - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) rand = str(self.randint()) self.assertRaises(IOError, bucket.new_binary_from_file, 'not_found_from_file', 'FILE_NOT_FOUND') diff --git a/riak/tests/test_pool.py b/riak/tests/test_pool.py index f57a2cd3..31d949fa 100644 --- a/riak/tests/test_pool.py +++ b/riak/tests/test_pool.py @@ -27,7 +27,7 @@ unittest = __import__('unittest2') else: import unittest - +import os class SimplePool(Pool): def __init__(self): @@ -47,6 +47,8 @@ def create_resource(self): return [] +@unittest.skipIf(os.environ.get('SKIP_POOL'), + 'Skipping connection pool tests') class PoolTest(unittest.TestCase): def test_yields_new_object_when_empty(self): """ diff --git a/riak/tests/test_search.py b/riak/tests/test_search.py index f3223da0..a48ee89b 100644 --- a/riak/tests/test_search.py +++ b/riak/tests/test_search.py @@ -12,120 +12,120 @@ class EnableSearchTests(object): @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') def test_bucket_search_enabled(self): - bucket = self.client.bucket("unsearch_bucket") + bucket = self.client.bucket(self.bucket_name) self.assertFalse(bucket.search_enabled()) @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') def test_enable_search_commit_hook(self): - bucket = self.client.bucket("search_bucket") + bucket = self.client.bucket(self.bucket_name) bucket.enable_search() - self.assertTrue(self.client.bucket("search_bucket").search_enabled()) + self.assertTrue(self.client.bucket(self.bucket_name).search_enabled()) @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') def test_disable_search_commit_hook(self): - bucket = self.client.bucket("no_search_bucket") + bucket = self.client.bucket(self.bucket_name) bucket.enable_search() - self.assertTrue(self.client.bucket("no_search_bucket")\ + self.assertTrue(self.client.bucket(self.bucket_name)\ .search_enabled()) bucket.disable_search() - self.assertFalse(self.client.bucket("no_search_bucket")\ + self.assertFalse(self.client.bucket(self.bucket_name)\ .search_enabled()) class SolrSearchTests(object): @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') def test_add_document_to_index(self): - self.client.solr().add("searchbucket", + self.client.solr().add(self.search_bucket, {"id": "doc", "username": "tony"}) - results = self.client.solr().search("searchbucket", "username:tony") + results = self.client.solr().search(self.search_bucket, "username:tony") self.assertEquals("tony", results['docs'][0]['username']) @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') - def test_add_multiple_documents_to_index(self): - self.client.solr().add("searchbucket", + def test_add_multiple_documents_to_iindex(self): + self.client.solr().add(self.search_bucket, {"id": "dizzy", "username": "dizzy"}, {"id": "russell", "username": "russell"}) results = self.client.solr()\ - .search("searchbucket", "username:russell OR username:dizzy") + .search(self.search_bucket, "username:russell OR username:dizzy") self.assertEquals(2, len(results['docs'])) @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') def test_delete_documents_from_search_by_id(self): - self.client.solr().add("searchbucket", + self.client.solr().add(self.search_bucket, {"id": "dizzy", "username": "dizzy"}, {"id": "russell", "username": "russell"}) - self.client.solr().delete("searchbucket", docs=["dizzy"]) + self.client.solr().delete(self.search_bucket, docs=["dizzy"]) results = self.client.solr()\ - .search("searchbucket", "username:russell OR username:dizzy") + .search(self.search_bucket, "username:russell OR username:dizzy") self.assertEquals(1, len(results['docs'])) @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') def test_delete_documents_from_search_by_query(self): - self.client.solr().add("searchbucket", + self.client.solr().add(self.search_bucket, {"id": "dizzy", "username": "dizzy"}, {"id": "russell", "username": "russell"}) self.client.solr()\ - .delete("searchbucket", + .delete(self.search_bucket, queries=["username:dizzy", "username:russell"]) results = self.client.solr()\ - .search("searchbucket", "username:russell OR username:dizzy") + .search(self.search_bucket, "username:russell OR username:dizzy") self.assertEquals(0, len(results['docs'])) @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') def test_delete_documents_from_search_by_query_and_id(self): - self.client.solr().add("searchbucket", + self.client.solr().add(self.search_bucket, {"id": "dizzy", "username": "dizzy"}, {"id": "russell", "username": "russell"}) - self.client.solr().delete("searchbucket", + self.client.solr().delete(self.search_bucket, docs=["dizzy"], queries=["username:russell"]) results = self.client.solr()\ - .search("searchbucket", + .search(self.search_bucket, "username:russell OR username:dizzy") self.assertEquals(0, len(results['docs'])) def test_build_rest_path_excludes_empty_query_params(self): self.assertEquals( self.client.get_transport().build_rest_path( - bucket=self.client.bucket("foo"), - key="bar", params={'r': None}), "/riak/foo/bar?") + bucket=self.client.bucket(self.search_bucket), + key="bar", params={'r': None}), "/riak/"+self.search_bucket+"/bar?") class SearchTests(object): @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') def test_solr_search_from_bucket(self): - bucket = self.client.bucket('searchbucket') + bucket = self.client.bucket(self.search_bucket) bucket.new("user", {"username": "roidrage"}).store() results = bucket.search("username:roidrage") self.assertEquals(1, len(results['docs'])) @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') def test_solr_search_with_params_from_bucket(self): - bucket = self.client.bucket('searchbucket') + bucket = self.client.bucket(self.search_bucket) bucket.new("user", {"username": "roidrage"}).store() results = bucket.search("username:roidrage", wt="xml") self.assertEquals(1, len(results['docs'])) @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') def test_solr_search_with_params(self): - bucket = self.client.bucket('searchbucket') + bucket = self.client.bucket(self.search_bucket) bucket.new("user", {"username": "roidrage"}).store() - results = self.client.solr().search("searchbucket", + results = self.client.solr().search(self.search_bucket, "username:roidrage", wt="xml") self.assertEquals(1, len(results['docs'])) @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') def test_solr_search(self): - bucket = self.client.bucket('searchbucket') + bucket = self.client.bucket(self.search_bucket) bucket.new("user", {"username": "roidrage"}).store() - results = self.client.solr().search("searchbucket", + results = self.client.solr().search(self.search_bucket, "username:roidrage") self.assertEquals(1, len(results["docs"])) @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') def test_search_integration(self): # Create some objects to search across... - bucket = self.client.bucket("searchbucket") + bucket = self.client.bucket(self.search_bucket) bucket.new("one", {"foo": "one", "bar": "red"}).store() bucket.new("two", {"foo": "two", "bar": "green"}).store() bucket.new("three", {"foo": "three", "bar": "blue"}).store() @@ -133,7 +133,7 @@ def test_search_integration(self): bucket.new("five", {"foo": "five", "bar": "yellow"}).store() # Run some operations... - results = self.client.solr().search("searchbucket", + results = self.client.solr().search(self.search_bucket, "foo:one OR foo:two") if (len(results) == 0): print "\n\nNot running test \"testSearchIntegration()\".\n" @@ -142,7 +142,7 @@ def test_search_integration(self): \"bin/search-cmd install searchbucket\".\n\n""" return self.assertEqual(len(results['docs']), 2) - query = "(foo:one OR foo:two OR foo:three OR foo:four) AND\ - (NOT bar:green)" - results = self.client.solr().search("searchbucket", query) + query = "(foo:one OR foo:two OR foo:three OR foo:four) AND" \ + " (NOT bar:green)" + results = self.client.solr().search(self.search_bucket, query) self.assertEqual(len(results['docs']), 3) From 29b12397d10c346019ea4b3edd7106e03bb0cd70 Mon Sep 17 00:00:00 2001 From: evan Date: Tue, 20 Nov 2012 14:08:33 -0800 Subject: [PATCH 2/6] pre-pep8 cleanup --- riak/tests/test_2i.py | 10 +-- riak/tests/test_all.py | 9 ++- riak/tests/test_mapreduce.py | 135 +++++++++++++++++------------------ 3 files changed, 77 insertions(+), 77 deletions(-) diff --git a/riak/tests/test_2i.py b/riak/tests/test_2i.py index d813e5d6..8664f23a 100644 --- a/riak/tests/test_2i.py +++ b/riak/tests/test_2i.py @@ -28,7 +28,7 @@ def test_secondary_index_store(self): return True # Create a new object with indexes... - bucket = self.client.bucket('indexbucket') + bucket = self.client.bucket(self.bucket_name) rand = self.randint() obj = bucket.new('mykey1', rand) obj.add_index('field1_bin', 'val1a') @@ -103,10 +103,10 @@ def test_set_indexes(self): if not self.is_2i_supported(): return True - bucket = self.client.bucket('indexbucket') + bucket = self.client.bucket(self.bucket_name) foo = bucket.new('foo', 1) foo.set_indexes((('field1_bin', 'test'), ('field2_int', 1337))).store() - result = self.client.index('indexbucket', 'field2_int', 1337).run() + result = self.client.index(self.bucket_name, 'field2_int', 1337).run() self.assertEqual(1, len(result)) self.assertEqual('foo', result[0].get_key()) @@ -119,7 +119,7 @@ def test_remove_indexes(self): if not self.is_2i_supported(): return True - bucket = self.client.bucket('indexbucket') + bucket = self.client.bucket(self.bucket_name) bar = bucket.new('bar', 1).add_index('bar_int', 1)\ .add_index('bar_int', 2).add_index('baz_bin', 'baz').store() result = bucket.get_index('bar_int', 1) @@ -172,7 +172,7 @@ def test_secondary_index_query(self): if not self.is_2i_supported(): return True - bucket = self.client.bucket('indexbucket') + bucket = self.client.bucket(self.bucket_name) bucket.\ new('mykey1', 'data1').\ diff --git a/riak/tests/test_all.py b/riak/tests/test_all.py index 43a4e343..31d44995 100644 --- a/riak/tests/test_all.py +++ b/riak/tests/test_all.py @@ -52,6 +52,7 @@ test_server.prepare() test_server.start() +testrun_search_bucket = None class BaseTestCase(object): @@ -74,15 +75,17 @@ def create_client(self, host=None, port=None, transport_class=None): transport_class=transport_class) def setUp(self): + global testrun_search_bucket self.bucket_name = self.randname() self.key_name = self.randname() - if not getattr(self, 'search_bucket', None): - print repr(self), 'creating search bucket' - self.search_bucket = self.randname() + if not testrun_search_bucket: + self.search_bucket = testrun_search_bucket = self.randname() c = self.create_client(HTTP_HOST, HTTP_PORT, RiakHttpTransport) b = c.bucket(self.search_bucket) b.enable_search() + else: + self.search_bucket = testrun_search_bucket self.client = self.create_client() diff --git a/riak/tests/test_mapreduce.py b/riak/tests/test_mapreduce.py index 84ba7d9f..97448604 100644 --- a/riak/tests/test_mapreduce.py +++ b/riak/tests/test_mapreduce.py @@ -7,7 +7,7 @@ class LinkTests(object): def test_store_and_get_links(self): # Create the object... - bucket = self.client.bucket("bucket") + bucket = self.client.bucket(self.bucket_name) bucket.new_binary("test_store_and_get_links", '2') \ .add_link(bucket.new("foo1")) \ .add_link(bucket.new("foo2"), "tag") \ @@ -18,7 +18,7 @@ def test_store_and_get_links(self): self.assertEqual(len(links), 3) for l in links: if (l.get_key() == "foo1"): - self.assertEqual(l.get_tag(), "bucket") + self.assertEqual(l.get_tag(), self.bucket_name) elif (l.get_key() == "foo2"): self.assertEqual(l.get_tag(), "tag") elif (l.get_key() == "foo3"): @@ -28,10 +28,10 @@ def test_store_and_get_links(self): def test_set_links(self): # Create the object - bucket = self.client.bucket("bucket") + bucket = self.client.bucket(self.bucket_name) bucket.new("foo", 2).set_links([bucket.new("foo1"), (bucket.new("foo2"), "tag"), - RiakLink("bucket", "foo2", "tag2")]).store() + RiakLink(self.bucket_name, "foo2", "tag2")]).store() obj = bucket.get("foo") links = sorted(obj.get_links(), key=lambda x: x.get_key()) self.assertEqual(len(links), 3) @@ -42,10 +42,10 @@ def test_set_links(self): self.assertEqual(links[2].get_tag(), "tag2") def test_set_links_all_links(self): - bucket = self.client.bucket("bucket") + bucket = self.client.bucket(self.bucket_name) foo1 = bucket.new("foo", 1) foo2 = bucket.new("foo2", 2).store() - links = [RiakLink("bucket", "foo2")] + links = [RiakLink(self.bucket_name, "foo2")] foo1.set_links(links, True) links = foo1.get_links() self.assertEqual(len(links), 1) @@ -53,31 +53,31 @@ def test_set_links_all_links(self): def test_link_walking(self): # Create the object... - bucket = self.client.bucket("bucket") + bucket = self.client.bucket(self.bucket_name) bucket.new("foo", 2) \ .add_link(bucket.new("foo1", "test1").store()) \ .add_link(bucket.new("foo2", "test2").store(), "tag") \ .add_link(bucket.new("foo3", "test3").store(), "tag2!@#%^&*)") \ .store() obj = bucket.get("foo") - results = obj.link("bucket").run() + results = obj.link(self.bucket_name).run() self.assertEqual(len(results), 3) - results = obj.link("bucket", "tag").run() + results = obj.link(self.bucket_name, "tag").run() self.assertEqual(len(results), 1) class ErlangMapReduceTests(object): def test_erlang_map_reduce(self): # Create the object... - bucket = self.client.bucket("bucket") + bucket = self.client.bucket(self.bucket_name) bucket.new("foo", 2).store() bucket.new("bar", 2).store() bucket.new("baz", 4).store() # Run the map... result = self.client \ - .add("bucket", "foo") \ - .add("bucket", "bar") \ - .add("bucket", "baz") \ + .add(self.bucket_name, "foo") \ + .add(self.bucket_name, "bar") \ + .add(self.bucket_name, "baz") \ .map(["riak_kv_mapreduce", "map_object_value"]) \ .reduce(["riak_kv_mapreduce", "reduce_set_union"]) \ .run() @@ -87,10 +87,10 @@ def test_erlang_map_reduce(self): class JSMapReduceTests(object): def test_javascript_source_map(self): # Create the object... - bucket = self.client.bucket("bucket") + bucket = self.client.bucket(self.bucket_name) bucket.new("foo", 2).store() # Run the map... - mr = self.client.add("bucket", "foo") + mr = self.client.add(self.bucket_name, "foo") result = mr.map( "function (v) { return [JSON.parse(v.values[0].data)]; }").run() self.assertEqual(result, [2]) @@ -108,26 +108,26 @@ def test_javascript_source_map(self): def test_javascript_named_map(self): # Create the object... - bucket = self.client.bucket("bucket") + bucket = self.client.bucket(self.bucket_name) bucket.new("foo", 2).store() # Run the map... result = self.client \ - .add("bucket", "foo") \ + .add(self.bucket_name, "foo") \ .map("Riak.mapValuesJson") \ .run() self.assertEqual(result, [2]) def test_javascript_source_map_reduce(self): # Create the object... - bucket = self.client.bucket("bucket") + bucket = self.client.bucket(self.bucket_name) bucket.new("foo", 2).store() bucket.new("bar", 3).store() bucket.new("baz", 4).store() # Run the map... result = self.client \ - .add("bucket", "foo") \ - .add("bucket", "bar") \ - .add("bucket", "baz") \ + .add(self.bucket_name, "foo") \ + .add(self.bucket_name, "bar") \ + .add(self.bucket_name, "baz") \ .map("function (v) { return [1]; }") \ .reduce("Riak.reduceSum") \ .run() @@ -135,15 +135,15 @@ def test_javascript_source_map_reduce(self): def test_javascript_named_map_reduce(self): # Create the object... - bucket = self.client.bucket("bucket") + bucket = self.client.bucket(self.bucket_name) bucket.new("foo", 2).store() bucket.new("bar", 3).store() bucket.new("baz", 4).store() # Run the map... result = self.client \ - .add("bucket", "foo") \ - .add("bucket", "bar") \ - .add("bucket", "baz") \ + .add(self.bucket_name, "foo") \ + .add(self.bucket_name, "bar") \ + .add(self.bucket_name, "baz") \ .map("Riak.mapValuesJson") \ .reduce("Riak.reduceSum") \ .run() @@ -165,15 +165,15 @@ def test_javascript_bucket_map_reduce(self): def test_javascript_arg_map_reduce(self): # Create the object... - bucket = self.client.bucket("bucket") + bucket = self.client.bucket(self.bucket_name) bucket.new("foo", 2).store() # Run the map... result = self.client \ - .add("bucket", "foo", 5) \ - .add("bucket", "foo", 10) \ - .add("bucket", "foo", 15) \ - .add("bucket", "foo", -15) \ - .add("bucket", "foo", -5) \ + .add(self.bucket_name, "foo", 5) \ + .add(self.bucket_name, "foo", 10) \ + .add(self.bucket_name, "foo", 15) \ + .add(self.bucket_name, "foo", -15) \ + .add(self.bucket_name, "foo", -5) \ .map("function(v, arg) { return [arg]; }") \ .reduce("Riak.reduceSum") \ .run() @@ -223,7 +223,7 @@ def test_key_filters_with_search_query(self): def test_map_reduce_from_object(self): # Create the object... - bucket = self.client.bucket("bucket") + bucket = self.client.bucket(self.bucket_name) bucket.new("foo", 2).store() obj = bucket.get("foo") result = obj.map("Riak.mapValuesJson").run() @@ -235,13 +235,13 @@ class MapReduceAliasTests(object): def test_map_values(self): # Add a value to the bucket - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) bucket.new_binary('one', data='value_1').store() bucket.new_binary('two', data='value_2').store() # Create a map reduce object and use one and two as inputs - mr = self.client.add('bucket', 'one')\ - .add('bucket', 'two') + mr = self.client.add(self.bucket_name, 'one')\ + .add(self.bucket_name, 'two') # Use the map_values alias result = mr.map_values().run() @@ -254,13 +254,13 @@ def test_map_values(self): def test_map_values_json(self): # Add a value to the bucket - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) bucket.new('one', data={'val': 'value_1'}).store() bucket.new('two', data={'val': 'value_2'}).store() # Create a map reduce object and use one and two as inputs - mr = self.client.add('bucket', 'one')\ - .add('bucket', 'two') + mr = self.client.add(self.bucket_name, 'one')\ + .add(self.bucket_name, 'two') # Use the map_values alias result = mr.map_values_json().run() @@ -273,13 +273,13 @@ def test_map_values_json(self): def test_reduce_sum(self): # Add a value to the bucket - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) bucket.new('one', data=1).store() bucket.new('two', data=2).store() # Create a map reduce object and use one and two as inputs - mr = self.client.add('bucket', 'one')\ - .add('bucket', 'two') + mr = self.client.add(self.bucket_name, 'one')\ + .add(self.bucket_name, 'two') # Use the map_values alias result = mr.map_values_json().reduce_sum().run() @@ -288,13 +288,13 @@ def test_reduce_sum(self): def test_reduce_min(self): # Add a value to the bucket - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) bucket.new('one', data=1).store() bucket.new('two', data=2).store() # Create a map reduce object and use one and two as inputs - mr = self.client.add('bucket', 'one')\ - .add('bucket', 'two') + mr = self.client.add(self.bucket_name, 'one')\ + .add(self.bucket_name, 'two') # Use the map_values alias result = mr.map_values_json().reduce_min().run() @@ -303,13 +303,13 @@ def test_reduce_min(self): def test_reduce_max(self): # Add a value to the bucket - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) bucket.new('one', data=1).store() bucket.new('two', data=2).store() # Create a map reduce object and use one and two as inputs - mr = self.client.add('bucket', 'one')\ - .add('bucket', 'two') + mr = self.client.add(self.bucket_name, 'one')\ + .add(self.bucket_name, 'two') # Use the map_values alias result = mr.map_values_json().reduce_max().run() @@ -318,13 +318,13 @@ def test_reduce_max(self): def test_reduce_sort(self): # Add a value to the bucket - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) bucket.new('one', data="value1").store() bucket.new('two', data="value2").store() # Create a map reduce object and use one and two as inputs - mr = self.client.add('bucket', 'one')\ - .add('bucket', 'two') + mr = self.client.add(self.bucket_name, 'one')\ + .add(self.bucket_name, 'two') # Use the map_values alias result = mr.map_values_json().reduce_sort().run() @@ -333,13 +333,13 @@ def test_reduce_sort(self): def test_reduce_sort_custom(self): # Add a value to the bucket - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) bucket.new('one', data="value1").store() bucket.new('two', data="value2").store() # Create a map reduce object and use one and two as inputs - mr = self.client.add('bucket', 'one')\ - .add('bucket', 'two') + mr = self.client.add(self.bucket_name, 'one')\ + .add(self.bucket_name, 'two') # Use the map_values alias result = mr.map_values_json().reduce_sort("""function(x,y) { @@ -351,13 +351,13 @@ def test_reduce_sort_custom(self): def test_reduce_numeric_sort(self): # Add a value to the bucket - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) bucket.new('one', data=1).store() bucket.new('two', data=2).store() # Create a map reduce object and use one and two as inputs - mr = self.client.add('bucket', 'one')\ - .add('bucket', 'two') + mr = self.client.add(self.bucket_name, 'one')\ + .add(self.bucket_name, 'two') # Use the map_values alias result = mr.map_values_json().reduce_numeric_sort().run() @@ -366,13 +366,13 @@ def test_reduce_numeric_sort(self): def test_reduce_limit(self): # Add a value to the bucket - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) bucket.new('one', data=1).store() bucket.new('two', data=2).store() # Create a map reduce object and use one and two as inputs - mr = self.client.add('bucket', 'one')\ - .add('bucket', 'two') + mr = self.client.add(self.bucket_name, 'one')\ + .add(self.bucket_name, 'two') # Use the map_values alias result = mr.map_values_json()\ @@ -383,13 +383,13 @@ def test_reduce_limit(self): def test_reduce_slice(self): # Add a value to the bucket - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) bucket.new('one', data=1).store() bucket.new('two', data=2).store() # Create a map reduce object and use one and two as inputs - mr = self.client.add('bucket', 'one')\ - .add('bucket', 'two') + mr = self.client.add(self.bucket_name, 'one')\ + .add(self.bucket_name, 'two') # Use the map_values alias result = mr.map_values_json()\ @@ -400,17 +400,14 @@ def test_reduce_slice(self): def test_filter_not_found(self): # Add a value to the bucket - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) bucket.new('one', data=1).store() bucket.new('two', data=2).store() - # Make sure "three" does not exist - bucket.get('three').delete() - # Create a map reduce object and use one and two as inputs - mr = self.client.add('bucket', 'one')\ - .add('bucket', 'two')\ - .add('bucket', 'three') + mr = self.client.add(self.bucket_name, 'one')\ + .add(self.bucket_name, 'two')\ + .add(self.bucket_name, self.key_name) # Use the map_values alias result = mr.map_values_json()\ From 0e0e8e9e47d435eff393ed1f913652c7a0a20d40 Mon Sep 17 00:00:00 2001 From: evan Date: Tue, 20 Nov 2012 14:45:21 -0800 Subject: [PATCH 3/6] pep8 cleanup --- riak/tests/test_all.py | 12 +++++++----- riak/tests/test_pool.py | 3 ++- riak/tests/test_search.py | 8 +++++--- 3 files changed, 14 insertions(+), 9 deletions(-) diff --git a/riak/tests/test_all.py b/riak/tests/test_all.py index 31d44995..5c5ad0fc 100644 --- a/riak/tests/test_all.py +++ b/riak/tests/test_all.py @@ -54,6 +54,7 @@ testrun_search_bucket = None + class BaseTestCase(object): @staticmethod @@ -61,7 +62,7 @@ def randint(): return random.randint(1, 999999) @staticmethod - def randname(length = 12): + def randname(length=12): out = '' for i in range(length): out += chr(random.randint(ord('a'), ord('z'))) @@ -80,7 +81,7 @@ def setUp(self): self.key_name = self.randname() if not testrun_search_bucket: self.search_bucket = testrun_search_bucket = self.randname() - c = self.create_client(HTTP_HOST, HTTP_PORT, + c = self.create_client(HTTP_HOST, HTTP_PORT, RiakHttpTransport) b = c.bucket(self.search_bucket) b.enable_search() @@ -88,7 +89,8 @@ def setUp(self): self.search_bucket = testrun_search_bucket self.client = self.create_client() - + + class RiakPbcTransportTestCase(BasicKVTests, KVFileTests, TwoITests, @@ -173,8 +175,8 @@ def test_bucket_search_enabled(self): def test_enable_search_commit_hook(self): bucket = self.client.bucket(self.bucket_name) - bucket.enable_search() - self.assertRaises(NotImplementedError) + bucket.enable_search() + self.assertRaises(NotImplementedError) class RiakHttpTransportTestCase(BasicKVTests, diff --git a/riak/tests/test_pool.py b/riak/tests/test_pool.py index 31d949fa..5fdb4c7a 100644 --- a/riak/tests/test_pool.py +++ b/riak/tests/test_pool.py @@ -29,6 +29,7 @@ import unittest import os + class SimplePool(Pool): def __init__(self): self.count = 0 @@ -47,7 +48,7 @@ def create_resource(self): return [] -@unittest.skipIf(os.environ.get('SKIP_POOL'), +@unittest.skipIf(os.environ.get('SKIP_POOL'), 'Skipping connection pool tests') class PoolTest(unittest.TestCase): def test_yields_new_object_when_empty(self): diff --git a/riak/tests/test_search.py b/riak/tests/test_search.py index a48ee89b..e8896425 100644 --- a/riak/tests/test_search.py +++ b/riak/tests/test_search.py @@ -37,7 +37,8 @@ class SolrSearchTests(object): def test_add_document_to_index(self): self.client.solr().add(self.search_bucket, {"id": "doc", "username": "tony"}) - results = self.client.solr().search(self.search_bucket, "username:tony") + results = self.client.solr().search(self.search_bucket, + "username:tony") self.assertEquals("tony", results['docs'][0]['username']) @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') @@ -61,7 +62,7 @@ def test_delete_documents_from_search_by_id(self): @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') def test_delete_documents_from_search_by_query(self): - self.client.solr().add(self.search_bucket, + self.client.solr().add(self.search_bucket, {"id": "dizzy", "username": "dizzy"}, {"id": "russell", "username": "russell"}) self.client.solr()\ @@ -88,7 +89,8 @@ def test_build_rest_path_excludes_empty_query_params(self): self.assertEquals( self.client.get_transport().build_rest_path( bucket=self.client.bucket(self.search_bucket), - key="bar", params={'r': None}), "/riak/"+self.search_bucket+"/bar?") + key="bar", params={'r': None}), + "/riak/" + self.search_bucket + "/bar?") class SearchTests(object): From 433f08f9eab46fcbdb045b59073a0a110a2e7d04 Mon Sep 17 00:00:00 2001 From: evan Date: Wed, 6 Feb 2013 16:17:48 -0800 Subject: [PATCH 4/6] convert the last few buckets --- riak/tests/test_2i.py | 2 +- riak/tests/test_mapreduce.py | 31 ++++++++++++++++--------------- 2 files changed, 17 insertions(+), 16 deletions(-) diff --git a/riak/tests/test_2i.py b/riak/tests/test_2i.py index 700af1f1..3112dd2c 100644 --- a/riak/tests/test_2i.py +++ b/riak/tests/test_2i.py @@ -228,7 +228,7 @@ def test_secondary_index_invalid_name(self): if not self.is_2i_supported(): return True - bucket = self.client.bucket('indexbucket') + bucket = self.client.bucket(self.bucket_name) with self.assertRaises(RiakError): bucket.new('k', 'a').add_index('field1', 'value1') diff --git a/riak/tests/test_mapreduce.py b/riak/tests/test_mapreduce.py index 74db79b8..3374c9ae 100644 --- a/riak/tests/test_mapreduce.py +++ b/riak/tests/test_mapreduce.py @@ -251,12 +251,12 @@ def test_map_reduce_from_object(self): self.assertEqual(result, [2]) def test_mr_list_add(self): - bucket = self.client.bucket("abucket") + bucket = self.client.bucket(self.bucket_name) for x in range(20): bucket.new('baz' + str(x), 'bazval' + str(x)).store() - mr = self.client.add('abucket', ['baz' + str(x) - for x in range(2, 5)]) + mr = self.client.add(self.bucket_name, ['baz' + str(x) + for x in range(2, 5)]) results = mr.map_values().run() results.sort() self.assertEqual(results, @@ -265,19 +265,20 @@ def test_mr_list_add(self): u'"bazval4"']) def test_mr_list_add_two_buckets(self): - bucket = self.client.bucket("bucket_a") + bucket = self.client.bucket(self.bucket_name) + name2 = self.randname() for x in range(10): bucket.new('foo' + str(x), 'fooval' + str(x)).store() - bucket = self.client.bucket("bucket_b") + bucket = self.client.bucket(name2) for x in range(10): bucket.new('bar' + str(x), 'barval' + str(x)).store() - mr = self.client.add('bucket_a', ['foo' + str(x) - for x in range(2, 4)]) - mr.add('bucket_b', ['bar' + str(x) - for x in range(5, 7)]) + mr = self.client.add(self.bucket_name, ['foo' + str(x) + for x in range(2, 4)]) + mr.add(name2, ['bar' + str(x) + for x in range(5, 7)]) results = mr.map_values().run() results.sort() @@ -500,12 +501,12 @@ def test_filter_not_found(self): class MapReduceStreamTests(object): def test_stream_results(self): - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) bucket.new('one', data=1).store() bucket.new('two', data=2).store() - mr = RiakMapReduce(self.client).add('bucket', 'one')\ - .add('bucket', 'two') + mr = RiakMapReduce(self.client).add(self.bucket_name, 'one')\ + .add(self.bucket_name, 'two') mr.map_values_json() results = [] for phase, data in mr.stream(): @@ -514,12 +515,12 @@ def test_stream_results(self): self.assertEqual(sorted(results), [1, 2]) def test_stream_cleanoperationsup(self): - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) bucket.new('one', data=1).store() bucket.new('two', data=2).store() - mr = RiakMapReduce(self.client).add('bucket', 'one')\ - .add('bucket', 'two') + mr = RiakMapReduce(self.client).add(self.bucket_name, 'one')\ + .add(self.bucket_name, 'two') mr.map_values_json() try: for phase, data in mr.stream(): From 6797fbfff915933b57dad1d877aaee6a79f18350 Mon Sep 17 00:00:00 2001 From: evan Date: Wed, 13 Feb 2013 14:04:51 -0800 Subject: [PATCH 5/6] clearing all properties now, some additional enhancements --- riak/client/operations.py | 6 +++--- riak/tests/test_all.py | 41 +++++++++++++++++++++++++++++---------- riak/tests/test_kv.py | 36 +++++++++++++++++++++------------- riak/tests/test_search.py | 14 ++++++++----- 4 files changed, 65 insertions(+), 32 deletions(-) diff --git a/riak/client/operations.py b/riak/client/operations.py index 3bde1571..047cc3b9 100644 --- a/riak/client/operations.py +++ b/riak/client/operations.py @@ -89,15 +89,15 @@ def set_bucket_props(self, transport, bucket, props): """ return transport.set_bucket_props(bucket, props) - @retryableHttpOnly - def clear_bucket_props(self, transport, bucket): + def clear_bucket_props(self, bucket): """ Resets bucket properties for the given bucket. :param bucket: the bucket whose properties will be set :type bucket: RiakBucket """ - return transport.clear_bucket_props(bucket) + with self._transport() as transport: + return transport.clear_bucket_props(bucket) @retryable def get_keys(self, transport, bucket): diff --git a/riak/tests/test_all.py b/riak/tests/test_all.py index 762f2110..ab7620dc 100644 --- a/riak/tests/test_all.py +++ b/riak/tests/test_all.py @@ -49,7 +49,33 @@ test_server.start() testrun_search_bucket = None - +testrun_props_bucket = None +testrun_sibs_bucket = None + +def setUpModule(): + global testrun_search_bucket, testrun_props_bucket, \ + testrun_sibs_bucket + + c = RiakClient(transport='http', http_port=HTTP_PORT) + + testrun_props_bucket = 'propsbucket' + testrun_sibs_bucket = 'sibsbucket' + c.bucket(testrun_sibs_bucket).allow_mult = True + + if not int(os.environ.get('SKIP_SEARCH', '0')): + testrun_search_bucket = 'searchbucket' + b = c.bucket(testrun_search_bucket) + b.enable_search() + +def tearDownModule(): + c = RiakClient(transport='http', http_port=HTTP_PORT) + if not int(os.environ.get('SKIP_SEARCH', '0')): + b = c.bucket(testrun_search_bucket) + b.clear_properties() + b = c.bucket(testrun_sibs_bucket) + b.clear_properties() + b = c.bucket(testrun_props_bucket) + b.clear_properties() class BaseTestCase(object): @@ -80,16 +106,11 @@ def create_client(self, host=None, http_port=None, pb_port=None, pb_port=pb_port, **client_args) def setUp(self): - global testrun_search_bucket self.bucket_name = self.randname() self.key_name = self.randname() - if not testrun_search_bucket: - self.search_bucket = testrun_search_bucket = self.randname() - c = self.create_client(HTTP_HOST, http_port=HTTP_PORT) - b = c.bucket(self.search_bucket) - b.enable_search() - else: - self.search_bucket = testrun_search_bucket + self.search_bucket = testrun_search_bucket + self.sibs_bucket = testrun_sibs_bucket + self.props_bucket = testrun_props_bucket self.client = self.create_client() @@ -171,7 +192,7 @@ def test_too_many_link_headers_shouldnt_break_http(self): self.assertEqual(len(stored_object.get_links()), 400) def test_clear_bucket_properties(self): - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.props_bucket) bucket.allow_mult = True self.assertTrue(bucket.allow_mult) bucket.n_val = 1 diff --git a/riak/tests/test_kv.py b/riak/tests/test_kv.py index 549a9dcb..579ab2c8 100644 --- a/riak/tests/test_kv.py +++ b/riak/tests/test_kv.py @@ -2,6 +2,7 @@ import os import cPickle import copy + try: import simplejson as json except ImportError: @@ -168,18 +169,21 @@ def test_delete(self): self.assertFalse(obj.exists) def test_set_bucket_properties(self): - bucket = self.client.bucket(self.bucket_name) + bucket = self.client.bucket(self.props_bucket) # Test setting allow mult... bucket.allow_mult = True - self.assertTrue(bucket.allow_mult) # Test setting nval... - bucket.n_val = 3 - self.assertEqual(bucket.n_val, 3) + bucket.n_val = 1 + + bucket2 = self.create_client().bucket(self.props_bucket) + self.assertTrue(bucket2.allow_mult) + self.assertEqual(bucket2.n_val, 1) # Test setting multiple properties... bucket.set_properties({"allow_mult": False, "n_val": 2}) - self.assertFalse(bucket.allow_mult) - self.assertEqual(bucket.n_val, 2) + bucket3 = self.create_client().bucket(self.props_bucket) + self.assertFalse(bucket3.allow_mult) + self.assertEqual(bucket3.n_val, 2) def test_if_none_match(self): bucket = self.client.bucket(self.bucket_name) @@ -197,9 +201,9 @@ def test_if_none_match(self): def test_siblings(self): # Set up the bucket, clear any existing object... - bucket = self.client.bucket(self.bucket_name) - bucket.allow_mult = True + bucket = self.client.bucket(self.sibs_bucket) obj = bucket.get_binary(self.key_name) + bucket.allow_mult = True # Even if it previously existed, let's store a base resolved version # from which we can diverge by sending a stale vclock. @@ -210,7 +214,7 @@ def test_siblings(self): vals = set() for i in range(5): other_client = self.create_client() - other_bucket = other_client.bucket(self.bucket_name) + other_bucket = other_client.bucket(self.sibs_bucket) while True: randval = self.randint() if randval not in vals: @@ -223,7 +227,7 @@ def test_siblings(self): # Make sure the object has itself plus four siblings... obj.reload() - self.assertTrue(bool(obj.siblings)) + #self.assertTrue(bool(obj.siblings)) self.assertEqual(len(obj.siblings), 5) # Get each of the values - make sure they match what was assigned @@ -279,7 +283,7 @@ def test_list_buckets(self): class HTTPBucketPropsTest(object): def test_rw_settings(self): - bucket = self.client.bucket(self.bucket_name) + bucket = self.client.bucket(self.props_bucket) self.assertEqual(bucket.r, "quorum") self.assertEqual(bucket.w, "quorum") self.assertEqual(bucket.dw, "quorum") @@ -301,9 +305,10 @@ def test_rw_settings(self): 'r': 'quorum', 'dw': 'quorum', 'rw': 'quorum'}) + bucket.clear_properties() def test_primary_quora(self): - bucket = self.client.bucket(self.bucket_name) + bucket = self.client.bucket(self.props_bucket) self.assertEqual(bucket.pr, 0) self.assertEqual(bucket.pw, 0) @@ -314,11 +319,12 @@ def test_primary_quora(self): self.assertEqual(bucket.pw, "quorum") bucket.set_properties({'pr': 0, 'pw': 0}) + bucket.clear_properties() class PbcBucketPropsTest(object): def test_rw_settings(self): - bucket = self.client.bucket('rwsettings') + bucket = self.client.bucket(self.props_bucket) with self.assertRaises(NotImplementedError): bucket.r with self.assertRaises(NotImplementedError): @@ -336,9 +342,11 @@ def test_rw_settings(self): bucket.dw = 2 with self.assertRaises(NotImplementedError): bucket.rw = 2 + with self.assertRaises(NotImplementedError): + bucket.clear_properties() def test_primary_quora(self): - bucket = self.client.bucket('primary_quora') + bucket = self.client.bucket(self.props_bucket) with self.assertRaises(NotImplementedError): bucket.pr with self.assertRaises(NotImplementedError): diff --git a/riak/tests/test_search.py b/riak/tests/test_search.py index b57c213b..9316b10d 100644 --- a/riak/tests/test_search.py +++ b/riak/tests/test_search.py @@ -17,19 +17,23 @@ def test_bucket_search_enabled(self): @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') def test_enable_search_commit_hook(self): - bucket = self.client.bucket(self.bucket_name) + bucket = self.client.bucket(self.search_bucket) + bucket.clear_properties() + self.assertFalse(self.create_client().bucket(self.search_bucket).search_enabled()) bucket.enable_search() - self.assertTrue(self.client.bucket(self.bucket_name).search_enabled()) + self.assertTrue(self.create_client().bucket(self.search_bucket).search_enabled()) @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined') def test_disable_search_commit_hook(self): - bucket = self.client.bucket(self.bucket_name) + bucket = self.client.bucket(self.search_bucket) + bucket.clear_properties() bucket.enable_search() - self.assertTrue(self.client.bucket(self.bucket_name)\ + self.assertTrue(self.create_client().bucket(self.search_bucket)\ .search_enabled()) bucket.disable_search() - self.assertFalse(self.client.bucket(self.bucket_name)\ + self.assertFalse(self.create_client().bucket(self.search_bucket)\ .search_enabled()) + bucket.enable_search() class SolrSearchTests(object): From 8dd33e29f68a4b8e145ada978720cd66872b1aff Mon Sep 17 00:00:00 2001 From: evan Date: Thu, 14 Feb 2013 15:19:05 -0800 Subject: [PATCH 6/6] make clear_bucket props retryable again. --- riak/client/operations.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/riak/client/operations.py b/riak/client/operations.py index 047cc3b9..9ce91dc2 100644 --- a/riak/client/operations.py +++ b/riak/client/operations.py @@ -89,15 +89,15 @@ def set_bucket_props(self, transport, bucket, props): """ return transport.set_bucket_props(bucket, props) - def clear_bucket_props(self, bucket): + @retryable + def clear_bucket_props(self, transport, bucket): """ Resets bucket properties for the given bucket. :param bucket: the bucket whose properties will be set :type bucket: RiakBucket """ - with self._transport() as transport: - return transport.clear_bucket_props(bucket) + return transport.clear_bucket_props(bucket) @retryable def get_keys(self, transport, bucket):