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)