def test_append_noreply(self):
key = generate_random_key(8)
val = generate_random_data(10)
val2 = generate_random_data(10)
self.client.set(key, val)
self.client.append(key, val2, noreply=True)
item = self.client.get(key)
assert val + val2 == item.value
def test_append_noreply(self):
key = generate_random_key(8)
val = generate_random_data(10)
val2 = generate_random_data(10)
self.client.set(key, val)
self.client.append(key, val2, noreply=True)
item = self.client.get(key)
assert val + val2 == item.value
def test_append(self):
key = generate_random_key(8)
val = generate_random_data(10)
val2 = generate_random_data(10)
# try to append to an invalid key
with self.assert_raises(NotStoredError):
self.client.append(key, val)
self.client.set(key, val)
self.client.append(key, val2)
item = self.client.get(key)
assert val + val2 == item.value
def test_append(self):
key = generate_random_key(8)
val = generate_random_data(10)
val2 = generate_random_data(10)
# try to append to an invalid key
with self.assert_raises(NotStoredError):
self.client.append(key, val)
self.client.set(key, val)
self.client.append(key, val2)
item = self.client.get(key)
assert val + val2 == item.value
def test_gets_multi(self):
key1 = generate_random_key(8)
val1 = generate_random_data(10)
key2 = generate_random_key(8)
val2 = generate_random_data(10)
# i can fetch values as normal, cas_unique is set
self.client.set(key1, val1)
self.client.set(key2, val2)
dct = self.client.gets_multi([key1, key2])
assert dct[key1].value == val1
assert dct[key2].value == val2
assert dct[key1].cas_unique is not None
assert dct[key2].cas_unique is not None
def test_gets_multi(self):
key1 = generate_random_key(8)
val1 = generate_random_data(10)
key2 = generate_random_key(8)
val2 = generate_random_data(10)
# i can fetch values as normal, cas_unique is set
self.client.set(key1, val1)
self.client.set(key2, val2)
dct = self.client.gets_multi([key1, key2])
assert dct[key1].value == val1
assert dct[key2].value == val2
assert dct[key1].cas_unique is not None
assert dct[key2].cas_unique is not None
def test_add_noreply(self):
key = generate_random_key(8)
val = generate_random_data(10)
self.client.add(key, val, noreply=True)
item = self.client.get(key)
assert val == item.value
def test_cas_noreply(self):
key = generate_random_key(8)
val = generate_random_data(10)
# set a key
self.client.set(key, val)
# get the cas_unique
item = self.client.gets(key)
cas_unique = item.cas_unique
# conditional update
val2 = generate_random_data(10)
self.client.cas(key, val2, cas_unique=cas_unique, noreply=True)
item = self.client.get(key)
assert item.value == val2
def test_cas_noreply(self):
key = generate_random_key(8)
val = generate_random_data(10)
# set a key
self.client.set(key, val)
# get the cas_unique
item = self.client.gets(key)
cas_unique = item.cas_unique
# conditional update
val2 = generate_random_data(10)
self.client.cas(key, val2, cas_unique=cas_unique, noreply=True)
item = self.client.get(key)
assert item.value == val2
def test_add_noreply(self):
key = generate_random_key(8)
val = generate_random_data(10)
self.client.add(key, val, noreply=True)
item = self.client.get(key)
assert val == item.value
def test_delete_noreply(self):
key = generate_random_key(8)
val = generate_random_data(10)
self.client.set(key, val)
self.client.delete(key, noreply=True)
with self.assert_raises(NotFoundError):
self.client.get(key)
def test_delete_noreply(self):
key = generate_random_key(8)
val = generate_random_data(10)
self.client.set(key, val)
self.client.delete(key, noreply=True)
with self.assert_raises(NotFoundError):
self.client.get(key)
def test_get_multiple(self):
key1 = generate_random_key(10)
val1 = generate_random_data(10)
key2 = generate_random_key(10)
key3 = generate_random_key(10)
val3 = generate_random_data(10)
self.client.set(key1, val1)
self.client.set(key3, val3)
keys = [key1, key2, key3]
dct = self.client.get_multi(keys)
assert val1 == dct[key1].value
assert val3 == dct[key3].value
def test_get_multiple(self):
key1 = generate_random_key(10)
val1 = generate_random_data(10)
key2 = generate_random_key(10)
key3 = generate_random_key(10)
val3 = generate_random_data(10)
self.client.set(key1, val1)
self.client.set(key3, val3)
keys = [key1, key2, key3]
dct = self.client.get_multi(keys)
assert val1 == dct[key1].value
assert val3 == dct[key3].value
def test_set_exptime_rel_1s(self):
key = generate_random_key(10)
val = generate_random_data(10)
self.client.set(key, val, exptime=1)
item = self.client.get(key) # still there
time.sleep(1.1)
with self.assert_raises(NotFoundError):
item = self.client.get(key) # expired
def test_set_and_get_small_key(self):
key = generate_random_key(4)
val = generate_random_data(5, 8)
self.client.set(key, val)
item = self.client.get(key)
val2 = item.value
assert val == val2
def test_set_and_get_large_value(self):
key = generate_random_key(10)
val = generate_random_data(1 << 19) # .5mb
self.client.set(key, val)
item = self.client.get(key)
val2 = item.value
assert val == val2
def test_set_flags(self):
key = generate_random_key(10)
val = generate_random_data(10)
flags = 15
self.client.set(key, val, flags=flags)
item = self.client.get(key)
assert val == item.value
assert flags == item.flags
def test_cas_stale(self):
key = generate_random_key(8)
val = generate_random_data(10)
# set a key
self.client.set(key, val)
# get the cas_unique
item = self.client.gets(key)
cas_unique = item.cas_unique
# "another client" updates it
val2 = generate_random_data(10)
self.client.set(key, val2)
# conditional update
val3 = generate_random_data(10)
with self.assert_raises(ExistsError):
self.client.cas(key, val3, cas_unique=cas_unique)
def test_set_and_get_small_key(self):
key = generate_random_key(4)
val = generate_random_data(5, 8)
self.client.set(key, val)
item = self.client.get(key)
val2 = item.value
assert val == val2
def test_set_exptime_rel_1s(self):
key = generate_random_key(10)
val = generate_random_data(10)
self.client.set(key, val, exptime=1)
item = self.client.get(key) # still there
time.sleep(1.1)
with self.assert_raises(NotFoundError):
item = self.client.get(key) # expired
def test_set_and_get_large_value(self):
key = generate_random_key(10)
val = generate_random_data(1 << 19) # .5mb
self.client.set(key, val)
item = self.client.get(key)
val2 = item.value
assert val == val2
def test_cas_stale(self):
key = generate_random_key(8)
val = generate_random_data(10)
# set a key
self.client.set(key, val)
# get the cas_unique
item = self.client.gets(key)
cas_unique = item.cas_unique
# "another client" updates it
val2 = generate_random_data(10)
self.client.set(key, val2)
# conditional update
val3 = generate_random_data(10)
with self.assert_raises(ExistsError):
self.client.cas(key, val3, cas_unique=cas_unique)
def test_set_flags(self):
key = generate_random_key(10)
val = generate_random_data(10)
flags = 15
self.client.set(key, val, flags=flags)
item = self.client.get(key)
assert val == item.value
assert flags == item.flags
def test_flush_all(self):
key = generate_random_key(4)
val = generate_random_data(5, 8)
# key set before flush is expired
self.client.set(key, val)
self.client.flush_all()
with self.assert_raises(NotFoundError):
self.client.get(key)
# sleep a bit to make sure we don't get any rounding errors on the
# exact flush timestamp that might affect later stores
time.sleep(1.5)
# key set after flush works as expected
key2 = generate_random_key(4)
val2 = generate_random_data(5, 8)
self.client.set(key2, val2)
item = self.client.get(key2)
assert item.value == val2
def test_flush_all(self):
key = generate_random_key(4)
val = generate_random_data(5, 8)
# key set before flush is expired
self.client.set(key, val)
self.client.flush_all()
with self.assert_raises(NotFoundError):
self.client.get(key)
# sleep a bit to make sure we don't get any rounding errors on the
# exact flush timestamp that might affect later stores
time.sleep(1.5)
# key set after flush works as expected
key2 = generate_random_key(4)
val2 = generate_random_data(5, 8)
self.client.set(key2, val2)
item = self.client.get(key2)
assert item.value == val2
def test_add(self):
key = generate_random_key(8)
val = generate_random_data(10)
self.client.add(key, val)
item = self.client.get(key)
assert val == item.value
# try to add an existing key
with self.assert_raises(NotStoredError):
self.client.add(key, val)
def test_set_noreply(self):
key = generate_random_key(10)
val = generate_random_data(10)
# set without requesting confirmation
self.client.set(key, val, noreply=True)
# verify that it worked
item = self.client.get(key)
assert val == item.value
def test_cas_ok(self):
key = generate_random_key(8)
val = generate_random_data(10)
# try to update a key that doesn't exist
with self.assert_raises(NotFoundError):
self.client.cas(key, val, cas_unique='1')
# set a key
self.client.set(key, val)
# get the cas_unique
item = self.client.gets(key)
cas_unique = item.cas_unique
# conditional update
val2 = generate_random_data(10)
self.client.cas(key, val2, cas_unique=cas_unique)
item = self.client.get(key)
assert item.value == val2
def test_set_noreply(self):
key = generate_random_key(10)
val = generate_random_data(10)
# set without requesting confirmation
self.client.set(key, val, noreply=True)
# verify that it worked
item = self.client.get(key)
assert val == item.value
def test_add(self):
key = generate_random_key(8)
val = generate_random_data(10)
self.client.add(key, val)
item = self.client.get(key)
assert val == item.value
# try to add an existing key
with self.assert_raises(NotStoredError):
self.client.add(key, val)
def test_cas_ok(self):
key = generate_random_key(8)
val = generate_random_data(10)
# try to update a key that doesn't exist
with self.assert_raises(NotFoundError):
self.client.cas(key, val, cas_unique='1')
# set a key
self.client.set(key, val)
# get the cas_unique
item = self.client.gets(key)
cas_unique = item.cas_unique
# conditional update
val2 = generate_random_data(10)
self.client.cas(key, val2, cas_unique=cas_unique)
item = self.client.get(key)
assert item.value == val2
def test_gets(self):
key = generate_random_key(8)
val = generate_random_data(10)
# set a key, record cas_unique
self.client.set(key, val)
item = self.client.gets(key)
# set again, cas_unique should have changed
self.client.set(key, val)
item2 = self.client.gets(key)
assert item.cas_unique != item2.cas_unique
def test_delete(self):
key = generate_random_key(8)
val = generate_random_data(10)
# try to delete invalid key
with self.assert_raises(NotFoundError):
self.client.delete(key)
self.client.set(key, val)
self.client.delete(key)
with self.assert_raises(NotFoundError):
self.client.get(key)
def test_gets(self):
key = generate_random_key(8)
val = generate_random_data(10)
# set a key, record cas_unique
self.client.set(key, val)
item = self.client.gets(key)
# set again, cas_unique should have changed
self.client.set(key, val)
item2 = self.client.gets(key)
assert item.cas_unique != item2.cas_unique
def test_delete(self):
key = generate_random_key(8)
val = generate_random_data(10)
# try to delete invalid key
with self.assert_raises(NotFoundError):
self.client.delete(key)
self.client.set(key, val)
self.client.delete(key)
with self.assert_raises(NotFoundError):
self.client.get(key)
def test_set_exptime_abs_2s(self):
key = generate_random_key(10)
val = generate_random_data(10)
# we don't know if we have time sync with the server, so fetch the
# server's time first
stats = self.client.get_stats()
now = int(stats['time'])
self.client.set(key, val, exptime=now + 1)
item = self.client.get(key) # still there
time.sleep(2.3)
with self.assert_raises(NotFoundError):
item = self.client.get(key) # expired
def test_set_exptime_abs_2s(self):
key = generate_random_key(10)
val = generate_random_data(10)
# we don't know if we have time sync with the server, so fetch the
# server's time first
stats = self.client.get_stats()
now = int(stats['time'])
self.client.set(key, val, exptime=now + 1)
item = self.client.get(key) # still there
time.sleep(2.3)
with self.assert_raises(NotFoundError):
item = self.client.get(key) # expired
def run(self, client, metrics):
# use client.set + client.flush_pipeline pattern
client.pipeline_mode = True
stats = client.get_stats()
capacity = stats['limit_maxbytes']
capacity_fmt = insert_number_commas(capacity)
metrics.pct_full = self.get_pct_full(client)
metrics.batch_size = 100
metrics.bytes_cum = 0
metrics.time_cum = 0
metrics.time_total_cum = 0
metrics.items_cum = 0
rate = -1
time_total_st = time.time()
while metrics.pct_full < self.percentage:
self.write("Cache is %.2f%% full of %s, inserting %s items (rate: %s items/s)" %
(metrics.pct_full, capacity_fmt, metrics.batch_size,
insert_number_commas(str(int(rate)))))
# Pre-generate keys and values to avoid timing this work
# TODO allow tuning the sizes of keys and values
keys = [generate_random_key_uuid(10)
for _ in xrange(metrics.batch_size)]
values = [generate_random_data(100, 1000)
for _ in xrange(metrics.batch_size)]
for key, value in izip(keys, values):
if not self._runnable:
return
client.set(key, value, noreply=True)
metrics.bytes_cum += len(key) + len(value)
time_st = time.time()
client.flush_pipeline()
duration = time.time() - time_st
rate = metrics.batch_size / duration
metrics.time_cum += duration
metrics.items_cum += metrics.batch_size
metrics.pct_full = self.get_pct_full(client)
metrics.time_total_cum = time.time() - time_total_st
def test_touch_noreply(self):
key = generate_random_key(8)
val = generate_random_data(10)
# expires in 3s
self.client.set(key, val, exptime=3)
time.sleep(1.5)
# keep it alive another 3s
self.client.touch(key, exptime=3, noreply=True)
time.sleep(1.5)
item = self.client.get(key)
assert val == item.value
def test_touch_noreply(self):
key = generate_random_key(8)
val = generate_random_data(10)
# expires in 3s
self.client.set(key, val, exptime=3)
time.sleep(1.5)
# keep it alive another 3s
self.client.touch(key, exptime=3, noreply=True)
time.sleep(1.5)
item = self.client.get(key)
assert val == item.value
def test_touch(self):
key = generate_random_key(8)
val = generate_random_data(10)
# try to touch an invalid key
with self.assert_raises(NotFoundError):
self.client.touch(key)
# expires in 3s
self.client.set(key, val, exptime=3)
time.sleep(1.5)
# keep it alive another 3s
# TODO: what should happen if exptime is unset?
self.client.touch(key, exptime=3)
time.sleep(1.5)
item = self.client.get(key)
assert val == item.value
def test_touch(self):
key = generate_random_key(8)
val = generate_random_data(10)
# try to touch an invalid key
with self.assert_raises(NotFoundError):
self.client.touch(key)
# expires in 3s
self.client.set(key, val, exptime=3)
time.sleep(1.5)
# keep it alive another 3s
# TODO: what should happen if exptime is unset?
self.client.touch(key, exptime=3)
time.sleep(1.5)
item = self.client.get(key)
assert val == item.value
def test_set_too_large_value(self):
key = generate_random_key(10)
val = generate_random_data(1 << 21) # 2mb, limit is 1mb
with self.assert_raises(ServerError):
self.client.set(key, val)
def test_set_too_large_value(self):
key = generate_random_key(10)
val = generate_random_data(1 << 21) # 2mb, limit is 1mb
with self.assert_raises(ServerError):
self.client.set(key, val)
def test_set_too_large_key(self):
key = generate_random_key(251) # limit is 250b
val = generate_random_data(1)
with self.assert_raises(ClientError):
self.client.set(key, val)
def test_set_too_large_key(self):
key = generate_random_key(251) # limit is 250b
val = generate_random_data(1)
with self.assert_raises(ClientError):
self.client.set(key, val)
