def test_setSecurity(self):
self.client.put(self.buildKey(1), "test_value_1")
acl = common.ACL(identity=100)
domain = common.Domain(roles=[common.Roles.READ])
acl.domains = [domain]
if self.adminClient.use_ssl:
self.adminClient.setSecurity([acl])
# Verify user 100 can only read
read_only_client = Client(self.host, self.port, identity=100)
read_only_client.get(self.buildKey(1)) # Should be OK.
args = (self.buildKey(2), 'test_value_2')
self.assertRaises(KineticMessageException, read_only_client.put,
*args)
else:
try:
#TODO: change this to self.assertRaises
self.adminClient.setSecurity([acl])
except KineticException:
pass
else:
self.fail('Exception should be thrown if not using SSL')
def setUp(self): c = Client() c.connect() self.device = c.config.worldWideName print self.device info = DeviceInfo(wwn=self.device, addresses=["127.0.0.1"]) m = MemcachedDeviceMap() m[self.device] = info
def test_setSecurity(self):
self.client.put(self.buildKey(1), "test_value_1")
acl = common.ACL(identity=100)
domain = common.Domain(roles=[common.Roles.READ])
acl.domains = [domain]
self.adminClient.setSecurity([acl])
# Verify user 100 can only read
read_only_client = Client(self.host, self.port, identity=100)
read_only_client.get(self.buildKey(1)) # Should be OK.
args = (self.buildKey(2), 'test_value_2')
self.assertRaises(KineticMessageException, read_only_client.put, *args)
def test_setSecurity(self):
self.client.put(self.buildKey(1), "test_value_1")
acl = common.ACL(identity=100)
domain = common.Domain(roles=[common.Roles.READ])
acl.domains = [domain]
self.adminClient.setSecurity([acl])
# Verify user 100 can only read
read_only_client = Client(self.host, self.port, identity=100)
read_only_client.get(self.buildKey(1)) # Should be OK.
args = (self.buildKey(2), 'test_value_2')
self.assertRaises(KineticMessageException, read_only_client.put, *args)
def _new_connection(self, device, **kwargs):
kwargs.setdefault('connect_timeout', self.connect_timeout)
try:
info = self.device_map[device]
except InvalidEntry as ex:
self.faulted_device(device)
raise DeviceNotAvailable("Invalid entry for device %s. %s" % (
device, ex))
while len(info.addresses) > 0:
# Try to connect to a random address
address = random.choice(info.addresses)
for i in range(1, self.connect_retry + 1):
try:
c = Client(address, info.port, **kwargs)
c.connect()
if c.config.worldWideName != info.wwn:
raise WrongDeviceConnection("Drive at %s is %s, expected %s." %
(c, c.config.worldWideName, info.wwn))
return c
except Timeout:
self.logger.warning('Drive %s connect timeout #%d (%ds)' % (
device, i, self.connect_timeout))
except WrongDeviceConnection:
# Wrong number, no need to keep trying, just remove it
self.logger.exception('Drive %s has an incorrect WWN' % (device))
self.faulted_device(device)
raise
except Exception:
self.logger.exception('Drive %s connection error #%d' % (
device, i))
if i < self.connect_retry:
sleep(1)
self.logger.error('Unable to connect to drive %s at %s after %s attempts' % (
device, c, i))
# Remove address from map
info.addresses.remove(address)
self.device_map[device] = info
self.faulted_device(device)
raise DeviceNotAvailable("Unable to connect to drive %s at any of it's addresses after %s attempts on each." % (
device, i))
def setUp(self):
self.test_dir = tempfile.mkdtemp()
self.ports = self.PORTS
self._sim_map = {}
try:
self._sim_map = start_simulators(_find_kinetic_jar(KINETIC_JAR),
self.test_dir, *self.ports)
self.client_map = {}
for port in self.ports:
self.client_map[port] = Client('localhost', port)
except Exception:
self.tearDown()
def detected(self, drive):
# Check existing data
try:
info = self.device_map[drive.wwn]
# Verify connection issues
#
# Interfaces coming from the drive will be trusted as correct
# although they might not be accesible
# if #known > #announced, all extra addresses will be dropped
if self.verify_addresses:
known = set(info.addresses)
announced = set(drive.addresses)
if known != announced:
# This can happen when the device can't be accessed
# through all of its interfaces
missing = announced - known
for a in missing:
try:
c = Client(a, drive.port)
c.connect()
# interface is back up
self.logger.info('Device interface %s is back online: %s',
a, drive)
c.close()
except:
# Interface still down
drive.addresses.remove(a)
except InvalidEntry as ex:
# Might happen that some script/test/old version
# wrote some garbage, no need to clean, we will overwrite
self.logger.warn('Corrupted entry detected: %s' % ex)
except DeviceNotFound:
# This happens when a device goes offline
# and then comes back up
self.logger.info('Device back online: %s' % drive)
self.device_map[drive.wwn] = drive
def test_setSecurity(self):
self.client.put(self.buildKey(1), "test_value_1")
acl = common.ACL(identity=100)
domain = common.Domain(roles=[common.Roles.READ])
acl.domains = [domain]
if self.adminClient.use_ssl:
self.adminClient.setSecurity([acl])
# Verify user 100 can only read
read_only_client = Client(self.host, self.port, identity=100)
read_only_client.get(self.buildKey(1)) # Should be OK.
args = (self.buildKey(2), "test_value_2")
self.assertRaises(KineticMessageException, read_only_client.put, *args)
else:
try:
# TODO: change this to self.assertRaises
self.adminClient.setSecurity([acl])
except KineticException:
pass
else:
self.fail("Exception should be thrown if not using SSL")
def setUpClass(cls):
cls.client = None
cls.baseKey = "tests/py/%s/" % cls.__name__
cls.port = int(KINETIC_PORT)
cls.host = KINETIC_HOST
cls.jar_path = _find_kinetic_jar(KINETIC_JAR)
cls.datadir = None
cls.simulator = None
cls.stdout = cls.stderr = None
try:
backoff = 0.1
while True:
sock = socket.socket()
try:
sock.connect((cls.host, cls.port))
except socket.error:
if backoff > 2:
raise
else:
# k, we can connect
sock.close()
break
cls._check_simulator()
time.sleep(backoff)
backoff *= 2 # double it!
except:
if hasattr(cls, 'stdout'):
try:
raise SimulatorRuntimeError(cls.stdout, cls.stderr,
cls.simulator.returncode)
except:
# this is some dodgy shit to setup the re-raise at the bottom
pass
cls.tearDownClass()
raise
cls.client = Client(cls.host, cls.port)
cls.client.connect()
def setUp(self):
super(KineticBasicTestCase, self).setUp()
self.client = Client(self.host, self.port)
self.client.connect()
class KineticBasicTestCase(BaseTestCase):
def setUp(self):
super(KineticBasicTestCase, self).setUp()
self.client = Client(self.host, self.port)
self.client.connect()
def test_command_put(self):
self.client.put(self.buildKey(0),"test_value")
def test_put_no_version_overwrite(self):
key = self.buildKey()
self.client.put(key, 'value')
self.assertEquals('value', self.client.get(key).value)
self.client.put(key, 'value1')
self.assertEquals('value1', self.client.get(key).value)
def test_put_no_overwrite_with_version(self):
key = self.buildKey()
self.client.put(key, 'value', new_version='0')
self.assertEquals('value', self.client.get(key).value)
# can't set it w/o any version
args = (key, 'value1')
self.assertRaises(KineticMessageException, self.client.put, *args)
# can't set new version
kwargs = dict(new_version='1')
self.assertRaises(KineticMessageException, self.client.put,
*args, **kwargs)
# still has orig value
self.assertEquals('value', self.client.get(key).value)
# can overwrite with correct version
self.client.put(key, 'value1', version='0')
self.assertEquals('value1', self.client.get(key).value)
def test_put_force_version_overwrite(self):
key = self.buildKey()
self.client.put(key, 'value', new_version='0')
self.assertEquals('value', self.client.get(key).value)
self.client.put(key, 'value1', force=True)
self.assertEquals('value1', self.client.get(key).value)
def test_command_get(self):
self.client.get(self.buildKey(0))
def test_command_getMetadata(self):
self.client.getMetadata(self.buildKey(0))
def test_command_getNext(self):
self.client.put(self.buildKey(1),"test_value_1")
self.client.put(self.buildKey(2),"test_value_2")
self.client.getNext(self.buildKey(1))
def test_command_getPrevious(self):
self.client.put(self.buildKey(1),"test_value_1")
self.client.put(self.buildKey(2),"test_value_2")
self.client.getPrevious(self.buildKey(2))
def test_command_delete(self):
self.client.delete(self.buildKey(0))
def test_delete_existing(self):
self.client.put(self.buildKey(0),"test_value")
x = self.client.delete(self.buildKey(0))
self.assertTrue(x)
def test_delete_non_existing(self):
x = self.client.delete(self.baseKey + "none_existing_test_key")
self.assertFalse(x)
#selft.assertRaises(KeyNotFound)
def test_put_getMetadata(self):
value = "test_value"
self.client.put(self.buildKey(0),value,new_version="20")
x = self.client.getMetadata(self.buildKey(0))
self.assertEqual(x.metadata.version, "20")
def test_put_get(self):
value = "test_value"
self.client.put(self.buildKey(0),value)
x = self.client.get(self.buildKey(0))
self.assertEqual(value, x.value)
def test_put_get_withVersion(self):
value = "test_value"
self.client.put(self.buildKey(0),value, new_version="1")
x = self.client.get(self.buildKey(0))
self.assertEqual(x.value, value)
self.assertEqual(x.metadata.version, "1")
def test_delete_nonExistent(self):
deleted = self.client.delete(self.buildKey(0))
self.assertEqual(deleted, False)
def test_put_delete_incorrectVersion(self):
value = "test_value"
self.client.put(self.buildKey(0),value, new_version="1")
with self.assertRaises(KineticMessageException):
self.client.delete(self.buildKey(0), "2")
x = self.client.get(self.buildKey(0))
self.assertEqual(x.value, value)
def test_put_delete_get_withVersion(self):
self.client.put(self.buildKey(0),"test_value", new_version="1")
deleted = self.client.delete(self.buildKey(0), "1")
self.assertEqual(deleted, True)
x = self.client.get(self.buildKey(0))
self.assertEqual(x, None)
def test_put_delete_get(self):
self.client.put(self.buildKey(0),"test_value")
deleted = self.client.delete(self.buildKey(0))
self.assertEqual(deleted, True)
x = self.client.get(self.buildKey(0))
self.assertEqual(x, None)
def test_getNext(self):
self.client.put(self.buildKey(1),"test_value_1")
yKey = self.buildKey(2)
yValue = "test_value_2"
self.client.put(yKey, yValue)
x = self.client.getNext(self.buildKey(1))
self.assertEqual(x.key, yKey)
self.assertEqual(x.value, yValue)
def test_getPrevious(self):
xKey = self.buildKey(1)
xValue = "test_value_1"
self.client.put(xKey,xValue)
self.client.put(self.buildKey(2),"test_value_2")
y = self.client.getPrevious(self.buildKey(2))
self.assertEqual(xKey, y.key)
self.assertEqual(xValue, y.value)
def setUpRangeTests(self):
self.client.put(self.buildKey(1),"test_value_1")
self.client.put(self.buildKey(2),"test_value_2")
self.client.put(self.buildKey(3),"test_value_3")
self.client.put(self.buildKey(4),"test_value_4")
self.client.put(self.buildKey(5),"test_value_5")
self.client.put(self.buildKey(6),"test_value_6")
self.client.put(self.buildKey(7),"test_value_7")
self.client.put(self.buildKey(8),"test_value_8")
self.client.put(self.buildKey(9),"test_value_9")
def test_getKeyRange_default(self):
self.setUpRangeTests()
expected = [self.buildKey(3),self.buildKey(4),self.buildKey(5),self.buildKey(6)]
xs = self.client.getKeyRange(self.buildKey(3),self.buildKey(6))
self.assertEqual(xs, expected)
def test_getKeyRange_empty(self):
self.setUpRangeTests()
xs = self.client.getKeyRange(self.baseKey + "nonexisting_test_key_1",self.baseKey + "nonexisting_test_key_99")
self.assertEqual(xs, [])
def test_getKeyRange_exclusiveStart(self):
self.setUpRangeTests()
expected = [self.buildKey(4),self.buildKey(5),self.buildKey(6)]
xs = self.client.getKeyRange(self.buildKey(3),self.buildKey(6),False,True)
self.assertEqual(xs, expected)
def test_getKeyRange_exclusiveEnd(self):
self.setUpRangeTests()
expected = [self.buildKey(3),self.buildKey(4),self.buildKey(5)]
xs = self.client.getKeyRange(self.buildKey(3),self.buildKey(6),True,False)
self.assertEqual(xs, expected)
def test_getKeyRange_bounded(self):
self.setUpRangeTests()
expected = [self.buildKey(4),self.buildKey(5)]
xs = self.client.getKeyRange(self.buildKey(4),self.buildKey(9),maxReturned=2)
self.assertEqual(xs, expected)
def test_getRange_default(self):
self.setUpRangeTests()
expectedKeys = [self.buildKey(1),self.buildKey(2),self.buildKey(3),self.buildKey(4),self.buildKey(5),self.buildKey(6)]
expectedValues = ["test_value_1","test_value_2","test_value_3","test_value_4","test_value_5","test_value_6"]
xs = self.client.getRange(self.buildKey(1),self.buildKey(6))
i = 0
for x in xs :
self.assertEqual(x.key, expectedKeys[i])
self.assertEqual(x.value, expectedValues[i])
i += 1
def test_value_too_big(self):
self.assertRaises(common.KineticClientException, self.client.put, self.buildKey(1), 'x' * (common.MAX_VALUE_SIZE + 1))
def test_key_too_big(self):
self.assertRaises(common.KineticClientException, self.client.put, self.buildKey('x' * (common.MAX_KEY_SIZE + 1)), 'y')
def test_noop(self):
self.client.noop()
def setUp(self):
super(BatchTestCase, self).setUp()
self.client = Client(self.host, self.port)
self.client.connect()
self._create_new_batch()
class BatchTestCase(BaseTestCase):
def setUp(self):
super(BatchTestCase, self).setUp()
self.client = Client(self.host, self.port)
self.client.connect()
self._create_new_batch()
def _create_new_batch(self):
self.batch = self.client.begin_batch()
if self.batch is None:
raise common.KineticException("unable to create batch")
def test_batch_initial_state(self):
is_completed = self.batch.is_completed()
op_count = len(self.batch)
self.batch.abort()
self.assertFalse(is_completed)
self.assertEquals(op_count, 0)
def test_batch_operation_count(self):
key1 = self.buildKey('test_batch_operation_count_1')
key2 = self.buildKey('test_batch_operation_count_2')
key3 = self.buildKey('test_batch_operation_count_3')
self.batch.put(key1, '')
self.assertEquals(len(self.batch), 1)
self.batch.put(key2, '')
self.assertEquals(len(self.batch), 2)
self.batch.delete(key3)
self.assertEquals(len(self.batch), 3)
self.batch.abort()
def test_batch_commit_is_completed(self):
key1 = self.buildKey('test_batch_commit_is_completed_1')
key2 = self.buildKey('test_batch_commit_is_completed_2')
self.assertFalse(self.batch.is_completed())
self.batch.put(key1, '')
self.batch.delete(key2)
self.assertFalse(self.batch.is_completed())
self.batch.commit()
self.assertTrue(self.batch.is_completed())
def test_batch_abort_is_completed(self):
key1 = self.buildKey('test_batch_abort_is_completed_1')
key2 = self.buildKey('test_batch_abort_is_completed_2')
self.assertFalse(self.batch.is_completed())
self.batch.put(key1, '')
self.batch.delete(key2)
self.assertFalse(self.batch.is_completed())
self.batch.abort()
self.assertTrue(self.batch.is_completed())
def test_empty_batch_abort(self):
# abort with no operations in batch
self.assertRaises(common.BatchAbortedException, self.batch.abort())
def test_batch_abort(self):
key = self.buildKey('key_should_not_exist')
self.batch.put(key, '')
self.batch.abort()
self.assertEqual(self.client.get(key), None)
def test_empty_batch_commit(self):
# commit with no operations in batch
self.assertRaises(common.BatchAbortedException, self.batch.commit())
def test_batch_commit(self):
key = self.buildKey('key_should_exist')
self.batch.put(key, '')
self.batch.commit()
self.assertIsNotNone(self.client.get(key))
def test_batch_delete_commit(self):
# put an entry
key = self.buildKey('test_batch_delete_commit')
self.client.put(key, '')
self.batch.delete(key)
self.batch.commit()
self.assertEqual(self.client.get(key), None)
def test_batch_delete_abort(self):
# put an entry
key = self.buildKey('test_batch_delete_abort')
self.client.put(key, '')
self.batch.delete(key)
self.batch.abort()
self.assertIsNotNone(self.client.get(key))
def test_batch_put_commit(self):
key = self.buildKey('test_batch_put_commit')
self.batch.put(key, '')
self.batch.commit()
self.assertIsNotNone(self.client.get(key))
def test_batch_put_abort(self):
key = self.buildKey('test_batch_put_abort')
self.batch.put(key, '')
self.batch.abort()
self.assertEqual(self.client.get(key), None)
def test_batch_multiple_put_commit(self):
key1 = self.buildKey('test_batch_multiple_put_commit_1')
key2 = self.buildKey('test_batch_multiple_put_commit_2')
self.batch.put(key1, '')
self.batch.put(key2, '')
self.batch.commit()
self.assertIsNotNone(self.client.get(key1))
self.assertIsNotNone(self.client.get(key2))
def test_batch_multiple_put_abort(self):
key1 = self.buildKey('test_batch_multiple_put_abort_1')
key2 = self.buildKey('test_batch_multiple_put_abort_2')
self.batch.put(key1, '')
self.batch.put(key2, '')
self.batch.abort()
self.assertEqual(self.client.get(key1), None)
self.assertEqual(self.client.get(key2), None)
def test_batch_multiple_delete_commit(self):
key1 = self.buildKey('test_batch_multiple_delete_commit_1')
key2 = self.buildKey('test_batch_multiple_delete_commit_2')
self.client.put(key1, '')
self.client.put(key2, '')
self.batch.delete(key1)
self.batch.delete(key2)
self.batch.commit()
self.assertEqual(self.client.get(key1), None)
self.assertEqual(self.client.get(key2), None)
def test_batch_multiple_delete_abort(self):
key1 = self.buildKey('test_batch_multiple_delete_abort_1')
key2 = self.buildKey('test_batch_multiple_delete_abort_2')
self.client.put(key1, '')
self.client.put(key2, '')
self.batch.delete(key1)
self.batch.delete(key2)
self.batch.abort()
self.assertIsNotNone(self.client.get(key1))
self.assertIsNotNone(self.client.get(key2))
def test_batch_mixed_commit(self):
key1 = self.buildKey('test_batch_mixed_commit_1')
key2 = self.buildKey('test_batch_mixed_commit_2')
self.client.put(key1, '')
self.batch.delete(key1)
self.batch.put(key2, '')
self.batch.commit()
self.assertEqual(self.client.get(key1), None)
self.assertIsNotNone(self.client.get(key2))
def test_batch_mixed_abort(self):
key1 = self.buildKey('test_batch_mixed_abort_1')
key2 = self.buildKey('test_batch_mixed_abort_2')
self.client.put(key1, '')
self.batch.delete(key1)
self.batch.put(key2, '')
self.batch.abort()
self.assertIsNotNone(self.client.get(key1))
self.assertEqual(self.client.get(key2), None)
def test_batch_reuse_after_commit(self):
key1 = self.buildKey('test_batch_reuse_after_commit_1')
key2 = self.buildKey('test_batch_reuse_after_commit_2')
self.batch.put(key1, '')
self.batch.commit()
args = (key2, '')
self.assertRaises(common.BatchCompletedException, self.batch.put, *args)
def test_batch_reuse_after_abort(self):
key = self.buildKey('test_batch_reuse_after_abort')
self.batch.put(key, '')
self.batch.abort()
args = (key)
self.assertRaises(common.BatchCompletedException, self.batch.delete, *args)
def setUp(self):
super(KineticBasicTestCase, self).setUp()
self.client = Client(self.host, self.port)
self.client.connect()
class KineticBasicTestCase(BaseTestCase):
def setUp(self):
super(KineticBasicTestCase, self).setUp()
self.client = Client(self.host, self.port)
self.client.connect()
def test_command_put(self):
self.client.put(self.buildKey(0), "test_value")
def test_put_no_version_overwrite(self):
key = self.buildKey()
self.client.put(key, 'value')
self.assertEquals('value', self.client.get(key).value)
self.client.put(key, 'value1')
self.assertEquals('value1', self.client.get(key).value)
def test_put_no_overwrite_with_version(self):
key = self.buildKey()
self.client.put(key, 'value', new_version='0')
self.assertEquals('value', self.client.get(key).value)
# can't set it w/o any version
args = (key, 'value1')
self.assertRaises(KineticMessageException, self.client.put, *args)
# can't set new version
kwargs = dict(new_version='1')
self.assertRaises(KineticMessageException, self.client.put, *args,
**kwargs)
# still has orig value
self.assertEquals('value', self.client.get(key).value)
# can overwrite with correct version
self.client.put(key, 'value1', version='0')
self.assertEquals('value1', self.client.get(key).value)
def test_put_force_version_overwrite(self):
key = self.buildKey()
self.client.put(key, 'value', new_version='0')
self.assertEquals('value', self.client.get(key).value)
self.client.put(key, 'value1', force=True)
self.assertEquals('value1', self.client.get(key).value)
def test_command_get(self):
self.client.get(self.buildKey(0))
def test_command_getMetadata(self):
self.client.getMetadata(self.buildKey(0))
def test_command_getNext(self):
self.client.put(self.buildKey(1), "test_value_1")
self.client.put(self.buildKey(2), "test_value_2")
self.client.getNext(self.buildKey(1))
def test_command_getPrevious(self):
self.client.put(self.buildKey(1), "test_value_1")
self.client.put(self.buildKey(2), "test_value_2")
self.client.getPrevious(self.buildKey(2))
def test_command_delete(self):
self.client.delete(self.buildKey(0))
def test_delete_existing(self):
self.client.put(self.buildKey(0), "test_value")
x = self.client.delete(self.buildKey(0))
self.assertTrue(x)
def test_delete_non_existing(self):
x = self.client.delete(self.baseKey + "none_existing_test_key")
self.assertFalse(x)
#selft.assertRaises(KeyNotFound)
def test_put_getMetadata(self):
value = "test_value"
self.client.put(self.buildKey(0), value, new_version="20")
x = self.client.getMetadata(self.buildKey(0))
self.assertEqual(x.metadata.version, "20")
def test_put_get(self):
value = "test_value"
self.client.put(self.buildKey(0), value)
x = self.client.get(self.buildKey(0))
self.assertEqual(value, x.value)
def test_put_get_withVersion(self):
value = "test_value"
self.client.put(self.buildKey(0), value, new_version="1")
x = self.client.get(self.buildKey(0))
self.assertEqual(x.value, value)
self.assertEqual(x.metadata.version, "1")
def test_delete_nonExistent(self):
deleted = self.client.delete(self.buildKey(0))
self.assertEqual(deleted, False)
def test_put_delete_incorrectVersion(self):
value = "test_value"
self.client.put(self.buildKey(0), value, new_version="1")
with self.assertRaises(KineticMessageException):
self.client.delete(self.buildKey(0), "2")
x = self.client.get(self.buildKey(0))
self.assertEqual(x.value, value)
def test_put_delete_get_withVersion(self):
self.client.put(self.buildKey(0), "test_value", new_version="1")
deleted = self.client.delete(self.buildKey(0), "1")
self.assertEqual(deleted, True)
x = self.client.get(self.buildKey(0))
self.assertEqual(x, None)
def test_put_delete_get(self):
self.client.put(self.buildKey(0), "test_value")
deleted = self.client.delete(self.buildKey(0))
self.assertEqual(deleted, True)
x = self.client.get(self.buildKey(0))
self.assertEqual(x, None)
def test_getNext(self):
self.client.put(self.buildKey(1), "test_value_1")
yKey = self.buildKey(2)
yValue = "test_value_2"
self.client.put(yKey, yValue)
x = self.client.getNext(self.buildKey(1))
self.assertEqual(x.key, yKey)
self.assertEqual(x.value, yValue)
def test_getPrevious(self):
xKey = self.buildKey(1)
xValue = "test_value_1"
self.client.put(xKey, xValue)
self.client.put(self.buildKey(2), "test_value_2")
y = self.client.getPrevious(self.buildKey(2))
self.assertEqual(xKey, y.key)
self.assertEqual(xValue, y.value)
def setUpRangeTests(self):
self.client.put(self.buildKey(1), "test_value_1")
self.client.put(self.buildKey(2), "test_value_2")
self.client.put(self.buildKey(3), "test_value_3")
self.client.put(self.buildKey(4), "test_value_4")
self.client.put(self.buildKey(5), "test_value_5")
self.client.put(self.buildKey(6), "test_value_6")
self.client.put(self.buildKey(7), "test_value_7")
self.client.put(self.buildKey(8), "test_value_8")
self.client.put(self.buildKey(9), "test_value_9")
def test_getKeyRange_default(self):
self.setUpRangeTests()
expected = [
self.buildKey(3),
self.buildKey(4),
self.buildKey(5),
self.buildKey(6)
]
xs = self.client.getKeyRange(self.buildKey(3), self.buildKey(6))
self.assertEqual(xs, expected)
def test_getKeyRange_empty(self):
self.setUpRangeTests()
xs = self.client.getKeyRange(self.baseKey + "nonexisting_test_key_1",
self.baseKey + "nonexisting_test_key_99")
self.assertEqual(xs, [])
def test_getKeyRange_exclusiveStart(self):
self.setUpRangeTests()
expected = [self.buildKey(4), self.buildKey(5), self.buildKey(6)]
xs = self.client.getKeyRange(self.buildKey(3), self.buildKey(6), False,
True)
self.assertEqual(xs, expected)
def test_getKeyRange_exclusiveEnd(self):
self.setUpRangeTests()
expected = [self.buildKey(3), self.buildKey(4), self.buildKey(5)]
xs = self.client.getKeyRange(self.buildKey(3), self.buildKey(6), True,
False)
self.assertEqual(xs, expected)
def test_getKeyRange_bounded(self):
self.setUpRangeTests()
expected = [self.buildKey(4), self.buildKey(5)]
xs = self.client.getKeyRange(self.buildKey(4),
self.buildKey(9),
maxReturned=2)
self.assertEqual(xs, expected)
def test_getRange_default(self):
self.setUpRangeTests()
expectedKeys = [
self.buildKey(1),
self.buildKey(2),
self.buildKey(3),
self.buildKey(4),
self.buildKey(5),
self.buildKey(6)
]
expectedValues = [
"test_value_1", "test_value_2", "test_value_3", "test_value_4",
"test_value_5", "test_value_6"
]
xs = self.client.getRange(self.buildKey(1), self.buildKey(6))
i = 0
for x in xs:
self.assertEqual(x.key, expectedKeys[i])
self.assertEqual(x.value, expectedValues[i])
i += 1
def test_value_too_big(self):
self.assertRaises(common.KineticClientException, self.client.put,
self.buildKey(1), 'x' * (common.MAX_VALUE_SIZE + 1))
def test_key_too_big(self):
self.assertRaises(common.KineticClientException, self.client.put,
self.buildKey('x' * (common.MAX_KEY_SIZE + 1)), 'y')
def test_noop(self):
self.client.noop()
class BatchTestCase(BaseTestCase):
def setUp(self):
super(BatchTestCase, self).setUp()
self.client = Client(self.host, self.port)
self.client.connect()
self._create_new_batch()
def _create_new_batch(self):
self.batch = self.client.begin_batch()
if self.batch is None:
raise common.KineticException("unable to create batch")
def test_batch_initial_state(self):
is_completed = self.batch.is_completed()
op_count = len(self.batch)
self.batch.abort()
self.assertFalse(is_completed)
self.assertEquals(op_count, 0)
def test_batch_operation_count(self):
key1 = self.buildKey('test_batch_operation_count_1')
key2 = self.buildKey('test_batch_operation_count_2')
key3 = self.buildKey('test_batch_operation_count_3')
self.batch.put(key1, '')
self.assertEquals(len(self.batch), 1)
self.batch.put(key2, '')
self.assertEquals(len(self.batch), 2)
self.batch.delete(key3)
self.assertEquals(len(self.batch), 3)
self.batch.abort()
def test_batch_commit_is_completed(self):
key1 = self.buildKey('test_batch_commit_is_completed_1')
key2 = self.buildKey('test_batch_commit_is_completed_2')
self.assertFalse(self.batch.is_completed())
self.batch.put(key1, '')
self.batch.delete(key2)
self.assertFalse(self.batch.is_completed())
self.batch.commit()
self.assertTrue(self.batch.is_completed())
def test_batch_abort_is_completed(self):
key1 = self.buildKey('test_batch_abort_is_completed_1')
key2 = self.buildKey('test_batch_abort_is_completed_2')
self.assertFalse(self.batch.is_completed())
self.batch.put(key1, '')
self.batch.delete(key2)
self.assertFalse(self.batch.is_completed())
self.batch.abort()
self.assertTrue(self.batch.is_completed())
def test_empty_batch_abort(self):
# abort with no operations in batch
self.assertRaises(common.BatchAbortedException, self.batch.abort())
def test_batch_abort(self):
key = self.buildKey('key_should_not_exist')
self.batch.put(key, '')
self.batch.abort()
self.assertEqual(self.client.get(key), None)
def test_empty_batch_commit(self):
# commit with no operations in batch
self.assertRaises(common.BatchAbortedException, self.batch.commit())
def test_batch_commit(self):
key = self.buildKey('key_should_exist')
self.batch.put(key, '')
self.batch.commit()
self.assertIsNotNone(self.client.get(key))
def test_batch_delete_commit(self):
# put an entry
key = self.buildKey('test_batch_delete_commit')
self.client.put(key, '')
self.batch.delete(key)
self.batch.commit()
self.assertEqual(self.client.get(key), None)
def test_batch_delete_abort(self):
# put an entry
key = self.buildKey('test_batch_delete_abort')
self.client.put(key, '')
self.batch.delete(key)
self.batch.abort()
self.assertIsNotNone(self.client.get(key))
def test_batch_put_commit(self):
key = self.buildKey('test_batch_put_commit')
self.batch.put(key, '')
self.batch.commit()
self.assertIsNotNone(self.client.get(key))
def test_batch_put_abort(self):
key = self.buildKey('test_batch_put_abort')
self.batch.put(key, '')
self.batch.abort()
self.assertEqual(self.client.get(key), None)
def test_batch_multiple_put_commit(self):
key1 = self.buildKey('test_batch_multiple_put_commit_1')
key2 = self.buildKey('test_batch_multiple_put_commit_2')
self.batch.put(key1, '')
self.batch.put(key2, '')
self.batch.commit()
self.assertIsNotNone(self.client.get(key1))
self.assertIsNotNone(self.client.get(key2))
def test_batch_multiple_put_abort(self):
key1 = self.buildKey('test_batch_multiple_put_abort_1')
key2 = self.buildKey('test_batch_multiple_put_abort_2')
self.batch.put(key1, '')
self.batch.put(key2, '')
self.batch.abort()
self.assertEqual(self.client.get(key1), None)
self.assertEqual(self.client.get(key2), None)
def test_batch_multiple_delete_commit(self):
key1 = self.buildKey('test_batch_multiple_delete_commit_1')
key2 = self.buildKey('test_batch_multiple_delete_commit_2')
self.client.put(key1, '')
self.client.put(key2, '')
self.batch.delete(key1)
self.batch.delete(key2)
self.batch.commit()
self.assertEqual(self.client.get(key1), None)
self.assertEqual(self.client.get(key2), None)
def test_batch_multiple_delete_abort(self):
key1 = self.buildKey('test_batch_multiple_delete_abort_1')
key2 = self.buildKey('test_batch_multiple_delete_abort_2')
self.client.put(key1, '')
self.client.put(key2, '')
self.batch.delete(key1)
self.batch.delete(key2)
self.batch.abort()
self.assertIsNotNone(self.client.get(key1))
self.assertIsNotNone(self.client.get(key2))
def test_batch_mixed_commit(self):
key1 = self.buildKey('test_batch_mixed_commit_1')
key2 = self.buildKey('test_batch_mixed_commit_2')
self.client.put(key1, '')
self.batch.delete(key1)
self.batch.put(key2, '')
self.batch.commit()
self.assertEqual(self.client.get(key1), None)
self.assertIsNotNone(self.client.get(key2))
def test_batch_mixed_abort(self):
key1 = self.buildKey('test_batch_mixed_abort_1')
key2 = self.buildKey('test_batch_mixed_abort_2')
self.client.put(key1, '')
self.batch.delete(key1)
self.batch.put(key2, '')
self.batch.abort()
self.assertIsNotNone(self.client.get(key1))
self.assertEqual(self.client.get(key2), None)
def test_batch_reuse_after_commit(self):
key1 = self.buildKey('test_batch_reuse_after_commit_1')
key2 = self.buildKey('test_batch_reuse_after_commit_2')
self.batch.put(key1, '')
self.batch.commit()
args = (key2, '')
self.assertRaises(common.BatchCompletedException, self.batch.put,
*args)
def test_batch_reuse_after_abort(self):
key = self.buildKey('test_batch_reuse_after_abort')
self.batch.put(key, '')
self.batch.abort()
args = (key)
self.assertRaises(common.BatchCompletedException, self.batch.delete,
*args)
def setUp(self):
super(BatchTestCase, self).setUp()
self.client = Client(self.host, self.port)
self.client.connect()
self._create_new_batch()
