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 _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)
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()