added watchdog file monitoring

tests/test_functionality.py

@@ -1,19 +1,13 @@
 
 import unittest
 
-from core.correctness.vars import CHAR_LOWERCASE, CHAR_UPPERCASE
+from core.correctness.vars import CHAR_LOWERCASE, CHAR_UPPERCASE, \
+    BAREBONES_NOTEBOOK
 from core.functionality import create_rules, generate_id
 from core.meow import BaseRule
 from patterns.file_event_pattern import FileEventPattern
 from recipes.jupyter_notebook_recipe import JupyterNotebookRecipe
 
-BAREBONES_NOTEBOOK = {
-    "cells": [],
-    "metadata": {},
-    "nbformat": 4,
-    "nbformat_minor": 4
-}
-
 valid_pattern_one = FileEventPattern(
     "pattern_one", "path_one", "recipe_one", "file_one")
 valid_pattern_two = FileEventPattern(

tests/test_meow.py

@@ -1,7 +1,11 @@
 
 import unittest
 
-from core.meow import BasePattern, BaseRecipe, BaseRule
+from typing import Any
+
+from core.correctness.vars import BAREBONES_NOTEBOOK
+from core.meow import BasePattern, BaseRecipe, BaseRule, BaseMonitor, \
+    BaseHandler
 
 
 class MeowTests(unittest.TestCase):
@@ -13,12 +17,97 @@ class MeowTests(unittest.TestCase):
 
     def testBaseRecipe(self)->None:
         with self.assertRaises(TypeError):
-            BaseRecipe("", "")
+            BaseRecipe("name", "")
+        
+        class NewRecipe(BaseRecipe):
+            pass
+        with self.assertRaises(NotImplementedError):
+            NewRecipe("name", "")
+
+        class FullRecipe(BaseRecipe):
+            def _is_valid_recipe(self, recipe:Any)->None:
+                pass
+            def _is_valid_parameters(self, parameters:Any)->None:
+                pass
+            def _is_valid_requirements(self, requirements:Any)->None:
+                pass
+        FullRecipe("name", "")
 
     def testBasePattern(self)->None:
         with self.assertRaises(TypeError):
-            BasePattern("", "")
+            BasePattern("name", "", "", "")
+
+        class NewPattern(BasePattern):
+            pass
+        with self.assertRaises(NotImplementedError):
+            NewPattern("name", "", "", "")
+
+        class FullPattern(BasePattern):
+            def _is_valid_recipe(self, recipe:Any)->None:
+                pass
+            def _is_valid_parameters(self, parameters:Any)->None:
+                pass
+            def _is_valid_output(self, outputs:Any)->None:
+                pass
+        FullPattern("name", "", "", "")
 
     def testBaseRule(self)->None:
         with self.assertRaises(TypeError):
-            BaseRule("", "")
+            BaseRule("name", "", "")
+
+        class NewRule(BaseRule):
+            pass
+        with self.assertRaises(NotImplementedError):
+            NewRule("name", "", "")
+
+        class FullRule(BaseRule):
+            pattern_type = "pattern"
+            recipe_type = "recipe"
+            def _is_valid_recipe(self, recipe:Any)->None:
+                pass
+            def _is_valid_pattern(self, pattern:Any)->None:
+                pass
+        FullRule("name", "", "")
+
+    def testBaseMonitor(self)->None:
+        with self.assertRaises(TypeError):
+            BaseMonitor("", "", "")
+
+        class TestMonitor(BaseMonitor):
+            pass
+
+        with self.assertRaises(NotImplementedError):
+            TestMonitor("", "", "")
+
+        class FullTestMonitor(BaseMonitor):
+            def start(self):
+                pass
+            def stop(self):
+                pass
+            def _is_valid_report(self, report:Any)->None:
+                pass
+            def _is_valid_listen(self, listen:Any)->None:
+                pass
+            def _is_valid_rules(self, rules:Any)->None:
+                pass
+        FullTestMonitor("", "", "")
+
+    def testBaseHandler(self)->None:
+        with self.assertRaises(TypeError):
+            BaseHandler("")
+
+        class TestHandler(BaseHandler):
+            pass
+
+        with self.assertRaises(NotImplementedError):
+            TestHandler("")
+
+        class FullTestHandler(BaseHandler):
+            def handle(self):
+                pass
+            def _is_valid_inputs(self, inputs:Any)->None:
+                pass
+        FullTestHandler("")
+
+
+

tests/test_patterns.py

@@ -1,15 +1,28 @@
 
+import shutil
+import os
 import unittest
 
-from patterns.file_event_pattern import FileEventPattern
+from multiprocessing import Pipe
 
+from core.correctness.vars import FILE_EVENTS, FILE_CREATE_EVENT, PIPE_READ, \
+    PIPE_WRITE, BAREBONES_NOTEBOOK
+from core.functionality import create_rules
+from patterns.file_event_pattern import FileEventPattern, WatchdogMonitor
+from recipes import JupyterNotebookRecipe
+
+TEST_BASE = "test_base"
 
 class CorrectnessTests(unittest.TestCase):
     def setUp(self) -> None:
-        return super().setUp()
+        super().setUp()
+        if not os.path.exists(TEST_BASE):
+            os.mkdir(TEST_BASE)
 
     def tearDown(self) -> None:
-        return super().tearDown()
+        super().tearDown()
+        if os.path.exists(TEST_BASE):
+            shutil.rmtree(TEST_BASE)
 
     def testFileEventPatternCreationMinimum(self)->None:
         FileEventPattern("name", "path", "recipe", "file")
@@ -79,3 +92,68 @@ class CorrectnessTests(unittest.TestCase):
         fep = FileEventPattern(
             "name", "path", "recipe", "file", outputs=outputs)
         self.assertEqual(fep.outputs, outputs)
+
+    def testFileEventPatternEventMask(self)->None:
+        fep = FileEventPattern("name", "path", "recipe", "file")
+        self.assertEqual(fep.event_mask, FILE_EVENTS)
+
+        with self.assertRaises(TypeError):
+            fep = FileEventPattern("name", "path", "recipe", "file", 
+                event_mask=FILE_CREATE_EVENT)
+
+        with self.assertRaises(ValueError):
+            fep = FileEventPattern("name", "path", "recipe", "file", 
+                event_mask=["nope"])
+
+        with self.assertRaises(ValueError):
+            fep = FileEventPattern("name", "path", "recipe", "file", 
+                event_mask=[FILE_CREATE_EVENT, "nope"])
+
+        self.assertEqual(fep.event_mask, FILE_EVENTS)
+
+    def testWatchdogMonitorMinimum(self)->None:
+        to_monitor = Pipe()
+        from_monitor = Pipe()
+        WatchdogMonitor(TEST_BASE, {}, from_monitor[PIPE_WRITE], 
+            to_monitor[PIPE_READ])
+
+    def testWatchdogMonitorEventIdentificaion(self)->None:
+        to_monitor = Pipe()
+        from_monitor = Pipe()
+
+        pattern_one = FileEventPattern(
+            "pattern_one", "A", "recipe_one", "file_one")
+        recipe = JupyterNotebookRecipe(
+            "recipe_one", BAREBONES_NOTEBOOK)
+
+        patterns = {
+            pattern_one.name: pattern_one,
+        }
+        recipes = {
+            recipe.name: recipe,
+        }
+        rules = create_rules(patterns, recipes)
+
+        wm = WatchdogMonitor(TEST_BASE, rules, from_monitor[PIPE_WRITE], 
+            to_monitor[PIPE_READ])
+
+        wm.start()
+
+        open(os.path.join(TEST_BASE, "A"), "w")
+        if from_monitor[PIPE_READ].poll(3):
+            message = from_monitor[PIPE_READ].recv()
+
+        self.assertIsNotNone(message)
+        event, rule = message
+        self.assertIsNotNone(event)
+        self.assertIsNotNone(rule)
+        self.assertEqual(event.src_path, os.path.join(TEST_BASE, "A"))
+
+        open(os.path.join(TEST_BASE, "B"), "w")
+        if from_monitor[PIPE_READ].poll(3):
+            new_message = from_monitor[PIPE_READ].recv()
+        else:
+            new_message = None
+        self.assertIsNone(new_message)
+
+        wm.stop()

tests/test_recipes.py

@@ -3,13 +3,7 @@ import jsonschema
 import unittest
 
 from recipes.jupyter_notebook_recipe import JupyterNotebookRecipe
-
-BAREBONES_NOTEBOOK = {
-    "cells": [],
-    "metadata": {},
-    "nbformat": 4,
-    "nbformat_minor": 4
-}
+from core.correctness.vars import BAREBONES_NOTEBOOK
 
 class CorrectnessTests(unittest.TestCase):
     def setUp(self)->None:

tests/test_rules.py

@@ -1,10 +1,10 @@
 
 import unittest
 
+from core.correctness.vars import BAREBONES_NOTEBOOK
 from patterns.file_event_pattern import FileEventPattern
 from recipes.jupyter_notebook_recipe import JupyterNotebookRecipe
 from rules.file_event_jupyter_notebook_rule import FileEventJupyterNotebookRule
-from test_recipes import BAREBONES_NOTEBOOK
 
 class CorrectnessTests(unittest.TestCase):
     def setUp(self) -> None: