def test_readonly_preexist_complete(
self,
name: str,
mapping: CacheDictMapping,
extra: Extra,
):
c = CacheDict.open_readonly(
path=f"{self.tmp_dir}/{name}.readonly.sqlite",
mapping=mapping,
sqlite_params=extra.sqlite_params,
)
if extra.preexisting:
preexist = extra.preexisting
else:
preexist = {}
item_count = 0
for (actual_key, actual_value) in c.items():
with self.subTest(actual_key=actual_key, actual_value=actual_value):
in_preexist = (actual_key, actual_value) in preexist.items()
self.assertTrue(in_preexist, "Missing key/value in preexisting items")
item_count += 1
preexist_present_count = sum(
1 for x in preexist.values() if x is not NOT_PRESENT
)
self.assertEqual(item_count, preexist_present_count)
self.assertEqual(len(c), preexist_present_count)
def test_readonly_preexist_get(
self,
name: str,
mapping: CacheDictMapping,
extra: Extra,
):
c = CacheDict.open_readonly(
path=f"{self.tmp_dir}/{name}.readonly.sqlite",
mapping=mapping,
sqlite_params=extra.sqlite_params,
)
if extra.preexisting:
preexist = extra.preexisting
else:
preexist = {}
missing_value = "MISSING_VALUE_MARKER"
for (key, expected) in preexist.items():
with self.subTest(key=key, expected=expected):
if expected is not NOT_PRESENT:
actual_value = c.get(key, missing_value)
self.assertIsNot(actual_value, missing_value)
self.assertEqual(actual_value, expected)
else:
actual_value = c.get(key, missing_value)
self.assertIs(actual_value, missing_value)
def test_readonly_iter(self, name: str, mapping: CacheDictMapping, extra: Extra):
c = CacheDict.open_readonly(
path=f"{self.tmp_dir}/{name}.readonly.sqlite",
mapping=mapping,
sqlite_params=extra.sqlite_params,
)
key_count = 0
for _ in iter(c):
key_count += 1
self.assertEqual(key_count, len(c))
def test_create_from_connection_noargs(
self,
name: str,
mapping: CacheDictMapping,
extra: Extra,
):
conn = sqlite3.connect("")
c = CacheDict._create_from_conn(
conn=conn,
mapping=mapping,
)
self.assertNotEqual(c, None)
def test_readonly_update_none(
self,
name: str,
mapping: CacheDictMapping,
extra: Extra,
):
c = CacheDict.open_readonly(
path=f"{self.tmp_dir}/{name}.readonly.sqlite",
mapping=mapping,
sqlite_params=extra.sqlite_params,
)
c.update()
def test_readonly_pop(
self,
name: str,
mapping: CacheDictMapping,
extra: Extra,
):
c = CacheDict.open_readonly(
path=f"{self.tmp_dir}/{name}.readonly.sqlite",
mapping=mapping,
sqlite_params=extra.sqlite_params,
)
if extra.preexisting:
preexist = extra.preexisting
else:
preexist = {}
for (key, expected) in preexist.items():
with self.subTest(key=key, expected=expected):
if expected is not NOT_PRESENT:
actual_value = c.get(key)
self.assertEqual(actual_value, expected)
with self.assertRaises(SqliteCachingException) as raised_context:
_ = c.pop(key)
actual: typing.Any = raised_context.exception
self.assertEqual(
actual.category.id,
CacheDictReadOnlyException.category_id,
actual.msg,
)
self.assertEqual(
actual.cause.id,
CacheDictReadOnlyException.id,
actual.msg,
)
else:
actual_value = c.get(key)
self.assertIsNone(actual_value)
with self.assertRaises(KeyError) as raised_context_keyerror:
_ = c.pop(key)
actual_ex: typing.Any = raised_context_keyerror.exception
self.assertIsInstance(actual_ex, SqliteCachingException)
self.assertEqual(
actual_ex.category.id,
CacheDictNoSuchKeyException.category_id,
actual_ex.msg,
)
self.assertEqual(
actual_ex.cause.id,
CacheDictNoSuchKeyException.id,
actual_ex.msg,
)
def test_open_readwrite_create(
self,
name: str,
mapping: CacheDictMapping,
extra: Extra,
):
c = CacheDict.open_readwrite(
path=f"{self.tmp_dir}/{name}.create.sqlite",
mapping=mapping,
create=ToCreate.DATABASE,
sqlite_params=extra.sqlite_params,
)
self.assertNotEqual(c, None)
def test_readonly_preexist(
self,
name: str,
mapping: CacheDictMapping,
extra: Extra,
):
c = CacheDict.open_readonly(
path=f"{self.tmp_dir}/{name}.readonly.sqlite",
mapping=mapping,
sqlite_params=extra.sqlite_params,
)
if extra.preexisting:
preexist = extra.preexisting
else:
preexist = {}
for (key, expected) in preexist.items():
with self.subTest(key=key, expected=expected):
if expected is not NOT_PRESENT:
actual_value = c[key]
self.assertEqual(actual_value, expected)
actual_present = key in c
self.assertTrue(actual_present)
actual_missing = key not in c
self.assertFalse(actual_missing)
else:
actual_present = key in c
self.assertFalse(actual_present)
actual_missing = key not in c
self.assertTrue(actual_missing)
with self.assertRaises(KeyError) as raised_context:
_ = c[key]
actual: typing.Any = raised_context.exception
self.assertIsInstance(actual, SqliteCachingException)
self.assertEqual(
actual.category.id,
CacheDictNoSuchKeyException.category_id,
actual.msg,
)
self.assertEqual(
actual.cause.id,
CacheDictNoSuchKeyException.id,
actual.msg,
)
def test_readonly_preexist_bool(
self,
name: str,
mapping: CacheDictMapping,
extra: Extra,
):
c = CacheDict.open_readonly(
path=f"{self.tmp_dir}/{name}.readonly.sqlite",
mapping=mapping,
sqlite_params=extra.sqlite_params,
)
actual = bool(c)
if extra.preexisting:
self.assertTrue(actual)
else:
self.assertFalse(actual)
def test_readonly_setdefault(
self,
name: str,
mapping: CacheDictMapping,
extra: Extra,
):
c = CacheDict.open_readonly(
path=f"{self.tmp_dir}/{name}.readonly.sqlite",
mapping=mapping,
sqlite_params=extra.sqlite_params,
)
if extra.preexisting:
preexist = extra.preexisting
else:
preexist = {}
missing_value = self._create_missing_value(mapping)
for (key, expected) in preexist.items():
with self.subTest(key=key, expected=expected):
if expected is not NOT_PRESENT:
actual_value = c.get(key)
self.assertIsNot(actual_value, missing_value)
self.assertEqual(actual_value, expected)
actual_value = c.setdefault(key, missing_value)
self.assertIsNot(actual_value, missing_value)
self.assertEqual(actual_value, expected)
else:
actual_value = c.get(key)
self.assertIsNone(actual_value)
with self.assertRaises(SqliteCachingException) as raised_context:
_ = c.setdefault(key, missing_value)
actual: typing.Any = raised_context.exception
self.assertEqual(
actual.category.id,
CacheDictReadOnlyException.category_id,
actual.msg,
)
self.assertEqual(
actual.cause.id,
CacheDictReadOnlyException.id,
actual.msg,
)
def test_open_readwrite(self, name: str, mapping: CacheDictMapping, extra: Extra):
c = CacheDict.open_readwrite(
path=f"{self.tmp_dir}/{name}.readwrite.sqlite",
mapping=mapping,
sqlite_params=extra.sqlite_params,
)
if extra.preexisting:
preexist = extra.preexisting
else:
preexist = {}
for (key, expected) in preexist.items():
with self.subTest(key=key, expected=expected):
if expected is not NOT_PRESENT:
actual = c[key]
self.assertEqual(actual, expected)
else:
with self.assertRaises(KeyError) as raised_context:
_ = c[key]
_ = raised_context.exception
self.assertNotEqual(c, None)
def test_readonly_update_kwargs(
self,
name: str,
mapping: CacheDictMapping,
extra: Extra,
):
c = CacheDict.open_readonly(
path=f"{self.tmp_dir}/{name}.readonly.sqlite",
mapping=mapping,
sqlite_params=extra.sqlite_params,
)
with self.assertRaises(SqliteCachingException) as raised_context:
c.update(x="a")
actual = raised_context.exception
self.assertEqual(
actual.category.id,
CacheDictUpdateKwargsException.category_id,
actual.msg,
)
self.assertEqual(
actual.cause.id,
CacheDictUpdateKwargsException.id,
actual.msg,
)
def test_readonly_update_mapping(
self,
name: str,
mapping: CacheDictMapping,
extra: Extra,
):
c = CacheDict.open_readonly(
path=f"{self.tmp_dir}/{name}.readonly.sqlite",
mapping=mapping,
sqlite_params=extra.sqlite_params,
)
with self.assertRaises(SqliteCachingException) as raised_context:
c.update({k: v for k, v in extra.updates})
actual: typing.Any = raised_context.exception
self.assertEqual(
actual.category.id,
CacheDictReadOnlyException.category_id,
actual.msg,
)
self.assertEqual(
actual.cause.id,
CacheDictReadOnlyException.id,
actual.msg,
)
def test_open_anon_disk(self, name: str, mapping: CacheDictMapping, extra: Extra):
c = CacheDict.open_anon_disk(
mapping=mapping,
sqlite_params=extra.sqlite_params,
)
self.assertNotEqual(c, None)