def test_full_coverage(self):
manager = HuntManager(**manager_kwargs())
hunt = default_hunt(time_range=create_timedelta('01:00:00'),
frequency=create_timedelta('01:00:00'))
manager.add_hunt(hunt)
# first test that the start time and end time are correct for normal operation
# for first-time hunt execution
self.assertTrue(hunt.ready)
# now put the last time we executed to 5 minutes ago
# ready should return False
hunt.last_executed_time = local_time() - datetime.timedelta(minutes=5)
self.assertFalse(hunt.ready)
# now put the last time we executed to 65 minutes ago
# ready should return True
hunt.last_executed_time = local_time() - datetime.timedelta(minutes=65)
self.assertTrue(hunt.ready)
# set the last time we executed to 3 hours ago
hunt.last_executed_time = local_time() - datetime.timedelta(hours=3)
# and the last end date to 2 hours ago
hunt.last_end_time = local_time() - datetime.timedelta(hours=2)
# so now we have 2 hours to cover under full coverage
# ready should return True, start should be 3 hours ago and end should be 2 hours ago
self.assertTrue(hunt.ready)
self.assertEquals(hunt.start_time, hunt.last_end_time)
self.assertEquals(hunt.end_time, hunt.last_end_time + hunt.time_range)
#logging.info(f"MARKER: start {hunt.start_time} end {hunt.end_time} comp {hunt.end_time - hunt.start_time} >= {hunt.time_range}")
# now let's pretend that we just executed that
# at this point, the last_end_time becomes the end_time
hunt.last_end_time = hunt.end_time
# and the last_executed_time becomes now
hunt.last_executed_time = local_time()
# at this point the hunt should still be ready because we're not caught up yet
self.assertTrue(hunt.ready)
# now give the hunt the ability to cover 2 hours instead of 1 to get caught up
hunt.max_time_range = create_timedelta('02:00:00')
# set the last time we executed to 3 hours ago
hunt.last_executed_time = local_time() - datetime.timedelta(hours=3)
# and the last end date to 2 hours ago
hunt.last_end_time = local_time() - datetime.timedelta(hours=2)
# now the difference between the stop and stop should be 2 hours instead of one
#logging.info(f"MARKER: start {hunt.start_time} end {hunt.end_time} comp {hunt.end_time - hunt.start_time} >= {hunt.time_range}")
self.assertTrue(hunt.end_time - hunt.start_time >= hunt.max_time_range)
# set the last time we executed to 3 hours ago
hunt.last_executed_time = local_time() - datetime.timedelta(hours=3)
# and the last end date to 2 hours ago
hunt.last_end_time = local_time() - datetime.timedelta(hours=2)
# so now we have 2 hours to cover but let's turn off full coverage
hunt.full_coverage = False
# it should be ready to run
self.assertTrue(hunt.ready)
def test_offset(self):
manager = HuntManager(**manager_kwargs())
hunt = default_hunt(time_range=create_timedelta('01:00:00'),
frequency=create_timedelta('01:00:00'),
offset=create_timedelta('00:30:00'))
manager.add_hunt(hunt)
# set the last time we executed to 3 hours ago
hunt.last_executed_time = local_time() - datetime.timedelta(hours=3)
# and the last end date to 2 hours ago
target_start_time = hunt.last_end_time = local_time(
) - datetime.timedelta(hours=2)
self.assertTrue(hunt.ready)
hunt.execute()
# the times passed to hunt.execute_query should be 30 minutes offset
self.assertEquals(target_start_time - hunt.offset,
hunt.exec_start_time)
self.assertEquals(hunt.last_end_time - hunt.offset, hunt.exec_end_time)
def test_hunt_persistence(self):
hunter = HuntManager(**manager_kwargs())
hunter.add_hunt(default_hunt())
hunter.hunts[0].last_executed_time = datetime.datetime(
2019, 12, 10, 8, 21, 13)
with open_hunt_db(hunter.hunts[0].type) as db:
c = db.cursor()
c.execute(
"""SELECT last_executed_time FROM hunt WHERE hunt_name = ?""",
(hunter.hunts[0].name, ))
row = c.fetchone()
self.assertIsNotNone(row)
last_executed_time = row[0]
self.assertTrue(isinstance(last_executed_time, datetime.datetime))
self.assertEquals(last_executed_time.year, 2019)
self.assertEquals(last_executed_time.month, 12)
self.assertEquals(last_executed_time.day, 10)
self.assertEquals(last_executed_time.hour, 8)
self.assertEquals(last_executed_time.minute, 21)
self.assertEquals(last_executed_time.second, 13)
def test_hunt_order(self):
hunter = HuntManager(**manager_kwargs())
# test initial hunt order
# these are added in the wrong order but the should be sorted when we access them
hunter.add_hunt(
default_hunt(name='test_hunt_3',
frequency=create_timedelta('00:30')))
hunter.add_hunt(
default_hunt(name='test_hunt_2',
frequency=create_timedelta('00:20')))
hunter.add_hunt(
default_hunt(name='test_hunt_1',
frequency=create_timedelta('00:10')))
# assume we've executed all of these hunts
for hunt in hunter.hunts:
hunt.last_executed_time = datetime.datetime.now()
# now they should be in this order
self.assertEquals(hunter.hunts[0].name, 'test_hunt_1')
self.assertEquals(hunter.hunts[1].name, 'test_hunt_2')
self.assertEquals(hunter.hunts[2].name, 'test_hunt_3')
def test_remove_hunt(self):
hunter = HuntManager(**manager_kwargs())
hunt = hunter.add_hunt(default_hunt())
removed = hunter.remove_hunt(hunt)
self.assertEquals(hunt.name, removed.name)
self.assertEquals(len(hunter.hunts), 0)
def test_add_duplicate_hunt(self):
# should not be allowed to add a hunt that already exists
hunter = HuntManager(**manager_kwargs())
hunter.add_hunt(default_hunt())
with self.assertRaises(KeyError):
hunter.add_hunt(default_hunt())
def test_add_hunt(self):
hunter = HuntManager(**manager_kwargs())
hunter.add_hunt(default_hunt())
self.assertEquals(len(hunter.hunts), 1)
