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
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
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()
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
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
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 testFilter(self):
''' Test that a duplicate is filtered when backed by a database
'''
j = Journal('AlertAnalyzer', 'data/alert_test/inject_DQ_alerts.json')
j.inject_queue(registry.get_service(SERVICE_ALERT_DELIVERY_Q))
alj = find_listener()
alj.journal.wait_for_entries(4)
out_j = Journal('AlertListener', 'data/alert_filter_test/unfiltered_alerts.json')
self.assertTrue(alj.journal.deep_match(out_j, ignore_times=True))
def testSmtpAlertListener(self):
''' Test the SMTP Alert Listener '''
server = start_smtp_server()
t = teal.Teal('data/alert_listener_test/test_01.conf', msgLevel=self.msglevel, logFile='stderr', commit_alerts=False, commit_checkpoints=False)
in_j = Journal('SMTP Journal', 'data/alert_test/inject_DQ_alerts.json')
in_j.inject_queue(registry.get_service(SERVICE_ALERT_DELIVERY_Q))
self.assertTrue(server.compare_messages(gen_message_list(in_j)))
t.shutdown()
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 testNegativeAlertIdMatch(self):
''' Runs a noise filter with all but one kind of alert id (negative match of alert id)'''
self.prepare_db()
t = teal.Teal('data/alert_filter_test/test_12.conf',msgLevel=self.msglevel,logFile='stderr')
j = Journal('AlertAnalyzer', 'data/alert_filter_test/inject_DQ_alerts.json')
j.inject_queue(registry.get_service(SERVICE_ALERT_DELIVERY_Q))
alj = find_listener()
alj.journal.wait_for_entries(3)
out_j = Journal('AlertListener', 'data/alert_filter_test/negative_alerts.json')
self.assertTrue(alj.journal.deep_match(out_j, ignore_times=True))
t.shutdown()
def testPartialNoiseFilter(self):
''' Runs a noise filter with some values '''
self.prepare_db()
t = teal.Teal('data/alert_filter_test/test_05.conf',msgLevel='warn',logFile='stderr')
j = Journal('AlertAnalyzer', 'data/alert_filter_test/inject_DQ_alerts.json')
j.inject_queue(registry.get_service(SERVICE_ALERT_DELIVERY_Q))
alj = find_listener()
alj.journal.wait_for_entries(4)
out_j = Journal('AlertListener', 'data/alert_filter_test/partial_alerts.json')
self.assertTrue(alj.journal.deep_match(out_j, ignore_times=True))
t.shutdown()
def testEmptyNoiseFilter(self):
''' Runs a noise filter with no values '''
self.prepare_db()
t = teal.Teal('data/alert_filter_test/test_03.conf',msgLevel='warn',logFile='stderr')
dq = registry.get_service(SERVICE_ALERT_DELIVERY)
self.assertEqual(dq.filters[0].get_name(),'NoiseAlertFilter')
j = Journal('AlertAnalyzer', 'data/alert_filter_test/inject_DQ_alerts.json')
j.inject_queue(registry.get_service(SERVICE_ALERT_DELIVERY_Q))
alj = find_listener()
alj.journal.wait_for_entries(7)
out_j = Journal('AlertListener', 'data/alert_filter_test/empty_alerts.json')
self.assertTrue(alj.journal.deep_match(out_j, ignore_times=True))
t.shutdown()
def testAnalyzers(self):
''' Validate functionality of both analyzer types '''
self.prepare_db()
t = teal.Teal('data/alert_filter_test/test_11.conf',msgLevel=self.msglevel,logFile='stderr')
j = Journal('AlertAnalyzer', 'data/alert_filter_test/inject_DQ_alerts.json')
j.inject_queue(registry.get_service(SERVICE_ALERT_DELIVERY_Q))
aif = find_listener('AlertFilterIfNameListener')
aif.journal.wait_for_entries(5)
anif = find_listener('AlertFilterIfNotNameListener')
anif.journal.wait_for_entries(4)
out_jif = Journal('AlertListener', 'data/alert_filter_test/ifname_alerts.json')
self.assertTrue(aif.journal.deep_match(out_jif, ignore_times=True))
out_jnif = Journal('AlertListener', 'data/alert_filter_test/ifnotname_alerts.json')
self.assertTrue(aif.journal.deep_match(out_jnif, ignore_times=True))
t.shutdown()
def testAlertAnalyzerSubclassing01(self):
''' Test that the alert analyzer subclass works properly '''
# 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)
def _execute_rule(self, dir, debug=False, wait_sec=60, wait_num=None, force_save=False,
max_key=None, inject_flush=False):
'''Run the test defined in the specified directory'''
config = 'data/gear_ruleset_test/' + dir + '/config.conf'
input = 'data/gear_ruleset_test/' + dir + '/event_input.json'
base_output = 'data/gear_ruleset_test/' + dir
test_files = os.listdir('data/gear_ruleset_test/' + dir)
# Figure out what output files need to be checked
out_prefix = 'alert_output'
out_to_check = []
for filename in test_files:
base, ext = os.path.splitext(filename)
if ext != '.json':
continue
if base[:len(out_prefix)] == out_prefix:
out_to_check.append(base[len(out_prefix):])
# out_to_check now contains the unique part of the output file name
if debug:
msg_level = 'debug'
else:
msg_level = self.msglevel
# TODO: Make work with duplicate checking
keep_ADC = self.force_env('TEAL_ALERT_DUPLICATE_CHECK', 'No')
myteal = teal.Teal(config, 'stderr', msgLevel=msg_level, commit_alerts=False, commit_checkpoints=False)
j_in = Journal('j_in', input)
# get the listeners to get the journals from
# Make a list to find
jl_names = []
j_out_list = {}
list_prefix = 'ListenerJournal'
for up in out_to_check:
jl_names.append( list_prefix + up)
listeners = get_service(SERVICE_ALERT_DELIVERY).listeners
for listener in listeners:
if listener.get_name() in jl_names:
j_out_list[listener.get_name()[len(list_prefix):]] = listener.journal
event_q = get_service(SERVICE_EVENT_Q)
if debug:
# Print before injection in case problem with injection
print j_in
j_in.inject_queue(event_q, no_delay=False, max_key=max_key)
if inject_flush == True:
self._inject_flush(event_q)
for up in out_to_check:
output = base_output + '/' + out_prefix + up + '.json'
j_exp = Journal('j_exp' + up, output )
if wait_num is None:
wait_num = len(j_exp)
self.assertTrue(j_out_list[up].wait_for_entries(wait_num, seconds=wait_sec))
if debug:
print j_exp
print j_out_list[up]
if force_save == True:
j_out_list[up].save(output)
self.assertTrue(j_out_list[up].deep_match(j_exp, ignore_delay=True, ignore_times=True, unordered=True))
myteal.shutdown()
self.restore_env('TEAL_ALERT_DUPLICATE_CHECK', keep_ADC)
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
