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_incr_over_size(self):
key = generate_random_key(10)
val = str(1 << 64) # cannot store in 64 bits
self.client.set(key, val)
with self.assert_raises(ClientError):
self.client.incr(key) # not treated as a number
def test_decr_underflow(self):
key = generate_random_key(10)
val = '0'
self.client.set(key, val)
val2 = self.client.decr(key)
assert int(val) == int(val2)
def test_decr_underflow(self):
key = generate_random_key(10)
val = '0'
self.client.set(key, val)
val2 = self.client.decr(key)
assert int(val) == int(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_incr_over_size(self):
key = generate_random_key(10)
val = str(1 << 64) # cannot store in 64 bits
self.client.set(key, val)
with self.assert_raises(ClientError):
self.client.incr(key) # not treated as a number
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_incr_noreply(self):
key = generate_random_key(10)
val = '1'
self.client.set(key, val)
self.client.incr(key, noreply=True)
item = self.client.get(key)
assert int(val) + 1 == int(item.value)
def test_incr_overflow(self):
key = generate_random_key(10)
val = str((1 << 64) - 1)
# set max unsigned 64bit value - overflows to 0
self.client.set(key, val)
val2 = self.client.incr(key)
assert val2 == str(0)
def test_incr_overflow(self):
key = generate_random_key(10)
val = str((1 << 64) - 1)
# set max unsigned 64bit value - overflows to 0
self.client.set(key, val)
val2 = self.client.incr(key)
assert val2 == str(0)
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_incr_noreply(self):
key = generate_random_key(10)
val = '1'
self.client.set(key, val)
self.client.incr(key, noreply=True)
item = self.client.get(key)
assert int(val) + 1 == int(item.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_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_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_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_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_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_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_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_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_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_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_incr(self):
key = generate_random_key(10)
val = '1'
# try to incr an invalid key
with self.assert_raises(NotFoundError):
self.client.incr(key)
self.client.set(key, val)
val2 = self.client.incr(key, '40')
assert int(val) + 40 == int(val2)
def test_incr(self):
key = generate_random_key(10)
val = '1'
# try to incr an invalid key
with self.assert_raises(NotFoundError):
self.client.incr(key)
self.client.set(key, val)
val2 = self.client.incr(key, '40')
assert int(val) + 40 == int(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_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_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_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_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_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_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_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_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 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_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_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_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_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_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_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_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_get_invalid_key(self):
key = generate_random_key(10)
self.client.delete(key, noreply=True)
with self.assert_raises(NotFoundError):
item = self.client.get(key)
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_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_get_invalid_key(self):
key = generate_random_key(10)
self.client.delete(key, noreply=True)
with self.assert_raises(NotFoundError):
item = self.client.get(key)
