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
})