def test_subscribe_no_data_then_set_data(self):
# subscribe
request = Subscribe(path=["b", "attr", "value"], delta=False)
request.set_callback(Mock())
self.handle_subscribe(request)
assert (self.o._tree.children["attr"].children["value"].update_requests
) == ([request])
self.assert_called_with(request.callback, Update(value=None))
request.callback.reset_mock()
# set data and check response
self.block["attr"] = Dummy()
with self.o.changes_squashed:
self.block.attr["value"] = 32
self.o.add_squashed_change(["b", "attr", "value"], 32)
assert self.block.attr.value == 32
self.assert_called_with(request.callback, Update(value=32))
request.callback.reset_mock()
# unsubscribe
unsub = Unsubscribe()
unsub.set_callback(request.callback)
self.handle_unsubscribe(unsub)
self.assert_called_with(request.callback, Return(value=None))
request.callback.reset_mock()
# notify and check no longer responding
with self.o.changes_squashed:
self.block.attr["value"] = 33
self.o.add_squashed_change(["b", "attr", "value"], 33)
assert self.block.attr.value == 33
request.callback.assert_not_called()
def test_update_squashing(self):
# set some data
self.block["attr"] = Dummy()
self.block.attr["value"] = 32
self.block["attr2"] = Dummy()
self.block.attr2["value"] = "st"
# subscribe once and check initial response
r1 = Subscribe(path=["b"], delta=True)
r1.set_callback(Mock())
r2 = Subscribe(path=["b"])
r2.set_callback(Mock())
self.handle_subscribe(r1)
self.handle_subscribe(r2)
expected = OrderedDict()
expected["attr"] = dict(value=32)
expected["attr2"] = dict(value="st")
self.assert_called_with(r1.callback, Delta(changes=[[[], expected]]))
self.assert_called_with(r2.callback, Update(value=expected))
r1.callback.reset_mock()
r2.callback.reset_mock()
# squash two changes together
with self.o.changes_squashed:
self.block.attr["value"] = 33
self.o.add_squashed_change(["b", "attr", "value"], 33)
assert self.block.attr.value == 33
self.block.attr2["value"] = "tr"
self.o.add_squashed_change(["b", "attr2", "value"], "tr")
assert self.block.attr2.value == "tr"
self.assert_called_with(
r1.callback,
Delta(
changes=[[["attr", "value"], 33], [["attr2", "value"], "tr"]]))
expected["attr"]["value"] = 33
expected["attr2"]["value"] = "tr"
self.assert_called_with(r2.callback, Update(value=expected))
class TestSubscribe(unittest.TestCase):
def setUp(self):
self.callback = MagicMock()
self.path = ["BL18I:XSPRESS3"]
self.delta = True
self.o = Subscribe(11, self.path, self.delta)
self.o.set_callback(self.callback)
def test_init(self):
assert self.o.typeid == "malcolm:core/Subscribe:1.0"
assert self.o.id == 11
assert self.o.callback == self.callback
assert self.path == self.o.path
assert self.delta == self.o.delta
def test_respond_with_update(self):
cb, response = self.o.update_response(value=5)
assert cb == self.callback
assert response.to_dict() == Update(id=11, value=5).to_dict()
def test_respond_with_delta(self):
changes = [[["path"], "value"]]
cb, response = self.o.delta_response(changes)
assert cb == self.callback
assert response.to_dict() == Delta(id=11, changes=changes).to_dict()
def test_setters(self):
self.o.path = ["BL18I:XSPRESS3", "state", "value"]
self.o.id = 19
d = self.o.to_dict(dict_cls=OrderedDict)
del d["delta"]
assert get_doc_json("subscribe_xspress3_state_value") == d
def test_doc(self):
assert get_doc_json("subscribe_xspress3") == self.o.to_dict()
def test_2_subscribes(self):
# set some data
self.block["attr"] = Dummy()
self.block.attr["value"] = 32
# subscribe once and check initial response
r1 = Subscribe(path=["b", "attr", "value"], delta=False)
r1.set_callback(Mock())
self.handle_subscribe(r1)
self.assert_called_with(r1.callback, Update(value=32))
r1.callback.reset_mock()
# subscribe again and check initial response
r2 = Subscribe(path=["b"], delta=True)
r2.set_callback(Mock())
self.handle_subscribe(r2)
self.assert_called_with(
r2.callback, Delta(changes=[[[], dict(attr=dict(value=32))]])
)
r2.callback.reset_mock()
# set some data and check only second got called
self.block["attr2"] = Dummy()
with self.o.changes_squashed:
self.block.attr2["value"] = "st"
self.o.add_squashed_change(["b", "attr2"], self.block.attr2)
r1.callback.assert_not_called()
self.assert_called_with(
r2.callback, Delta(changes=[[["attr2"], dict(value="st")]])
)
r2.callback.reset_mock()
# delete the first and check calls
with self.o.changes_squashed:
self.block.data.pop("attr")
self.o.add_squashed_delete(["b", "attr"])
self.assert_called_with(r1.callback, Update(value=None))
r1.callback.reset_mock()
self.assert_called_with(r2.callback, Delta(changes=[[["attr"]]]))
r2.callback.reset_mock()
# add it again and check updates
self.block["attr"] = Dummy()
with self.o.changes_squashed:
self.block.attr["value"] = 22
self.o.add_squashed_change(["b", "attr"], self.block.attr)
self.assert_called_with(r1.callback, Update(value=22))
self.assert_called_with(
r2.callback, Delta(changes=[[["attr"], dict(value=22)]])
)
class TestUnsubscribe(unittest.TestCase):
def setUp(self):
self.callback = MagicMock()
self.subscribe = Subscribe(32, ["."])
self.subscribe.set_callback(self.callback)
self.subscribes = {self.subscribe.generate_key(): self.subscribe}
self.o = Unsubscribe(32)
self.o.set_callback(self.callback)
def test_init(self):
assert self.o.typeid == "malcolm:core/Unsubscribe:1.0"
assert self.o.id == 32
def test_keys_same(self):
assert self.subscribes[self.o.generate_key()] == self.subscribe
def test_doc(self):
assert get_doc_json("unsubscribe") == self.o.to_dict()
