def test_throws_exception_on_start_when_path_is_wrong_type(self):
db = None
with self.assertRaises(pmemkv.Error):
db = Database(self.engine, {"path":1234, "size": 1073741824})
with self.assertRaises(pmemkv.ConfigTypeError):
db = Database(self.engine, {"path":1234, "size": 1073741824})
self.assertEqual(db, None)
def test_get_same_element_two_times(self):
db = Database(self.engine, self.config)
db['dict_test'] = "123"
val1 = db['dict_test']
val2 = db['dict_test']
self.assertEqual(val1, val2)
db.stop()
def test_dict_get_item(self):
db = Database(self.engine, self.config)
key = "dict_test"
db[key] = "123"
temp = db[key]
self.assertEqual(temp, "123")
db.stop()
def test_delete_same_element_two_times(self):
db = Database(self.engine, self.config)
db['dict_test'] = "123"
del db['dict_test']
with self.assertRaises(KeyError):
del db['dict_test']
db.stop()
def test_dict_item_del(self):
db = Database(self.engine, self.config)
db['dict_test'] = "123"
del db['dict_test']
with self.assertRaises(KeyError):
temp = db['dict_test']
db.stop()
def test_throws_exception_on_start_when_engine_is_invalid(self):
db = None
with self.assertRaises(pmemkv.Error):
db = Database(r"nope.nope", self.config)
with self.assertRaises(pmemkv.WrongEngineName):
db = Database(r"nope.nope", self.config)
self.assertEqual(db, None)
def test_throws_exception_on_start_when_config_is_empty(self):
db = None
with self.assertRaises(pmemkv.Error):
db = Database(self.engine, {})
""" InvalidArgument is for consistency with pmemkv interface
reference in pmemkv test: basic_tests/PmemkvCApiTest.NullConfig
"""
with self.assertRaises(pmemkv.InvalidArgument):
db = Database(self.engine, {})
def test_puts_basic_values(self):
db = Database(self.engine, self.config)
self.assertFalse(db.exists(r"key1"))
db.put(r"key1", r"value1")
self.assertTrue(db.exists(r"key1"))
self.assertEqual(db.get_string(r"key1"), r"value1")
db.stop()
def test_puts_utf8_key(self):
db = Database(self.engine, self.config)
val = r"to remember, note, record"
db.put(r"记", val)
self.assertTrue(db.exists(r"记"))
self.assertEqual(db.get_string(r"记"), val)
db.stop()
def test_stops_engine_multiple_times(self):
db = Database(self.engine, self.config)
self.assertFalse(db.stopped)
db.stop()
self.assertTrue(db.stopped)
db.stop()
self.assertTrue(db.stopped)
db.stop()
self.assertTrue(db.stopped)
def test_databases_interference(self):
db1 = Database(self.engine, self.config)
db2 = Database(self.engine, self.config)
db1['1'] = "A"
db2['2'] = "B"
with self.assertRaises(KeyError):
temp = db2['1']
db1.stop()
db2.stop()
def test_throws_exception_on_start_when_config_is_empty(self):
db = None
try:
db = Database(self.engine, "{}")
self.assertFalse(True)
except ValueError as ve:
self.assertEqual(ve.args[0], "pmemkv_open failed")
self.assertEqual(db, None)
def test_throws_exception_in_context_manager(self):
class TestException(Exception):
pass
def callback(val):
raise TestException()
key = "dict_test"
val = "123"
with Database(self.engine, self.config) as db:
db[key] = val
with self.assertRaises(TestException):
db.get(key, callback)
with self.assertRaises(TestException):
with Database(self.engine, self.config) as db:
db[key] = val
db.get(key, callback)
def test_throws_exception_on_start_when_engine_is_invalid(self):
db = None
try:
db = Database(r"nope.nope", self.config)
self.assertFalse(True)
except ValueError as ve:
self.assertEqual(ve.args[0], "pmemkv_open failed")
self.assertEqual(db, None)
def test_throws_exception_on_start_when_path_is_wrong_type(self):
db = None
try:
db = Database(self.engine, '{"path":1234}')
self.assertFalse(True)
except ValueError as ve:
self.assertEqual(ve.args[0], "pmemkv_open failed")
self.assertEqual(db, None)
def test_get_lambda_in_callback(self):
key = "dict_test"
val = "123"
db = Database(self.engine, self.config)
db[key] = val
db.get(key, lambda v, k=key: self.assertEqual(memoryview(v).tobytes(),
"123".encode('utf-8')))
db.get(key, lambda v, k=key: self.assertEqual(k, "dict_test"))
db.stop()
def test_get_out_of_bound_access_in_callback(self):
key = "dict_test"
val = "123"
db = Database(self.engine, self.config)
db[key] = val
with self.assertRaises(IndexError):
db.get(key, lambda v: memoryview(v).tobytes()[4])
with self.assertRaises(TypeError):
db.get(key, lambda v: memoryview(v)[1])
db.stop()
def test_exception_on_start_when_config_is_malformed(self):
db = None
try:
db = Database(self.engine, "{")
self.assertFalse(True)
except ValueError as ve:
self.assertEqual(
ve.args[0], "Creating a pmemkv config from JSON string failed")
self.assertEqual(db, None)
def test_uses_get_keys(self):
db = Database(self.engine, self.config)
db.put(r"1", r"one")
db.put(r"2", r"two")
self.formatter = r"<{}>,"
self.key = r""
db.get_keys(self.all_and_each)
self.assertEqual(self.key_and_value, r"<1>,<2>,")
db.stop()
def test_throws_exception_on_start_when_path_is_invalid(self):
db = None
with self.assertRaises(pmemkv.Error):
db = Database(self.engine, {"path":"/tmp/123/234/345/456/567/678/nope.nope", "size": 1073741824})
""" This part need to be commented out due to pmemkv issue
https://github.com/pmem/pmemkv/issues/565
with self.assertRaises(pmemkv.InvalidArgument):
db = Database(self.engine, {"path":"/tmp/123/234/345/456/567/678/nope.nope", "size": 1073741824})
"""
self.assertEqual(db, None)
def test_throws_exception_on_start_when_path_is_invalid(self):
db = None
try:
db = Database(
self.engine,
"{\"path\":\"/tmp/123/234/345/456/567/678/nope.nope\"}")
self.assertFalse(True)
except ValueError as ve:
self.assertEqual(ve.args[0], "pmemkv_open failed")
self.assertEqual(db, None)
def test_get_exception_in_callback(self):
class LocalException(Exception):
pass
def callback(key):
raise LocalException('TestException')
db = Database(self.engine, self.config)
key = "dict_test"
val = "123"
db[key] = val
try:
db.get(key, callback)
except LocalException as e:
db.stop()
self.assertEqual(type(e).__name__ , "LocalException")
db.stop()
def test_get_assert_in_callback(self):
def callback (key):
self.assertEqual(memoryview(key).tobytes(), "123".encode('utf-8'))
key = "dict_test"
val = "123"
db = Database(self.engine, self.config)
db[key] = val
db.get(key, callback)
db.stop()
def test_stop_engine_multiple_times(self):
""" In case of failure, this test cause segmentation fault.
As there is no way to catch segmentation fault in python, just do not
assert anything.
"""
db = Database(self.engine, self.config)
db.stop()
db.stop()
db.stop()
def test_get_with_value_indexing(self):
key = "dict_test"
val = "123"
db = Database(self.engine, self.config)
db[key] = val
db.get(key,
lambda v, k=key: self.assertEqual(
(memoryview(v)[0:2]).tobytes(), "12".encode('utf-8')))
db.stop()
def test_get_copy_to_class_member(self):
class Callback:
def __init__(self):
self.result = None
def __call__(self, key):
self.result = bytes(key)
callback = Callback()
db = Database(self.engine, self.config)
key = "dict_test"
val = "123"
db[key] = val
db.get(key, callback)
db.remove(key)
db[key] = "Some other string"
self.assertEqual(callback.result.decode(), val)
db.stop()
def test_get_AttributeError_in_callback(self):
def callback (key):
self.assertEqual(key.NonexistentMethod(), "123".encode('utf-8'))
key = "dict_test"
val = "123"
db = Database(self.engine, self.config)
db[key] = val
try:
db.get(key, callback)
except Exception as e:
assert type(e).__name__ == "AttributeError"
db.stop()
def test_get_copy_to_class_member(self):
class Callback:
def __init__(self):
self.result = None
def __call__(self, key):
self.result = memoryview(key)
callback = Callback()
db = Database(self.engine, self.config)
key = "dict_test"
val = "123"
db[key] = val
db.get(key, callback)
self.assertEqual(callback.result.tobytes(), "123".encode('utf-8'))
db.stop()
def test_call_del_inside_callback(self):
def callback(val):
del(val)
# check if buffer protocol object was properly removed
with self.assertRaises(UnboundLocalError):
del(val)
key = "dict_test"
val = "123"
db = Database(self.engine, self.config)
db[key] = val
db.get(key, callback)
# check if key is accessable
self.assertEqual(db[key], val)
db.stop()
def test_gets_missing_key(self):
db = Database(self.engine, self.config)
self.assertFalse(db.exists(r"key1"))
with self.assertRaises(KeyError):
db.get_string(r"key1")
db.stop()
