def test_invalid_duplicate_labels(self): predicate_a = BoboPredicateCallable(predicate_key_a_value_a) predicate_b = BoboPredicateCallable(predicate_key_a_value_b) pattern = BoboPattern() \ .followed_by(LABEL_LAYER_A, predicate_a) \ .followed_by(LABEL_LAYER_A, predicate_b) with self.assertRaises(RuntimeError): BoboRuleBuilder.nfa(NFA_NAME_A, pattern)
def test_invalid_first_state_is_optional(self): predicate_a = BoboPredicateCallable(predicate_key_a_value_a) predicate_b = BoboPredicateCallable(predicate_key_a_value_b) pattern = BoboPattern() \ .followed_by(LABEL_LAYER_A, predicate_a, optional=True) \ .followed_by(LABEL_LAYER_B, predicate_b) with self.assertRaises(RuntimeError): BoboRuleBuilder.nfa(NFA_NAME_A, pattern)
def test_invalid_accepting_states_are_nondeterministic(self): predicate_a = BoboPredicateCallable(predicate_key_a_value_a) predicate_b = BoboPredicateCallable(predicate_key_a_value_b) predicate_c = BoboPredicateCallable(predicate_key_a_value_c) pattern = BoboPattern() \ .followed_by(LABEL_LAYER_A, predicate_a) \ .followed_by_any(LABEL_LAYER_B, [predicate_b, predicate_c]) with self.assertRaises(RuntimeError): BoboRuleBuilder.nfa(NFA_NAME_A, pattern)
def test_action(self): # action event data a_timestamp = EpochNSClock.generate_timestamp() a_name = NAME_A a_success = True a_for_event = CompositeEvent( timestamp=EpochNSClock.generate_timestamp(), name=NAME_B, history=BoboHistory(), data={} ) a_exception = EXCEPTION_A a_description = DESCRIPTION_A a_data = DATA_A a_event_id = EVENT_ID_A # create dict representation of action event a_dict = { ActionEvent.TIMESTAMP: a_timestamp, ActionEvent.NAME: a_name, ActionEvent.SUCCESS: a_success, ActionEvent.FOR_EVENT: a_for_event.to_dict(), ActionEvent.EXCEPTION: a_exception, ActionEvent.DESCRIPTION: a_description, ActionEvent.DATA: a_data, ActionEvent.EVENT_ID: a_event_id } # build actual action event from dict a_event_1 = BoboRuleBuilder.action(a_dict) a_event_2 = BoboRuleBuilder.event(a_dict) for a_event in [a_event_1, a_event_2]: self.assertEqual(a_event.timestamp, a_timestamp) self.assertEqual(a_event.name, a_name) self.assertEqual(a_event.success, a_success) self.assertEqual(a_event.exception, a_exception) self.assertEqual(a_event.description, a_description) self.assertDictEqual(a_event.data, a_data) self.assertEqual(a_event.event_id, a_event_id) c_event = a_event.for_event self.assertIsInstance(c_event, CompositeEvent) self.assertEqual(c_event.timestamp, a_for_event.timestamp) self.assertEqual(c_event.name, a_for_event.name) self.assertIsNone(c_event.history.first) self.assertDictEqual(c_event.data, a_for_event.data) self.assertEqual(c_event.event_id, a_for_event.event_id)
def run(d: dict, buffer: SharedVersionedMatchBuffer, nfa: BoboNFA) -> 'BoboRun': """ :param d: A dict representation of a BoboRun instance. :type d: dict :param buffer: A buffer to use with the new BoboRun instance. :type buffer: SharedVersionedMatchBuffer :param nfa: An automaton to use with the new BoboRun instance. :type nfa: BoboNFA :return: A new BoboRun instance. """ event = BoboRuleBuilder.event(d[BoboRun.EVENT]) start_time = d[BoboRun.START_TIME] start_state = nfa.states[d[BoboRun.START_STATE_NAME]] current_state = nfa.states[d[BoboRun.CURRENT_STATE_NAME]] run_id = d[BoboRun.RUN_ID] version = RunVersion.list_to_version(d[BoboRun.VERSION]) last_proceed_had_clone = d[BoboRun.LAST_PROCESS_CLONED] halted = d[BoboRun.HALTED] return BoboRun(buffer=buffer, nfa=nfa, event=event, start_time=start_time, start_state=start_state, current_state=current_state, run_id=run_id, version=version, put_event=False, last_process_cloned=last_proceed_had_clone, halted=halted)
def test_bobo_run(self): buffer_orig = SharedVersionedMatchBuffer() nfa_orig = BoboRuleBuilder.nfa(name_nfa=NFA_NAME_A, pattern=stub_pattern) original = BoboRun(buffer=buffer_orig, nfa=nfa_orig, event=event_a) generated = BoboDeciderBuilder \ .run(d=original.to_dict(), buffer=original.buffer, nfa=original.nfa) self.assertEqual(original.buffer, generated.buffer) self.assertEqual(original.nfa, generated.nfa) self.assertDictEqual(original.event.to_dict(), generated.event.to_dict()) self.assertEqual(original.start_time, generated.start_time) self.assertEqual(original.start_state, generated.start_state) self.assertEqual(original.current_state, generated.current_state) self.assertEqual(original.id, generated.id) self.assertEqual(original.version.get_version_as_str(), generated.version.get_version_as_str()) self.assertEqual(original.last_process_cloned(), generated.last_process_cloned()) self.assertEqual(original.is_halted(), generated.is_halted())
def test_sliding_first_window_to_halt(self): predicate_a = BoboPredicateCallable(predicate_key_a_value_a) predicate_b = BoboPredicateCallable(predicate_key_a_value_b) predicate_c = BoboPredicateCallable(predicate_key_a_value_c) predicate_first_window = WindowSlidingFirst( interval_sec=range_sec) event_a = PrimitiveEvent(timestamp_low, {KEY: VAL_1}) event_b = PrimitiveEvent(timestamp_mid, {KEY: VAL_2}) event_c = PrimitiveEvent(timestamp_upp, {KEY: VAL_3}) pattern_a = BoboPattern() \ .followed_by(LABEL_LAYER_A, predicate_a) \ .followed_by(LABEL_LAYER_B, predicate_b) \ .followed_by(LABEL_LAYER_C, predicate_c) \ .precondition(predicate_first_window) handler = BoboNFAHandler( BoboRuleBuilder.nfa(NFA_NAME_A, pattern_a), SharedVersionedMatchBuffer()) handlersub = NFAHandlerSubscriber() handler.subscribe(handlersub) handler.process(event_a) handler.process(event_b) handler.process(event_c) self.assertEqual(len(handlersub.final), 1)
def _config_definitions(self) -> None: for event_def in self._event_defs: handler = BoboNFAHandler(nfa=BoboRuleBuilder.nfa( name_nfa=event_def.name, pattern=event_def.pattern), buffer=SharedVersionedMatchBuffer(), max_recent=self._max_recent) self._decider.add_nfa_handler(handler) # Decider -> Producer self._decider.subscribe(event_def.name, self._producer) if self._recursive: # Producer -> Decider self._producer.subscribe(event_def.name, self._decider) # Producer -> Forwarder self._producer.subscribe(event_def.name, self._forwarder) if event_def.action is not None: # Producer -> Action self._producer.subscribe(event_def.name, event_def.action) # Action -> Producer event_def.action.subscribe(self._producer) if self._distributed: # Handler -> Outgoing handler.subscribe(self._manager.outgoing) # Producer -> Outgoing self._producer.subscribe(event_def.name, self._manager.outgoing)
def test_sliding_last_window_to_halt(self): timestamp_lower = EpochNSClock.generate_timestamp() sleep(0.5) timestamp_upper = EpochNSClock.generate_timestamp() window_range_ns = timestamp_upper - timestamp_lower timestamp_a = timestamp_lower timestamp_b = timestamp_a + window_range_ns timestamp_c = timestamp_b + window_range_ns + 1 predicate_a = BoboPredicateCallable(predicate_key_a_value_a) predicate_b = BoboPredicateCallable(predicate_key_a_value_b) predicate_c = BoboPredicateCallable(predicate_key_a_value_c) predicate_first_window = WindowSlidingLast(window_range_ns) event_a = PrimitiveEvent(timestamp_a, {KEY: VAL_1}) event_b = PrimitiveEvent(timestamp_b, {KEY: VAL_2}) event_c = PrimitiveEvent(timestamp_c, {KEY: VAL_3}) pattern_a = BoboPattern() \ .followed_by(LABEL_LAYER_A, predicate_a) \ .followed_by(LABEL_LAYER_B, predicate_b) \ .followed_by(LABEL_LAYER_C, predicate_c) \ .precondition(predicate_first_window) handler = BoboNFAHandler(BoboRuleBuilder.nfa(NFA_NAME_A, pattern_a), SharedVersionedMatchBuffer()) handlersub = NFAHandlerSubscriber() handler.subscribe(handlersub) handler.process(event_a) handler.process(event_b) handler.process(event_c) self.assertEqual(len(handlersub.final), 1)
def test_generate_nfa_deterministic_negated(self): predicate_a = BoboPredicateCallable(predicate_key_a_value_a) predicate_b = BoboPredicateCallable(predicate_key_a_value_b) predicate_c = BoboPredicateCallable(predicate_key_a_value_c) pattern = BoboPattern() \ .followed_by(LABEL_LAYER_A, predicate_a) \ .not_followed_by(LABEL_LAYER_B, predicate_b) \ .followed_by(LABEL_LAYER_C, predicate_c) nfa = BoboRuleBuilder.nfa(NFA_NAME_A, pattern) state_name_a = "{}-{}-{}".format(LABEL_LAYER_A, 1, 1) state_name_b = "{}-{}-{}".format(LABEL_LAYER_B, 1, 1) state_name_c = "{}-{}-{}".format(LABEL_LAYER_C, 1, 1) # variables self.assertEqual(nfa.name, NFA_NAME_A) self.assertEqual(3, len(nfa.states)) self.assertEqual(3, len(nfa.transitions)) self.assertEqual(state_name_a, nfa.start_state.name) self.assertEqual(state_name_c, nfa.final_state.name) self.assertEqual(0, len(nfa.preconditions)) # states self.assertTrue(state_name_a in nfa.states) self.assertTrue(state_name_b in nfa.states) self.assertTrue(state_name_c in nfa.states) self.assertEqual(state_name_a, nfa.states[state_name_a].name) self.assertEqual(state_name_b, nfa.states[state_name_b].name) self.assertEqual(state_name_c, nfa.states[state_name_c].name) self.assertEqual(LABEL_LAYER_A, nfa.states[state_name_a].label) self.assertEqual(LABEL_LAYER_B, nfa.states[state_name_b].label) self.assertEqual(LABEL_LAYER_C, nfa.states[state_name_c].label) self.assertFalse(nfa.states[state_name_a].is_negated) self.assertTrue(nfa.states[state_name_b].is_negated) self.assertFalse(nfa.states[state_name_c].is_negated) self.assertFalse(nfa.states[state_name_a].is_optional) self.assertFalse(nfa.states[state_name_b].is_optional) self.assertFalse(nfa.states[state_name_c].is_optional) # transitions self.assertTrue(state_name_a in nfa.transitions) self.assertTrue(state_name_b in nfa.transitions) self.assertTrue(state_name_c in nfa.transitions) self.assertListEqual([state_name_b], nfa.transitions[state_name_a].state_names) self.assertListEqual([state_name_c], nfa.transitions[state_name_b].state_names) self.assertListEqual([], nfa.transitions[state_name_c].state_names) self.assertFalse(nfa.transitions[state_name_a].is_strict) self.assertFalse(nfa.transitions[state_name_b].is_strict) self.assertFalse(nfa.transitions[state_name_c].is_strict)
def handler_setup(nfa_name, pattern, max_recent: int = 1): buffer = SharedVersionedMatchBuffer() nfa = BoboRuleBuilder.nfa(name_nfa=nfa_name, pattern=pattern) handler = BoboNFAHandler(nfa=nfa, buffer=buffer, max_recent=max_recent) handlersub = NFAHandlerSubscriber() handler.subscribe(handlersub) return nfa, buffer, handler, handlersub
def test_composite(self): # composite event data c_timestamp = EpochNSClock.generate_timestamp() c_name = NAME_A c_data = DATA_A c_id = EVENT_ID_A # primitive event used in composite event's history p_timestamp = EpochNSClock.generate_timestamp() p_data = NAME_B p_label = LABEL_A p_id = EVENT_ID_B # create dict representation of composite event c_dict = { CompositeEvent.TIMESTAMP: c_timestamp, CompositeEvent.NAME: c_name, CompositeEvent.HISTORY: { p_label: [{ PrimitiveEvent.TIMESTAMP: p_timestamp, PrimitiveEvent.DATA: p_data, PrimitiveEvent.EVENT_ID: p_id }] }, CompositeEvent.DATA: c_data, CompositeEvent.EVENT_ID: c_id } # check composite event c_event_1 = BoboRuleBuilder.composite(c_dict) c_event_2 = BoboRuleBuilder.event(c_dict) for c_event in [c_event_1, c_event_2]: self.assertEqual(c_event.timestamp, c_timestamp) self.assertEqual(c_event.name, c_name) self.assertEqual(c_event.data, c_data) self.assertEqual(c_event.event_id, c_id) # Check primitive event in history p_event = c_event.history.events[p_label][0] self.assertEqual(p_event.timestamp, p_timestamp) self.assertEqual(p_event.data, p_data) self.assertEqual(p_event.event_id, p_id)
def test_primitive(self): # primitive event data p_timestamp = EpochNSClock.generate_timestamp() p_data = DATA_A p_id = EVENT_ID_A # Create dict representation of primitive event p_dict = { PrimitiveEvent.TIMESTAMP: p_timestamp, PrimitiveEvent.DATA: p_data, PrimitiveEvent.EVENT_ID: p_id } # Build actual primitive event from dict p_event_1 = BoboRuleBuilder.primitive(p_dict) p_event_2 = BoboRuleBuilder.event(p_dict) for p_event in [p_event_1, p_event_2]: self.assertEqual(p_event.timestamp, p_timestamp) self.assertEqual(p_event.data, p_data) self.assertEqual(p_event.event_id, p_id)
def _handle_final(self, data: str) -> None: json_data = json.loads(data) nfa_name = json_data[bdc.NFA_NAME] run_id = json_data[bdc.RUN_ID] event = BoboRuleBuilder.composite(json_data[bdc.EVENT]) for subscriber in self._subs: subscriber.on_dist_run_final( nfa_name=nfa_name, run_id=run_id, event=event )
def test_primitive_none(self): p_timestamp = EpochNSClock.generate_timestamp() p_data = DATA_A p_id = EVENT_ID_A with self.assertRaises(RuntimeError): BoboRuleBuilder.primitive({ PrimitiveEvent.TIMESTAMP: None, PrimitiveEvent.DATA: p_data, PrimitiveEvent.EVENT_ID: p_id }) with self.assertRaises(RuntimeError): BoboRuleBuilder.primitive({ PrimitiveEvent.TIMESTAMP: p_timestamp, PrimitiveEvent.DATA: None, PrimitiveEvent.EVENT_ID: p_id }) with self.assertRaises(RuntimeError): BoboRuleBuilder.primitive({ PrimitiveEvent.TIMESTAMP: p_timestamp, PrimitiveEvent.DATA: p_data, PrimitiveEvent.EVENT_ID: None })
def match_event(d: dict) -> 'MatchEvent': """ :param d: A dict representation of a MatchEvent instance. :type d: dict :return: A new MatchEvent instance. """ return MatchEvent(nfa_name=d[MatchEvent.NFA_NAME], label=d[MatchEvent.LABEL], event=BoboRuleBuilder.event(d[MatchEvent.EVENT]), next_ids=d[MatchEvent.NEXT_IDS], previous_ids=d[MatchEvent.PREVIOUS_IDS])
def _handle_clone(self, data: str) -> None: json_data = json.loads(data) nfa_name = json_data[bdc.NFA_NAME] run_id = json_data[bdc.RUN_ID] state_to = json_data[bdc.STATE_TO] event = BoboRuleBuilder.event(json_data[bdc.EVENT]) for subscriber in self._subs: subscriber.on_dist_run_clone( nfa_name=nfa_name, run_id=run_id, next_state_name=state_to, next_event=event )
def _handle_transition(self, data: str) -> None: json_data = json.loads(data) nfa_name = json_data[bdc.NFA_NAME] run_id = json_data[bdc.RUN_ID] state_from = json_data[bdc.STATE_FROM] state_to = json_data[bdc.STATE_TO] event = BoboRuleBuilder.event(json_data[bdc.EVENT]) for subscriber in self._subs: subscriber.on_dist_run_transition( nfa_name=nfa_name, run_id=run_id, state_name_from=state_from, state_name_to=state_to, event=event )
def test_composite_none(self): c_timestamp = EpochNSClock.generate_timestamp() c_name = NAME_A c_history = {} c_data = DATA_A c_id = EVENT_ID_A with self.assertRaises(RuntimeError): BoboRuleBuilder.composite({ CompositeEvent.TIMESTAMP: None, CompositeEvent.NAME: c_name, CompositeEvent.HISTORY: c_history, CompositeEvent.DATA: c_data, CompositeEvent.EVENT_ID: c_id }) with self.assertRaises(RuntimeError): BoboRuleBuilder.composite({ CompositeEvent.TIMESTAMP: c_timestamp, CompositeEvent.NAME: None, CompositeEvent.HISTORY: c_history, CompositeEvent.DATA: c_data, CompositeEvent.EVENT_ID: c_id }) with self.assertRaises(RuntimeError): BoboRuleBuilder.composite({ CompositeEvent.TIMESTAMP: c_timestamp, CompositeEvent.NAME: c_name, CompositeEvent.HISTORY: None, CompositeEvent.DATA: c_data, CompositeEvent.EVENT_ID: c_id }) with self.assertRaises(RuntimeError): BoboRuleBuilder.composite({ CompositeEvent.TIMESTAMP: c_timestamp, CompositeEvent.NAME: c_name, CompositeEvent.HISTORY: c_history, CompositeEvent.DATA: c_data, CompositeEvent.EVENT_ID: None })
def test_fixed_window_to_final(self): timestamp_lower = EpochNSClock.generate_timestamp() sleep(0.1) timestamp_a = EpochNSClock.generate_timestamp() sleep(0.1) timestamp_b = EpochNSClock.generate_timestamp() sleep(0.1) timestamp_c = EpochNSClock.generate_timestamp() sleep(0.1) timestamp_upper = EpochNSClock.generate_timestamp() sleep(0.1) predicate_a = BoboPredicateCallable(predicate_key_a_value_a) predicate_b = BoboPredicateCallable(predicate_key_a_value_b) predicate_c = BoboPredicateCallable(predicate_key_a_value_c) predicate_fixed_window = WindowFixed(timestamp_lower, timestamp_upper) event_a = PrimitiveEvent(timestamp_a, {KEY: VAL_1}) event_b = PrimitiveEvent(timestamp_b, {KEY: VAL_2}) event_c = PrimitiveEvent(timestamp_c, {KEY: VAL_3}) pattern_a = BoboPattern() \ .followed_by(LABEL_LAYER_A, predicate_a) \ .followed_by(LABEL_LAYER_B, predicate_b) \ .followed_by(LABEL_LAYER_C, predicate_c) \ .precondition(predicate_fixed_window) handler = BoboNFAHandler( BoboRuleBuilder.nfa(NFA_NAME_A, pattern_a), SharedVersionedMatchBuffer()) handlersub = NFAHandlerSubscriber() handler.subscribe(handlersub) handler.process(event_a) handler.process(event_b) handler.process(event_c) self.assertEqual(len(handlersub.final_history), 1) self.assertDictEqual(handlersub.final_history[0].events, {LABEL_LAYER_A: [event_a], LABEL_LAYER_B: [event_b], LABEL_LAYER_C: [event_c]})
def test_generate_nfa_times(self): predicate_a = BoboPredicateCallable(predicate_key_a_value_a) pattern = BoboPattern() \ .followed_by(LABEL_LAYER_A, predicate_a, times=5) nfa = BoboRuleBuilder.nfa(NFA_NAME_A, pattern) state_name_a1 = "{}-{}-{}".format(LABEL_LAYER_A, 1, 1) state_name_a2 = "{}-{}-{}".format(LABEL_LAYER_A, 1, 2) state_name_a3 = "{}-{}-{}".format(LABEL_LAYER_A, 1, 3) state_name_a4 = "{}-{}-{}".format(LABEL_LAYER_A, 1, 4) state_name_a5 = "{}-{}-{}".format(LABEL_LAYER_A, 1, 5) # variables self.assertEqual(5, len(nfa.states)) self.assertEqual(5, len(nfa.transitions)) self.assertEqual(state_name_a1, nfa.start_state.name) self.assertEqual(state_name_a5, nfa.final_state.name) # states self.assertEqual(state_name_a1, nfa.states[state_name_a1].name) self.assertEqual(state_name_a2, nfa.states[state_name_a2].name) self.assertEqual(state_name_a3, nfa.states[state_name_a3].name) self.assertEqual(state_name_a4, nfa.states[state_name_a4].name) self.assertEqual(state_name_a5, nfa.states[state_name_a5].name) self.assertEqual(LABEL_LAYER_A, nfa.states[state_name_a1].label) self.assertEqual(LABEL_LAYER_A, nfa.states[state_name_a2].label) self.assertEqual(LABEL_LAYER_A, nfa.states[state_name_a3].label) self.assertEqual(LABEL_LAYER_A, nfa.states[state_name_a4].label) self.assertEqual(LABEL_LAYER_A, nfa.states[state_name_a5].label) # transitions self.assertListEqual([state_name_a2], nfa.transitions[state_name_a1].state_names) self.assertListEqual([state_name_a3], nfa.transitions[state_name_a2].state_names) self.assertListEqual([state_name_a4], nfa.transitions[state_name_a3].state_names) self.assertListEqual([state_name_a5], nfa.transitions[state_name_a4].state_names) self.assertListEqual([], nfa.transitions[state_name_a5].state_names)
def test_history(self): p1_hist = "p1_hist" p2_hist = "p2_hist" # Primitive events used in history p1_timestamp = EpochNSClock.generate_timestamp() p1_data = "p1_data" p2_timestamp = EpochNSClock.generate_timestamp() p2_data = "p2_data" p1_id = "p1_id_123" p2_id = "p2_id_123" h_dict = { p1_hist: [{ PrimitiveEvent.TIMESTAMP: p1_timestamp, PrimitiveEvent.DATA: p1_data, PrimitiveEvent.EVENT_ID: p1_id }], p2_hist: [{ PrimitiveEvent.TIMESTAMP: p2_timestamp, PrimitiveEvent.DATA: p2_data, PrimitiveEvent.EVENT_ID: p2_id }] } history = BoboRuleBuilder.history(h_dict) p1_event = history.events[p1_hist][0] self.assertEqual(p1_event.timestamp, p1_timestamp) self.assertEqual(p1_event.data, p1_data) self.assertEqual(p1_event.event_id, p1_id) p2_event = history.events[p2_hist][0] self.assertEqual(p2_event.timestamp, p2_timestamp) self.assertEqual(p2_event.data, p2_data) self.assertEqual(p2_event.event_id, p2_id)
def test_generate_nfa_loop(self): predicate_a = BoboPredicateCallable(predicate_key_a_value_a) predicate_b = BoboPredicateCallable(predicate_key_a_value_b) predicate_c = BoboPredicateCallable(predicate_key_a_value_c) pattern = BoboPattern() \ .followed_by(LABEL_LAYER_A, predicate_a) \ .followed_by(LABEL_LAYER_B, predicate_b, loop=True) \ .followed_by(LABEL_LAYER_C, predicate_c) nfa = BoboRuleBuilder.nfa(NFA_NAME_A, pattern) state_name_a = "{}-{}-{}".format(LABEL_LAYER_A, 1, 1) state_name_b = "{}-{}-{}".format(LABEL_LAYER_B, 1, 1) state_name_c = "{}-{}-{}".format(LABEL_LAYER_C, 1, 1) # variables self.assertEqual(3, len(nfa.states)) self.assertEqual(3, len(nfa.transitions)) self.assertEqual(state_name_a, nfa.start_state.name) self.assertEqual(state_name_c, nfa.final_state.name) # states self.assertEqual(state_name_a, nfa.states[state_name_a].name) self.assertEqual(state_name_b, nfa.states[state_name_b].name) self.assertEqual(state_name_c, nfa.states[state_name_c].name) self.assertEqual(LABEL_LAYER_A, nfa.states[state_name_a].label) self.assertEqual(LABEL_LAYER_B, nfa.states[state_name_b].label) self.assertEqual(LABEL_LAYER_C, nfa.states[state_name_c].label) # transitions self.assertListEqual([state_name_b], nfa.transitions[state_name_a].state_names) self.assertEqual({state_name_b, state_name_c}, set(nfa.transitions[state_name_b].state_names)) self.assertListEqual([], nfa.transitions[state_name_c].state_names)
def _handle_action(self, data: str) -> None: json_data = json.loads(data) event = BoboRuleBuilder.action(json_data[bdc.EVENT]) for subscriber in self._subs: subscriber.on_dist_action(event=event)
def test_invalid_empty_pattern(self): with self.assertRaises(RuntimeError): BoboRuleBuilder.nfa(NFA_NAME_A, BoboPattern())
def test_action_none(self): # action event data a_timestamp = EpochNSClock.generate_timestamp() a_name = NAME_A a_success = True a_for_event = CompositeEvent( timestamp=EpochNSClock.generate_timestamp(), name=NAME_B, history=BoboHistory(), data={} ) a_exception = EXCEPTION_A a_description = DESCRIPTION_A a_data = DATA_A a_event_id = EVENT_ID_A with self.assertRaises(RuntimeError): BoboRuleBuilder.action({ ActionEvent.TIMESTAMP: None, ActionEvent.NAME: a_name, ActionEvent.SUCCESS: a_success, ActionEvent.FOR_EVENT: a_for_event.to_dict(), ActionEvent.EXCEPTION: a_exception, ActionEvent.DESCRIPTION: a_description, ActionEvent.DATA: a_data, ActionEvent.EVENT_ID: a_event_id }) with self.assertRaises(RuntimeError): BoboRuleBuilder.action({ ActionEvent.TIMESTAMP: a_timestamp, ActionEvent.NAME: None, ActionEvent.SUCCESS: a_success, ActionEvent.FOR_EVENT: a_for_event.to_dict(), ActionEvent.EXCEPTION: a_exception, ActionEvent.DESCRIPTION: a_description, ActionEvent.DATA: a_data, ActionEvent.EVENT_ID: a_event_id }) with self.assertRaises(RuntimeError): BoboRuleBuilder.action({ ActionEvent.TIMESTAMP: a_timestamp, ActionEvent.NAME: a_name, ActionEvent.SUCCESS: None, ActionEvent.FOR_EVENT: a_for_event.to_dict(), ActionEvent.EXCEPTION: a_exception, ActionEvent.DESCRIPTION: a_description, ActionEvent.DATA: a_data, ActionEvent.EVENT_ID: a_event_id }) with self.assertRaises(RuntimeError): BoboRuleBuilder.action({ ActionEvent.TIMESTAMP: a_timestamp, ActionEvent.NAME: a_name, ActionEvent.SUCCESS: a_success, ActionEvent.FOR_EVENT: None, ActionEvent.EXCEPTION: a_exception, ActionEvent.DESCRIPTION: a_description, ActionEvent.DATA: a_data, ActionEvent.EVENT_ID: a_event_id }) with self.assertRaises(RuntimeError): BoboRuleBuilder.action({ ActionEvent.TIMESTAMP: a_timestamp, ActionEvent.NAME: a_name, ActionEvent.SUCCESS: a_success, ActionEvent.FOR_EVENT: a_for_event.to_dict(), ActionEvent.EXCEPTION: a_exception, ActionEvent.DESCRIPTION: a_description, ActionEvent.DATA: a_data, ActionEvent.EVENT_ID: None })