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 testEventPreventedWhenValueUnchanged(self):
pm = PropertyLayer()
pm["testkey"] = "testvalue"
mock = Mock()
pm.wire(mock.method)
pm["testkey"] = "testvalue"
mock.method.assert_not_called()
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 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 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 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()
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 __init__(self, pm: PropertyManager):
self.subscriptions = {}
self.profileSubscriptions = {}
self._layer = PropertyLayer()
super().__init__(self._layer)
for key, value in pm.items():
self._addSource(key, value)
pm.wire(self.handleSdrDeviceChange)
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 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"})
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 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 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 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 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 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"})
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 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 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 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 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 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")
def testMissesProperty(self):
pm = PropertyLayer()
pm["testkey"] = "testvalue"
pf = PropertyFilter(pm, "other_key")
self.assertFalse("testkey" in pf)
with self.assertRaises(KeyError):
x = pf["testkey"]
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 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")
def testRejectsWrite(self):
pm = PropertyLayer()
pm["testkey"] = "old value"
pf = PropertyFilter(pm, "otherkey")
with self.assertRaises(KeyError):
pf["testkey"] = "new value"
self.assertEqual(pm["testkey"], "old value")
def _loadConfig():
for file in ["/etc/openwebrx/config_webrx.py", "./config_webrx.py"]:
try:
return ClassicConfig._loadPythonFile(file)
except FileNotFoundError:
pass
return PropertyLayer()
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 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(None)
