def test_file_size_limit(self):
"""
Keeps inserting new keys into the database until the database reaches its limit
When no more keys are allowed to be inserted anymore, it checks the size of the database
It deletes all the keys before returning so other tests can run smoothly
"""
# Reduce to maximum limit so the test can execute efficiently
KeyValueStore._DB_SIZE_LIMIT = 30 * 1024 * 1024 # 30 Mega Bytes
store = KeyValueStore.open('test')
keys = [] # To keep track of the keys to delete later
while True:
key, value = TestKVS.get_new_key_value(store)
try:
store.create(key, value)
keys.append(key)
except Exception as e:
size = TestKVS.get_test_db_size()
db_limit = KeyValueStore._DB_SIZE_LIMIT
expression = .95 * db_limit <= size <= 1.05 * db_limit
self.assertTrue(expression)
# Delete the keys so other tests can run
deleted = 0
for key in keys:
store.delete(key)
deleted += 1
print("deleted " + str(deleted) + " keys")
return
def test_create_read(self):
"""
Creates a key and retrieves and checks that both the values are equal
"""
store = KeyValueStore.open('test')
key, value = TestKVS.get_new_key_value(store)
store.create(key, value)
returned_value = store.read(key)
self.assertEqual(value, returned_value)
def test_ttl_delete(self):
"""
Creates a key with ttl = 1
Waits for two seconds
And checks that the key is already gone by deleting it
"""
store = KeyValueStore.open('test')
key, value = TestKVS.get_new_key_value(store)
store.create(key, value, 1)
time.sleep(2)
self.assertRaises(Exception, store.delete, key)
def test_delete(self):
"""
Creates a key
Deletes it
Checks that the store raises exception on reading the key
"""
store = KeyValueStore.open('test')
key, value = TestKVS.get_new_key_value(store)
store.create(key, value)
store.delete(key)
self.assertRaises(Exception, store.read, key)
def test_another_process(self):
"""
Opens a data store and makes the other process open the same data store
Checks if we get the exception
"""
print('Testing another process access on same file')
store = KeyValueStore.open('test')
output = subprocess.check_output(
"python another_process_for_testing.py",
shell=True).decode('utf-8')
print('Other process said: ' + output)
# Assert that the exception code is as expected
self.assertEqual(100, int(json.loads(output)['Exception code']))
def test_multi_threading(self):
"""
Creates two threads
Both the threads accesses the same data store
One thread creates a key, the other thread tries to read the key and asserts the value
"""
store = KeyValueStore.open('test')
key, value = TestKVS.get_new_key_value(store)
create_thread = threading.Thread(target=TestKVS.create_key_and_wait,
args=(
key,
value,
))
read_thread = threading.Thread(target=self.wait_and_read_key,
args=(
key,
value,
))
create_thread.start()
read_thread.start()
def create_key_and_wait(cls, key, value):
"""Creates a key and waits for 1 second"""
store = KeyValueStore.open('test')
store.create(key, value)
time.sleep(1)
def wait_and_read_key(self, key, value):
"""Waits for half a second and reads the given key and asserts the value"""
store = KeyValueStore.open('test')
time.sleep(0.5)
self.assertEqual(value, store.read(key))
from kvs import KeyValueStore
store = KeyValueStore.open('haris')
while True:
print("c-> Create")
print("r-> Read")
print("d-> Delete")
choice = input()
if choice == 'c':
print(
"Enter key, value(only a string and not JSON object), and ttl (space separated)"
)
key, value, ttl = input().split()
value = {'value': value}
try:
store.create(key, value, ttl)
except Exception as e:
print(e)
elif choice == 'r':
print("Enter key")
key = input()
try:
value = store.read(key)
print(value)
except Exception as e:
print(e)
from kvs import KeyValueStore
import json
"""
Only meant for testing
Opens the data store named test that would be generated while tests are being executed
If test is successful, opening test from here should raise an exception
"""
try:
store = KeyValueStore.open('test')
except Exception as e:
json_object = {"Exception message": e.args[0], "Exception code": e.args[1]}
print(json.dumps(json_object))