updated event dict to always include path, should be more future proof

tests/test_functionality.py

@@ -6,7 +6,7 @@ from multiprocessing import Pipe, Queue
 from time import sleep
 
 from core.correctness.vars import CHAR_LOWERCASE, CHAR_UPPERCASE, \
-    SHA256, TEST_MONITOR_BASE, COMPLETE_NOTEBOOK, EVENT_TYPE
+    SHA256, TEST_MONITOR_BASE, COMPLETE_NOTEBOOK, EVENT_TYPE, EVENT_PATH
 from core.functionality import generate_id, wait, get_file_hash, rmtree, \
     make_dir, parameterize_jupyter_notebook, create_event
     
@@ -219,18 +219,20 @@ class CorrectnessTests(unittest.TestCase):
             "# The first cell\n\ns = 4\nnum = 1000")
 
     def testCreateEvent(self)->None:
-        event = create_event("test")
+        event = create_event("test", "path")
 
         self.assertEqual(type(event), dict)
         self.assertTrue(EVENT_TYPE in event.keys())
-        self.assertEqual(len(event.keys()), 1)
+        self.assertEqual(len(event.keys()), 2)
         self.assertEqual(event[EVENT_TYPE], "test")
+        self.assertEqual(event[EVENT_PATH], "path")
 
-        event2 = create_event("test2", {"a":1})
+        event2 = create_event("test2", "path2", {"a":1})
 
         self.assertEqual(type(event2), dict)
         self.assertTrue(EVENT_TYPE in event2.keys())
-        self.assertEqual(len(event2.keys()), 2)
+        self.assertEqual(len(event2.keys()), 3)
         self.assertEqual(event2[EVENT_TYPE], "test2")
+        self.assertEqual(event2[EVENT_PATH], "path2")
         self.assertEqual(event2["a"], 1)
 

tests/test_meow.py

@@ -8,7 +8,7 @@ from typing import Any, Union
 
 from core.correctness.vars import TEST_HANDLER_BASE, TEST_JOB_OUTPUT, \
     TEST_MONITOR_BASE, BAREBONES_NOTEBOOK, WATCHDOG_BASE, WATCHDOG_RULE, \
-    WATCHDOG_SRC, WATCHDOG_TYPE, EVENT_TYPE
+    EVENT_PATH, WATCHDOG_TYPE, EVENT_TYPE
 from core.functionality import make_dir, rmtree
 from core.meow import BasePattern, BaseRecipe, BaseRule, BaseMonitor, \
     BaseHandler, create_rules
@@ -223,8 +223,8 @@ class MeowTests(unittest.TestCase):
         self.assertEqual(message[EVENT_TYPE], WATCHDOG_TYPE)
         self.assertIn(WATCHDOG_BASE, message)
         self.assertEqual(message[WATCHDOG_BASE], TEST_MONITOR_BASE)
-        self.assertIn(WATCHDOG_SRC, message)
+        self.assertIn(EVENT_PATH, message)
-        self.assertEqual(message[WATCHDOG_SRC], 
+        self.assertEqual(message[EVENT_PATH], 
             os.path.join(start_dir, "A.txt"))
         self.assertIn(WATCHDOG_RULE, message)
         self.assertEqual(message[WATCHDOG_RULE].name, rule.name)
@@ -286,8 +286,8 @@ class MeowTests(unittest.TestCase):
         self.assertEqual(message[EVENT_TYPE], WATCHDOG_TYPE)
         self.assertIn(WATCHDOG_BASE, message)
         self.assertEqual(message[WATCHDOG_BASE], TEST_MONITOR_BASE)
-        self.assertIn(WATCHDOG_SRC, message)
+        self.assertIn(EVENT_PATH, message)
-        self.assertEqual(message[WATCHDOG_SRC], 
+        self.assertEqual(message[EVENT_PATH], 
             os.path.join(start_dir, "A.txt"))
         self.assertIn(WATCHDOG_RULE, message)
         self.assertEqual(message[WATCHDOG_RULE].name, rule.name)

tests/test_patterns.py

@@ -6,7 +6,7 @@ from multiprocessing import Pipe
 
 from core.correctness.vars import FILE_CREATE_EVENT, BAREBONES_NOTEBOOK, \
     TEST_MONITOR_BASE, EVENT_TYPE, WATCHDOG_RULE, WATCHDOG_BASE, \
-    WATCHDOG_SRC, WATCHDOG_TYPE
+    WATCHDOG_TYPE, EVENT_PATH
 from core.functionality import rmtree, make_dir
 from core.meow import create_rules
 from patterns.file_event_pattern import FileEventPattern, WatchdogMonitor, \
@@ -183,11 +183,11 @@ class CorrectnessTests(unittest.TestCase):
         self.assertIsNotNone(event)
         self.assertEqual(type(event), dict)
         self.assertTrue(EVENT_TYPE in event.keys())        
-        self.assertTrue(WATCHDOG_SRC in event.keys())        
+        self.assertTrue(EVENT_PATH in event.keys())        
         self.assertTrue(WATCHDOG_BASE in event.keys())        
         self.assertTrue(WATCHDOG_RULE in event.keys())        
         self.assertEqual(event[EVENT_TYPE], WATCHDOG_TYPE)
-        self.assertEqual(event[WATCHDOG_SRC], os.path.join(TEST_MONITOR_BASE, "A"))
+        self.assertEqual(event[EVENT_PATH], os.path.join(TEST_MONITOR_BASE, "A"))
         self.assertEqual(event[WATCHDOG_BASE], TEST_MONITOR_BASE)
         self.assertEqual(event[WATCHDOG_RULE].name, rule.name)
 

tests/test_recipes.py

@@ -12,7 +12,7 @@ from recipes.jupyter_notebook_recipe import JupyterNotebookRecipe, \
 from rules.file_event_jupyter_notebook_rule import FileEventJupyterNotebookRule
 from core.correctness.vars import BAREBONES_NOTEBOOK, TEST_HANDLER_BASE, \
     TEST_JOB_OUTPUT, TEST_MONITOR_BASE, COMPLETE_NOTEBOOK, EVENT_TYPE, \
-    WATCHDOG_BASE, WATCHDOG_RULE, WATCHDOG_SRC, WATCHDOG_TYPE
+    WATCHDOG_BASE, WATCHDOG_RULE, WATCHDOG_TYPE, EVENT_PATH
 from core.functionality import rmtree, make_dir, read_notebook
 from core.meow import create_rules
 
@@ -131,7 +131,7 @@ class CorrectnessTests(unittest.TestCase):
 
         event = {
             EVENT_TYPE: WATCHDOG_TYPE,
-            WATCHDOG_SRC: os.path.join(TEST_MONITOR_BASE, "A"),
+            EVENT_PATH: os.path.join(TEST_MONITOR_BASE, "A"),
             WATCHDOG_BASE: TEST_MONITOR_BASE,
             WATCHDOG_RULE: rule
         }

tests/test_validation.py

@@ -8,7 +8,7 @@ from core.correctness.validation import check_type, check_implementation, \
     valid_string, valid_dict, valid_list, valid_existing_file_path, \
     valid_existing_dir_path, valid_non_existing_path, valid_event
 from core.correctness.vars import VALID_NAME_CHARS, TEST_MONITOR_BASE, \
-    SHA256, EVENT_TYPE
+    SHA256, EVENT_TYPE, EVENT_PATH
 from core.functionality import rmtree, make_dir
 
 class CorrectnessTests(unittest.TestCase):
@@ -208,10 +208,11 @@ class CorrectnessTests(unittest.TestCase):
             valid_non_existing_path("first/second")
 
     def testEventValidation(self)->None:
-        valid_event({EVENT_TYPE: "test"})
+        valid_event({EVENT_TYPE: "test", EVENT_PATH: "path"})
-        valid_event({EVENT_TYPE: "another"})
+        valid_event({EVENT_TYPE: "anything", EVENT_PATH: "path", "a": 1})
-        valid_event({EVENT_TYPE: "anything", "a": 1})
+
-        valid_event({EVENT_TYPE: "something", 1: 1})
+        with self.assertRaises(KeyError):
+            valid_event({EVENT_TYPE: "test"})
 
         with self.assertRaises(KeyError):
             valid_event({"EVENT_TYPE": "test"})