def testDBtruncate(self): ''' Test that the DB tables correctly truncate ''' # Truncate the tables self.prepare_db() teal = Teal('data/aaaa_assumptions_test/minimal.conf', 'stderr', msgLevel=self.msglevel, data_only=True, commit_alerts=False, commit_checkpoints=False) self.dbi = registry.get_service(SERVICE_DB_INTERFACE) self.cnxn = self.dbi.get_connection() self.cursor = self.cnxn.cursor() # Check the tables self._check_rows(db_interface.TABLE_EVENT_LOG, 0) self._check_rows(db_interface.TABLE_ALERT_LOG, 0) self._check_rows(db_interface.TABLE_ALERT2ALERT, 0) self._check_rows(db_interface.TABLE_CHECKPOINT, 0) self.cnxn.close() teal.shutdown() teal = Teal('data/aaaa_assumptions_test/minimal.conf', 'stderr', msgLevel=self.msglevel) self.dbi = registry.get_service(SERVICE_DB_INTERFACE) self.cnxn = self.dbi.get_connection() self.cursor = self.cnxn.cursor() # Check the tables self._check_rows(db_interface.TABLE_EVENT_LOG, 0) self._check_rows(db_interface.TABLE_ALERT_LOG, 0) self._check_rows(db_interface.TABLE_ALERT2ALERT, 0) self._check_rows(db_interface.TABLE_CHECKPOINT, 1) self.cnxn.close() teal.shutdown()
class TealTestDemoEventQ(TealTestCase): '''Test the demo configuration ''' def testDemo1EventQ(self): '''Test that the first demo flow works -- Inject Event Q''' self.teal = Teal('data/teal_test/configurationtest_05_auto.conf', 'stderr', msgLevel=self.msglevel, commit_alerts=False, commit_checkpoints=False, run_mode=TEAL_RUN_MODE_HISTORIC) j_in = Journal('j_in', file='data/demo/data_sample_demo_NEW_001.json') j_out_aaq = Journal('j_out_aaq') j_out_dq = Journal('j_out_dq') j_out_lis = Journal('j_out_lis') q_in = registry.get_service(SERVICE_EVENT_Q) q_out_aaq = registry.get_service(SERVICE_ALERT_ANALYZER_Q) q_out_dq = registry.get_service(SERVICE_ALERT_DELIVERY_Q) q_out_dq.register_listener(j_out_dq) q_out_aaq.register_listener(j_out_aaq) listeners = get_service(SERVICE_ALERT_DELIVERY).listeners for listener in listeners: if listener.get_name() == 'outputJournal': j_out_lis = listener.journal j_in.inject_queue(q_in) self.assertTrue(j_out_lis.wait_for_entries(3)) j_exp_aaq = Journal('j_exp_aaq', 'data/teal_test/data_sample_demo_NEW_001_AAQ_Result.json') self.assertTrue(j_out_aaq.deep_match(j_exp_aaq, ignore_delay=True, ignore_times=True)) j_exp_dq = Journal('j_exp_dq', 'data/teal_test/data_sample_demo_NEW_001_DQ_Result.json') self.assertTrue(j_out_dq.deep_match(j_exp_dq, ignore_delay=True, ignore_times=True)) j_exp_lis = Journal('j_exp_lis', 'data/teal_test/data_sample_demo_NEW_001_LIS_Result.json') self.assertTrue(j_out_lis.deep_match(j_exp_lis, ignore_delay=True, ignore_times=True)) q_out_aaq.unregister_listener(j_out_aaq) q_out_dq.unregister_listener(j_out_dq) self.teal.shutdown()
class JournalTest(TealTestCase): def setUp(self): self.teal = Teal('data/common/configurationtest.conf', 'stderr', msgLevel=self.msglevel, commit_alerts=False, commit_checkpoints=False) def tearDown(self): self.teal.shutdown() def testJournalLoadSave(self): ''' Test loading and saving a json file ''' Journal('test journal', file='data/journal_test/data_sample_001_NEW.json') # TODO: Clean up the file after it gets created #j.save('data/journal_test/data_sample_001_NEW_AUTO_OUT.json') return def testJournalQueue(self): ''' Test injecting the Journal through a queue''' lq = ListenableQueue('test journal queue') j = Journal('test journal -- input', file='data/journal_test/data_sample_001_NEW.json') j_rec = Journal('j_rec -- output') lq.register_listener(j_rec) j.inject_queue(lq) while len(j) != len(j_rec): # p rint ('waiting for queue to process %s of %s' % (str(len(j_rec)), str(len(j)))) sleep(1.0) #p rint j #p rint j_rec self.assertTrue(j.deep_match(j)) self.assertTrue(j.deep_match(j_rec, ignore_delay=True)) return
class AlertTestDuplicateSupport(TealTestCase): def testDisableDup(self): ''' Test That disable dup works''' self.teal = Teal('data/common/configurationtest.conf', 'stderr', msgLevel=self.msglevel, commit_alerts=False, commit_checkpoints=False) am = get_service(SERVICE_ALERT_MGR) self.assertEqual(len(am.in_mem_alerts), 0) self.assertEqual(len(am.in_mem_alerts_duplicate), 0) self.assertEqual(len(am.active_alerts_open), 0) create_teal_alert('XXXXXXXX', 'no reason at all', 'medium well', loc_instance="YYY") self.assertEqual(len(am.in_mem_alerts), 1) self.assertEqual(len(am.in_mem_alerts_duplicate), 0) self.assertEqual(len(am.active_alerts_open), 1) create_teal_alert('XXXXXXXX', 'no reason at all', 'medium well', loc_instance="YYY") self.assertEqual(len(am.in_mem_alerts), 2) self.assertEqual(len(am.in_mem_alerts_duplicate), 1) self.assertEqual(len(am.active_alerts_open), 1) create_teal_alert('XXXXXXXX', 'no reason at all', 'medium well', loc_instance="YYY", disable_dup=True) self.assertEqual(len(am.in_mem_alerts), 3) self.assertEqual(len(am.in_mem_alerts_duplicate), 1) self.assertEqual(len(am.active_alerts_open), 2) create_teal_alert('XXXXXXXX', 'no reason at all', 'medium well', loc_instance="YYY", disable_dup=True) self.assertEqual(len(am.in_mem_alerts), 4) self.assertEqual(len(am.in_mem_alerts_duplicate), 1) self.assertEqual(len(am.active_alerts_open), 3) create_teal_alert('XXXXXXXX', 'no reason at all', 'medium well', loc_instance="YYY") self.assertEqual(len(am.in_mem_alerts), 5) self.assertEqual(len(am.in_mem_alerts_duplicate), 2) self.assertEqual(len(am.active_alerts_open), 3) self.teal.shutdown() return
class JournalTestWithOptionalData(TealTestCase): def setUp(self): self.teal = Teal('data/common/configurationtest.conf', 'stderr', msgLevel=self.msglevel, commit_alerts=False, commit_checkpoints=False) def tearDown(self): self.teal.shutdown() # def testJournalLoadSave(self): # ''' Test loading and saving a json file with optional fields. ''' # j = Journal('test journal', file='data/journal_test/data_sample_002_NEW.json') # j.save('data/journal_test/data_sample_002_NEW_AUTO_OUT.json') # return def testJournalQueue(self): ''' Test injecting a Journal containing optional fields through a queue''' lq = ListenableQueue('test journal queue') j = Journal('test journal', file='data/journal_test/data_sample_002_NEW.json') j_rec = Journal('j_rec') lq.register_listener(j_rec) j.inject_queue(lq) while len(j) != len(j_rec): # p rint ('waiting for queue to process %s of %s' % (str(len(j_rec)), str(len(j)))) sleep(1.0) #p rint j #p rint j_rec self.assertTrue(j.deep_match(j)) self.assertTrue(j.deep_match(j_rec, ignore_delay=True)) return
def testHistoricOnlyHistoric(self): ''' Verify that the historic monitor can only be run in historic mode ''' self.assertRaisesTealError(TealError, "Historic monitor can only enabled for historic use. Unsupported value specified: realtime", Teal, 'data/teal_test/bad_hist_mon_01.conf', 'stderr', self.msglevel, 'now', 'realtime') self.assertRaisesTealError(TealError, "Historic monitor can only enabled for historic use. Unsupported value specified: all", Teal, 'data/teal_test/bad_hist_mon_02.conf', 'stderr', self.msglevel, 'now', 'historic') # Should run ... clear the DB and run it with no events, so nothing will happen self.prepare_db() teal = Teal('data/teal_test/bad_hist_mon_03.conf', 'stderr', self.msglevel, 'now', 'historic') teal.shutdown()
def testEnabledHistoric(self): ''' Verify that historic indicator on enabled plug-in control works ''' teal = Teal('data/teal_test/good_01.conf', 'stderr', msgLevel=self.msglevel, run_mode='historic', commit_alerts=False, commit_checkpoints=False) event_q_lsrs = registry.get_service(SERVICE_EVENT_Q).listener_methods self.assertEquals(len(event_q_lsrs), 1) names = [] for lsr_m in event_q_lsrs: names.append(lsr_m.__self__.get_name()) self.assertTrue('AnalyzerTest055a' in names) teal.shutdown()
def setUp(self): global VFYRULE t = Teal('data/tlcommands_test/test.conf',data_only=True) teal_path = registry.get_service(registry.TEAL_ROOT_DIR) VFYRULE = os.path.join(teal_path,'bin/tlvfyrule') t.shutdown() tmp_data_dir = os.path.join(os.environ.get('TEAL_ROOT_DIR','/opt/teal'),'data') self.teal_data_dir = self.force_env('TEAL_DATA_DIR', tmp_data_dir) return
class TealTestDemoDB(TealTestCase): '''Test the demo configuration ''' def testDemo1DB(self): '''Test demo flow by injecting into DB''' self.prepare_db() keep_var = self.force_env('TEAL_TEST_POOL_TIMERS_OFF', 'YES') self.teal = Teal('data/teal_test/configurationtest_05_semaphore_auto.conf', 'stderr', msgLevel=self.msglevel) j_in = Journal('j_in', file='data/demo/data_sample_demo_NEW_001.json') j_out_eq = Journal('j_out_eq') j_out_aaq = Journal('j_out_aaq') j_out_dq = Journal('j_out_dq') j_out_lis = Journal('j_out_lis') q_out_eq = registry.get_service(SERVICE_EVENT_Q) q_out_aaq = registry.get_service(SERVICE_ALERT_ANALYZER_Q) q_out_dq = registry.get_service(SERVICE_ALERT_DELIVERY_Q) q_out_eq.register_listener(j_out_eq) q_out_dq.register_listener(j_out_dq) q_out_aaq.register_listener(j_out_aaq) listeners = get_service(SERVICE_ALERT_DELIVERY).listeners for listener in listeners: if listener.get_name() == 'outputJournal': j_out_lis = listener.journal try: j_in.insert_in_db(progress_cb=None, truncate=False, use_rec_ids=True, no_delay=False, post=True) except: print 'INSERTION FAILED' q_out_eq.unregister_listener(j_out_eq) q_out_dq.unregister_listener(j_out_dq) q_out_aaq.unregister_listener(j_out_aaq) raise # Yes, only 2: Flush can't be injected to connector, so pool does not get closed, so last event # Does not get turned into an alert! self.assertTrue(j_out_lis.wait_for_entries(2)) # Note these connector ('C') versions have one less alert # The analyzer is being run in historic mode (see configuration) if that was # changed to runtime then the pool would time out and the last alert would be journaled j_exp_aaq = Journal('j_exp_aaq', 'data/teal_test/data_sample_demo_NEW_001_AAQ_Result_C.json') self.assertTrue(j_out_aaq.deep_match(j_exp_aaq, ignore_delay=True, ignore_times=True)) j_exp_dq = Journal('j_exp_dq', 'data/teal_test/data_sample_demo_NEW_001_DQ_Result_C.json') self.assertTrue(j_out_dq.deep_match(j_exp_dq, ignore_delay=True, ignore_times=True)) j_exp_lis = Journal('j_exp_lis', 'data/teal_test/data_sample_demo_NEW_001_LIS_Result_C.json') self.assertTrue(j_out_lis.deep_match(j_exp_lis, ignore_delay=True, ignore_times=True)) q_out_eq.unregister_listener(j_out_eq) q_out_dq.unregister_listener(j_out_dq) q_out_aaq.unregister_listener(j_out_aaq) self.teal.shutdown() self.restore_env('TEAL_TEST_POOL_TIMERS_OFF', keep_var)
class TEALShutdownModeTest3b(TealTestCase): ''' Test setting of shutdown mode works ''' def setUp(self): self.t = Teal('data/checkpoint_test/shutdown_immediate.conf', 'stderr', msgLevel=self.msglevel, data_only=True) def tearDown(self): self.t.shutdown() def testSettingImmediateShutdownMode(self): ''' Test that the shutdown mode to immediate works config ''' self.assertEqual(SHUTDOWN_MODE_IMMEDIATE, registry.get_service(registry.SERVICE_SHUTDOWN_MODE))
class TEALShutdownModeTest1(TealTestCase): ''' Test setting of shutdown mode works ''' def setUp(self): self.t = Teal('data/tlcommands_test/test.conf', 'stderr', msgLevel=self.msglevel, data_only=True) def tearDown(self): self.t.shutdown() def testDefaultShutdownMode(self): ''' Test that the shutdown mode correctly defaults ''' self.assertEqual(SHUTDOWN_MODE_DEFERRED, registry.get_service(registry.SERVICE_SHUTDOWN_MODE))
class AlertListenerFailureTest(TealTestCase): """Test the alert delivery (filters and listeners)""" def setUp(self): """Setup Teal""" # Not testing duplicates, so OK to turn off self.keep_ADC = self.force_env("TEAL_ALERT_DUPLICATE_CHECK", "No") self.teal = Teal( "data/alert_delivery_test/listener_failure/test.conf", "stderr", msgLevel=self.msglevel, commit_alerts=False, commit_checkpoints=False, ) return def tearDown(self): """Teardown teal""" self.teal.shutdown() self.restore_env("TEAL_ALERT_DUPLICATE_CHECK", self.keep_ADC) return def testGeneralFilters(self): """test alert delivery with global and local filtering""" j_in_dq = Journal("j_in_DQ", "data/alert_delivery_test/listener_failure/inject_DQ_alerts.json") dq_q = get_service(SERVICE_ALERT_DELIVERY_Q) # Get the AlertListenerJournal journals listeners = get_service(SERVICE_ALERT_DELIVERY).listeners for listener in listeners: name = listener.get_name() if name == "AllAlerts": j_out_all = listener.journal if name == "OnlyAnalyzer1": j_out_analyzer1 = listener.journal # inject j_in_dq.inject_queue(dq_q) # Create a TEAL alert create_teal_alert("XXXXXXXX", "no reason at all", "medium well", loc_instance="YYY") # Get expected values j_out_all_exp = Journal("all_exp", "data/alert_delivery_test/analyzer_filter/alerts_out_all.json") j_out_analyzer1_exp = Journal("analyzer1", "data/alert_delivery_test/analyzer_filter/alerts_out_analyzer1.json") # wait for stuff to come out self.assertTrue(j_out_all.wait_for_entries(len(j_out_all_exp) + 3)) self.assertTrue(j_out_analyzer1.wait_for_entries(len(j_out_analyzer1_exp))) # Check that it was what was expected # Can't really check this because the location is unique for each machine and run # Make sure only 3 extra self.assertEqual(len(j_out_all) - len(j_out_all_exp), 3) # self.assertTrue(j_out_all.deep_match(j_out_all_exp, ignore_delay=True, ignore_times=True)) self.assertTrue(j_out_analyzer1.deep_match(j_out_analyzer1_exp, ignore_delay=True, ignore_times=True)) return
class AlertDeliveryTest(TealTestCase): """Test the alert delivery (filters and listeners)""" def setUp(self): """Setup Teal""" self.keep_ADC = self.force_env("TEAL_ALERT_DUPLICATE_CHECK", "No") self.teal = Teal( "data/alert_delivery_test/test_local_filters.conf", "stderr", msgLevel=self.msglevel, commit_alerts=False, commit_checkpoints=False, ) return def tearDown(self): """Teardown teal""" self.teal.shutdown() self.restore_env("TEAL_ALERT_DUPLICATE_CHECK", self.keep_ADC) return def testGeneralFilters(self): """test alert delivery with global and local filtering""" j_in_dq = Journal("j_in_DQ", "data/alert_delivery_test/data_sample_inject_DQ.json") # p rint str(j_in_dq) dq_q = get_service(SERVICE_ALERT_DELIVERY_Q) # Get the AlertListenerJournal journals listeners = get_service(SERVICE_ALERT_DELIVERY).listeners for listener in listeners: name = listener.get_name() # p rint name if name == "AllAlerts": j_out_all = listener.journal if name == "OnlyAlertId": j_out_alert_id = listener.journal if name == "OnlyAlertIdUrgent": j_out_ai_urgent = listener.journal # inject j_in_dq.inject_queue(dq_q) # wait for stuff to come out self.assertTrue(j_out_all.wait_for_entries(5)) self.assertTrue(j_out_alert_id.wait_for_entries(3)) self.assertTrue(j_out_ai_urgent.wait_for_entries(2)) # j_out_all_exp = Journal("j_out_all_exp", "data/alert_delivery_test/data_sample_out_all_alerts.json") self.assertTrue(j_out_all.deep_match(j_out_all_exp, ignore_delay=True, ignore_times=True)) j_out_alert_id_exp = Journal("j_out_alert_id_exp", "data/alert_delivery_test/data_sample_out_alert_id.json") self.assertTrue(j_out_alert_id.deep_match(j_out_alert_id_exp, ignore_delay=True, ignore_times=True)) j_out_ai_urgent_exp = Journal("j_out_ai_urgent_exp", "data/alert_delivery_test/data_sample_out_ai_urgent.json") self.assertTrue(j_out_ai_urgent.deep_match(j_out_ai_urgent_exp, ignore_delay=True, ignore_times=True)) return
class TEALShutdownModeTest3a(TealTestCase): ''' Test setting of shutdown mode works ''' def setUp(self): self.keep_mode = self.force_env(TEAL_SHUTDOWN_MODE, SHUTDOWN_MODE_IMMEDIATE) self.t = Teal('data/tlcommands_test/test.conf', 'stderr', msgLevel=self.msglevel, data_only=True) def tearDown(self): self.t.shutdown() self.restore_env(TEAL_SHUTDOWN_MODE, self.keep_mode) def testSettingImmediateShutdownMode(self): ''' Test that the shutdown mode to immediate works ENV ''' self.assertEqual(SHUTDOWN_MODE_IMMEDIATE, registry.get_service(registry.SERVICE_SHUTDOWN_MODE))
class TEALShutdownModeTest2(TealTestCase): ''' Test setting of shutdown mode works ''' def setUp(self): self.keep_mode = self.force_env(TEAL_SHUTDOWN_MODE, SHUTDOWN_MODE_DEFERRED) self.t = Teal('data/tlcommands_test/test.conf', 'stderr', msgLevel=self.msglevel, data_only=True) def tearDown(self): self.t.shutdown() self.restore_env(TEAL_SHUTDOWN_MODE, self.keep_mode) def testSettingDeferredShutdownMode(self): ''' Test that the shutdown mode being set to deferred works ''' self.assertEqual(SHUTDOWN_MODE_DEFERRED, registry.get_service(registry.SERVICE_SHUTDOWN_MODE))
class TEALShutdownModeTest4(TealTestCase): ''' Test setting of shutdown mode ignored ''' def setUp(self): self.keep_mode = self.force_env(TEAL_SHUTDOWN_MODE, SHUTDOWN_MODE_IMMEDIATE) self.t = Teal('data/tlcommands_test/test.conf', 'stderr', msgLevel=self.msglevel, data_only=True, run_mode=TEAL_RUN_MODE_HISTORIC, commit_alerts=False) def tearDown(self): self.t.shutdown() self.restore_env(TEAL_SHUTDOWN_MODE, self.keep_mode) def testSettingImmediateShutdownMode(self): ''' Test that the shutdown mode to immediate ignored if HISTORIC ''' self.assertEqual(SHUTDOWN_MODE_DEFERRED, registry.get_service(registry.SERVICE_SHUTDOWN_MODE))
def setUp(self): # Setup to use the tllsckpt command t = Teal('data/tlcommands_test/test.conf', 'stderr', msgLevel=self.msglevel, data_only=True) teal_path = registry.get_service(registry.TEAL_ROOT_DIR) self.tllsckpt = os.path.join(teal_path,'bin/tllsckpt') t.shutdown() self.prepare_db() # Need to have checkpointing to DB off so this doesn't interfer with the other instance of TEAL's checkpoints self.teal = Teal('data/checkpoint_test/noop_monitor.conf','stderr',msgLevel=self.msglevel, commit_checkpoints=False) self.db = registry.get_service(registry.SERVICE_DB_INTERFACE) self.query = self.db.gen_select( [EVENT_CPF_CHKPT_ID, EVENT_CPF_NAME, EVENT_CPF_STATUS, EVENT_CPF_EVENT_RECID, EVENT_CPF_DATA], db_interface.TABLE_CHECKPOINT) self.query_mon_data = self.db.gen_select([EVENT_CPF_DATA], db_interface.TABLE_CHECKPOINT, where="${0} = 'monitor_event_queue'".format(EVENT_CPF_NAME), where_fields=[EVENT_CPF_NAME]) self.truncate = self.db.gen_truncate(db_interface.TABLE_CHECKPOINT)
class AlertAnalyzerSubclassTest3(TealTestCase): '''Test the alert analyzer can be subclassed ''' def setUp(self): '''Setup Teal''' self.keep_ADC = self.force_env('TEAL_ALERT_DUPLICATE_CHECK', 'Yes') self.remove_env('TEAL_ALERT_DUPLICATE_CHECK') # Get rid of environment variable so configuration will be used self.teal = Teal('data/alert_analyzer_test/test02.conf', "stderr", msgLevel=self.msglevel, commit_alerts=False, commit_checkpoints=False) def tearDown(self): '''Teardown teal''' self.teal.shutdown() self.restore_env('TEAL_ALERT_DUPLICATE_CHECK', self.keep_ADC) def testAlertAnalyzerSubclassing01_3(self): ''' Test that the alert analyzer subclass works properly and that environment section in configuration works correctly ''' # Get the alert listener for listener in get_service(SERVICE_ALERT_DELIVERY).listeners: if listener.get_name() == 'AllAlerts': j_out_all = listener.journal # Pump in some events j_in_event = Journal('j_in_events', 'data/alert_analyzer_test/inject_events01.json') j_in_event.inject_queue(get_service(SERVICE_EVENT_Q)) # Check that the analyzer got them -- only len because can't compare locations self.assertTrue(j_out_all.wait_for_entries(27)) # Pump in some alerts j_in_alert = Journal('j_in_events', 'data/alert_analyzer_test/inject_alerts01.json') j_in_alert.inject_queue(get_service(SERVICE_ALERT_ANALYZER_Q)) # Check that the analyzer got them -- only len because can't compare locations self.assertTrue(j_out_all.wait_for_entries(34)) alertmgr = get_service(SERVICE_ALERT_MGR) self.assertEqual(len(alertmgr.in_mem_alerts_duplicate), 0)
class TealTestSemaphoreInit(TealTestCase): '''Test the situation where TEAL starts and then shuts down immediately without processing events. Testing to ensure the monitor semaphore which is touched during shutdown is initialized correctly.''' def setUp(self): '''Setup Teal''' self.teal = Teal('data/checkpoint_test/configurationtest_05_semaphore.conf', 'stderr', msgLevel=self.msglevel) return def tearDown(self): '''Teardown teal''' if self.teal is not None: self.teal.shutdown() return def testTealSemaphoreInit(self): '''Test checkpoint value after inserting into an empty db.''' # If there is a problem, the shutdown process would throw # an exception. return
class EventTest(TealTestCase): def setUp(self): self.teal = Teal( "data/common/configurationtest.conf", "stderr", msgLevel=self.msglevel, commit_alerts=False, commit_checkpoints=False, ) def tearDown(self): """Nothing to do ... yet """ self.teal.shutdown() def testCreateRecIdOnly(self): """Test basic event creation """ te1 = Event.fromDict({EVENT_ATTR_REC_ID: 1}) self.assertEquals(te1.get_rec_id(), 1) # Can't use any other get methods, since they will try to # load the Event from the DB is they are not set self.assertEquals(te1.event_id, None) self.assertEquals(te1.time_occurred, None) self.assertEquals(te1.time_logged, None) self.assertEquals(te1.src_comp, None) self.assertEquals(te1.src_loc, None) self.assertEquals(te1.rpt_comp, None) self.assertEquals(te1.rpt_loc, None) self.assertEquals(te1.event_cnt, None) self.assertEquals(te1.elapsed_time, None) self.assertEquals(te1.raw_data, None) # No associations # Not valid because missing required fields self.assertFalse(te1.is_valid()) return def testCreateDict(self): """Create from a dictionary""" right_now = datetime.now() crt_dict = {} crt_dict[EVENT_ATTR_REC_ID] = 2 crt_dict[EVENT_ATTR_EVENT_ID] = "Event2" crt_dict[EVENT_ATTR_TIME_OCCURRED] = right_now crt_dict[EVENT_ATTR_TIME_LOGGED] = right_now + timedelta(seconds=1) crt_dict[EVENT_ATTR_SRC_COMP] = "SC" crt_dict[EVENT_ATTR_SRC_LOC] = "SCL" crt_dict[EVENT_ATTR_SRC_LOC_TYPE] = "S" crt_dict[EVENT_ATTR_RPT_COMP] = "RC" crt_dict[EVENT_ATTR_RPT_LOC] = "RL" crt_dict[EVENT_ATTR_RPT_LOC_TYPE] = "S" crt_dict[EVENT_ATTR_EVENT_CNT] = 12 crt_dict[EVENT_ATTR_ELAPSED_TIME] = 4 crt_dict[EVENT_ATTR_RAW_DATA_FMT] = long("0x5445535400000001", 16) crt_dict[EVENT_ATTR_RAW_DATA] = "When in the course" te1 = Event.fromDict(crt_dict) self.assertEquals(te1.get_rec_id(), 2) # Can't use any other get methods, since they will try to # load the Event from the DB is they are not set self.assertEquals(te1.event_id, crt_dict[EVENT_ATTR_EVENT_ID]) self.assertEquals(te1.time_occurred, crt_dict[EVENT_ATTR_TIME_OCCURRED]) self.assertEquals(te1.time_logged, crt_dict[EVENT_ATTR_TIME_LOGGED]) self.assertEquals(te1.src_comp, crt_dict[EVENT_ATTR_SRC_COMP]) self.assertEquals(te1.src_loc.get_location(), crt_dict[EVENT_ATTR_SRC_LOC]) self.assertEquals(te1.src_loc.get_id(), crt_dict[EVENT_ATTR_SRC_LOC_TYPE]) self.assertEquals(te1.rpt_comp, crt_dict[EVENT_ATTR_RPT_COMP]) self.assertEquals(te1.rpt_loc.get_location(), crt_dict[EVENT_ATTR_RPT_LOC]) self.assertEquals(te1.rpt_loc.get_id(), crt_dict[EVENT_ATTR_RPT_LOC_TYPE]) self.assertEquals(te1.event_cnt, crt_dict[EVENT_ATTR_EVENT_CNT]) self.assertEquals(te1.elapsed_time, crt_dict[EVENT_ATTR_ELAPSED_TIME]) self.assertEquals(te1.raw_data[EXT_DATA_RAW_DATA], crt_dict[EVENT_ATTR_RAW_DATA]) # No associations # Valid because has all required fields self.assertTrue(te1.is_valid()) # Reuse local crt_dict[EVENT_ATTR_REC_ID] = 5 te1 = Event.fromDict(crt_dict) self.assertEquals(te1.get_rec_id(), 5) # Can't use any other get methods, since they will try to # load the Event from the DB is they are not set self.assertEquals(te1.event_id, crt_dict[EVENT_ATTR_EVENT_ID]) self.assertEquals(te1.time_occurred, crt_dict[EVENT_ATTR_TIME_OCCURRED]) self.assertEquals(te1.time_logged, crt_dict[EVENT_ATTR_TIME_LOGGED]) self.assertEquals(te1.src_comp, crt_dict[EVENT_ATTR_SRC_COMP]) self.assertEquals(te1.src_loc.get_location(), crt_dict[EVENT_ATTR_SRC_LOC]) self.assertEquals(te1.src_loc.get_id(), crt_dict[EVENT_ATTR_SRC_LOC_TYPE]) self.assertEquals(te1.rpt_comp, crt_dict[EVENT_ATTR_RPT_COMP]) self.assertEquals(te1.rpt_loc.get_location(), crt_dict[EVENT_ATTR_RPT_LOC]) self.assertEquals(te1.rpt_loc.get_id(), crt_dict[EVENT_ATTR_RPT_LOC_TYPE]) self.assertEquals(te1.event_cnt, crt_dict[EVENT_ATTR_EVENT_CNT]) self.assertEquals(te1.elapsed_time, crt_dict[EVENT_ATTR_ELAPSED_TIME]) self.assertEquals(te1.raw_data[EXT_DATA_RAW_DATA], crt_dict[EVENT_ATTR_RAW_DATA]) # No associations # Not valid because has all required fields self.assertTrue(te1.is_valid()) return def testCreateTuple1(self): """Create from a tuple""" right_now = datetime.now() crt_dict = {} crt_dict[EVENT_ATTR_REC_ID] = 2 crt_dict[EVENT_ATTR_EVENT_ID] = "Event2" crt_dict[EVENT_ATTR_TIME_OCCURRED] = right_now crt_dict[EVENT_ATTR_TIME_LOGGED] = right_now + timedelta(seconds=1) crt_dict[EVENT_ATTR_SRC_COMP] = "SC" crt_dict[EVENT_ATTR_SRC_LOC] = "SCL" crt_dict[EVENT_ATTR_SRC_LOC_TYPE] = "S" crt_dict[EVENT_ATTR_RPT_COMP] = "RC" crt_dict[EVENT_ATTR_RPT_LOC] = "RL" crt_dict[EVENT_ATTR_RPT_LOC_TYPE] = "S" crt_dict[EVENT_ATTR_EVENT_CNT] = None crt_dict[EVENT_ATTR_ELAPSED_TIME] = None crt_dict[EVENT_ATTR_RAW_DATA_FMT] = long("0x5445535400000001", 16) crt_dict[EVENT_ATTR_RAW_DATA] = "When in the course" in_tuple = ( crt_dict[EVENT_ATTR_REC_ID], crt_dict[EVENT_ATTR_EVENT_ID], crt_dict[EVENT_ATTR_TIME_OCCURRED], crt_dict[EVENT_ATTR_TIME_LOGGED], crt_dict[EVENT_ATTR_SRC_COMP], crt_dict[EVENT_ATTR_SRC_LOC], crt_dict[EVENT_ATTR_SRC_LOC_TYPE], crt_dict[EVENT_ATTR_RPT_COMP], crt_dict[EVENT_ATTR_RPT_LOC], crt_dict[EVENT_ATTR_RPT_LOC_TYPE], crt_dict[EVENT_ATTR_EVENT_CNT], crt_dict[EVENT_ATTR_ELAPSED_TIME], crt_dict[EVENT_ATTR_RAW_DATA_FMT], crt_dict[EVENT_ATTR_RAW_DATA], ) te1 = Event.fromDB(in_tuple) self.assertEquals(te1.get_rec_id(), 2) # Can't use any other get methods, since they will try to # load the Event from the DB is they are not set self.assertEquals(te1.event_id, crt_dict[EVENT_ATTR_EVENT_ID]) self.assertEquals(te1.time_occurred, crt_dict[EVENT_ATTR_TIME_OCCURRED]) self.assertEquals(te1.time_logged, crt_dict[EVENT_ATTR_TIME_LOGGED]) self.assertEquals(te1.src_comp, crt_dict[EVENT_ATTR_SRC_COMP]) self.assertEquals(te1.src_loc.get_location(), crt_dict[EVENT_ATTR_SRC_LOC]) self.assertEquals(te1.src_loc.get_id(), crt_dict[EVENT_ATTR_SRC_LOC_TYPE]) self.assertEquals(te1.rpt_comp, crt_dict[EVENT_ATTR_RPT_COMP]) self.assertEquals(te1.rpt_loc.get_location(), crt_dict[EVENT_ATTR_RPT_LOC]) self.assertEquals(te1.rpt_loc.get_id(), crt_dict[EVENT_ATTR_RPT_LOC_TYPE]) self.assertEquals(te1.event_cnt, crt_dict[EVENT_ATTR_EVENT_CNT]) self.assertEquals(te1.elapsed_time, crt_dict[EVENT_ATTR_ELAPSED_TIME]) self.assertEquals(te1.raw_data[EXT_DATA_RAW_DATA], crt_dict[EVENT_ATTR_RAW_DATA]) # No associations # Valid because has all required fields self.assertTrue(te1.is_valid()) # Reuse local crt_dict[EVENT_ATTR_REC_ID] = 5 te1 = Event.fromDict(crt_dict) self.assertEquals(te1.get_rec_id(), 5) # Can't use any other get methods, since they will try to # load the Event from the DB is they are not set self.assertEquals(te1.event_id, crt_dict[EVENT_ATTR_EVENT_ID]) self.assertEquals(te1.time_occurred, crt_dict[EVENT_ATTR_TIME_OCCURRED]) self.assertEquals(te1.time_logged, crt_dict[EVENT_ATTR_TIME_LOGGED]) self.assertEquals(te1.src_comp, crt_dict[EVENT_ATTR_SRC_COMP]) self.assertEquals(te1.src_loc.get_location(), crt_dict[EVENT_ATTR_SRC_LOC]) self.assertEquals(te1.src_loc.get_id(), crt_dict[EVENT_ATTR_SRC_LOC_TYPE]) self.assertEquals(te1.rpt_comp, crt_dict[EVENT_ATTR_RPT_COMP]) self.assertEquals(te1.rpt_loc.get_location(), crt_dict[EVENT_ATTR_RPT_LOC]) self.assertEquals(te1.rpt_loc.get_id(), crt_dict[EVENT_ATTR_RPT_LOC_TYPE]) self.assertEquals(te1.event_cnt, crt_dict[EVENT_ATTR_EVENT_CNT]) self.assertEquals(te1.elapsed_time, crt_dict[EVENT_ATTR_ELAPSED_TIME]) self.assertEquals(te1.raw_data[EXT_DATA_RAW_DATA], crt_dict[EVENT_ATTR_RAW_DATA]) # No associations # Not valid because has all required fields self.assertTrue(te1.is_valid()) return def testCreateTuple2(self): """Create from a tuple""" right_now = datetime.now() crt_dict = {} crt_dict[EVENT_ATTR_REC_ID] = 2 crt_dict[EVENT_ATTR_EVENT_ID] = "Event2" crt_dict[EVENT_ATTR_TIME_OCCURRED] = right_now crt_dict[EVENT_ATTR_TIME_LOGGED] = right_now + timedelta(seconds=1) crt_dict[EVENT_ATTR_SRC_COMP] = "SC" crt_dict[EVENT_ATTR_SRC_LOC] = "SCL" crt_dict[EVENT_ATTR_SRC_LOC_TYPE] = "S" crt_dict[EVENT_ATTR_RPT_COMP] = "RC" crt_dict[EVENT_ATTR_RPT_LOC] = None crt_dict[EVENT_ATTR_RPT_LOC_TYPE] = "S" crt_dict[EVENT_ATTR_EVENT_CNT] = None crt_dict[EVENT_ATTR_ELAPSED_TIME] = None crt_dict[EVENT_ATTR_RAW_DATA_FMT] = long("0x5445535400000001", 16) crt_dict[EVENT_ATTR_RAW_DATA] = "When in the course" in_tuple = ( crt_dict[EVENT_ATTR_REC_ID], crt_dict[EVENT_ATTR_EVENT_ID], crt_dict[EVENT_ATTR_TIME_OCCURRED], crt_dict[EVENT_ATTR_TIME_LOGGED], crt_dict[EVENT_ATTR_SRC_COMP], crt_dict[EVENT_ATTR_SRC_LOC], crt_dict[EVENT_ATTR_SRC_LOC_TYPE], crt_dict[EVENT_ATTR_RPT_COMP], crt_dict[EVENT_ATTR_RPT_LOC], crt_dict[EVENT_ATTR_RPT_LOC_TYPE], crt_dict[EVENT_ATTR_EVENT_CNT], crt_dict[EVENT_ATTR_ELAPSED_TIME], crt_dict[EVENT_ATTR_RAW_DATA_FMT], crt_dict[EVENT_ATTR_RAW_DATA], ) te1 = Event.fromDB(in_tuple) self.assertEquals(te1.get_rec_id(), 2) # Can't use any other get methods, since they will try to # load the Event from the DB is they are not set self.assertEquals(te1.event_id, crt_dict[EVENT_ATTR_EVENT_ID]) self.assertEquals(te1.time_occurred, crt_dict[EVENT_ATTR_TIME_OCCURRED]) self.assertEquals(te1.time_logged, crt_dict[EVENT_ATTR_TIME_LOGGED]) self.assertEquals(te1.src_comp, crt_dict[EVENT_ATTR_SRC_COMP]) self.assertEquals(te1.src_loc.get_location(), crt_dict[EVENT_ATTR_SRC_LOC]) self.assertEquals(te1.src_loc.get_id(), crt_dict[EVENT_ATTR_SRC_LOC_TYPE]) self.assertEquals(te1.rpt_comp, crt_dict[EVENT_ATTR_RPT_COMP]) self.assertEquals(te1.rpt_loc, None) self.assertEquals(te1.event_cnt, crt_dict[EVENT_ATTR_EVENT_CNT]) self.assertEquals(te1.elapsed_time, crt_dict[EVENT_ATTR_ELAPSED_TIME]) self.assertEquals(te1.raw_data[EXT_DATA_RAW_DATA], crt_dict[EVENT_ATTR_RAW_DATA]) # No associations # Valid because has all required fields self.assertFalse(te1.is_valid()) return def testCreateTuple3(self): """Create from a tuple""" right_now = datetime.now() crt_dict = {} crt_dict[EVENT_ATTR_REC_ID] = 2 crt_dict[EVENT_ATTR_EVENT_ID] = "Event2" crt_dict[EVENT_ATTR_TIME_OCCURRED] = right_now crt_dict[EVENT_ATTR_TIME_LOGGED] = right_now + timedelta(seconds=1) crt_dict[EVENT_ATTR_SRC_COMP] = "SC" crt_dict[EVENT_ATTR_SRC_LOC] = "SCL" crt_dict[EVENT_ATTR_SRC_LOC_TYPE] = "S" crt_dict[EVENT_ATTR_RPT_COMP] = "RC" crt_dict[EVENT_ATTR_RPT_LOC] = "RL" crt_dict[EVENT_ATTR_RPT_LOC_TYPE] = None crt_dict[EVENT_ATTR_EVENT_CNT] = None crt_dict[EVENT_ATTR_ELAPSED_TIME] = None crt_dict[EVENT_ATTR_RAW_DATA_FMT] = long("0x5445535400000001", 16) crt_dict[EVENT_ATTR_RAW_DATA] = "When in the course" in_tuple = ( crt_dict[EVENT_ATTR_REC_ID], crt_dict[EVENT_ATTR_EVENT_ID], crt_dict[EVENT_ATTR_TIME_OCCURRED], crt_dict[EVENT_ATTR_TIME_LOGGED], crt_dict[EVENT_ATTR_SRC_COMP], crt_dict[EVENT_ATTR_SRC_LOC], crt_dict[EVENT_ATTR_SRC_LOC_TYPE], crt_dict[EVENT_ATTR_RPT_COMP], crt_dict[EVENT_ATTR_RPT_LOC], crt_dict[EVENT_ATTR_RPT_LOC_TYPE], crt_dict[EVENT_ATTR_EVENT_CNT], crt_dict[EVENT_ATTR_ELAPSED_TIME], crt_dict[EVENT_ATTR_RAW_DATA_FMT], crt_dict[EVENT_ATTR_RAW_DATA], ) te1 = Event.fromDB(in_tuple) self.assertEquals(te1.get_rec_id(), 2) # Can't use any other get methods, since they will try to # load the Event from the DB is they are not set self.assertEquals(te1.event_id, crt_dict[EVENT_ATTR_EVENT_ID]) self.assertEquals(te1.time_occurred, crt_dict[EVENT_ATTR_TIME_OCCURRED]) self.assertEquals(te1.time_logged, crt_dict[EVENT_ATTR_TIME_LOGGED]) self.assertEquals(te1.src_comp, crt_dict[EVENT_ATTR_SRC_COMP]) self.assertEquals(te1.src_loc.get_location(), crt_dict[EVENT_ATTR_SRC_LOC]) self.assertEquals(te1.src_loc.get_id(), crt_dict[EVENT_ATTR_SRC_LOC_TYPE]) self.assertEquals(te1.rpt_comp, crt_dict[EVENT_ATTR_RPT_COMP]) self.assertEquals(te1.rpt_loc, None) # Couldn't create self.assertEquals(te1.event_cnt, crt_dict[EVENT_ATTR_EVENT_CNT]) self.assertEquals(te1.elapsed_time, crt_dict[EVENT_ATTR_ELAPSED_TIME]) self.assertEquals(te1.raw_data[EXT_DATA_RAW_DATA], crt_dict[EVENT_ATTR_RAW_DATA]) # No associations # Valid because has all required fields self.assertFalse(te1.is_valid()) return def testEventMatch(self): """Test the match method""" # Create an event to work with right_now = datetime.now() crt_dict = {} crt_dict[EVENT_ATTR_REC_ID] = 2 crt_dict[EVENT_ATTR_EVENT_ID] = "Event2" crt_dict[EVENT_ATTR_TIME_OCCURRED] = right_now crt_dict[EVENT_ATTR_TIME_LOGGED] = right_now + timedelta(seconds=1) crt_dict[EVENT_ATTR_SRC_COMP] = "SC" crt_dict[EVENT_ATTR_SRC_LOC] = "node##app##pid" crt_dict[EVENT_ATTR_SRC_LOC_TYPE] = "S" crt_dict[EVENT_ATTR_RPT_COMP] = "RC" crt_dict[EVENT_ATTR_RPT_LOC] = "node2##app2##pid" crt_dict[EVENT_ATTR_RPT_LOC_TYPE] = "S" crt_dict[EVENT_ATTR_EVENT_CNT] = 12 crt_dict[EVENT_ATTR_ELAPSED_TIME] = 4 crt_dict[EVENT_ATTR_RAW_DATA_FMT] = long("0x5445535400000001", 16) crt_dict[EVENT_ATTR_RAW_DATA] = "When in the course" te1 = teal.Event.fromDict(crt_dict) # match(event_id, src_comp, src_loc, rpt_loc, scope) # Always matches self.assertTrue(te1.match(None, None, None, None, None)) # Check event id self.assertTrue(te1.match("Event2", None, None, None, None)) self.assertFalse(te1.match("Event3", None, None, None, None)) # Check src comp self.assertTrue(te1.match(None, "SC", None, None, None)) self.assertFalse(te1.match(None, "RC", None, None, None)) self.assertTrue(te1.match("Event2", "SC", None, None, None)) self.assertFalse(te1.match("Event2", "RC", None, None, None)) self.assertFalse(te1.match("Event3", "SC", None, None, None)) # Check scr loc chk_loc1 = Location("S", "node##app##pid") self.assertTrue(te1.match(None, None, chk_loc1, None, None)) self.assertTrue(te1.match(None, None, chk_loc1, None, "application")) self.assertTrue(te1.match(None, None, chk_loc1, None, "node")) self.assertTrue(te1.match(None, None, chk_loc1, None, "pid")) self.assertTrue(te1.match("Event2", "SC", chk_loc1, None, "node")) chk_loc2 = Location("S", "node##app##pid2") self.assertFalse(te1.match(None, None, chk_loc2, None, None)) self.assertTrue(te1.match(None, None, chk_loc2, None, "application")) self.assertTrue(te1.match(None, None, chk_loc2, None, "node")) self.assertFalse(te1.match(None, None, chk_loc2, None, "pid")) self.assertTrue(te1.match("Event2", "SC", chk_loc2, None, "node")) self.assertFalse(te1.match("Event2", "SC", chk_loc2, None, "pid")) chk_loc3 = Location("C", "MB") self.assertFalse(te1.match(None, None, chk_loc3, None, None)) self.assertFalse(te1.match(None, None, chk_loc3, None, "application")) # Check rpt_loc chk_loc1r = Location("S", "node2##app2##pid") self.assertTrue(te1.match(None, None, None, chk_loc1r, None)) self.assertTrue(te1.match(None, None, None, chk_loc1r, "application")) self.assertTrue(te1.match(None, None, None, chk_loc1r, "node")) self.assertTrue(te1.match(None, None, None, chk_loc1r, "pid")) self.assertTrue(te1.match(None, None, chk_loc1, chk_loc1r, None)) self.assertTrue(te1.match(None, None, chk_loc1, chk_loc1r, "application")) self.assertTrue(te1.match(None, None, chk_loc1, chk_loc1r, "node")) self.assertTrue(te1.match(None, None, chk_loc1, chk_loc1r, "pid")) self.assertFalse(te1.match(None, None, chk_loc2, chk_loc1r, "pid")) chk_loc2r = Location("S", "node2##app2##pidzzz") self.assertFalse(te1.match(None, None, chk_loc1, chk_loc2r, "pid")) self.assertTrue(te1.match("Event2", "SC", chk_loc1, chk_loc1r, "node")) # Test with no rpt loc del crt_dict[EVENT_ATTR_RPT_COMP] del crt_dict[EVENT_ATTR_RPT_LOC] te2 = Event.fromDict(crt_dict) self.assertFalse(te2.match("Event2", "SC", chk_loc1, chk_loc1r, "node")) self.assertTrue(te2.match("Event2", "SC", chk_loc1, None, "node")) return def testCreateBadlocations(self): """Create from a dictionary with bad locations""" keep_env = self.force_env("TEAL_LOCATION_VALIDATION", "IMMEDIATE") right_now = datetime.now() crt_dict = {} crt_dict[EVENT_ATTR_REC_ID] = 72 crt_dict[EVENT_ATTR_EVENT_ID] = "Event 7" crt_dict[EVENT_ATTR_TIME_OCCURRED] = right_now crt_dict[EVENT_ATTR_TIME_LOGGED] = right_now + timedelta(seconds=1) crt_dict[EVENT_ATTR_SRC_COMP] = "SC" crt_dict[EVENT_ATTR_SRC_LOC] = "Sbad" crt_dict[EVENT_ATTR_SRC_LOC_TYPE] = "DABs" crt_dict[EVENT_ATTR_RPT_COMP] = "RC" crt_dict[EVENT_ATTR_RPT_LOC] = "Rbad" crt_dict[EVENT_ATTR_RPT_LOC_TYPE] = "DABr" crt_dict[EVENT_ATTR_EVENT_CNT] = 12 crt_dict[EVENT_ATTR_ELAPSED_TIME] = 4 crt_dict[EVENT_ATTR_RAW_DATA_FMT] = long("0x5445535400000001", 16) crt_dict[EVENT_ATTR_RAW_DATA] = "When in the course" te1 = Event.fromDict(crt_dict) self.assertEquals(te1.get_rec_id(), 72) # Can't use any other get methods, since they will try to # load the Event from the DB is they are not set self.assertEquals(te1.event_id, crt_dict[EVENT_ATTR_EVENT_ID]) self.assertEquals(te1.time_occurred, crt_dict[EVENT_ATTR_TIME_OCCURRED]) self.assertEquals(te1.time_logged, crt_dict[EVENT_ATTR_TIME_LOGGED]) self.assertEquals(te1.src_comp, crt_dict[EVENT_ATTR_SRC_COMP]) self.assertEquals(te1.src_loc, None) self.assertEquals(te1.rpt_comp, crt_dict[EVENT_ATTR_RPT_COMP]) self.assertEquals(te1.rpt_loc, None) self.assertEquals(te1.event_cnt, crt_dict[EVENT_ATTR_EVENT_CNT]) self.assertEquals(te1.elapsed_time, crt_dict[EVENT_ATTR_ELAPSED_TIME]) self.assertEquals(te1.raw_data[EXT_DATA_RAW_DATA], crt_dict[EVENT_ATTR_RAW_DATA]) self.restore_env("TEAL_LOCATION_VALIDATION", keep_env) return
class RestartTest(TealTestCase): def setUp(self): self.prepare_db() def tearDown(self): self.stop_teal() def testRestartBeginEmptyDb(self): ''' Verify we can start up in begin mode with an empty DB ''' self.restart_with_empty_db('begin') def testRestartRecoveryEmptyDb(self): ''' Verify we can start up in recovery with an empty DB ''' self.restart_with_empty_db('recovery') def testRestartLastProcEmptyDb(self): ''' Verify we can start up in lastproc mode with an empty DB ''' self.restart_with_empty_db('lastproc') def testRestartNowEmptyDb(self): ''' Verify we can start up in now mode with an empty DB ''' self.restart_with_empty_db('now') def testRestartLastProc(self): ''' Verify lastproc mode by reading events that have been added after shutdown ''' self.add_entries_before_restart() # Add a few more events so we process things self.start_teal_no_monitor() j_inj = Journal('Pre-populate','data/restart_test/three_events_one.json') j_inj.insert_in_db(use_rec_ids=False, no_delay=True) self.stop_teal() # Now start up in lastproc mode and see that we don't get entries ... not checkpoints so acts like Now self.start_teal('lastproc') j_act = self.find_analyzer().journal self.assertFalse(j_act.wait_for_entries(1,seconds=3, msg_mode='quiet')) #self.assertTrue(j_act.wait_for_entries(3)) #j_exp = Journal('After restart','data/restart_test/three_events_one_fromq.json') #self.assertTrue(j_act.deep_match(j_exp,ignore_delay=True)) j_act.clear() # Make sure we start getting new entries self.inject_new_entries() def testRestartNow(self): ''' Verify now mode by making sure no previous events are read ''' self.add_entries_before_restart() # Now start up in now mode and make sure we don't get any events self.start_teal('now') j_act = self.find_analyzer().journal self.assertFalse(j_act.wait_for_entries(1,seconds=3, msg_mode='quiet')) j_empty = Journal('Empty') self.assertTrue(j_act.deep_match(j_empty,ignore_delay=True)) # Make sure we start getting new entries self.inject_new_entries() def testRestartBegin(self): ''' Verify begin mode by reading all events in the DB ''' self.add_entries_before_restart() # Now start up in begin mode and make sure we get ALL the events self.start_teal('begin') j_act = self.find_analyzer().journal j_exp = Journal('After begin','data/restart_test/three_events_one_fromq.json') self.assertTrue(j_act.wait_for_entries(3)) self.assertTrue(j_act.deep_match(j_exp,ignore_delay=True)) j_act.clear() # Make sure we start getting new entries self.inject_new_entries() def testRestartRecovery(self): ''' Verify recovery mode by reading events that have been added after shutdown ''' self.add_entries_before_restart() # Add a few more events so we process things self.start_teal_no_monitor() j_inj = Journal('Pre-populate','data/restart_test/three_events_one.json') j_inj.insert_in_db(use_rec_ids=False, no_delay=True) self.stop_teal() # Now start up in recovery mode and see that we get 3 events self.start_teal('recovery') j_act = self.find_analyzer().journal self.assertFalse(j_act.wait_for_entries(1,seconds=3, msg_mode='quiet')) #self.assertTrue(j_act.wait_for_entries(3)) #j_exp = Journal('After restart','data/restart_test/three_events_one_fromq.json') #self.assertTrue(j_act.deep_match(j_exp,ignore_delay=True)) j_act.clear() # Make sure we start getting new entries self.inject_new_entries() def restart_with_empty_db(self,restart): ''' Restart TEAL in the specified mode. This assumes that since the database is empty, there will be no events being processed ''' self.start_teal(restart) # Make sure that our analyzer doesn't get any events j_act = self.find_analyzer().journal j_empty = Journal('Empty') self.assertFalse(j_act.wait_for_entries(1, seconds=5, msg_mode='quiet')) self.assertTrue(j_act.deep_match(j_empty,ignore_delay=True)) # Make sure we start getting new events self.inject_new_entries() def add_entries_before_restart(self, stop_teal=True): ''' Add events to TEAL and make sure they are processed ''' self.start_teal('now') # Insert a set of events and process them j_act = self.find_analyzer().journal j_inj = Journal('Pre-populate','data/restart_test/three_events_one.json') j_inj.insert_in_db(no_delay=True, truncate=True) # Truncate is testing that we handle the ckpt table being destroyed registry.get_service(registry.SERVICE_NOTIFIER).post() self.assertTrue(j_act.wait_for_entries(3)) j_exp = Journal('Expected', 'data/restart_test/three_events_one_fromq.json') self.assertTrue(j_act.deep_match(j_exp, ignore_delay=True)) # Stop this instance of TEAL if requested otherwise it is up # to the caller to stop it if stop_teal: self.stop_teal() def inject_new_entries(self,exp_json='data/restart_test/three_events_one_fromq.json',exp_num=3): ''' Verify that events still flow through TEAL after startup ''' # Now make sure we start getting new events j_inj = Journal('After restart','data/restart_test/three_events_one.json') j_inj.insert_in_db(use_rec_ids=False, no_delay=True) registry.get_service(registry.SERVICE_NOTIFIER).post() j_exp = Journal('Inject New Entries', exp_json) j_act = self.find_analyzer().journal self.assertTrue(j_act.wait_for_entries(exp_num)) self.assertTrue(j_act.deep_match(j_exp, ignore_delay=True)) def find_analyzer(self): ''' Find the Test analyzer that holds onto the journal for processing ''' o = None event_q = registry.get_service(registry.SERVICE_EVENT_Q) for lm in event_q.listener_methods: o = lm.__self__ if o.get_name() == "RestartAnalyzer": break; return o def start_teal(self,restart): ''' Start up teal with Journal Analyzer ''' self.t = Teal('data/restart_test/teal_nodelta_noanalyze.conf', logFile='stderr', msgLevel=self.msglevel, restart=restart) def start_teal_no_monitor(self): ''' start Teal without a monitor so events can be added ''' self.t = Teal('data/common/dbinterfaceonly.conf', logFile='stderr', msgLevel=self.msglevel, commit_checkpoints=False, data_only=True, commit_alerts=False) def stop_teal(self): ''' Shutdown the currently active TEAL instance ''' try: self.t.shutdown() except: pass
class AlertTestStates(TealTestCase): def testStateIncompleteIM(self): ''' Test alert gets created in memory in incomplete state''' self.teal = Teal('data/common/configurationtest.conf', 'stderr', msgLevel=self.msglevel, commit_alerts=False, commit_checkpoints=False) am = get_service(SERVICE_ALERT_MGR) t_alert = am.allocate('TestAlert', {}) self.assertEquals(t_alert.state, ALERT_STATE_INCOMPLETE) # No metadata self.assertRaises(KeyError, am.commit, t_alert) self.teal.shutdown() def testStateIncompleteDB(self): ''' Test alert gets created in memory in incomplete state''' self.teal = Teal('data/alert_test/test.conf', 'stderr', msgLevel=self.msglevel, commit_alerts=True, commit_checkpoints=False) am = get_service(SERVICE_ALERT_MGR) t_alert = am.allocate('TestAlert', {}) self.assertEquals(t_alert.state, ALERT_STATE_INCOMPLETE) # No metadata self.assertRaises(KeyError, am.commit, t_alert) self.teal.shutdown() def testStateOtherStatesIM(self): '''test alert state NEW in memory''' self.teal = Teal('data/alert_test/test.conf', 'stderr', msgLevel=self.msglevel, commit_alerts=False, commit_checkpoints=False) j_in_dq = Journal('j_in_DQ', 'data/alert_test/inject_DQ_alerts.json') tq = ListenableQueue('test LQ') ql = CheckAlertStateListener(7) tq.register_listener(ql) j_in_dq.inject_queue(tq, progress_cb=None, fail_on_invalid=False, no_delay=True) ql.my_event.wait() self.assertEquals(ql.count, 7) ta1 = ql.alerts[0] am = get_service(SERVICE_ALERT_MGR) # TODO: Should not be hardcoded rec ids after this self.assertRaisesTealError(AlertMgrError, 'Operation not allowed on duplicate alert', am.close, 5) self.assertRaisesTealError(AlertMgrError, 'Operation not allowed on duplicate alert', am.close, 6) self.assertRaisesTealError(AlertMgrError, 'Current alert state does not allow this operation', am.reopen, ta1.rec_id) am.close(ta1.rec_id) self.assertEquals(ta1.state, ALERT_STATE_CLOSED) self.assertRaisesTealError(AlertMgrError, 'Current alert state does not allow this operation', am.close, ta1.rec_id) self.assertRaisesTealError(AlertMgrError, 'Alert with specified record id not found', am.close, 23456) self.assertEquals(ql.alerts[1].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[2].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[3].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[4].state, ALERT_STATE_CLOSED) self.assertEquals(ql.alerts[5].state, ALERT_STATE_CLOSED) self.assertEquals(ql.alerts[6].state, ALERT_STATE_OPEN) # reopen it self.assertRaisesTealError(AlertMgrError, 'Alert with specified record id not found', am.reopen, 23456) self.assertRaisesTealError(AlertMgrError, 'Operation not allowed on duplicate alert', am.reopen, 5) self.assertRaisesTealError(AlertMgrError, 'Operation not allowed on duplicate alert', am.reopen, 6) am.reopen(ta1.rec_id) self.assertEquals(ta1.state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[1].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[2].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[3].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[4].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[5].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[6].state, ALERT_STATE_OPEN) am.close(3) self.assertEquals(ta1.state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[1].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[2].state, ALERT_STATE_CLOSED) self.assertEquals(ql.alerts[3].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[4].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[5].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[6].state, ALERT_STATE_OPEN) am.reopen(3) self.assertEquals(ta1.state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[1].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[2].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[3].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[4].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[5].state, ALERT_STATE_OPEN) self.assertEquals(ql.alerts[6].state, ALERT_STATE_OPEN) self.teal.shutdown() return def testStateOtherStatesDB(self): '''test alert state NEW in memory''' self.prepare_db() self.teal = Teal('data/alert_test/test.conf', 'stderr', msgLevel=self.msglevel, commit_alerts=True, commit_checkpoints=False) j_in_dq = Journal('j_in_DQ', 'data/alert_test/inject_DQ_alerts.json') tq = ListenableQueue('test LQ') ql = CheckAlertStateListener(7) tq.register_listener(ql) j_in_dq.inject_queue(tq, progress_cb=None, fail_on_invalid=False, no_delay=True) ql.my_event.wait() self.assertEquals(ql.count, 7) ta1 = ql.alerts[0] am = get_service(SERVICE_ALERT_MGR) self.assertEquals(ta1.state, ALERT_STATE_OPEN) # TODO: Really should query to get the recid to use for hardcoded ones in rest of this test case self.assertRaisesTealError(AlertMgrError, 'Operation not allowed on duplicate alert', am.close, 5) self.assertRaisesTealError(AlertMgrError, 'Operation not allowed on duplicate alert', am.close, 6) self.assertRaisesTealError(AlertMgrError, 'Current alert state does not allow this operation', am.reopen, ta1.rec_id) am.close(ta1.rec_id) # Get duplicates of this one self.assertRaisesTealError(AlertMgrError, 'Current alert state does not allow this operation', am.close, ta1.rec_id) self.assertRaisesTealError(AlertMgrError, 'Alert with specified record id not found', am.close, 23456) # Note that in memory won't be updated ... only in DB # so lets get it from the DB dbi = get_service(SERVICE_DB_INTERFACE) event_cnxn, cursor =_get_connection(dbi) self.assert_alert_closed(dbi, cursor, ta1.rec_id) self.assert_alert_open(dbi, cursor, 2) self.assert_alert_open(dbi, cursor, 3) self.assert_alert_open(dbi, cursor, 4) self.assert_alert_closed(dbi, cursor, 5) self.assert_alert_closed(dbi, cursor, 6) self.assert_alert_open(dbi, cursor, 7) self.assertRaisesTealError(AlertMgrError, 'Alert with specified record id not found', am.reopen, 23456) self.assertRaisesTealError(AlertMgrError, 'Operation not allowed on duplicate alert', am.reopen, 5) self.assertRaisesTealError(AlertMgrError, 'Operation not allowed on duplicate alert', am.reopen, 6) # reopen it am.reopen(ta1.rec_id) event_cnxn, cursor =_get_connection(dbi, event_cnxn) self.assert_alert_open(dbi, cursor, ta1.rec_id) self.assert_alert_open(dbi, cursor, 2) self.assert_alert_open(dbi, cursor, 3) self.assert_alert_open(dbi, cursor, 4) self.assert_alert_open(dbi, cursor, 5) self.assert_alert_open(dbi, cursor, 6) self.assert_alert_open(dbi, cursor, 7) am.close(3) event_cnxn, cursor =_get_connection(dbi, event_cnxn) self.assert_alert_open(dbi, cursor, ta1.rec_id) self.assert_alert_open(dbi, cursor, 2) self.assert_alert_closed(dbi, cursor, 3) self.assert_alert_open(dbi, cursor, 4) self.assert_alert_open(dbi, cursor, 5) self.assert_alert_open(dbi, cursor, 6) self.assert_alert_open(dbi, cursor, 7) am.reopen(3) event_cnxn, cursor =_get_connection(dbi, event_cnxn) self.assert_alert_open(dbi, cursor, ta1.rec_id) self.assert_alert_open(dbi, cursor, 2) self.assert_alert_open(dbi, cursor, 3) self.assert_alert_open(dbi, cursor, 4) self.assert_alert_open(dbi, cursor, 5) self.assert_alert_open(dbi, cursor, 6) self.assert_alert_open(dbi, cursor, 7) event_cnxn.close() self.teal.shutdown() return def assert_alert_closed(self, dbi, cursor, rec_id): ''' Check that the alert for the specified rec_id is closed ''' dbi.select(cursor, ['state'], db_interface.TABLE_ALERT_LOG, where='$rec_id = ?', where_fields=['rec_id'], parms=(rec_id,)) row = cursor.fetchone() self.assertTrue(row != None) self.assertTrue(row[0] != None) self.assertEquals(row[0],ALERT_STATE_CLOSED) return def assert_alert_open(self, dbi, cursor, rec_id): ''' Check that the alert for the specified rec_id is closed ''' dbi.select(cursor, ['state'], db_interface.TABLE_ALERT_LOG, where='$rec_id = ?', where_fields=['rec_id'], parms=(rec_id,)) row = cursor.fetchone() self.assertTrue(row != None) self.assertTrue(row[0] != None) self.assertEquals(row[0],ALERT_STATE_OPEN) return
class TealTest(TealTestCase): def testTooManyMonitors(self): ''' Verify that Teal fails if more than one monitor is specified''' self.assertRaisesTealError(TealError, "There can only be one section called 'event_monitor'", Teal, 'data/teal_test/tealtest_01.conf', 'stderr', self.msglevel,'now','realtime',False, False, None, False, '', False) def testTooFewMonitors(self): ''' Verify that Teal fails if no monitor is specified''' self.assertRaisesTealError(TealError, 'No monitor configured - must have one monitor configured and enabled', Teal, 'data/teal_test/tealtest_03.conf', 'stderr', self.msglevel,'now','realtime',False, False, None, False, '', False) def testTooManyDatabases(self): ''' Verify that Teal fails if more than one database is specified''' #TODO: Need to create a dummy database connection or full db connection usport #self.assertRaises(TealError, Teal, 'data/teal_test/tealtest_02.conf', 'stderr') pass def testBadEnabled(self): '''Verify failure when plugin section has bad value for enabled keyword''' self.assertRaisesTealError(TealError, "Configuration section 'event_monitor.EventMonitorNoop' has an unrecognized value for enabled keyword: 'bad_value'", Teal, 'data/teal_test/bad_02.conf','stderr', self.msglevel,'now','realtime',False, False, None, False, '', False) def testBadEnvHasConfig(self): ''' Verify failure when environment section specifies a config dir ''' self.assertRaisesTealError(TealError, "Option 'TEAL_CONF_DIR' is not allowed in the 'environment' stanza", Teal, 'data/teal_test/bad_03.conf','stderr', self.msglevel,'now','realtime',False, False, None, False, '', False) def testBadRunModeValue(self): ''' Verify failure if bad runmode is passed ''' self.assertRaisesTealError(TealError, "Unrecognized run mode specified: bad_mode", Teal, 'data/teal_test/bad_02.conf', 'stderr', self.msglevel, 'now', 'bad_mode') def testEnabledRealtime(self): ''' Verify that realtime indicator on enabled plug-in control works ''' teal = Teal('data/teal_test/good_01.conf', 'stderr', msgLevel=self.msglevel, run_mode='realtime', commit_alerts=False, commit_checkpoints=False) event_q_lsrs = registry.get_service(SERVICE_EVENT_Q).listener_methods self.assertEquals(len(event_q_lsrs), 2) names = [] for lsr_m in event_q_lsrs: names.append(lsr_m.__self__.get_name()) self.assertTrue('AnalyzerTest055a' in names) self.assertTrue('AnalyzerTest055b' in names) teal.shutdown() def testEnabledHistoric(self): ''' Verify that historic indicator on enabled plug-in control works ''' teal = Teal('data/teal_test/good_01.conf', 'stderr', msgLevel=self.msglevel, run_mode='historic', commit_alerts=False, commit_checkpoints=False) event_q_lsrs = registry.get_service(SERVICE_EVENT_Q).listener_methods self.assertEquals(len(event_q_lsrs), 1) names = [] for lsr_m in event_q_lsrs: names.append(lsr_m.__self__.get_name()) self.assertTrue('AnalyzerTest055a' in names) teal.shutdown() def testHistoricOnlyHistoric(self): ''' Verify that the historic monitor can only be run in historic mode ''' self.assertRaisesTealError(TealError, "Historic monitor can only enabled for historic use. Unsupported value specified: realtime", Teal, 'data/teal_test/bad_hist_mon_01.conf', 'stderr', self.msglevel, 'now', 'realtime') self.assertRaisesTealError(TealError, "Historic monitor can only enabled for historic use. Unsupported value specified: all", Teal, 'data/teal_test/bad_hist_mon_02.conf', 'stderr', self.msglevel, 'now', 'historic') # Should run ... clear the DB and run it with no events, so nothing will happen self.prepare_db() teal = Teal('data/teal_test/bad_hist_mon_03.conf', 'stderr', self.msglevel, 'now', 'historic') teal.shutdown() def testRealtimeOnlyRealtime(self): ''' Verify that the realtime monitor can only be run in realtime mode ''' self.assertRaisesTealError(TealError, "Realtime monitor can only enabled for realtime use. Unsupported value specified: historic", Teal, 'data/teal_test/bad_real_mon_01.conf', 'stderr', self.msglevel, 'now', 'historic') self.assertRaisesTealError(TealError, "Realtime monitor can only enabled for realtime use. Unsupported value specified: all", Teal, 'data/teal_test/bad_real_mon_02.conf', 'stderr', self.msglevel, 'now', 'realtime') # Notifier is checked after the enabled check ... so this makes sure enabled check passed keep_ev = self.remove_env('TEAL_TEST_NOTIFIER_CONFIG') self.assertRaisesTealError(TealError, "RealtimeMonitor requires notifier be specified in the configuration file or as an environment variable", Teal, 'data/teal_test/bad_real_mon_03.conf', 'stderr', self.msglevel, 'now', 'realtime') self.restore_env('TEAL_TEST_NOTIFIER_CONFIG', keep_ev) def testEnvInConfig(self): ''' Test that having env in the config works ''' keep_root_dir = self.remove_env(TEAL_ROOT_DIR) keep_log_dir = self.remove_env(TEAL_LOG_DIR) keep_data_dir = self.remove_env(TEAL_DATA_DIR) self.teal = Teal('data/teal_test/env_test.conf', 'stderr', msgLevel=self.msglevel, data_only=True, commit_alerts=False, commit_checkpoints=False) root_dir = registry.get_service(registry.TEAL_ROOT_DIR) data_dir = registry.get_service(registry.TEAL_DATA_DIR) log_dir = registry.get_service(registry.TEAL_LOG_DIR) tealp = Process(target=check_environment, args=(root_dir, data_dir, log_dir)) tealp.start() tealp.join() self.teal.shutdown() self.restore_env(TEAL_ROOT_DIR, keep_root_dir) self.restore_env(TEAL_LOG_DIR, keep_log_dir) self.restore_env(TEAL_DATA_DIR, keep_data_dir) # After everything is restored, make sure that the subprocess completed successfully self.assertEquals(tealp.exitcode, 0)
class AlertTestBasic(TealTestCase): def setUp(self): self.teal = Teal('data/common/configurationtest.conf','stderr',msgLevel=self.msglevel, commit_alerts=False, commit_checkpoints=False) def tearDown(self): '''Nothing to do ... yet ''' self.teal.shutdown() def testAlertRawDataDict(self): ''' test the raw data dictionary support ''' t_alert = get_service(SERVICE_ALERT_MGR).allocate('TestAlert', {}) # Test with no raw data t_dictO = t_alert.get_raw_data_as_dict() self.assertEquals(t_alert.raw_data, None) self.assertEquals(len(t_dictO), 1) self.assertTrue('non_dict_raw_data' in t_dictO) self.assertEquals(t_dictO['non_dict_raw_data'], None) t_dictO = None # Set raw data to a value t_alert.raw_data = 'stuff' t_dict0 = t_alert.get_raw_data_as_dict() self.assertEquals(t_alert.raw_data, 'stuff') self.assertEquals(len(t_dict0), 1) self.assertTrue('non_dict_raw_data' in t_dict0) self.assertEquals(t_dict0['non_dict_raw_data'], 'stuff') t_dict0['k1'] = 'v1' t_alert.set_raw_data_from_dict(t_dict0) self.assertEquals(t_alert.raw_data, '{"k1":"v1"}stuff') t_dict2 = t_alert.get_raw_data_as_dict() self.assertEquals(len(t_dict2), 2) self.assertTrue('non_dict_raw_data' in t_dict2) self.assertEquals(t_dict2['non_dict_raw_data'], 'stuff') self.assertTrue('k1' in t_dict2) self.assertEquals(t_dict2['k1'], 'v1') t_dict2 = None t_dict0['k2'] = 'v2' t_alert.set_raw_data_from_dict(t_dict0) self.assertEquals(t_alert.raw_data, '{"k2":"v2","k1":"v1"}stuff') t_dict2 = t_alert.get_raw_data_as_dict() self.assertEquals(len(t_dict2), 3) self.assertTrue('non_dict_raw_data' in t_dict2) self.assertEquals(t_dict2['non_dict_raw_data'], 'stuff') self.assertTrue('k1' in t_dict2) self.assertEquals(t_dict2['k1'], 'v1') self.assertTrue('k2' in t_dict2) self.assertEquals(t_dict2['k2'], 'v2') t_dict0 = {'key1':'value1','key3':'value3'} t_alert.raw_data = None t_dictO = t_alert.get_raw_data_as_dict() self.assertEquals(t_alert.raw_data, None) self.assertEquals(len(t_dictO), 1) self.assertTrue('non_dict_raw_data' in t_dictO) self.assertEquals(t_dictO['non_dict_raw_data'], None) t_dictO = None t_alert.set_raw_data_from_dict(t_dict0) self.assertEquals(t_alert.raw_data, '{"key3":"value3","key1":"value1"}') t_dict2 = t_alert.get_raw_data_as_dict() self.assertEquals(len(t_dict2), 2) self.assertTrue('non_dict_raw_data' not in t_dict2) self.assertTrue('key1' in t_dict2) self.assertEquals(t_dict2['key1'], 'value1') self.assertTrue('key3' in t_dict2) self.assertEquals(t_dict2['key3'], 'value3') t_dict0 = {'non_dict_raw_data':'when in the course'} t_alert.set_raw_data_from_dict(t_dict0) self.assertEquals(t_alert.raw_data, 'when in the course') # Bug test t_alert.raw_data = '{"fru_list":"{HFI_DDG,Isolation Procedure,,,},{HFI_CAB,Symbolic Procedure,Uf.i.s-P1-T11-T3,,},{CABCONT,Symbolic Procedure,Uf.i.s-P1-T11-T3,,},{47K1234,FRU,Ug.h.t-P1-R2, 47K1234,YL55555,ABC123,TRMD},{47K1234,FRU,Uf.i.s-P1-R3,47K1234,YL12345,ABC123,TRMD},"}' n_dict = t_alert.get_raw_data_as_dict() return
def generate_event_log(self, event_lines): ''' Generate the event data required to log an AMM event This will return two tuples, the first one is the data for the common event structure and the second is for the extended data ''' t = Teal(None, data_only=True, msgLevel='warn', logFile='$TEAL_LOG_DIR/tlammtraphandler.log') db = registry.get_service(registry.SERVICE_DB_INTERFACE) event_valid = self.is_valid() # Generate the event id src_comp = 'AMM' if event_valid: event_id = hex(self.evt_name).upper()[2:].rjust(8,'0') # Check if this event should be reported or not if event_filtered(event_id): return time_occurred = self.date_time src_loc_type = 'D' try: src_node_address = socket.gethostbyaddr(self.sys_ip_address)[0] except socket.herror: src_node_address = self.sys_ip_address if (self.source_id.startswith('BLADE_')): tmp_loc = find_blade_name(db, self.sys_ip_address, self.source_id) # If a node was found, use that instead of the AMM address if (tmp_loc != self.source_id): src_loc = tmp_loc else: # Unknown blade - report it as a subcomponent of the AMM src_loc = '{0}##{1}'.format(src_node_address, self.source_id) else: src_loc = '{0}##{1}'.format(src_node_address, self.source_id) rpt_comp = 'AMM' rpt_loc_type = 'A' rpt_loc = src_node_address else: event_id = AMM_INVALID_EVENT time_occurred = datetime.now() src_loc_type = 'A' src_loc = socket.gethostname() rpt_comp = None rpt_loc_type = None rpt_loc = None # Generate the extended data if event_valid: raw_data_fmt = AMM_EXTDATA_FMT raw_data = None exd = (self.app_id, self.sp_txt_id, self.sys_uuid, self.sys_sern, self.app_type, self.priority, self.msg_text, self.host_contact, self.host_location, self.blade_name, self.blade_sern, self.blade_uuid, self.evt_name, self.source_id, self.call_home_flag, self.sys_ip_address, self.sys_machine_model, self.blade_machine_model) else: raw_data_fmt = 0 raw_data = event_lines[0:2048] exd = None # Generate the common base event conn = db.get_connection() cursor = conn.cursor() cbe = (event_id, time_occurred, src_comp, src_loc_type, src_loc, rpt_comp, rpt_loc_type, rpt_loc, raw_data_fmt, raw_data) db.insert(cursor, [event.EVENT_ATTR_EVENT_ID, event.EVENT_ATTR_TIME_OCCURRED, event.EVENT_ATTR_SRC_COMP, event.EVENT_ATTR_SRC_LOC_TYPE, event.EVENT_ATTR_SRC_LOC, event.EVENT_ATTR_RPT_COMP, event.EVENT_ATTR_RPT_LOC_TYPE, event.EVENT_ATTR_RPT_LOC, event.EVENT_ATTR_RAW_DATA_FMT, event.EVENT_ATTR_RAW_DATA], db_interface.TABLE_EVENT_LOG, parms=cbe) if exd: db.insert_dependent(cursor, event.EVENT_ATTR_REC_ID, [AMM_APP_ID, AMM_SP_TXT_ID, AMM_SYS_UUID, AMM_SYS_SERN, AMM_APP_TYPE, AMM_PRIORITY, AMM_MSG_TEXT, AMM_HOST_CONTACT, AMM_HOST_LOCATION, AMM_BLADE_NAME, AMM_BLADE_SERN, AMM_BLADE_UUID, AMM_EVT_NAME, AMM_SOURCE_ID, AMM_CALL_HOME_FLAG, AMM_SYS_IP_ADDRESS, AMM_SYS_MACHINE_MODEL, AMM_BLADE_MACHINE_MODEL], extdata.extdata_fmt2table_name(AMM_EXTDATA_FMT), parms=exd) conn.commit() cursor.close() conn.close() t.shutdown() # Tell TEAL that a new event has been added teal_semaphore.Semaphore().post()
class TealCheckpointShutdownTest(TealTestCase): def setUp(self): # Setup to use the tllsckpt command t = Teal('data/tlcommands_test/test.conf', 'stderr', msgLevel=self.msglevel, data_only=True) teal_path = registry.get_service(registry.TEAL_ROOT_DIR) self.tllsckpt = os.path.join(teal_path,'bin/tllsckpt') t.shutdown() self.prepare_db() # Need to have checkpointing to DB off so this doesn't interfer with the other instance of TEAL's checkpoints self.teal = Teal('data/checkpoint_test/noop_monitor.conf','stderr',msgLevel=self.msglevel, commit_checkpoints=False) self.db = registry.get_service(registry.SERVICE_DB_INTERFACE) self.query = self.db.gen_select( [EVENT_CPF_CHKPT_ID, EVENT_CPF_NAME, EVENT_CPF_STATUS, EVENT_CPF_EVENT_RECID, EVENT_CPF_DATA], db_interface.TABLE_CHECKPOINT) self.query_mon_data = self.db.gen_select([EVENT_CPF_DATA], db_interface.TABLE_CHECKPOINT, where="${0} = 'monitor_event_queue'".format(EVENT_CPF_NAME), where_fields=[EVENT_CPF_NAME]) self.truncate = self.db.gen_truncate(db_interface.TABLE_CHECKPOINT) def tearDown(self): self.teal.shutdown() def testContolledShutdownClean(self): # Make sure the checkpoint table has no values cnxn = self.db.get_connection() cnxn.cursor().execute(self.truncate) cnxn.commit() # Start teal and let it shutdown gracefully tealp = Process(target=run_teal, args=(self.msglevel,1.0)) tealp.start() tealp.join() # Now check the table to be sure we shut down cleanly cnxn = self.db.get_connection() cursor = cnxn.cursor() cursor.execute(self.query) row = cursor.fetchone() self.assertTrue(row) self.assertEqual(row[1],'Demo1Analyzer') self.assertEqual(row[2],'S') self.assertEqual(row[3], None) self.assertEqual(row[4], None) row = cursor.fetchone() self.assertTrue(row) self.assertEqual(row[1],'monitor_event_queue') self.assertEqual(row[2],'S') self.assertEqual(row[3], None) self.assertEqual(row[4], 'recovery None') row = cursor.fetchone() self.assertEqual(row, None) self.assertCmdWorks([self.tllsckpt], exp_good_msg='Demo1Analyzer S Nonemonitor_event_queue S NoneMAX_event_rec_id None', exp_err_msg='', print_out=False) self.assertCmdWorks([self.tllsckpt, '-f', 'brief'], exp_good_msg='Demo1Analyzer S Nonemonitor_event_queue S NoneMAX_event_rec_id None', exp_err_msg='', print_out=False) self.assertCmdWorks([self.tllsckpt, '-f', 'text'], exp_good_msg='===================================================' + 'name : Demo1Analyzer' + 'status : S' + 'event_recid : None' + 'data : None' + '===================================================' + 'name : monitor_event_queue' + 'status : S' + 'event_recid : None' + 'data : recovery None' + '===================================================' + 'name : MAX_event_rec_id' + 'status : ' + 'event_recid : None' + 'data :', exp_err_msg='', print_out=False) self.assertCmdWorks([self.tllsckpt, '-f', 'json'], exp_good_msg='{"status": "S", "data": null, "name": "Demo1Analyzer", "event_recid": null}' + '{"status": "S", "data": "recovery None", "name": "monitor_event_queue", "event_recid": null}' + '{"status": " ", "data": "", "name": "MAX_event_rec_id", "event_recid": null}', exp_err_msg='', print_out=False) self.assertCmdWorks([self.tllsckpt, '-f', 'csv'], exp_good_msg='Demo1Analyzer,S,,monitor_event_queue,S,,recovery NoneMAX_event_rec_id, ,,', exp_err_msg='', print_out=False) cnxn.close() return def testControlledShutdownDirty(self): # Start TEAL and let it shutdown badly tealp = Process(target=run_teal, args=(self.msglevel,1000.0)) tealp.start() try_times = 11 time.sleep(10) while try_times > 0: time.sleep(1) cnxn = self.db.get_connection() cursor = cnxn.cursor() cursor.execute(self.query_mon_data) row = cursor.fetchone() if row is not None: try_times = 0 else: try_times -= 1 #cnxn.close() <<<< uncommenting changing the timing enough that it stops working! tealp.terminate() tealp.join() # Now check the table to be sure we shut down cleanly cnxn = self.db.get_connection() cursor = cnxn.cursor() cursor.execute(self.query) row = cursor.fetchone() self.assertEqual(row[1],'Demo1Analyzer') self.assertEqual(row[2],'R') self.assertEqual(row[3], None) self.assertEqual(row[4], None) row = cursor.fetchone() self.assertEqual(row[1],'monitor_event_queue') self.assertEqual(row[2],'R') self.assertEqual(row[3], None) self.assertEqual(row[4], 'recovery None') row = cursor.fetchone() self.assertEqual(row, None) self.assertCmdWorks([self.tllsckpt], exp_good_msg='Demo1Analyzer R Nonemonitor_event_queue R NoneMAX_event_rec_id None', exp_err_msg='', print_out=False) self.assertCmdWorks([self.tllsckpt, '-f', 'brief'], exp_good_msg='Demo1Analyzer R Nonemonitor_event_queue R NoneMAX_event_rec_id None', exp_err_msg='', print_out=False) self.assertCmdWorks([self.tllsckpt, '-f', 'text'], exp_good_msg='===================================================' + 'name : Demo1Analyzer' + 'status : R' + 'event_recid : None' + 'data : None' + '===================================================' + 'name : monitor_event_queue' + 'status : R' + 'event_recid : None' + 'data : recovery None' + '===================================================' + 'name : MAX_event_rec_id' + 'status : ' + 'event_recid : None' + 'data :', exp_err_msg='', print_out=False) self.assertCmdWorks([self.tllsckpt, '-f', 'json'], exp_good_msg='{"status": "R", "data": null, "name": "Demo1Analyzer", "event_recid": null}' + '{"status": "R", "data": "recovery None", "name": "monitor_event_queue", "event_recid": null}' + '{"status": " ", "data": "", "name": "MAX_event_rec_id", "event_recid": null}', exp_err_msg='', print_out=False) self.assertCmdWorks([self.tllsckpt, '-f', 'csv'], exp_good_msg='Demo1Analyzer,R,,monitor_event_queue,R,,recovery NoneMAX_event_rec_id, ,,', exp_err_msg='', print_out=False) cnxn.close() return
def run_teal(msglevel, sleep_amount): teal = Teal('data/checkpoint_test/configurationtest_05_semaphore.conf', 'stderr', msgLevel=msglevel) time.sleep(sleep_amount) teal.shutdown() return
class AlertAnalyzerFilterTest(TealTestCase): """Test the alert delivery (filters and listeners)""" def setUp(self): """Setup Teal""" # Not testing duplicates, so OK to turn off self.keep_ADC = self.force_env("TEAL_ALERT_DUPLICATE_CHECK", "No") self.teal = Teal( "data/alert_delivery_test/analyzer_filter/test.conf", "stderr", msgLevel=self.msglevel, commit_alerts=False, commit_checkpoints=False, ) return def tearDown(self): """Teardown teal""" self.teal.shutdown() self.restore_env("TEAL_ALERT_DUPLICATE_CHECK", self.keep_ADC) return def testGeneralFilters(self): """test alert delivery with global and local filtering""" j_in_dq = Journal("j_in_DQ", "data/alert_delivery_test/analyzer_filter/inject_DQ_alerts.json") dq_q = get_service(SERVICE_ALERT_DELIVERY_Q) # Get the AlertListenerJournal journals listeners = get_service(SERVICE_ALERT_DELIVERY).listeners for listener in listeners: name = listener.get_name() if name == "AllAlerts": j_out_all = listener.journal if name == "OnlyAnalyzer1": j_out_analyzer1 = listener.journal if name == "AnyButAnalyzer1": j_out_not_analyzer1 = listener.journal if name == "OnlyAnalyzer2and3": j_out_analyzer2and3 = listener.journal if name == "AnyButAnalyzer2and3": j_out_not_analyzer2and3 = listener.journal if name == "AnyButAnalyzer1and2and3": j_out_not_analyzer1and2and3 = listener.journal # inject j_in_dq.inject_queue(dq_q) # Get expected values j_out_all_exp = Journal("all_exp", "data/alert_delivery_test/analyzer_filter/alerts_out_all.json") j_out_analyzer1_exp = Journal("analyzer1", "data/alert_delivery_test/analyzer_filter/alerts_out_analyzer1.json") j_out_not_analyzer1_exp = Journal( "not_analyzer1", "data/alert_delivery_test/analyzer_filter/alerts_out_not_analyzer1.json" ) j_out_analyzer2and3_exp = Journal( "analyzer2and3", "data/alert_delivery_test/analyzer_filter/alerts_out_analyzer2and3.json" ) j_out_not_analyzer2and3_exp = Journal( "not_analyzer2and3", "data/alert_delivery_test/analyzer_filter/alerts_out_not_analyzer2and3.json" ) j_out_not_analyzer1and2and3_exp = Journal( "not_analyzer1and2and3", "data/alert_delivery_test/analyzer_filter/alerts_out_not_analyzer1and2and3.json" ) # wait for stuff to come out self.assertTrue(j_out_all.wait_for_entries(len(j_out_all_exp))) self.assertTrue(j_out_analyzer1.wait_for_entries(len(j_out_analyzer1_exp))) self.assertTrue(j_out_not_analyzer1.wait_for_entries(len(j_out_not_analyzer1_exp))) self.assertTrue(j_out_analyzer2and3.wait_for_entries(len(j_out_analyzer2and3_exp))) self.assertTrue(j_out_not_analyzer2and3.wait_for_entries(len(j_out_not_analyzer2and3_exp))) self.assertTrue(j_out_not_analyzer1and2and3.wait_for_entries(len(j_out_not_analyzer1and2and3_exp))) # Check that it was what was expected self.assertTrue(j_out_all.deep_match(j_out_all_exp, ignore_delay=True, ignore_times=True)) self.assertTrue(j_out_analyzer1.deep_match(j_out_analyzer1_exp, ignore_delay=True, ignore_times=True)) self.assertTrue(j_out_not_analyzer1.deep_match(j_out_not_analyzer1_exp, ignore_delay=True, ignore_times=True)) self.assertTrue(j_out_analyzer2and3.deep_match(j_out_analyzer2and3_exp, ignore_delay=True, ignore_times=True)) self.assertTrue( j_out_not_analyzer2and3.deep_match(j_out_not_analyzer2and3_exp, ignore_delay=True, ignore_times=True) ) self.assertTrue( j_out_not_analyzer1and2and3.deep_match( j_out_not_analyzer1and2and3_exp, ignore_delay=True, ignore_times=True ) ) return
class JournalTestWithDB(TealTestCase): def testJournalWriteEventDB1(self): ''' Test writing to Event log DB basic ''' self.teal = Teal('data/journal_test/events_001.conf','stderr',msgLevel=self.msglevel) j = Journal('DB test journal to write', file='data/journal_test/events_001.json') j.insert_in_db(truncate=True, no_delay=True) jdb = Journal('DB test journal to read') jdb.select_from_db('event') self.assertTrue(j.deep_match(jdb, ignore_delay=True, ignore_times=False, ignore_rec_id=False)) #p rint j #p rint jdb self.teal.shutdown() return def testJournalWriteEventDB2(self): ''' Test writing to Event log DB without recids ''' self.teal = Teal('data/journal_test/events_001.conf','stderr',msgLevel=self.msglevel) j = Journal('DB test journal to write', file='data/journal_test/events_001.json') j.insert_in_db(truncate=True, use_rec_ids=False, no_delay=True) jdb = Journal('DB test journal to read') jdb.select_from_db('event') self.assertTrue(j.deep_match(jdb, ignore_delay=True, ignore_times=False, ignore_rec_id=True)) #p rint j #p rint jdb self.teal.shutdown() return def testJournalWriteEventDB3(self): ''' Test reading from event DB with a subset of fields ''' self.teal = Teal('data/journal_test/events_001.conf','stderr',msgLevel=self.msglevel) j = Journal('DB test journal to write', file='data/journal_test/events_001.json') j.insert_in_db(truncate=True, use_rec_ids=False, no_delay=True) jdb = Journal('DB test journal to read') jdb.select_from_db('event', event_fields=[EVENT_ATTR_REC_ID, EVENT_ATTR_EVENT_ID]) jexp = Journal('DB expected', 'data/journal_test/events_004.json') self.assertTrue(jexp.deep_match(jdb, ignore_delay=True, ignore_times=False, ignore_rec_id=True)) #p rint j #p rint jdb self.teal.shutdown() return def testJournalWriteAlertDB1(self): ''' Test writing of Alert log DB basic ''' self.teal = Teal('data/journal_test/events_001.conf','stderr',msgLevel=self.msglevel) # Events je = Journal('DB test input EVENTS', file='data/journal_test/events_002.json') je.insert_in_db(truncate=True, no_delay=True) # Alerts ja = Journal('DB test input ALERTS', file='data/journal_test/alerts_002.json') ja.insert_in_db(truncate=False, no_delay=True) # Check events jedb = Journal('Read DB test EVENTS') jedb.select_from_db('event') self.assertTrue(je.deep_match(jedb, ignore_delay=True, ignore_times=False, ignore_rec_id=False)) #p rint je #p rint jedb # Check alerts jadb = Journal('Read DB test ALERTS') jadb.select_from_db('alert') self.assertTrue(ja.deep_match(jadb, ignore_delay=True, ignore_times=False, ignore_rec_id=False)) #p rint ja #p rint jadb self.teal.shutdown() return def testJournalWriteAlertDB2(self): ''' Test getting alerts without associations ''' self.teal = Teal('data/journal_test/events_001.conf','stderr',msgLevel=self.msglevel) # Events je = Journal('DB test input EVENTS', file='data/journal_test/events_002.json') je.insert_in_db(truncate=True, no_delay=True) # Alerts ja = Journal('DB test input ALERTS', file='data/journal_test/alerts_002.json') ja.insert_in_db(truncate=False, no_delay=True) # Check alerts jadb = Journal('Read DB test ALERTS') jadb.select_from_db('alert', include_alert_assoc=False) jaexp = Journal('DB test expected', 'data/journal_test/alerts_003.json') self.assertTrue(jaexp.deep_match(jadb, ignore_delay=True, ignore_times=False, ignore_rec_id=False)) #p rint ja #p rint jadb self.teal.shutdown() return def testJournalWriteAlertDB3(self): ''' Test getting only some fields of an alert ''' self.teal = Teal('data/journal_test/events_001.conf','stderr',msgLevel=self.msglevel) # Events je = Journal('DB test input EVENTS', file='data/journal_test/events_002.json') je.insert_in_db(truncate=True, no_delay=True) # Alerts ja = Journal('DB test input ALERTS', file='data/journal_test/alerts_002.json') ja.insert_in_db(truncate=False, no_delay=True) # Check alerts jadb = Journal('Read DB test ALERTS') jadb.select_from_db('alert', include_alert_assoc=False, alert_fields=[ALERT_ATTR_REC_ID, ALERT_ATTR_ALERT_ID, ALERT_ATTR_RECOMMENDATION]) jaexp = Journal('DB test expected', 'data/journal_test/alerts_005.json') self.assertTrue(jaexp.deep_match(jadb, ignore_delay=True, ignore_times=False, ignore_rec_id=False)) #p rint ja #p rint jadb self.teal.shutdown() return def testJournalWriteAlertDB4(self): ''' Test writing of Alert log queue after reading from DB ''' # This test does not work with duplicate checking -- probably don't want it to keep_ADC = self.force_env('TEAL_ALERT_DUPLICATE_CHECK', 'No') self.teal = Teal('data/journal_test/events_002.conf','stderr',msgLevel=self.msglevel) # Events je = Journal('DB test input EVENTS', file='data/journal_test/events_002.json') je.insert_in_db(truncate=True, no_delay=True) # Alerts ja = Journal('DB test input ALERTS', file='data/journal_test/alerts_002.json') ja.insert_in_db(truncate=False, no_delay=True) # Check events jedb = Journal('Read DB test EVENTS') jedb.select_from_db('event') self.assertTrue(je.deep_match(jedb, ignore_delay=True, ignore_times=False, ignore_rec_id=False)) # Check alerts jadb = Journal('Read DB test ALERTS') jadb.select_from_db('alert') self.assertTrue(ja.deep_match(jadb, ignore_delay=True, ignore_times=False, ignore_rec_id=False)) # Now insert into the Delivery Queue and make sure all come out jadb.inject_queue(get_service(SERVICE_ALERT_DELIVERY_Q), progress_cb=None, fail_on_invalid=False, no_delay=True) listeners = get_service(SERVICE_ALERT_DELIVERY).listeners for listener in listeners: name = listener.get_name() if name == 'Journal': j_out_all = listener.journal self.assertTrue(j_out_all.wait_for_entries(6)) self.assertTrue(j_out_all.deep_match(jadb, ignore_delay=True, ignore_times=True)) self.teal.shutdown() self.restore_env('TEAL_ALERT_DUPLICATE_CHECK', keep_ADC) return
class LocationTest(TealTestCase): def setUp(self): self.teal = Teal('data/location_test/locationtest_01.conf', 'stderr', msgLevel=self.msglevel, commit_alerts=False, commit_checkpoints=False) def tearDown(self): self.teal.shutdown() def testSimpleGood(self): ''' Test good path simple locations ''' simple1 = Location('TS','a') self.assertEqual(simple1.get_location(),'a') simple2 = Location('TS','a.b') self.assertEqual(simple2.get_location(),'a.b') simple3 = Location('TS','a.b.c') self.assertEqual(simple3.get_location(),'a.b.c') def testComplexGood(self): ''' Test good path complex locations ''' # Minimum tree specified complex1 = Location('TC',"R") self.assertEqual(complex1.get_location(),'R') complex2 = Location('TC',"R-H") self.assertEqual(complex2.get_location(),'R-H') # No value allowed complex3 = Location('TC',"R-H-JC") self.assertEqual(complex3.get_location(),'R-H-JC') # min-only specified complex4 = Location('TC',"R-H-MM12345") self.assertEqual(complex4.get_location(),'R-H-MM12345') complex4a = Location('TC',"R-H-MM"+str(sys.maxint)) self.assertEqual(complex4a.get_location(),'R-H-MM'+str(sys.maxint)) # Range specified complex5 = Location('TC',"R-H-PS9") self.assertEqual(complex5.get_location(),'R-H-PS9') # max-only specified complex6 = Location('TC',"R-H-K0") self.assertEqual(complex6.get_location(),'R-H-K0') # Full tree specified complex7 = Location('TC',"R-H-K20-S") self.assertEqual(complex7.get_location(),'R-H-K20-S') def testComplexBad(self): ''' Test invalid complex locations ''' keep_env = self.force_env('TEAL_LOCATION_VALIDATION', 'IMMEDIATE') self.assertRaises(KeyError, Location, 'TZ',"R-H") # Invalid Type of Location self.assertRaises(TypeError, Location, 'TC',["R","H"]) # Create with something that is not a string self.assertRaises(ValueError, Location, 'TC',"R01") # No value allowed self.assertRaises(ValueError, Location, 'TC',"R-H02") # No value allowed child self.assertRaises(ValueError, Location, 'TC',"R-H-JC10") # No value allowed leaf self.assertRaises(ValueError, Location, 'TC',"R-H-PS") # No value specified but required ) self.assertRaises(ValueError, Location, 'TC',"R-H-PS0") # Below specified min value (min/max specified) self.assertRaises(ValueError, Location, 'TC',"R-H-PS11") # Above specified max value (min/max specified) self.assertRaises(ValueError, Location, 'TC',"R-H-MM4") # Below specified min value (min-only specified) self.assertRaises(ValueError, Location, 'TC',"R-H-K21") # Above specified max value (max-only specified) self.assertRaises(ValueError, Location, 'TC',"R-H-K20-S12") # No value allowed on leaf after multi-node component self.assertRaises(ValueError, Location, 'TC',"R-H-K20-S-Z") # Too many components self.assertRaises(ValueError, Location, 'TC',"R-H-X-S") # Unknown component self.assertRaises(ValueError, Location, 'TC',"R-xH-X-S") # Bad front end self.assertRaises(ValueError, Location, 'TC',"R-Hx1-X-S") # Bad back end self.restore_env('TEAL_LOCATION_VALIDATION', keep_env) return def testComplexBadDefered(self): ''' Test invalid complex locations with validation deferred ''' cbad1 = Location('TZ', 'R-H') self.assertEqual('TZ: R-H', str(cbad1)) self.assertRaises(KeyError, cbad1.get_substitution_dict) self.assertRaises(KeyError, cbad1.get_comp_value, 'dummy') self.assertRaises(KeyError, cbad1.new_location_by_scope, 'dummy') self.assertEqual('TZ', cbad1.get_id()) self.assertEqual('R-H', cbad1.get_location()) cbad2 = Location('TZ', 'R-H') cbad3 = Location('TZ', 'R-I') self.assertTrue(cbad1 == cbad2) self.assertFalse(cbad1 == cbad3) self.assertTrue(cbad1.match(cbad2, None)) self.assertRaises(KeyError, cbad1.match, cbad2, 'dummy') return def testSimpleMatch(self): simple1 = Location('TS','a.b.c') simple2 = Location('TS','a.b.z') simple3 = Location('TS','x.y.z') self.assertTrue(simple1.match(simple1)) self.assertFalse(simple1.match(simple2)) self.assertTrue(simple1.match(simple2,'child')) self.assertTrue(simple1.match(simple2,'parent')) self.assertFalse(simple1.match(simple3)) self.assertFalse(simple1.match(simple3,'child')) self.assertFalse(simple1.match(simple3,'parent')) def testComplexMatch(self): ''' Test matching scopes with complex locations ''' complex1 = Location('TC',"R-H-PS9") complex2 = Location('TC',"R-H-K8-S") complex3 = Location('TC',"R-H-K9-S") self.assertTrue(complex1.match(complex1)) self.assertTrue(complex1.match(complex1)) self.assertFalse(complex1.match(complex2)) self.assertTrue(complex1.match(complex2,'home')) self.assertTrue(complex1.match(complex2,'top')) self.assertFalse(complex2.match(complex3)) # Can do different length w/o problems complex2 = Location('TC','R-H') complex3 = Location('TC','R-H-K9-S') self.assertFalse(complex2.match(complex3,'kilroy')) self.assertFalse(complex3.match(complex2,'kilroy')) def testComplexMatchBad(self): ''' Test matching scopes with complex locations and errors ''' simple1 = Location('TS','a.b.c') simple2 = Location('TS','a.b.z') complex1 = Location('TC',"R-H-PS9") # Can't mix location types self.assertFalse(simple1.match(complex1)) # Can't use an invalid location component self.assertRaises(KeyError, simple1.match, simple2,'mom') def testSimpleComponentValues(self): ''' Test getting the value of a component for simple locations ''' simple1 = Location('TS','a.b.c') self.assertEquals(simple1.get_comp_value('grandchild'),'c') self.assertEquals(simple1.get_comp_value('child'),'b') self.assertEquals(simple1.get_comp_value('parent'),'a') def testComplexComponentValues(self): ''' Test getting the value of a component for complex locations ''' complex1 = Location('TC',"R-H-K8-S") self.assertEquals(complex1.get_comp_value('kilroy'),'8') def testComplexComponentValuesBad(self): ''' Test getting the value of a component for complex locations ''' complex1 = Location('TC',"R-H-K8-S") self.assertRaises(ValueError, complex1.get_comp_value, 'home') self.assertRaises(ValueError, complex1.get_comp_value, 'jecarey') def testNewLocationByScope(self): ''' Test creating a new location with a given scope ''' complex1 = Location('TC',"R-H-K8-S") complex2 = complex1.new_location_by_scope('kilroy') self.assertEquals(complex2,Location('TC','R-H-K8')) complex3 = complex1.new_location_by_scope('home') complex4 = complex2.new_location_by_scope('home') self.assertEquals(complex3,complex4) self.assertRaises(KeyError, complex1.new_location_by_scope, 'bad') # Scoping lower than the id will just return the id complex5 = complex3.new_location_by_scope('kilroy') self.assertEquals(complex3,complex5) def testMisc(self): ''' Test miscellaneous Location capabilities ''' l1 = Location("TS",'foo') l2 = Location("TC",'R-H-K8-S') self.assertNotEqual(hash(l1),hash(l2)) self.assertEquals(hash(l1),hash(l1)) self.assertEqual(l1.get_id(),'TS') self.assertEqual(l2.get_id(),'TC') def testLocationService(self): ''' Test Location Service public functions ''' loc_svc = registry.get_service(SERVICE_LOCATION) self.assertTrue(loc_svc.is_scope_valid('TC','kilroy')) self.assertFalse(loc_svc.is_scope_valid('TC','archerc')) def testSubstitutionDict(self): ''' Test getting the substitution dictionary ''' l1 = Location("TS",'foo') sd1 = l1.get_substitution_dict() self.assertEquals(len(sd1.keys()), 1) self.assertTrue('parent' in sd1) self.assertEquals(sd1['parent'], 'foo') l2 = Location("TC",'R-H-K8-S') sd2 = l2.get_substitution_dict() self.assertEquals(len(sd2.keys()), 4) self.assertTrue('kilroy' in sd2) self.assertEquals(sd2['kilroy'], 'K8') self.assertTrue('src' in sd2) self.assertEquals(sd2['src'], 'S') self.assertTrue('top' in sd2) self.assertEquals(sd2['top'], 'R') self.assertTrue('home' in sd2) self.assertEquals(sd2['home'], 'H') return