def test_hash_not_found_block_after_end(self):
"""
Log: check existing hash specifying datetime after interval
The Repository must fail to verify existence of a hash if a
datetime of the incorrect interval is specified.
"""
time_res_s = self.repo._config['time_res_s']
data = self.get_logging_test_data()
req = self.repo.append_log(data,
hasher_class=self.hasher_class,
hasher_config=self.hasher_kwargs)
dt = req['datetime']
n = muteacle.interval_number(dt, time_res_s)
intv_late = muteacle.interval_start(dt.year, dt.month, dt.day,
time_res_s, n + 1)
# logged data
for i in self.data:
with self.subTest(intv_late=intv_late, item=i):
result = self.repo.check_log(intv_late, i)
self.assertFalse(result)
# unlogged data
self.assertFalse(self.repo.check_log(intv_late, self.item_skipped))
def test_hash_found_interval_mid_class_change(self):
"""
Log: check existing hash using mid-interval datetime
Hashes must remain verifiable across changes in hasher
configuration.
"""
time_res_s = self.repo._config['time_res_s']
data_a = self.get_logging_test_data()
req_a = self.repo.append_log(
data_a,
hasher_class=self.repo.supported_hashers['ScryptHasher'],
hasher_config=self.hasher_kwargs_sc)
dt_a = req_a['datetime']
data_b = self.get_logging_test_data()
req_b = self.repo.append_log(
data_b,
hasher_class=self.repo.supported_hashers['PBKDF2Hasher'],
hasher_config=self.hasher_kwargs)
n = muteacle.interval_number(dt_a, time_res_s)
intv_mid = muteacle.interval_mid(dt_a.year, dt_a.month, dt_a.day,
time_res_s, n)
for i in data_a:
with self.subTest(intv_mid=intv_mid, item=i):
result = self.repo.check_log(intv_mid, i)
self.assertTrue(result)
for i in data_b:
with self.subTest(intv_mid=intv_mid, item=i):
result = self.repo.check_log(intv_mid, i)
self.assertTrue(result)
def test_hash_not_found_interval_mid_class_change(self):
"""
Log: check non-existing hash using mid-interval datetime
across changes in hasher configuration.
"""
time_res_s = self.repo._config['time_res_s']
data_a = self.get_logging_test_data()
req_a = self.repo.append_log(
data_a,
hasher_class=self.repo.supported_hashers['ScryptHasher'],
hasher_config=self.hasher_kwargs_sc)
dt_a = req_a['datetime']
data_b = self.get_logging_test_data()
req_b = self.repo.append_log(
data_b,
hasher_class=self.repo.supported_hashers['PBKDF2Hasher'],
hasher_config=self.hasher_kwargs)
n = muteacle.interval_number(dt_a, time_res_s)
intv_mid = muteacle.interval_mid(dt_a.year, dt_a.month, dt_a.day,
time_res_s, n)
result = self.repo.check_log(intv_mid, self.item_skipped)
self.assertFalse(result)
def test_hash_found_interval_mid_trs_downgrade(self):
"""
Log: check existing hash using mid-interval datetime /w trs downgrade
Hashes must be verifiable despite a change in the time_res_s
setting on the Repository. This test verifies hash recall
across downgrades of time_res_s (increasing time_res_s causes a
lower time resolution)
"""
time_res_s_a = 1
self.repo.set_config({'time_res_s': time_res_s_a})
while self.repo.pending_repo_config_datetime() is not None:
pass
data_a = self.get_logging_test_data()
req_a = self.repo.append_log(data_a,
hasher_config=self.hasher_kwargs_sc)
dt_a = req_a['datetime']
n_a = muteacle.interval_number(dt_a, time_res_s_a)
int_mid_a = muteacle.interval_mid(dt_a.year, dt_a.month, dt_a.day,
time_res_s_a, n_a)
time_res_s_b = 2
self.repo.set_config({'time_res_s': time_res_s_b})
while self.repo.pending_repo_config_datetime() is not None:
pass
data_b = self.get_logging_test_data()
req_b = self.repo.append_log(data_b,
hasher_config=self.hasher_kwargs_sc)
dt_b = req_b['datetime']
n_b = muteacle.interval_number(dt_b, time_res_s_b)
int_mid_b = muteacle.interval_mid(dt_a.year, dt_a.month, dt_a.day,
time_res_s_b, n_b)
for i in data_a:
with self.subTest(intv_mid=int_mid_a, item=i):
result = self.repo.check_log(int_mid_a, i)
self.assertTrue(result)
for i in data_b:
with self.subTest(intv_mid=int_mid_b, item=i):
result = self.repo.check_log(int_mid_b, i)
self.assertTrue(result)
# TODO: reset time_res_s
self.repo.set_config(self.repo_kwargs)
while self.repo.pending_repo_config_datetime() is not None:
pass
def test_all_time_res_s(self):
valid_values = [x for x in range(1,86401) if 86400%x == 0]
combs = combinations(valid_values, 2)
dt = datetime.utcnow()
for c in combs:
# combs should contain 2-element tuples with different valid
# values of time_res_s
with self.subTest(time_res_s_a=c[0], time_res_s_b=c[1]):
dt_ns = interval_next_common_start(dt, c[0], c[1])
na = interval_number(dt_ns, c[0])
nb = interval_number(dt_ns, c[1])
dt_ia = interval_start(
dt_ns.year, dt_ns.month, dt_ns.day, na, c[0]
)
dt_ib = interval_start(
dt_ns.year, dt_ns.month, dt_ns.day, nb, c[1]
)
self.assertEqual(dt_ia, dt_ns)
self.assertEqual(dt_ib, dt_ns)
self.assertGreater(dt_ns, dt)
def test_interval_number_24_hour_intervals(self):
time_res_s = 86400
expected_results = {
datetime(2020, 12, 25, 0, 0) : 0,
datetime(2020, 12, 25, 11, 59) : 0,
datetime(2020, 12, 25, 12, 00) : 0,
datetime(2020, 12, 25, 23, 59) : 0,
}
for k in expected_results.keys():
with self.subTest(ts=k):
intvn_out = interval_number(k, time_res_s)
intvn_expected = expected_results[k]
self.assertEqual(intvn_out, intvn_expected)
def test_hash_not_found_interval_mid_trs_upgrade(self):
"""
Log: check non-existing hash /w mid-interval datetime /w trs upgrade
Repository must confirm the absence of a hash regardless of
changes in the time_res_s setting. This test verifies test
negatives across upgrades of time_res_s (smaller time_res_s
means a finer time resolution).
"""
time_res_s_a = 2
self.repo.set_config({'time_res_s': time_res_s_a})
while self.repo.pending_repo_config_datetime() is not None:
pass
data_a = self.get_logging_test_data()
req_a = self.repo.append_log(data_a,
hasher_config=self.hasher_kwargs_sc)
dt_a = req_a['datetime']
n_a = muteacle.interval_number(dt_a, time_res_s_a)
int_mid_a = muteacle.interval_mid(dt_a.year, dt_a.month, dt_a.day,
time_res_s_a, n_a)
time_res_s_b = 1
self.repo.set_config({'time_res_s': time_res_s_b})
while self.repo.pending_repo_config_datetime() is not None:
pass
data_b = self.get_logging_test_data()
req_b = self.repo.append_log(data_b,
hasher_config=self.hasher_kwargs_sc)
dt_b = req_b['datetime']
n_b = muteacle.interval_number(dt_b, time_res_s_b)
int_mid_b = muteacle.interval_mid(dt_a.year, dt_a.month, dt_a.day,
time_res_s_b, n_b)
result_a = self.repo.check_log(int_mid_a, self.item_skipped)
self.assertFalse(result_a)
result_b = self.repo.check_log(int_mid_b, self.item_skipped)
self.assertFalse(result_b)
def test_hash_not_found_interval_end(self):
"""
Log: check non-existing hash specifying end-of-interval datetime
"""
time_res_s = self.repo._config['time_res_s']
data = self.get_logging_test_data()
req = self.repo.append_log(data,
hasher_class=self.hasher_class,
hasher_config=self.hasher_kwargs)
dt = req['datetime']
n = muteacle.interval_number(dt, time_res_s)
intv_end = muteacle.interval_end(dt.year, dt.month, dt.day, time_res_s,
n)
result = self.repo.check_log(intv_end, self.item_skipped)
self.assertFalse(result)
def test_interval_number_3_hour_intervals(self):
time_res_s = 10800
expected_results = {
datetime(2020, 12, 25, 0, 0) : 0,
datetime(2020, 12, 25, 3, 0) : 1,
datetime(2020, 12, 25, 6, 0) : 2,
datetime(2020, 12, 25, 9, 0) : 3,
datetime(2020, 12, 25, 12, 0) : 4,
datetime(2020, 12, 25, 15, 0) : 5,
datetime(2020, 12, 25, 18, 0) : 6,
datetime(2020, 12, 25, 21, 0) : 7,
datetime(2020, 12, 25, 23, 59, 59) : 7,
}
for k in expected_results.keys():
with self.subTest(ts=k):
intvn_out = interval_number(k, time_res_s)
intvn_expected = expected_results[k]
self.assertEqual(intvn_out, intvn_expected)
def test_hash_found_interval_start(self):
"""
Log: check existing hash specifying start-of-interval datetime
"""
time_res_s = self.repo._config['time_res_s']
data = self.get_logging_test_data()
req = self.repo.append_log(data,
hasher_class=self.hasher_class,
hasher_config=self.hasher_kwargs)
dt = req['datetime']
n = muteacle.interval_number(dt, time_res_s)
intv_start = muteacle.interval_start(dt.year, dt.month, dt.day,
time_res_s, n)
for i in data:
with self.subTest(intv_start=intv_start, item=i):
result = self.repo.check_log(intv_start, i)
self.assertTrue(result)
def test_get_hashers_interval_end(self):
"""
Hasher: load hashers specifying datetime at end of interval
"""
ts = datetime.utcnow().timestamp()
meta = {'test': 'get_hashers_interval_end', 'ts': ts}
time_res_s = self.repo._config['time_res_s']
muteacle.sleep_until_interval_end(time_res_s)
req = self.repo.new_hasher(config={'meta': meta})
hasher = req['hasher']
dt = req['datetime']
n = muteacle.interval_number(dt, time_res_s)
dt_end = muteacle.interval_end(dt.year, dt.month, dt.day, time_res_s,
n)
hashers_loaded = self.repo.get_hashers(dt_end)
self.assertIn(hasher, hashers_loaded)
def test_interval_number_1_second_intervals(self):
time_res_s = 1
expected_results = {
datetime(2020, 12, 25, 0, 0) : 0,
datetime(2020, 12, 25, 2, 0) : 7200,
datetime(2020, 12, 25, 4, 0) : 14400,
datetime(2020, 12, 25, 6, 0) : 21600,
datetime(2020, 12, 25, 8, 0) : 28800,
datetime(2020, 12, 25, 10, 0) : 36000,
datetime(2020, 12, 25, 12, 0) : 43200,
datetime(2020, 12, 25, 14, 0) : 50400,
datetime(2020, 12, 25, 16, 0) : 57600,
datetime(2020, 12, 25, 18, 0) : 64800,
datetime(2020, 12, 25, 20, 0) : 72000,
datetime(2020, 12, 25, 22, 0) : 79200,
datetime(2020, 12, 25, 23, 59, 59) : 86399,
}
for k in expected_results.keys():
with self.subTest(ts=k):
intvn_out = interval_number(k, time_res_s)
intvn_expected = expected_results[k]
self.assertEqual(intvn_out, intvn_expected)