move tests to match folder structure

test/owrx/property/filter/test_by_lambda.py

@@ -0,0 +1,17 @@
+from owrx.property.filter import ByLambda
+from unittest import TestCase
+from unittest.mock import Mock
+
+
+class TestByLambda(TestCase):
+    def testPositive(self):
+        mock = Mock(return_value=True)
+        filter = ByLambda(mock)
+        self.assertTrue(filter.apply("test_key"))
+        mock.assert_called_with("test_key")
+
+    def testNegateive(self):
+        mock = Mock(return_value=False)
+        filter = ByLambda(mock)
+        self.assertFalse(filter.apply("test_key"))
+        mock.assert_called_with("test_key")

test/owrx/property/filter/test_by_property_name.py

@@ -0,0 +1,12 @@
+from owrx.property.filter import ByPropertyName
+from unittest import TestCase
+
+
+class ByPropertyNameTest(TestCase):
+    def testNameIsInList(self):
+        filter = ByPropertyName("test_key")
+        self.assertTrue(filter.apply("test_key"))
+
+    def testNameNotInList(self):
+        filter = ByPropertyName("test_key")
+        self.assertFalse(filter.apply("other_key"))

test/owrx/property/test_property_carousel.py

@@ -0,0 +1,125 @@
+from unittest import TestCase
+from unittest.mock import Mock
+from owrx.property import PropertyCarousel, PropertyLayer, PropertyDeleted, PropertyWriteError
+
+
+class PropertyCarouselTest(TestCase):
+    def testInitiallyEmpty(self):
+        pc = PropertyCarousel()
+        with self.assertRaises(KeyError):
+            x = pc["testkey"]
+
+    def testPropertyAccess(self):
+        pc = PropertyCarousel()
+        pl = PropertyLayer(testkey="testvalue")
+        pc.addLayer("test", pl)
+        pc.switch("test")
+        self.assertEqual(pc["testkey"], "testvalue")
+
+    def testWriteAccess(self):
+        pc = PropertyCarousel()
+        pl = PropertyLayer(testkey="old_value")
+        pc.addLayer("test", pl)
+        pc.switch("test")
+        pc["testkey"] = "new_value"
+        self.assertEqual(pc["testkey"], "new_value")
+        self.assertEqual(pl["testkey"], "new_value")
+
+    def testForwardsEvents(self):
+        pc = PropertyCarousel()
+        pl = PropertyLayer(testkey="old_value")
+        pc.addLayer("test", pl)
+        pc.switch("test")
+        mock = Mock()
+        pc.wire(mock.method)
+        pc["testkey"] = "new_value"
+        mock.method.assert_called_once_with({"testkey": "new_value"})
+
+    def testStopsForwardingAfterSwitch(self):
+        pc = PropertyCarousel()
+        pl_x = PropertyLayer(testkey="old_value")
+        pc.addLayer("x", pl_x)
+        pl_y = PropertyLayer(testkey="new_value")
+        pc.addLayer("y", pl_y)
+        pc.switch("x")
+        pc.switch("y")
+        mock = Mock()
+        pc.wire(mock.method)
+        pl_x["testkey"] = "new_value"
+        mock.method.assert_not_called()
+
+    def testEventsOnSwitch(self):
+        pc = PropertyCarousel()
+        pl_x = PropertyLayer(old_key="old_value")
+        pc.addLayer("x", pl_x)
+        pl_y = PropertyLayer(new_key="new_value")
+        pc.addLayer("y", pl_y)
+        pc.switch("x")
+        mock = Mock()
+        pc.wire(mock.method)
+        pc.switch("y")
+        mock.method.assert_called_once_with({"old_key": PropertyDeleted, "new_key": "new_value"})
+
+    def testNoEventsIfKeysDontChange(self):
+        pc = PropertyCarousel()
+        pl_x = PropertyLayer(testkey="same_value")
+        pc.addLayer("x", pl_x)
+        pl_y = PropertyLayer(testkey="same_value")
+        pc.addLayer("y", pl_y)
+        pc.switch("x")
+        mock = Mock()
+        pc.wire(mock.method)
+        pc.switch("y")
+        mock.method.assert_not_called()
+
+    def testKeyErrorOnInvalidSwitch(self):
+        pc = PropertyCarousel()
+        with self.assertRaises(KeyError):
+            pc.switch("doesntmatter")
+
+    def testRemoveLayer(self):
+        pc = PropertyCarousel()
+        pl = PropertyLayer(testkey="testvalue")
+        pc.addLayer("x", pl)
+        pc.switch("x")
+        self.assertEqual(pc["testkey"], "testvalue")
+        pc.removeLayer("x")
+        with self.assertRaises(KeyError):
+            pc.switch("x")
+
+    def testPropertyResetAfterRemoval(self):
+        pc = PropertyCarousel()
+        pl = PropertyLayer(testkey="testvalue")
+        pc.addLayer("x", pl)
+        pc.switch("x")
+        self.assertEqual(pc["testkey"], "testvalue")
+        pc.removeLayer("x")
+        with self.assertRaises(KeyError):
+            x = pc["testkey"]
+
+    def testEmptySwitch(self):
+        pc = PropertyCarousel()
+        pl = PropertyLayer(testkey="testvalue")
+        pc.addLayer("x", pl)
+        pc.switch("x")
+        self.assertEqual(pc["testkey"], "testvalue")
+        pc.switch()
+        with self.assertRaises(KeyError):
+            x = pc["testkey"]
+
+    def testErrorOnWriteOnDefaultLayer(self):
+        pc = PropertyCarousel()
+        with self.assertRaises(PropertyWriteError):
+            pc["testkey"] = "testvalue"
+
+    def testSendsChangesIfActiveLayerIsReplaced(self):
+        pc = PropertyCarousel()
+        pl = PropertyLayer(testkey="testvalue")
+        pc.addLayer("x", pl)
+        pc.switch("x")
+        self.assertEqual(pc["testkey"], "testvalue")
+        mock = Mock()
+        pc.wire(mock.method)
+        pl = PropertyLayer(testkey="othervalue")
+        pc.addLayer("x", pl)
+        mock.method.assert_called_once_with({"testkey": "othervalue"})

test/owrx/property/test_property_deletion.py

@@ -0,0 +1,8 @@
+from unittest import TestCase
+from owrx.property import PropertyDeletion
+
+
+class PropertyDeletionTest(TestCase):
+    def testDeletionEvaluatesToFalse(self):
+        deletion = PropertyDeletion()
+        self.assertFalse(deletion)

test/owrx/property/test_property_filter.py

@@ -0,0 +1,82 @@
+from unittest import TestCase
+from unittest.mock import Mock
+from owrx.property import PropertyLayer, PropertyFilter, PropertyDeleted
+
+
+class PropertyFilterTest(TestCase):
+    def testPassesProperty(self):
+        pm = PropertyLayer()
+        pm["testkey"] = "testvalue"
+        mock = Mock()
+        mock.apply.return_value = True
+        pf = PropertyFilter(pm, mock)
+        self.assertEqual(pf["testkey"], "testvalue")
+
+    def testMissesProperty(self):
+        pm = PropertyLayer()
+        pm["testkey"] = "testvalue"
+        mock = Mock()
+        mock.apply.return_value = False
+        pf = PropertyFilter(pm, mock)
+        self.assertFalse("testkey" in pf)
+        with self.assertRaises(KeyError):
+            x = pf["testkey"]
+
+    def testForwardsEvent(self):
+        pm = PropertyLayer()
+        mock = Mock()
+        mock.apply.return_value = True
+        pf = PropertyFilter(pm, mock)
+        mock = Mock()
+        pf.wire(mock.method)
+        pm["testkey"] = "testvalue"
+        mock.method.assert_called_once_with({"testkey": "testvalue"})
+
+    def testForwardsPropertyEvent(self):
+        pm = PropertyLayer()
+        mock = Mock()
+        mock.apply.return_value = True
+        pf = PropertyFilter(pm, mock)
+        mock = Mock()
+        pf.wireProperty("testkey", mock.method)
+        pm["testkey"] = "testvalue"
+        mock.method.assert_called_once_with("testvalue")
+
+    def testForwardsWrite(self):
+        pm = PropertyLayer()
+        mock = Mock()
+        mock.apply.return_value = True
+        pf = PropertyFilter(pm, mock)
+        pf["testkey"] = "testvalue"
+        self.assertTrue("testkey" in pm)
+        self.assertEqual(pm["testkey"], "testvalue")
+
+    def testOverwrite(self):
+        pm = PropertyLayer()
+        pm["testkey"] = "old value"
+        mock = Mock()
+        mock.apply.return_value = True
+        pf = PropertyFilter(pm, mock)
+        pf["testkey"] = "new value"
+        self.assertEqual(pm["testkey"], "new value")
+        self.assertEqual(pf["testkey"], "new value")
+
+    def testRejectsWrite(self):
+        pm = PropertyLayer()
+        pm["testkey"] = "old value"
+        mock = Mock()
+        mock.apply.return_value = False
+        pf = PropertyFilter(pm, mock)
+        with self.assertRaises(KeyError):
+            pf["testkey"] = "new value"
+        self.assertEqual(pm["testkey"], "old value")
+
+    def testPropagatesDeletion(self):
+        pm = PropertyLayer(testkey="somevalue")
+        filter_mock = Mock()
+        filter_mock.apply.return_value = True
+        pf = PropertyFilter(pm, filter_mock)
+        mock = Mock()
+        pf.wire(mock.method)
+        del pf["testkey"]
+        mock.method.assert_called_once_with({"testkey": PropertyDeleted})

test/owrx/property/test_property_layer.py

@@ -0,0 +1,93 @@
+from owrx.property import PropertyLayer, PropertyDeleted
+from unittest import TestCase
+from unittest.mock import Mock
+
+
+class PropertyLayerTest(TestCase):
+    def testCreationWithKwArgs(self):
+        pm = PropertyLayer(testkey="value")
+        self.assertEqual(pm["testkey"], "value")
+
+        # this should be synonymous, so this is rather for illustration purposes
+        contents = {"testkey": "value"}
+        pm = PropertyLayer(**contents)
+        self.assertEqual(pm["testkey"], "value")
+
+    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")
+
+    def testEventPreventedWhenValueUnchanged(self):
+        pm = PropertyLayer()
+        pm["testkey"] = "testvalue"
+        mock = Mock()
+        pm.wire(mock.method)
+        pm["testkey"] = "testvalue"
+        mock.method.assert_not_called()
+
+    def testDeletionIsSent(self):
+        pm = PropertyLayer(testkey="somevalue")
+        mock = Mock()
+        pm.wireProperty("testkey", mock.method)
+        mock.method.reset_mock()
+        del pm["testkey"]
+        mock.method.assert_called_once_with(PropertyDeleted)
+
+    def testDeletionInGeneralWiring(self):
+        pm = PropertyLayer(testkey="somevalue")
+        mock = Mock()
+        pm.wire(mock.method)
+        del pm["testkey"]
+        mock.method.assert_called_once_with({"testkey": PropertyDeleted})
+
+    def testNoDeletionEventWhenPropertyDoesntExist(self):
+        pm = PropertyLayer(otherkey="somevalue")
+        mock = Mock()
+        pm.wireProperty("testkey", mock.method)
+        mock.method.reset_mock()
+        with self.assertRaises(KeyError):
+            del pm["testkey"]
+        mock.method.assert_not_called()

test/owrx/property/test_property_readonly.py

@@ -0,0 +1,23 @@
+from unittest import TestCase
+from owrx.property import PropertyLayer, PropertyReadOnly, PropertyWriteError
+
+
+class PropertyReadOnlyTest(TestCase):
+    def testPreventsWrites(self):
+        layer = PropertyLayer()
+        layer["testkey"] = "initial value"
+        ro = PropertyReadOnly(layer)
+        with self.assertRaises(PropertyWriteError):
+            ro["testkey"] = "new value"
+        with self.assertRaises(PropertyWriteError):
+            ro["otherkey"] = "testvalue"
+        self.assertEqual(ro["testkey"], "initial value")
+        self.assertNotIn("otherkey", ro)
+
+    def testPreventsDeletes(self):
+        layer = PropertyLayer(testkey="some value")
+        ro = PropertyReadOnly(layer)
+        with self.assertRaises(PropertyWriteError):
+            del ro["testkey"]
+        self.assertEqual(ro["testkey"], "some value")
+        self.assertEqual(layer["testkey"], "some value")

test/owrx/property/test_property_stack.py

@@ -0,0 +1,240 @@
+from unittest import TestCase
+from unittest.mock import Mock
+from owrx.property import PropertyLayer, PropertyStack, PropertyDeleted
+
+
+class PropertyStackTest(TestCase):
+    def testLayer(self):
+        om = PropertyStack()
+        pm = PropertyLayer()
+        pm["testkey"] = "testvalue"
+        om.addLayer(1, pm)
+        self.assertEqual(om["testkey"], "testvalue")
+
+    def testHighPriority(self):
+        om = PropertyStack()
+        low_pm = PropertyLayer()
+        high_pm = PropertyLayer()
+        low_pm["testkey"] = "low value"
+        high_pm["testkey"] = "high value"
+        om.addLayer(1, low_pm)
+        om.addLayer(0, high_pm)
+        self.assertEqual(om["testkey"], "high value")
+
+    def testPriorityFallback(self):
+        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 = PropertyStack()
+        low_pm = PropertyLayer()
+        high_pm = PropertyLayer()
+        low_pm["testkey"] = "low value"
+        high_pm["testkey"] = "high value"
+        om.addLayer(1, low_pm)
+        om.addLayer(0, high_pm)
+        self.assertEqual(om["testkey"], "high value")
+        om.removeLayer(high_pm)
+        self.assertEqual(om["testkey"], "low value")
+
+    def testLayerRemovalByPriority(self):
+        om = PropertyStack()
+        low_pm = PropertyLayer()
+        high_pm = PropertyLayer()
+        low_pm["testkey"] = "low value"
+        high_pm["testkey"] = "high value"
+        om.addLayer(1, low_pm)
+        om.addLayer(0, high_pm)
+        self.assertEqual(om["testkey"], "high value")
+        om.removeLayerByPriority(0)
+        self.assertEqual(om["testkey"], "low value")
+
+    def testPropertyChange(self):
+        layer = PropertyLayer()
+        stack = PropertyStack()
+        stack.addLayer(0, layer)
+        mock = Mock()
+        stack.wire(mock.method)
+        layer["testkey"] = "testvalue"
+        mock.method.assert_called_once_with({"testkey": "testvalue"})
+
+    def testPropertyChangeEventPriority(self):
+        low_layer = PropertyLayer()
+        high_layer = PropertyLayer()
+        low_layer["testkey"] = "initial low value"
+        high_layer["testkey"] = "initial high value"
+        stack = PropertyStack()
+        stack.addLayer(1, low_layer)
+        stack.addLayer(0, high_layer)
+        mock = Mock()
+        stack.wire(mock.method)
+        low_layer["testkey"] = "modified low value"
+        mock.method.assert_not_called()
+        high_layer["testkey"] = "modified high value"
+        mock.method.assert_called_once_with({"testkey": "modified high value"})
+
+    def testPropertyEventOnLayerAdd(self):
+        low_layer = PropertyLayer()
+        low_layer["testkey"] = "low value"
+        stack = PropertyStack()
+        stack.addLayer(1, low_layer)
+        mock = Mock()
+        stack.wireProperty("testkey", mock.method)
+        mock.reset_mock()
+        high_layer = PropertyLayer()
+        high_layer["testkey"] = "high value"
+        stack.addLayer(0, high_layer)
+        mock.method.assert_called_once_with("high value")
+
+    def testNoEventOnExistingValue(self):
+        low_layer = PropertyLayer()
+        low_layer["testkey"] = "same value"
+        stack = PropertyStack()
+        stack.addLayer(1, low_layer)
+        mock = Mock()
+        stack.wireProperty("testkey", mock.method)
+        mock.reset_mock()
+        high_layer = PropertyLayer()
+        high_layer["testkey"] = "same value"
+        stack.addLayer(0, high_layer)
+        mock.method.assert_not_called()
+
+    def testEventOnLayerWithNewProperty(self):
+        low_layer = PropertyLayer()
+        low_layer["existingkey"] = "existing value"
+        stack = PropertyStack()
+        stack.addLayer(1, low_layer)
+        mock = Mock()
+        stack.wireProperty("newkey", mock.method)
+        high_layer = PropertyLayer()
+        high_layer["newkey"] = "new value"
+        stack.addLayer(0, high_layer)
+        mock.method.assert_called_once_with("new value")
+
+    def testEventOnLayerRemoval(self):
+        low_layer = PropertyLayer()
+        high_layer = PropertyLayer()
+        stack = PropertyStack()
+        stack.addLayer(1, low_layer)
+        stack.addLayer(0, high_layer)
+        low_layer["testkey"] = "low value"
+        high_layer["testkey"] = "high value"
+
+        mock = Mock()
+        stack.wireProperty("testkey", mock.method)
+        mock.method.assert_called_once_with("high value")
+        mock.reset_mock()
+        stack.removeLayer(high_layer)
+        mock.method.assert_called_once_with("low value")
+
+    def testNoneOnKeyRemoval(self):
+        low_layer = PropertyLayer()
+        high_layer = PropertyLayer()
+        stack = PropertyStack()
+        stack.addLayer(1, low_layer)
+        stack.addLayer(0, high_layer)
+        low_layer["testkey"] = "low value"
+        high_layer["testkey"] = "high value"
+        high_layer["unique key"] = "unique value"
+
+        mock = Mock()
+        stack.wireProperty("unique key", mock.method)
+        mock.method.assert_called_once_with("unique value")
+        mock.reset_mock()
+        stack.removeLayer(high_layer)
+        mock.method.assert_called_once_with(PropertyDeleted)
+
+    def testReplaceLayer(self):
+        first_layer = PropertyLayer()
+        first_layer["testkey"] = "old value"
+        second_layer = PropertyLayer()
+        second_layer["testkey"] = "new value"
+
+        stack = PropertyStack()
+        stack.addLayer(0, first_layer)
+
+        mock = Mock()
+        stack.wireProperty("testkey", mock.method)
+        mock.method.assert_called_once_with("old value")
+        mock.reset_mock()
+
+        stack.replaceLayer(0, second_layer)
+        mock.method.assert_called_once_with("new value")
+
+    def testUnwiresEventsOnRemoval(self):
+        layer = PropertyLayer()
+        layer["testkey"] = "before"
+        stack = PropertyStack()
+        stack.addLayer(0, layer)
+        mock = Mock()
+        stack.wire(mock.method)
+        stack.removeLayer(layer)
+        mock.method.assert_called_once_with({"testkey": PropertyDeleted})
+        mock.reset_mock()
+
+        layer["testkey"] = "after"
+        mock.method.assert_not_called()
+
+    def testReplaceLayerNoEventWhenValueUnchanged(self):
+        fixed = PropertyLayer()
+        fixed["testkey"] = "fixed value"
+        first_layer = PropertyLayer()
+        first_layer["testkey"] = "same value"
+        second_layer = PropertyLayer()
+        second_layer["testkey"] = "same value"
+
+        stack = PropertyStack()
+        stack.addLayer(1, fixed)
+        stack.addLayer(0, first_layer)
+        mock = Mock()
+        stack.wire(mock.method)
+        mock.method.assert_not_called()
+
+        stack.replaceLayer(0, second_layer)
+        mock.method.assert_not_called()
+
+    def testWritesToExpectedLayer(self):
+        om = PropertyStack()
+        low_pm = PropertyLayer()
+        high_pm = PropertyLayer()
+        low_pm["testkey"] = "low value"
+        om.addLayer(1, low_pm)
+        om.addLayer(0, high_pm)
+        om["testkey"] = "new value"
+        self.assertEqual(low_pm["testkey"], "new value")
+
+    def testDeletionEvent(self):
+        ps = PropertyStack()
+        pm = PropertyLayer(testkey="testvalue")
+        ps.addLayer(0, pm)
+        mock = Mock()
+        ps.wire(mock.method)
+        del ps["testkey"]
+        mock.method.assert_called_once_with({"testkey": PropertyDeleted})
+
+    def testDeletionWithSecondLayer(self):
+        ps = PropertyStack()
+        low_pm = PropertyLayer(testkey="testvalue")
+        high_pm = PropertyLayer()
+        ps.addLayer(0, high_pm)
+        ps.addLayer(1, low_pm)
+        mock = Mock()
+        ps.wire(mock.method)
+        del low_pm["testkey"]
+        mock.method.assert_called_once_with({"testkey": PropertyDeleted})
+
+    def testChangeEventWhenKeyDeleted(self):
+        ps = PropertyStack()
+        low_pm = PropertyLayer(testkey="lowvalue")
+        high_pm = PropertyLayer(testkey="highvalue")
+        ps.addLayer(0, high_pm)
+        ps.addLayer(1, low_pm)
+        mock = Mock()
+        ps.wire(mock.method)
+        del high_pm["testkey"]
+        mock.method.assert_called_once_with({"testkey": "lowvalue"})

test/owrx/property/test_property_validator.py

@@ -0,0 +1,37 @@
+from unittest import TestCase
+from owrx.property import PropertyLayer, PropertyValidator, PropertyValidationError
+from owrx.property.validators import NumberValidator, StringValidator
+
+
+class PropertyValidatorTest(TestCase):
+    def testPassesUnvalidated(self):
+        pm = PropertyLayer()
+        pv = PropertyValidator(pm)
+        pv["testkey"] = "testvalue"
+        self.assertEqual(pv["testkey"], "testvalue")
+        self.assertEqual(pm["testkey"], "testvalue")
+
+    def testPassesValidValue(self):
+        pv = PropertyValidator(PropertyLayer(), {"testkey": NumberValidator()})
+        pv["testkey"] = 42
+        self.assertEqual(pv["testkey"], 42)
+
+    def testThrowsErrorOnInvalidValue(self):
+        pv = PropertyValidator(PropertyLayer(), {"testkey": NumberValidator()})
+        with self.assertRaises(PropertyValidationError):
+            pv["testkey"] = "text"
+
+    def testSetValidator(self):
+        pv = PropertyValidator(PropertyLayer())
+        pv.setValidator("testkey", NumberValidator())
+        with self.assertRaises(PropertyValidationError):
+            pv["testkey"] = "text"
+
+    def testUpdateValidator(self):
+        pv = PropertyValidator(PropertyLayer(), {"testkey": StringValidator()})
+        # this should pass
+        pv["testkey"] = "text"
+        pv.setValidator("testkey", NumberValidator())
+        # this should raise
+        with self.assertRaises(PropertyValidationError):
+            pv["testkey"] = "text"

test/owrx/property/validators/test_bool_validator.py

@@ -0,0 +1,17 @@
+from unittest import TestCase
+from owrx.property.validators import BoolValidator
+
+
+class NumberValidatorTest(TestCase):
+    def testPassesNumbers(self):
+        validator = BoolValidator()
+        self.assertTrue(validator.isValid(True))
+        self.assertTrue(validator.isValid(False))
+
+    def testDoesntPassOthers(self):
+        validator = BoolValidator()
+        self.assertFalse(validator.isValid(123))
+        self.assertFalse(validator.isValid(-2))
+        self.assertFalse(validator.isValid(.5))
+        self.assertFalse(validator.isValid("text"))
+        self.assertFalse(validator.isValid(object()))

test/owrx/property/validators/test_float_validator.py

@@ -0,0 +1,15 @@
+from unittest import TestCase
+from owrx.property.validators import FloatValidator
+
+
+class FloatValidatorTest(TestCase):
+    def testPassesNumbers(self):
+        validator = FloatValidator()
+        self.assertTrue(validator.isValid(.5))
+
+    def testDoesntPassOthers(self):
+        validator = FloatValidator()
+        self.assertFalse(validator.isValid(123))
+        self.assertFalse(validator.isValid(-2))
+        self.assertFalse(validator.isValid("text"))
+        self.assertFalse(validator.isValid(object()))

test/owrx/property/validators/test_integer_validator.py

@@ -0,0 +1,15 @@
+from unittest import TestCase
+from owrx.property.validators import IntegerValidator
+
+
+class IntegerValidatorTest(TestCase):
+    def testPassesIntegers(self):
+        validator = IntegerValidator()
+        self.assertTrue(validator.isValid(123))
+        self.assertTrue(validator.isValid(-2))
+
+    def testDoesntPassOthers(self):
+        validator = IntegerValidator()
+        self.assertFalse(validator.isValid(.5))
+        self.assertFalse(validator.isValid("text"))
+        self.assertFalse(validator.isValid(object()))

test/owrx/property/validators/test_lambda_validator.py

@@ -0,0 +1,21 @@
+from unittest import TestCase
+from unittest.mock import Mock
+from owrx.property.validators import LambdaValidator
+
+
+class LambdaValidatorTest(TestCase):
+    def testPassesValue(self):
+        mock = Mock()
+        validator = LambdaValidator(mock.method)
+        validator.isValid("test")
+        mock.method.assert_called_once_with("test")
+
+    def testReturnsTrue(self):
+        validator = LambdaValidator(lambda x: True)
+        self.assertTrue(validator.isValid("any value"))
+        self.assertTrue(validator.isValid(3.1415926))
+
+    def testReturnsFalse(self):
+        validator = LambdaValidator(lambda x: False)
+        self.assertFalse(validator.isValid("any value"))
+        self.assertFalse(validator.isValid(42))

test/owrx/property/validators/test_number_validator.py

@@ -0,0 +1,18 @@
+from unittest import TestCase
+from owrx.property.validators import NumberValidator
+
+
+class NumberValidatorTest(TestCase):
+    def testPassesNumbers(self):
+        validator = NumberValidator()
+        self.assertTrue(validator.isValid(123))
+        self.assertTrue(validator.isValid(-2))
+        self.assertTrue(validator.isValid(.5))
+
+    def testDoesntPassOthers(self):
+        validator = NumberValidator()
+        # bool is a subclass of int, so it passes this test.
+        # not sure if we need to be more specific or if this is alright.
+        # self.assertFalse(validator.isValid(True))
+        self.assertFalse(validator.isValid("text"))
+        self.assertFalse(validator.isValid(object()))

test/owrx/property/validators/test_or_validator.py

@@ -0,0 +1,17 @@
+from unittest import TestCase
+from owrx.property.validators import OrValidator, IntegerValidator, StringValidator
+
+
+class OrValidatorTest(TestCase):
+    def testPassesAnyValidators(self):
+        validator = OrValidator(IntegerValidator(), StringValidator())
+        self.assertTrue(validator.isValid(42))
+        self.assertTrue(validator.isValid("text"))
+
+    def testRejectsOtherTypes(self):
+        validator = OrValidator(IntegerValidator(), StringValidator())
+        self.assertFalse(validator.isValid(.5))
+
+    def testRejectsIfNoValidator(self):
+        validator = OrValidator()
+        self.assertFalse(validator.isValid("any value"))

test/owrx/property/validators/test_regex_validator.py

@@ -0,0 +1,17 @@
+from unittest import TestCase
+from owrx.property.validators import RegexValidator
+import re
+
+
+class RegexValidatorTest(TestCase):
+    def testMatchesRegex(self):
+        validator = RegexValidator(re.compile("abc"))
+        self.assertTrue(validator.isValid("abc"))
+
+    def testDoesntMatchRegex(self):
+        validator = RegexValidator(re.compile("abc"))
+        self.assertFalse(validator.isValid("xyz"))
+
+    def testFailsIfValueIsNoString(self):
+        validator = RegexValidator(re.compile("abc"))
+        self.assertFalse(validator.isValid(42))

test/owrx/property/validators/test_string_validator.py

@@ -0,0 +1,14 @@
+from unittest import TestCase
+from owrx.property.validators import StringValidator
+
+class StringValidatorTest(TestCase):
+    def testPassesStrings(self):
+        validator = StringValidator()
+        self.assertTrue(validator.isValid("text"))
+
+    def testDoesntPassOthers(self):
+        validator = StringValidator()
+        self.assertFalse(validator.isValid(123))
+        self.assertFalse(validator.isValid(-2))
+        self.assertFalse(validator.isValid(.5))
+        self.assertFalse(validator.isValid(object()))

test/owrx/property/validators/test_validator.py

@@ -0,0 +1,20 @@
+from unittest import TestCase
+from owrx.property.validators import Validator, NumberValidator, LambdaValidator, StringValidator
+
+
+class ValidatorTest(TestCase):
+
+    def testReturnsValidator(self):
+        validator = NumberValidator()
+        self.assertIs(validator, Validator.of(validator))
+
+    def testTransformsLambda(self):
+        def my_callable(v):
+            return True
+        validator = Validator.of(my_callable)
+        self.assertIsInstance(validator, LambdaValidator)
+        self.assertTrue(validator.isValid("test"))
+
+    def testGetsValidatorByKey(self):
+        validator = Validator.of("str")
+        self.assertIsInstance(validator, StringValidator)