NikolajDanger/meow_base
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

✨ Final touches

Browse Source
This commit is contained in:
NikolajDanger
2023-05-27 18:48:11 +02:00
parent ee4739e9f2
commit 81091df34b
3 changed files with 537 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

557
tests/test_patterns.py
View File

@ -1,7 +1,7 @@
import io
import os
import unittest
import threading
import socket
import time
from datetime import datetime
@ -17,15 +17,15 @@ from meow_base.patterns.file_event_pattern import FileEventPattern, \
WatchdogMonitor, _DEFAULT_MASK, WATCHDOG_HASH, WATCHDOG_BASE, \
EVENT_TYPE_WATCHDOG, WATCHDOG_EVENT_KEYS, create_watchdog_event
from meow_base.patterns.network_event_pattern import NetworkEventPattern, \
NetworkMonitor, NETWORK_HASH, NETWORK_BASE, EVENT_TYPE_NETWORK, \
NETWORK_EVENT_KEYS, create_network_event, Connector
NetworkMonitor, TRIGGERING_PORT, EVENT_TYPE_NETWORK, \
NETWORK_EVENT_KEYS, create_network_event
from meow_base.recipes.jupyter_notebook_recipe import JupyterNotebookRecipe
from meow_base.recipes.python_recipe import PythonRecipe
from shared import BAREBONES_NOTEBOOK, TEST_MONITOR_BASE, \
COUNTING_PYTHON_SCRIPT, APPENDING_NOTEBOOK, setup, teardown
def patterns_equal(tester, pattern_one, pattern_two):
def file_patterns_equal(tester, pattern_one, pattern_two):
tester.assertEqual(pattern_one.name, pattern_two.name)
tester.assertEqual(pattern_one.recipe, pattern_two.recipe)
tester.assertEqual(pattern_one.parameters, pattern_two.parameters)
@ -37,6 +37,14 @@ def patterns_equal(tester, pattern_one, pattern_two):
tester.assertEqual(pattern_one.event_mask, pattern_two.event_mask)
tester.assertEqual(pattern_one.sweep, pattern_two.sweep)
def network_patterns_equal(tester, pattern_one, pattern_two):
tester.assertEqual(pattern_one.name, pattern_two.name)
tester.assertEqual(pattern_one.recipe, pattern_two.recipe)
tester.assertEqual(pattern_one.parameters, pattern_two.parameters)
tester.assertEqual(pattern_one.outputs, pattern_two.outputs)
tester.assertEqual(pattern_one.triggering_port,
pattern_two.triggering_port)
def recipes_equal(tester, recipe_one, recipe_two):
tester.assertEqual(recipe_one.name, recipe_two.name)
@ -630,9 +638,9 @@ class WatchdogMonitorTests(unittest.TestCase):
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 2)
self.assertIn(pattern_one.name, patterns)
patterns_equal(self, patterns[pattern_one.name], pattern_one)
file_patterns_equal(self, patterns[pattern_one.name], pattern_one)
self.assertIn(pattern_two.name, patterns)
patterns_equal(self, patterns[pattern_two.name], pattern_two)
file_patterns_equal(self, patterns[pattern_two.name], pattern_two)
# Test WatchdogMonitor add_pattern function
def testMonitorAddPattern(self)->None:
@ -660,7 +668,7 @@ class WatchdogMonitorTests(unittest.TestCase):
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 1)
self.assertIn(pattern_one.name, patterns)
patterns_equal(self, patterns[pattern_one.name], pattern_one)
file_patterns_equal(self, patterns[pattern_one.name], pattern_one)
wm.add_pattern(pattern_two)
@ -669,9 +677,9 @@ class WatchdogMonitorTests(unittest.TestCase):
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 2)
self.assertIn(pattern_one.name, patterns)
patterns_equal(self, patterns[pattern_one.name], pattern_one)
file_patterns_equal(self, patterns[pattern_one.name], pattern_one)
self.assertIn(pattern_two.name, patterns)
patterns_equal(self, patterns[pattern_two.name], pattern_two)
file_patterns_equal(self, patterns[pattern_two.name], pattern_two)
with self.assertRaises(KeyError):
wm.add_pattern(pattern_two)
@ -681,9 +689,9 @@ class WatchdogMonitorTests(unittest.TestCase):
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 2)
self.assertIn(pattern_one.name, patterns)
patterns_equal(self, patterns[pattern_one.name], pattern_one)
file_patterns_equal(self, patterns[pattern_one.name], pattern_one)
self.assertIn(pattern_two.name, patterns)
patterns_equal(self, patterns[pattern_two.name], pattern_two)
file_patterns_equal(self, patterns[pattern_two.name], pattern_two)
# Test WatchdogMonitor update_patterns function
def testMonitorUpdatePattern(self)->None:
@ -711,7 +719,7 @@ class WatchdogMonitorTests(unittest.TestCase):
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 1)
self.assertIn(pattern_one.name, patterns)
patterns_equal(self, patterns[pattern_one.name], pattern_one)
file_patterns_equal(self, patterns[pattern_one.name], pattern_one)
pattern_one.recipe = "top_secret_recipe"
@ -742,7 +750,7 @@ class WatchdogMonitorTests(unittest.TestCase):
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 1)
self.assertIn(pattern_one.name, patterns)
patterns_equal(self, patterns[pattern_one.name], pattern_one)
file_patterns_equal(self, patterns[pattern_one.name], pattern_one)
with self.assertRaises(KeyError):
wm.update_pattern(pattern_two)
@ -751,7 +759,7 @@ class WatchdogMonitorTests(unittest.TestCase):
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 1)
self.assertIn(pattern_one.name, patterns)
patterns_equal(self, patterns[pattern_one.name], pattern_one)
file_patterns_equal(self, patterns[pattern_one.name], pattern_one)
# Test WatchdogMonitor remove_patterns function
def testMonitorRemovePattern(self)->None:
@ -779,7 +787,7 @@ class WatchdogMonitorTests(unittest.TestCase):
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 1)
self.assertIn(pattern_one.name, patterns)
patterns_equal(self, patterns[pattern_one.name], pattern_one)
file_patterns_equal(self, patterns[pattern_one.name], pattern_one)
with self.assertRaises(KeyError):
wm.remove_pattern(pattern_two)
@ -789,7 +797,7 @@ class WatchdogMonitorTests(unittest.TestCase):
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 1)
self.assertIn(pattern_one.name, patterns)
patterns_equal(self, patterns[pattern_one.name], pattern_one)
file_patterns_equal(self, patterns[pattern_one.name], pattern_one)
wm.remove_pattern(pattern_one)
@ -1109,8 +1117,7 @@ class NetworkMonitorTests(unittest.TestCase):
with self.assertRaises(TypeError):
event = create_network_event("path", rule)
event = create_network_event(
"path", rule, "base", time(), "hash")
event = create_network_event("path", rule, time(), 8181)
self.assertEqual(type(event), dict)
self.assertEqual(len(event.keys()), len(NETWORK_EVENT_KEYS))
@ -1120,15 +1127,13 @@ class NetworkMonitorTests(unittest.TestCase):
self.assertEqual(event[EVENT_TYPE], EVENT_TYPE_NETWORK)
self.assertEqual(event[EVENT_PATH], "path")
self.assertEqual(event[EVENT_RULE], rule)
self.assertEqual(event[NETWORK_BASE], "base")
self.assertEqual(event[NETWORK_HASH], "hash")
self.assertEqual(event[TRIGGERING_PORT], 8181)
event = create_network_event(
"path2",
rule,
"base",
time(),
"hash",
8182,
extras={"a":1}
)
@ -1136,8 +1141,6 @@ class NetworkMonitorTests(unittest.TestCase):
self.assertTrue(EVENT_TYPE in event.keys())
self.assertTrue(EVENT_PATH in event.keys())
self.assertTrue(EVENT_RULE in event.keys())
self.assertTrue(NETWORK_BASE in event.keys())
self.assertTrue(NETWORK_HASH in event.keys())
self.assertEqual(len(event.keys()), len(NETWORK_EVENT_KEYS)+1)
for key, value in NETWORK_EVENT_KEYS.items():
self.assertTrue(key in event.keys())
@ -1145,15 +1148,8 @@ class NetworkMonitorTests(unittest.TestCase):
self.assertEqual(event[EVENT_TYPE], EVENT_TYPE_NETWORK)
self.assertEqual(event[EVENT_PATH], "path2")
self.assertEqual(event[EVENT_RULE], rule)
self.assertEqual(event[TRIGGERING_PORT], 8182)
self.assertEqual(event["a"], 1)
self.assertEqual(event[NETWORK_BASE], "base")
self.assertEqual(event[NETWORK_HASH], "hash")
# Test NetworkMonitor created
def testNetworkMonitorMinimum(self)->None:
from_monitor = Pipe()
NetworkMonitor({}, {}, from_monitor[1])
# Test NetworkMonitor naming
def testNetworkMonitorNaming(self)->None:
@ -1164,75 +1160,9 @@ class NetworkMonitorTests(unittest.TestCase):
monitor = NetworkMonitor({}, {})
self.assertTrue(monitor.name.startswith("monitor_"))
# Test Connector data transfer when packet is smaller than buffer
def testConnector(self)->None:
message = b'test data'
localhost = "127.0.0.1"
port = 8181
temp_path = f"{TEST_MONITOR_BASE}/result"
receiver = Connector(localhost, port)
sender = Connector(localhost, port)
receiver_thread = threading.Thread(
target=receiver.receive,
args=(temp_path,)
)
sender_thread = threading.Thread(
target=sender.send,
args=(message,)
)
receiver_thread.start()
sender_thread.start()
sender_thread.join(5)
receiver_thread.join(5)
self.assertFalse(sender_thread.is_alive())
self.assertFalse(receiver_thread.is_alive())
with open(temp_path,"rb") as file_pointer:
result_data = file_pointer.read()
self.assertEqual(message, result_data)
# Test Connector data transfer when packet is larger than buffer
def testConnectorBiggerThanBuffer(self)->None:
message = b'test data'
buffer_size = 4
localhost = "127.0.0.1"
port = 8181
temp_path = f"{TEST_MONITOR_BASE}/result"
receiver = Connector(localhost, port)
sender = Connector(localhost, port)
receiver_thread = threading.Thread(
target=receiver.receive,
args=(temp_path,buffer_size,)
)
sender_thread = threading.Thread(
target=sender.send,
args=(message,)
)
receiver_thread.start()
sender_thread.start()
sender_thread.join(5)
receiver_thread.join(5)
self.assertFalse(sender_thread.is_alive())
self.assertFalse(receiver_thread.is_alive())
with open(temp_path,"rb") as file_pointer:
result_data = file_pointer.read()
self.assertEqual(message, result_data)
# Test NetworkMonitor identifies expected network events
def testNetworkMonitorEventIdentification(self)->None:
localhost = "127.0.0.1"
port = 8181
from_monitor_reader, from_monitor_writer = Pipe()
@ -1249,41 +1179,416 @@ class NetworkMonitorTests(unittest.TestCase):
recipe.name: recipe,
}
wm = NetworkMonitor(patterns, recipes)
wm.to_runner_event = from_monitor_writer
monitor = NetworkMonitor(patterns, recipes)
monitor.to_runner_event = from_monitor_writer
rules = wm.get_rules()
rules = monitor.get_rules()
self.assertEqual(len(rules), 1)
rule = rules[list(rules.keys())[0]]
# wm.start()
monitor.start()
# # open(os.path.join(TEST_MONITOR_BASE, "A"), "w")
sender = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sender.connect((localhost,port))
sender.sendall(b'test')
sender.close()
# if from_monitor_reader.poll(3):
# message = from_monitor_reader.recv()
if from_monitor_reader.poll(3):
message = from_monitor_reader.recv()
# self.assertIsNotNone(message)
# event = message
# self.assertIsNotNone(event)
# self.assertEqual(type(event), dict)
# self.assertTrue(EVENT_TYPE in event.keys())
# self.assertTrue(EVENT_PATH in event.keys())
# self.assertTrue(WATCHDOG_BASE in event.keys())
# self.assertTrue(EVENT_RULE in event.keys())
# self.assertEqual(event[EVENT_TYPE], EVENT_TYPE_WATCHDOG)
# self.assertEqual(event[EVENT_PATH],
# os.path.join(TEST_MONITOR_BASE, "A"))
# self.assertEqual(event[WATCHDOG_BASE], TEST_MONITOR_BASE)
# self.assertEqual(event[EVENT_RULE].name, rule.name)
self.assertIsNotNone(message)
event = message
self.assertIsInstance(event, dict)
self.assertTrue(EVENT_TYPE in event.keys())
self.assertTrue(EVENT_PATH in event.keys())
self.assertTrue(EVENT_RULE in event.keys())
for key, value in NETWORK_EVENT_KEYS.items():
self.assertTrue(key in event.keys())
self.assertIsInstance(event[key], value)
self.assertEqual(event[EVENT_TYPE], EVENT_TYPE_NETWORK)
self.assertEqual(event[TRIGGERING_PORT], port)
self.assertEqual(event[EVENT_RULE].name, rule.name)
monitor.stop()
# Test NetworkMonitor get_patterns function
def testNetworkMonitorGetPatterns(self)->None:
pattern_one = NetworkEventPattern(
"pattern_one",
8181,
"recipe_one",
parameters={})
pattern_two = NetworkEventPattern(
"pattern_two",
8182,
"recipe_two",
parameters={})
monitor = NetworkMonitor(
{
pattern_one.name: pattern_one,
pattern_two.name: pattern_two
},
{}
)
patterns = monitor.get_patterns()
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 2)
self.assertIn(pattern_one.name, patterns)
network_patterns_equal(self, patterns[pattern_one.name], pattern_one)
self.assertIn(pattern_two.name, patterns)
network_patterns_equal(self, patterns[pattern_two.name], pattern_two)
# Test NetworkMonitor add_pattern function
def testNetworkAddPattern(self)->None:
pattern_one = NetworkEventPattern(
"pattern_one",
8181,
"recipe_one",
parameters={})
pattern_two = NetworkEventPattern(
"pattern_two",
8182,
"recipe_two",
parameters={})
monitor = NetworkMonitor(
{pattern_one.name: pattern_one},
{}
)
patterns = monitor.get_patterns()
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 1)
self.assertIn(pattern_one.name, patterns)
network_patterns_equal(self, patterns[pattern_one.name], pattern_one)
monitor.add_pattern(pattern_two)
patterns = monitor.get_patterns()
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 2)
self.assertIn(pattern_one.name, patterns)
network_patterns_equal(self, patterns[pattern_one.name], pattern_one)
self.assertIn(pattern_two.name, patterns)
network_patterns_equal(self, patterns[pattern_two.name], pattern_two)
with self.assertRaises(KeyError):
monitor.add_pattern(pattern_two)
patterns = monitor.get_patterns()
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 2)
self.assertIn(pattern_one.name, patterns)
network_patterns_equal(self, patterns[pattern_one.name], pattern_one)
self.assertIn(pattern_two.name, patterns)
network_patterns_equal(self, patterns[pattern_two.name], pattern_two)
# Test NetworkMonitor update_patterns function
def testMonitorUpdatePattern(self)->None:
pattern_one = NetworkEventPattern(
"pattern_one",
8181,
"recipe_one",
parameters={})
pattern_two = NetworkEventPattern(
"pattern_two",
8182,
"recipe_two",
parameters={})
monitor = NetworkMonitor(
{pattern_one.name: pattern_one},
{}
)
patterns = monitor.get_patterns()
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 1)
self.assertIn(pattern_one.name, patterns)
network_patterns_equal(self, patterns[pattern_one.name], pattern_one)
pattern_one.recipe = "top_secret_recipe"
patterns = monitor.get_patterns()
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 1)
self.assertIn(pattern_one.name, patterns)
self.assertEqual(patterns[pattern_one.name].name,
pattern_one.name)
self.assertEqual(patterns[pattern_one.name].recipe,
"recipe_one")
self.assertEqual(patterns[pattern_one.name].parameters,
pattern_one.parameters)
self.assertEqual(patterns[pattern_one.name].outputs,
pattern_one.outputs)
self.assertEqual(patterns[pattern_one.name].triggering_port,
pattern_one.triggering_port)
monitor.update_pattern(pattern_one)
patterns = monitor.get_patterns()
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 1)
self.assertIn(pattern_one.name, patterns)
network_patterns_equal(self, patterns[pattern_one.name], pattern_one)
with self.assertRaises(KeyError):
monitor.update_pattern(pattern_two)
patterns = monitor.get_patterns()
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 1)
self.assertIn(pattern_one.name, patterns)
network_patterns_equal(self, patterns[pattern_one.name], pattern_one)
# Test NetworkMonitor remove_patterns function
def testMonitorRemovePattern(self)->None:
pattern_one = NetworkEventPattern(
"pattern_one",
8181,
"recipe_one",
parameters={})
pattern_two = NetworkEventPattern(
"pattern_two",
8182,
"recipe_two",
parameters={})
monitor = NetworkMonitor(
{pattern_one.name: pattern_one},
{}
)
patterns = monitor.get_patterns()
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 1)
self.assertIn(pattern_one.name, patterns)
network_patterns_equal(self, patterns[pattern_one.name], pattern_one)
with self.assertRaises(KeyError):
monitor.remove_pattern(pattern_two)
patterns = monitor.get_patterns()
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 1)
self.assertIn(pattern_one.name, patterns)
network_patterns_equal(self, patterns[pattern_one.name], pattern_one)
monitor.remove_pattern(pattern_one)
patterns = monitor.get_patterns()
self.assertIsInstance(patterns, dict)
self.assertEqual(len(patterns), 0)
# Test NetworkMonitor get_recipes function
def testMonitorGetRecipes(self)->None:
recipe_one = JupyterNotebookRecipe(
"recipe_one", BAREBONES_NOTEBOOK)
recipe_two = JupyterNotebookRecipe(
"recipe_two", BAREBONES_NOTEBOOK)
monitor = NetworkMonitor(
{},
{
recipe_one.name: recipe_one,
recipe_two.name: recipe_two
}
)
recipes = monitor.get_recipes()
self.assertIsInstance(recipes, dict)
self.assertEqual(len(recipes), 2)
self.assertIn(recipe_one.name, recipes)
recipes_equal(self, recipes[recipe_one.name], recipe_one)
self.assertIn(recipe_two.name, recipes)
recipes_equal(self, recipes[recipe_two.name], recipe_two)
# Test NetworkMonitor add_recipe function
def testMonitorAddRecipe(self)->None:
recipe_one = JupyterNotebookRecipe(
"recipe_one", BAREBONES_NOTEBOOK)
recipe_two = JupyterNotebookRecipe(
"recipe_two", BAREBONES_NOTEBOOK)
monitor = NetworkMonitor(
{},
{
recipe_one.name: recipe_one
}
)
recipes = monitor.get_recipes()
self.assertIsInstance(recipes, dict)
self.assertEqual(len(recipes), 1)
self.assertIn(recipe_one.name, recipes)
recipes_equal(self, recipes[recipe_one.name], recipe_one)
monitor.add_recipe(recipe_two)
recipes = monitor.get_recipes()
self.assertIsInstance(recipes, dict)
self.assertEqual(len(recipes), 2)
self.assertIn(recipe_one.name, recipes)
recipes_equal(self, recipes[recipe_one.name], recipe_one)
self.assertIn(recipe_two.name, recipes)
recipes_equal(self, recipes[recipe_two.name], recipe_two)
with self.assertRaises(KeyError):
monitor.add_recipe(recipe_two)
recipes = monitor.get_recipes()
self.assertIsInstance(recipes, dict)
self.assertEqual(len(recipes), 2)
self.assertIn(recipe_one.name, recipes)
recipes_equal(self, recipes[recipe_one.name], recipe_one)
self.assertIn(recipe_two.name, recipes)
recipes_equal(self, recipes[recipe_two.name], recipe_two)
# Test NetworkMonitor update_recipe function
def testMonitorUpdateRecipe(self)->None:
recipe_one = JupyterNotebookRecipe(
"recipe_one", BAREBONES_NOTEBOOK)
recipe_two = JupyterNotebookRecipe(
"recipe_two", BAREBONES_NOTEBOOK)
monitor = NetworkMonitor(
{},
{
recipe_one.name: recipe_one
}
)
recipes = monitor.get_recipes()
self.assertIsInstance(recipes, dict)
self.assertEqual(len(recipes), 1)
self.assertIn(recipe_one.name, recipes)
recipes_equal(self, recipes[recipe_one.name], recipe_one)
recipe_one.source = "top_secret_source"
recipes = monitor.get_recipes()
self.assertIsInstance(recipes, dict)
self.assertEqual(len(recipes), 1)
self.assertIn(recipe_one.name, recipes)
self.assertEqual(recipes[recipe_one.name].name,
recipe_one.name)
self.assertEqual(recipes[recipe_one.name].recipe,
recipe_one.recipe)
self.assertEqual(recipes[recipe_one.name].parameters,
recipe_one.parameters)
self.assertEqual(recipes[recipe_one.name].requirements,
recipe_one.requirements)
self.assertEqual(recipes[recipe_one.name].source,
"")
monitor.update_recipe(recipe_one)
recipes = monitor.get_recipes()
self.assertIsInstance(recipes, dict)
self.assertEqual(len(recipes), 1)
self.assertIn(recipe_one.name, recipes)
recipes_equal(self, recipes[recipe_one.name], recipe_one)
with self.assertRaises(KeyError):
monitor.update_recipe(recipe_two)
recipes = monitor.get_recipes()
self.assertIsInstance(recipes, dict)
self.assertEqual(len(recipes), 1)
self.assertIn(recipe_one.name, recipes)
recipes_equal(self, recipes[recipe_one.name], recipe_one)
# Test NetworkMonitor remove_recipe function
def testMonitorRemoveRecipe(self)->None:
recipe_one = JupyterNotebookRecipe(
"recipe_one", BAREBONES_NOTEBOOK)
recipe_two = JupyterNotebookRecipe(
"recipe_two", BAREBONES_NOTEBOOK)
monitor = NetworkMonitor(
{},
{
recipe_one.name: recipe_one
}
)
recipes = monitor.get_recipes()
self.assertIsInstance(recipes, dict)
self.assertEqual(len(recipes), 1)
self.assertIn(recipe_one.name, recipes)
recipes_equal(self, recipes[recipe_one.name], recipe_one)
with self.assertRaises(KeyError):
monitor.remove_recipe(recipe_two)
recipes = monitor.get_recipes()
self.assertIsInstance(recipes, dict)
self.assertEqual(len(recipes), 1)
self.assertIn(recipe_one.name, recipes)
recipes_equal(self, recipes[recipe_one.name], recipe_one)
monitor.remove_recipe(recipe_one)
recipes = monitor.get_recipes()
self.assertIsInstance(recipes, dict)
self.assertEqual(len(recipes), 0)
# Test NetworkMonitor get_rules function
def testMonitorGetRules(self)->None:
pattern_one = NetworkEventPattern(
"pattern_one",
8181,
"recipe_one",
parameters={})
pattern_two = NetworkEventPattern(
"pattern_two",
8182,
"recipe_two",
parameters={})
recipe_one = JupyterNotebookRecipe(
"recipe_one", BAREBONES_NOTEBOOK)
recipe_two = JupyterNotebookRecipe(
"recipe_two", BAREBONES_NOTEBOOK)
patterns = {
pattern_one.name: pattern_one,
pattern_two.name: pattern_two,
}
recipes = {
recipe_one.name: recipe_one,
recipe_two.name: recipe_two,
}
monitor = NetworkMonitor(
patterns,
recipes
)
rules = monitor.get_rules()
self.assertIsInstance(rules, dict)
self.assertEqual(len(rules), 2)
# # open(os.path.join(TEST_MONITOR_BASE, "B"), "w")
# if from_monitor_reader.poll(3):
# new_message = from_monitor_reader.recv()
# else:
# new_message = None
# self.assertIsNone(new_message)
# wm.stop()