def test_bucket_nq(self):
default_bt = BucketType(None, "default")
foo_bt = BucketType(None, "foo")
a = RiakBucket('client', 'a', default_bt)
b = RiakBucket('client', 'b', default_bt)
c = RiakBucket('client', 'a', foo_bt)
self.assertNotEqual(a, b, 'matched with a different bucket')
self.assertNotEqual(a, c, 'matched with a different bucket type')
def test_bucket_eq(self):
default_bt = BucketType(None, "default")
foo_bt = BucketType(None, "foo")
a = RiakBucket('client', 'a', default_bt)
b = RiakBucket('client', 'a', default_bt)
c = RiakBucket('client', 'a', foo_bt)
d = RiakBucket('client', 'a', foo_bt)
self.assertEqual(a, b)
self.assertEqual(c, d)
def test_object_eq(self):
a = RiakObject(None, 'bucket', 'key')
b = RiakObject(None, 'bucket', 'key')
self.assertEqual(a, b)
default_bt = BucketType(None, "default")
bucket_a = RiakBucket('client', 'a', default_bt)
bucket_b = RiakBucket('client', 'a', default_bt)
c = RiakObject(None, bucket_a, 'key')
d = RiakObject(None, bucket_b, 'key')
self.assertEqual(c, d)
def test_bucket_hash(self):
default_bt = BucketType(None, "default")
foo_bt = BucketType(None, "foo")
a = RiakBucket('client', 'a', default_bt)
b = RiakBucket('client', 'a', default_bt)
c = RiakBucket('client', 'c', default_bt)
d = RiakBucket('client', 'a', foo_bt)
self.assertEqual(hash(a), hash(b), 'same bucket has different hashes')
self.assertNotEqual(hash(a), hash(c), 'different bucket has same hash')
self.assertNotEqual(
hash(a), hash(d),
'same bucket, different bucket type has same hash')
def test_object_nq(self):
a = RiakObject(None, 'bucket', 'key')
b = RiakObject(None, 'bucket', 'not key')
c = RiakObject(None, 'not bucket', 'key')
self.assertNotEqual(a, b, 'matched with different keys')
self.assertNotEqual(a, c, 'matched with different buckets')
default_bt = BucketType(None, "default")
foo_bt = BucketType(None, "foo")
bucket_a = RiakBucket('client', 'a', default_bt)
bucket_b = RiakBucket('client', 'a', foo_bt)
c = RiakObject(None, bucket_a, 'key')
d = RiakObject(None, bucket_b, 'key')
self.assertNotEqual(c, d)
def bucket(self, name, bucket_type='default'):
"""
Get the bucket by the specified name. Since buckets always exist,
this will always return a
:class:`RiakBucket <riak.bucket.RiakBucket>`.
If you are using a bucket that is contained in a bucket type, it is
preferable to access it from the bucket type object::
# Preferred:
client.bucket_type("foo").bucket("bar")
# Equivalent, but not preferred:
client.bucket("bar", bucket_type="foo")
:param name: the bucket name
:type name: str
:param bucket_type: the parent bucket-type
:type bucket_type: :class:`BucketType <riak.bucket.BucketType>`
or str
:rtype: :class:`RiakBucket <riak.bucket.RiakBucket>`
"""
if not isinstance(name, string_types):
raise TypeError('Bucket name must be a string')
if isinstance(bucket_type, string_types):
bucket_type = self.bucket_type(bucket_type)
elif not isinstance(bucket_type, BucketType):
raise TypeError('bucket_type must be a string '
'or riak.bucket.BucketType')
return self._buckets.setdefault((bucket_type, name),
RiakBucket(self, name, bucket_type))
def bucket(self, name):
"""
Get the bucket by the specified name. Since buckets always exist,
this will always return a :class:`RiakBucket <riak.bucket.RiakBucket>`.
:rtype: :class:`RiakBucket <riak.bucket.RiakBucket>`
"""
return RiakBucket(self, name)
def __getattr__(self, name):
"""
Get a bucket directly by passing it's name.
Returns a new ``RiakBucket`` instance.
:param name: The bucket name
:type name: string
"""
return RiakBucket(self, name)
def test_object_hash(self):
a = RiakObject(None, 'bucket', 'key')
b = RiakObject(None, 'bucket', 'key')
c = RiakObject(None, 'bucket', 'not key')
self.assertEqual(hash(a), hash(b), 'same object has different hashes')
self.assertNotEqual(hash(a), hash(c), 'different object has same hash')
default_bt = BucketType(None, "default")
foo_bt = BucketType(None, "foo")
bucket_a = RiakBucket('client', 'a', default_bt)
bucket_b = RiakBucket('client', 'a', foo_bt)
d = RiakObject(None, bucket_a, 'key')
e = RiakObject(None, bucket_a, 'key')
f = RiakObject(None, bucket_b, 'key')
g = RiakObject(None, bucket_b, 'not key')
self.assertEqual(hash(d), hash(e),
'same object, same bucket_type has different hashes')
self.assertNotEqual(
hash(e), hash(f), 'same object, different bucket type has the '
'same hash')
self.assertNotEqual(
hash(d), hash(g), 'different object, different bucket '
'type has same hash')
def bucket(self, name):
"""
Get the bucket by the specified name. Since buckets always exist,
this will always return a :class:`RiakBucket <riak.bucket.RiakBucket>`.
:rtype: :class:`RiakBucket <riak.bucket.RiakBucket>`
"""
if not isinstance(name, str):
raise TypeError('Bucket name must be a string')
if name in self._buckets:
return self._buckets[name]
else:
bucket = RiakBucket(self, name)
self._buckets[name] = bucket
return bucket
def test_bucket_hash(self):
a = RiakBucket('client', 'a')
b = RiakBucket('client', 'a')
c = RiakBucket('client', 'c')
self.assertEqual(hash(a), hash(b), 'same bucket has different hashes')
self.assertNotEqual(hash(a), hash(c), 'different bucket has same hash')
def test_bucket_nq(self):
a = RiakBucket('client', 'a')
b = RiakBucket('client', 'b')
self.assertNotEqual(a, b, 'matched with a different bucket')
def test_bucket_eq(self):
a = RiakBucket('client', 'a')
b = RiakBucket('client', 'a')
self.assertEqual(a, b)
