def test_simple(self): oid = self.createObject(RaleighSSet.TYPE) sset = RaleighSSet(self.client, oid) sset.insert('key-01', 'value-01') sset.insert('key-02', 'value-02') data = sset.get('key-01') self.assertEquals(data['value'], 'value-01') data = sset.get('key-02') self.assertEquals(data['value'], 'value-02') self.assertRaises(RaleighException, sset.get, 'key-03') data = sset.scan(2) self.assertEquals(data['keys'], ['key-01', 'key-02']) self.assertEquals(data['values'], ['value-01', 'value-02']) data = sset.pop('key-01') self.assertEquals(data['value'], 'value-01') self.assertRaises(RaleighException, sset.get, 'key-01') data = sset.scan(2) self.assertEquals(data['keys'], ['key-02']) self.assertEquals(data['values'], ['value-02']) data = sset.update('key-02', 'value-02b') self.assertEquals(data['old_value'], 'value-02') data = sset.get('key-02') self.assertEquals(data['value'], 'value-02b')
def test_scanner(self): oid = self.createObject(RaleighSSet.TYPE) sset = RaleighSSet(self.client, oid) for i in xrange(10): sset.insert('key-%2d' % i, 'value-%2d' % i) for i, (key, value) in enumerate(sset.create_scanner()): self.assertEquals(key, 'key-%2d' % i) self.assertEquals(value, 'value-%2d' % i)
def execute(self, client): sset = RaleighSSet(client, self.oid) nrequests = 0 exception = None for i in xrange(self.NREQUESTS): x = randint(0, 9999999999) try: nrequests += 1 sset.insert('Key-%010d' % x, 'Value-%010d' % x) except RaleighException as e: pass except Exception as e: exception = e break return nrequests, exception
def test_txn_key_locked(self): oid = self.createObject(RaleighSSet.TYPE) sset = RaleighSSet(self.client, oid) txn_1 = RaleighTransaction(self.client) txn_1.begin() txn_2 = RaleighTransaction(self.client) txn_2.begin() sset.insert('key-01', 'value-01', txn_1.txn_id) self.assertRaises(RaleighException, sset.insert, 'key-01', 'value-02', txn_2.txn_id) txn_2.rollback() txn_1.commit() data = sset.get('key-01') self.assertEquals(data['value'], 'value-01')
def test_txn_multi_obj(self): def _sset_get(sset, key, txn_id, expected): try: data = sset.get(key, txn_id) print sset, data assert data['value'] == expected, (data['value'] == expected) except Exception as e: print sset, e assert expected == None, expected oid_1 = self.createObject(RaleighSSet.TYPE) sset_1 = RaleighSSet(self.client, oid_1) oid_2 = self.createObject(RaleighSSet.TYPE) sset_2 = RaleighSSet(self.client, oid_2) key = 'key-01' value = 'value-01' # Test Rollback txn = RaleighTransaction(self.client) txn.begin() sset_1.insert(key, value, txn.txn_id) sset_2.insert(key, value, txn.txn_id) self.assertRaises(RaleighException, sset_1.get, key) self.assertRaises(RaleighException, sset_2.get, key) data = sset_1.get(key, txn.txn_id) self.assertEquals(data['value'], value) data = sset_2.get(key, txn.txn_id) self.assertEquals(data['value'], value) txn.rollback() self.assertRaises(RaleighException, sset_1.get, key) self.assertRaises(RaleighException, sset_2.get, key) # Test Commit txn = RaleighTransaction(self.client) txn.begin() sset_1.insert(key, value, txn.txn_id) sset_2.insert(key, value, txn.txn_id) self.assertRaises(RaleighException, sset_1.get, key) self.assertRaises(RaleighException, sset_2.get, key) data = sset_1.get(key, txn.txn_id) self.assertEquals(data['value'], value) data = sset_2.get(key, txn.txn_id) self.assertEquals(data['value'], value) txn.commit() data = sset_1.get(key) self.assertEquals(data['value'], value) data = sset_2.get(key) self.assertEquals(data['value'], value)
def test_long_run(self): oid = self.createObject(RaleighSSet.TYPE) sset = RaleighSSet(self.client, oid) hkey = lambda x: sha1('%d' % x).hexdigest() hval = lambda x, v: sha1('%d-v%s' % (x, v)).hexdigest() NKEYS = (64 * 1024) / (20 + 40) VERIFY_MOD = 100 class Data: def __init__(self): self.data = [] self.rm_keys = set() def __len__(self): return len(self.data) def get(self, key): index = self._get_index(key) return index, self.data[index][1] def insert(self, key, value): insort(self.data, (key, value)) def update(self, key, value): index = self._get_index(key) self.data[index] = (key, value) def remove(self, key): del self.data[self._get_index(key)] self.rm_keys.add(key) def is_removed(self, key): return key in self.rm_keys def _get_index(self, key): index = bisect_left(self.data, (key, None)) if index != len(self.data) and self.data[index][0] == key: return index raise ValueError def _verify_sset_data(sset, test_data): for j in xrange(len(test_data)): key = hkey(j) if test_data.is_removed(key): self.assertRaises(RaleighException, sset.get, key) else: _, value = test_data.get(key) result = sset.get(key) self.assertEquals(result['value'], value) for j, (key, value) in enumerate(sset.create_scanner()): index, test_value = test_data.get(key) self.assertEquals(test_value, value) self.assertEquals(index, j) test_data = Data() # Insert and Verify for i in xrange(NKEYS): key, value = hkey(i), hval(i, 1) sset.insert(key, value) test_data.insert(key, value) if i % VERIFY_MOD == 0: _verify_sset_data(sset, test_data) _verify_sset_data(sset, test_data) # Update and Verify for i in xrange(0, NKEYS, 2): key, value = hkey(i), hval(i, 2) sset.update(key, value) test_data.update(key, value) if i % VERIFY_MOD == 0: _verify_sset_data(sset, test_data) _verify_sset_data(sset, test_data) # Delete and Verify for i in xrange(1, NKEYS, 2): key = hkey(i) sset.pop(key) test_data.remove(key) if i % VERIFY_MOD == 0: _verify_sset_data(sset, test_data) _verify_sset_data(sset, test_data)