diff --git a/riak/client/operations.py b/riak/client/operations.py index 3bde1571..9ce91dc2 100644 --- a/riak/client/operations.py +++ b/riak/client/operations.py @@ -89,7 +89,7 @@ def set_bucket_props(self, transport, bucket, props): """ return transport.set_bucket_props(bucket, props) - @retryableHttpOnly + @retryable def clear_bucket_props(self, transport, bucket): """ Resets bucket properties for the given bucket. diff --git a/riak/tests/test_2i.py b/riak/tests/test_2i.py index 7b247cfb..3112dd2c 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].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').\ @@ -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_all.py b/riak/tests/test_all.py index 85f22d9d..ab7620dc 100644 --- a/riak/tests/test_all.py +++ b/riak/tests/test_all.py @@ -48,6 +48,34 @@ test_server.prepare() 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): @@ -59,6 +87,13 @@ 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, http_port=None, pb_port=None, protocol=None, **client_args): host = host or self.host or HOST @@ -71,14 +106,13 @@ def create_client(self, host=None, http_port=None, pb_port=None, pb_port=pb_port, **client_args) def setUp(self): - self.client = self.create_client() + self.bucket_name = self.randname() + self.key_name = self.randname() + self.search_bucket = testrun_search_bucket + self.sibs_bucket = testrun_sibs_bucket + self.props_bucket = testrun_props_bucket - # 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.client = self.create_client() class RiakPbcTransportTestCase(BasicKVTests, @@ -100,6 +134,8 @@ def setUp(self): self.host = PB_HOST self.pb_port = PB_PORT self.protocol = 'pbc' + self.http_client = self.create_client(HTTP_HOST, + http_port=HTTP_PORT) super(RiakPbcTransportTestCase, self).setUp() def test_uses_client_id_if_given(self): @@ -109,12 +145,12 @@ def test_uses_client_id_if_given(self): def test_bucket_search_enabled(self): with self.assertRaises(NotImplementedError): - bucket = self.client.bucket("unsearch_bucket") + bucket = self.client.bucket(self.bucket_name) bucket.search_enabled() def test_enable_search_commit_hook(self): with self.assertRaises(NotImplementedError): - bucket = self.client.bucket("search_bucket") + bucket = self.client.bucket(self.bucket_name) bucket.enable_search() @@ -140,12 +176,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") @@ -156,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 6e4981f4..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: @@ -37,19 +38,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.bucket.name, 'bucket') + self.assertEqual(obj.bucket.name, self.bucket_name) self.assertEqual(obj.key, 'foo') self.assertEqual(obj.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') @@ -102,85 +103,91 @@ def test_stream_keys_abort(self): self.assertEqual(True, robj.exists) 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.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.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') + obj = bucket.new(self.key_name, data, 'application/x-pickle') obj.store() - obj2 = bucket.get("foo") + obj2 = bucket.get(self.key_name) self.assertEqual(data, obj2.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') + obj = bucket.new(self.key_name, data, 'application/x-pickle') obj.store() - obj2 = bucket.get("foo") + obj2 = bucket.get(self.key_name) self.assertEqual(data, obj2.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.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.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.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('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() @@ -194,9 +201,10 @@ def test_if_none_match(self): def test_siblings(self): # Set up the bucket, clear any existing object... - bucket = self.client.bucket('multiBucket') + bucket = self.client.bucket(self.sibs_bucket) + obj = bucket.get_binary(self.key_name) bucket.allow_mult = True - obj = bucket.get_binary('foo') + # Even if it previously existed, let's store a base resolved version # from which we can diverge by sending a stale vclock. obj.data = 'start' @@ -206,20 +214,20 @@ 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.sibs_bucket) 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)) # 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 @@ -237,43 +245,45 @@ def test_siblings(self): self.assertEqual(obj.data, obj3.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.data = {"foo": "bar"} + o = o.store() self.assertEqual(o.data, {"foo": "bar"}) self.assertEqual(o.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.data = "1234567890" + o = o.store() self.assertEqual(o.data, "1234567890") self.assertEqual(o.content_type, "application/octet-stream") 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.usermeta = {'custom': 'some metadata'} obj.store() - obj = bucket.get('fooster') + obj = bucket.get(self.key_name) self.assertEqual('some metadata', obj.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(bucket in buckets) + self.assertTrue(self.bucket_name in [x.name for x in buckets]) class HTTPBucketPropsTest(object): def test_rw_settings(self): - bucket = self.client.bucket('rwsettings') + bucket = self.client.bucket(self.props_bucket) self.assertEqual(bucket.r, "quorum") self.assertEqual(bucket.w, "quorum") self.assertEqual(bucket.dw, "quorum") @@ -295,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('primary_quora') + bucket = self.client.bucket(self.props_bucket) self.assertEqual(bucket.pr, 0) self.assertEqual(bucket.pw, 0) @@ -308,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): @@ -330,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): @@ -346,25 +360,25 @@ def test_primary_quora(self): class KVFileTests(object): def test_store_binary_object_from_file(self): - bucket = self.client.bucket('bucket') + bucket = self.client.bucket(self.bucket_name) 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.data, None) self.assertEqual(obj.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) 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.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) self.assertRaises(IOError, bucket.new_binary_from_file, 'not_found_from_file', 'FILE_NOT_FOUND') obj = bucket.get_binary('not_found_from_file') diff --git a/riak/tests/test_mapreduce.py b/riak/tests/test_mapreduce.py index 2238bac9..3374c9ae 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.key == "foo1"): - self.assertEqual(l.tag, "bucket") + self.assertEqual(l.tag, self.bucket_name) elif (l.key == "foo2"): self.assertEqual(l.tag, "tag") elif (l.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.key) self.assertEqual(len(links), 3) @@ -42,10 +42,10 @@ def test_set_links(self): self.assertEqual(links[2].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) 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,65 +53,65 @@ 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() self.assertEqual(len(result), 2) def test_client_exceptional_paths(self): - 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() #adding a b-key pair to a bucket input with self.assertRaises(ValueError): - mr = self.client.add('bucket') - mr.add('bucket', 'bar') + mr = self.client.add(self.bucket_name) + mr.add(self.bucket_name, 'bar') #adding a b-key pair to a query input with self.assertRaises(ValueError): - mr = self.client.search('bucket', 'fleh') - mr.add('bucket', 'bar') + mr = self.client.search(self.bucket_name, 'fleh') + mr.add(self.bucket_name, 'bar') #adding a key filter to a query input with self.assertRaises(ValueError): - mr = self.client.search('bucket', 'fleh') + mr = self.client.search(self.bucket_name, 'fleh') mr.add_key_filter("tokenize", "-", 1) 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]) @@ -129,26 +129,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() @@ -156,15 +156,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() @@ -186,15 +186,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() @@ -244,19 +244,19 @@ 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() 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() @@ -316,13 +317,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() @@ -335,13 +336,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() @@ -354,13 +355,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() @@ -369,13 +370,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() @@ -384,13 +385,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() @@ -399,13 +400,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() @@ -414,13 +415,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) { @@ -432,13 +433,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() @@ -447,13 +448,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()\ @@ -464,13 +465,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()\ @@ -481,17 +482,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()\ @@ -503,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(): @@ -517,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(): diff --git a/riak/tests/test_pool.py b/riak/tests/test_pool.py index d552bcaa..6021510f 100644 --- a/riak/tests/test_pool.py +++ b/riak/tests/test_pool.py @@ -27,6 +27,7 @@ unittest = __import__('unittest2') else: import unittest +import os class SimplePool(Pool): @@ -47,6 +48,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 a56ec63c..9316b10d 100644 --- a/riak/tests/test_search.py +++ b/riak/tests/test_search.py @@ -12,75 +12,80 @@ 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.search_bucket) + bucket.clear_properties() + self.assertFalse(self.create_client().bucket(self.search_bucket).search_enabled()) bucket.enable_search() - self.assertTrue(self.client.bucket("search_bucket").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("no_search_bucket") + bucket = self.client.bucket(self.search_bucket) + bucket.clear_properties() bucket.enable_search() - self.assertTrue(self.client.bucket("no_search_bucket")\ + self.assertTrue(self.create_client().bucket(self.search_bucket)\ .search_enabled()) bucket.disable_search() - self.assertFalse(self.client.bucket("no_search_bucket")\ + self.assertFalse(self.create_client().bucket(self.search_bucket)\ .search_enabled()) + bucket.enable_search() 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'])) @@ -88,38 +93,38 @@ def test_delete_documents_from_search_by_query_and_id(self): 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() @@ -127,8 +132,8 @@ def test_search_integration(self): bucket.new("five", {"foo": "five", "bar": "yellow"}).store() # Run some operations... - results = self.client.solr.search("searchbucket", - "foo:one OR foo:two") + results = self.client.solr.search(self.search_bucket, + "foo:one OR foo:two") if (len(results) == 0): print "\n\nNot running test \"testSearchIntegration()\".\n" print """Please ensure that you have installed the Riak @@ -138,5 +143,6 @@ def test_search_integration(self): 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) + results = self.client.solr.search(self.search_bucket, query) + self.assertEqual(len(results['docs']), 3)