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