rewrite property engine

Property class is gone; logic is now done with Layers, Stack and Filter

test/property/test_property.py

@@ -1,28 +0,0 @@
-import unittest
-from unittest.mock import Mock
-from owrx.property import Property
-
-
-class PropertyTest(unittest.TestCase):
-    def testValue(self):
-        prop = Property("testvalue")
-        self.assertEqual(prop.getValue(), "testvalue")
-
-    def testChangeValue(self):
-        prop = Property("before")
-        prop.setValue("after")
-        self.assertEqual(prop.getValue(), "after")
-
-    def testInitialValueOnCallback(self):
-        prop = Property("before")
-        m = Mock()
-        prop.wire(m.method)
-        m.method.assert_called_once_with("before")
-
-    def testChangedValueOnCallback(self):
-        prop = Property("before")
-        m = Mock()
-        prop.wire(m.method)
-        m.reset_mock()
-        prop.setValue("after")
-        m.method.assert_called_with("after")

test/property/test_property_filter.py

@@ -0,0 +1,51 @@
+from unittest import TestCase
+from unittest.mock import Mock
+from owrx.property import PropertyLayer, PropertyFilter
+
+
+class PropertyFilterTest(TestCase):
+
+    def testPassesProperty(self):
+        pm = PropertyLayer()
+        pm["testkey"] = "testvalue"
+        pf = PropertyFilter(pm, "testkey")
+        self.assertEqual(pf["testkey"], "testvalue")
+
+    def testMissesPropert(self):
+        pm = PropertyLayer()
+        pm["testkey"] = "testvalue"
+        pf = PropertyFilter(pm, "other_key")
+        self.assertFalse("testkey" in pf)
+        with self.assertRaises(KeyError):
+            x = pf["testkey"]
+
+    def testForwardsEvent(self):
+        pm = PropertyLayer()
+        pf = PropertyFilter(pm, "testkey")
+        mock = Mock()
+        pf.wire(mock.method)
+        pm["testkey"] = "testvalue"
+        mock.method.assert_called_once_with("testkey", "testvalue")
+
+    def testForwardsPropertyEvent(self):
+        pm = PropertyLayer()
+        pf = PropertyFilter(pm, "testkey")
+        mock = Mock()
+        pf.wireProperty("testkey", mock.method)
+        pm["testkey"] = "testvalue"
+        mock.method.assert_called_once_with("testvalue")
+
+    def testForwardsWrite(self):
+        pm = PropertyLayer()
+        pf = PropertyFilter(pm, "testkey")
+        pf["testkey"] = "testvalue"
+        self.assertTrue("testkey" in pm)
+        self.assertEqual(pm["testkey"], "testvalue")
+
+    def testOverwrite(self):
+        pm = PropertyLayer()
+        pm["testkey"] = "old value"
+        pf = PropertyFilter(pm, "testkey")
+        pf["testkey"] = "new value"
+        self.assertEqual(pm["testkey"], "new value")
+        self.assertEqual(pf["testkey"], "new value")

test/property/test_property_layer.py

@@ -0,0 +1,52 @@
+from owrx.property import PropertyLayer
+from unittest import TestCase
+from unittest.mock import Mock
+
+
+class PropertyLayerTest(TestCase):
+    def testKeyIsset(self):
+        pm = PropertyLayer()
+        self.assertFalse("some_key" in pm)
+
+    def testKeyError(self):
+        pm = PropertyLayer()
+        with self.assertRaises(KeyError):
+            x = pm["some_key"]
+
+    def testSubscription(self):
+        pm = PropertyLayer()
+        pm["testkey"] = "before"
+        mock = Mock()
+        pm.wire(mock.method)
+        pm["testkey"] = "after"
+        mock.method.assert_called_once_with("testkey", "after")
+
+    def testUnsubscribe(self):
+        pm = PropertyLayer()
+        pm["testkey"] = "before"
+        mock = Mock()
+        sub = pm.wire(mock.method)
+        pm["testkey"] = "between"
+        mock.method.assert_called_once_with("testkey", "between")
+
+        mock.reset_mock()
+        pm.unwire(sub)
+        pm["testkey"] = "after"
+        mock.method.assert_not_called()
+
+    def testContains(self):
+        pm = PropertyLayer()
+        pm["testkey"] = "value"
+        self.assertTrue("testkey" in pm)
+
+    def testDoesNotContain(self):
+        pm = PropertyLayer()
+        self.assertFalse("testkey" in pm)
+
+    def testSubscribeBeforeSet(self):
+        pm = PropertyLayer()
+        mock = Mock()
+        pm.wireProperty("testkey", mock.method)
+        mock.method.assert_not_called()
+        pm["testkey"] = "newvalue"
+        mock.method.assert_called_once_with("newvalue")

test/property/test_property_stack.py

@@ -1,20 +1,20 @@
 from unittest import TestCase
 from unittest.mock import Mock
-from owrx.property import PropertyManager, PropertyLayers
+from owrx.property import PropertyLayer, PropertyStack
 
 
-class TestPropertyLayers(TestCase):
+class PropertyStackTest(TestCase):
     def testLayer(self):
-        om = PropertyLayers()
-        pm = PropertyManager()
+        om = PropertyStack()
+        pm = PropertyLayer()
         pm["testkey"] = "testvalue"
         om.addLayer(1, pm)
         self.assertEqual(om["testkey"], "testvalue")
 
     def testHighPriority(self):
-        om = PropertyLayers()
-        low_pm = PropertyManager()
-        high_pm = PropertyManager()
+        om = PropertyStack()
+        low_pm = PropertyLayer()
+        high_pm = PropertyLayer()
         low_pm["testkey"] = "low value"
         high_pm["testkey"] = "high value"
         om.addLayer(1, low_pm)
@@ -22,18 +22,18 @@ class TestPropertyLayers(TestCase):
         self.assertEqual(om["testkey"], "high value")
 
     def testPriorityFallback(self):
-        om = PropertyLayers()
-        low_pm = PropertyManager()
-        high_pm = PropertyManager()
+        om = PropertyStack()
+        low_pm = PropertyLayer()
+        high_pm = PropertyLayer()
         low_pm["testkey"] = "low value"
         om.addLayer(1, low_pm)
         om.addLayer(0, high_pm)
         self.assertEqual(om["testkey"], "low value")
 
     def testLayerRemoval(self):
-        om = PropertyLayers()
-        low_pm = PropertyManager()
-        high_pm = PropertyManager()
+        om = PropertyStack()
+        low_pm = PropertyLayer()
+        high_pm = PropertyLayer()
         low_pm["testkey"] = "low value"
         high_pm["testkey"] = "high value"
         om.addLayer(1, low_pm)