class TestSystemWSCommsServerAndClient(TestSystemWSCommsServerOnly): socket = 8882 def setUp(self): super(TestSystemWSCommsServerAndClient, self).setUp() self.process2 = Process("proc2", self.sf) self.block2 = Block() ClientController(self.process2, self.block2, 'hello') self.cc = WSClientComms("cc", self.process2, "ws://localhost:%s/ws" % self.socket) self.process2.start() self.cc.start() def tearDown(self): super(TestSystemWSCommsServerAndClient, self).tearDown() self.cc.stop() self.cc.wait() self.process2.stop() def test_server_with_malcolm_client(self): # Normally we would wait for it to be connected here, but it isn't # attached to a process so just sleep for a bit time.sleep(0.5) ret = self.block2.say_hello("me2") self.assertEqual(ret, dict(greeting="Hello me2"))
def test_report_changes(self): change = [["path"], "value"] s = MagicMock() p = Process("proc", s) s.reset_mock() p.report_changes(change) p.q.put.assert_called_once_with(BlockChanges(changes=[change]))
def test_spawned_adds_to_other_spawned(self): s = MagicMock() p = Process("proc", s) spawned = p.spawn(callable, "fred", a=4) self.assertEqual(spawned, s.spawn.return_value) self.assertEqual(p._other_spawned, [spawned]) s.spawn.assert_called_once_with(callable, "fred", a=4)
def test_add_block(self): p = Process("proc", MagicMock()) b = MagicMock() p.add_block("myblock", b) b.set_parent.assert_called_once_with(p, "myblock") req = p.q.put.call_args[0][0] self.assertEqual(req.block, b)
def test_on_changed(self): change = [["path"], "value"] s = MagicMock() p = Process("proc", s) s.reset_mock() p.on_changed(change, notify=False) p.q.put.assert_called_once_with(BlockChanged(change=change))
class TestSystemWSCommsServerOnly(unittest.TestCase): socket = 8881 def setUp(self): self.sf = SyncFactory("sync") self.process = Process("proc", self.sf) block = Block() HelloController(self.process, block, 'hello') self.sc = WSServerComms("sc", self.process, self.socket) self.process.start() self.sc.start() def tearDown(self): self.sc.stop() self.sc.wait() self.process.stop() @gen.coroutine def send_message(self): conn = yield websocket_connect("ws://localhost:%s/ws" % self.socket) req = dict(type="Post", id=0, endpoint=["hello", "say_hello"], parameters=dict(name="me")) conn.write_message(json.dumps(req)) resp = yield conn.read_message() resp = json.loads(resp) self.assertEqual( resp, dict(id=0, type="Return", value=dict(greeting="Hello me"))) conn.close() def test_server_and_simple_client(self): self.send_message()
def setUp(self): self.process = Process("proc") self.part = MyPart("test_part") self.part2 = MyPart("test_part2") self.o = MyController(self.process, "mri", [self.part, self.part2]) self.context = Context(self.process) self.process.start()
def setUp(self): self.sf = SyncFactory("sync") self.process = Process("proc", self.sf) block = Block() HelloController(self.process, block, 'hello') self.sc = WSServerComms("sc", self.process, self.socket) self.process.start() self.sc.start()
def test_add_block(self): p = Process("proc", MagicMock()) b = Block() b.set_process_path(p, ("name", )) c = MagicMock() p.add_block(b, c) self.assertEqual(p._blocks["name"], b) self.assertEqual(p._controllers["name"], c)
def test_add_block(self): p = Process("proc", MagicMock()) b = Block() b.set_process_path(p, ("name",)) c = MagicMock() p.add_block(b, c) self.assertEqual(p._blocks["name"], b) self.assertEqual(p._controllers["name"], c)
def setUp(self): self.process = Process("proc") self.part = MyPart("test_part") self.controller = MyController(self.process, "mri", [self.part]) self.process.add_controller("mri", self.controller) self.context = Context(self.process) self.block = self.controller.make_view(self.context) self.process.start() self.process.my_method_executed = False
def test_on_changed_with_notify(self): change = [["path"], "value"] s = MagicMock() p = Process("proc", s) s.reset_mock() p.on_changed(change) p.q.put.assert_has_calls([ call(BlockChanged(change=change)), call(BlockNotify(name="path"))])
def setUp(self): super(TestSystemWSCommsServerAndClient, self).setUp() self.process2 = Process("proc2", self.sf) self.block2 = Block() ClientController(self.process2, self.block2, 'hello') self.cc = WSClientComms("cc", self.process2, "ws://localhost:%s/ws" % self.socket) self.process2.start() self.cc.start()
def test_block_respond(self): p = Process("proc", MagicMock()) p.q.put = MagicMock() response = MagicMock() response_queue = MagicMock() p.block_respond(response, response_queue) block_response = p.q.put.call_args[0][0] self.assertEquals(block_response.response, response) self.assertEquals(block_response.response_queue, response_queue)
def setUp(self): sync_factory = SyncFactory("sync") self.process = Process("proc", sync_factory) block = Block("hello") self.process.add_block(block) HelloController(block) self.sc = WSServerComms("sc", self.process, 8888) self.process.start() self.sc.start()
def test_block_respond_triggers_response(self): p = Process("proc", MagicMock()) response = MagicMock() response_queue = MagicMock() p.q.get = MagicMock( side_effect=[BlockRespond(response, response_queue), PROCESS_STOP]) p.recv_loop() response_queue.put.assert_called_once_with(response)
def test_unsubscribe_error(self): p = Process("proc", MagicMock()) unsub = Unsubscribe(MagicMock(), MagicMock()) unsub.set_id(1234) unsub.response_queue.qsize.return_value = 0 p.q.get = MagicMock(side_effect=[unsub, PROCESS_STOP]) p.recv_loop() responses = unsub.response_queue.put.call_args_list self.assertEquals(1, len(responses)) response = responses[0][0][0] self.assertEquals(Error, type(response))
def test_unsubscribe_error(self): p = Process("proc", MagicMock()) unsub = Unsubscribe(MagicMock(), MagicMock()) unsub.set_id(1234) p.q.get = MagicMock(side_effect=[unsub, PROCESS_STOP]) p.recv_loop() responses = unsub.response_queue.put.call_args_list self.assertEquals(1, len(responses)) response = responses[0][0][0] self.assertEquals(Error, type(response)) self.assertEquals("No subscription found for id 1234", response.message)
def test_multiple_notifies_single_change(self): block_1 = MagicMock( to_dict=MagicMock(return_value={"attr": "initial_value"})) block_1.name = "block_1" block_2 = MagicMock( to_dict=MagicMock(return_value={"attr2": "initial_value"})) block_2.name = "block_2" sub_1 = MagicMock() sub_1.endpoint = ["block_1"] sub_1.delta = False sub_2 = MagicMock() sub_2.endpoint = ["block_1"] sub_2.delta = True sub_3 = MagicMock() sub_3.endpoint = ["block_2"] sub_3.delta = False sub_4 = MagicMock() sub_4.endpoint = ["block_2"] sub_4.delta = True change_1 = [["block_1", "attr"], "final_value"] change_2 = [["block_2", "attr2"], "final_value"] request_1 = BlockNotify("block_1") request_2 = BlockChanged(change_1) request_3 = BlockChanged(change_2) request_4 = BlockNotify("block_1") request_5 = BlockNotify("block_1") request_6 = BlockNotify("block_2") p = Process("proc", MagicMock()) p.q.get = MagicMock(side_effect=[request_1, request_2, request_3, request_4, request_5, request_6, PROCESS_STOP]) p.q.put = MagicMock(side_effect=p.q.put) p._subscriptions["block_1"] = [sub_1, sub_2] p._subscriptions["block_2"] = [sub_3, sub_4] p._handle_block_add(BlockAdd(block_1)) p._handle_block_add(BlockAdd(block_2)) p.recv_loop() call_list = sub_1.response_queue.put.call_args_list self.assertEquals(1, len(call_list)) self.assertIsInstance(call_list[0][0][0], Update) self.assertEquals({"attr": "final_value"}, call_list[0][0][0].value) call_list = sub_2.response_queue.put.call_args_list self.assertEquals(1, len(call_list)) self.assertIsInstance(call_list[0][0][0], Delta) self.assertEquals([[["attr"], "final_value"]], call_list[0][0][0].changes) call_list = sub_3.response_queue.put.call_args_list self.assertEquals(1, len(call_list)) self.assertIsInstance(call_list[0][0][0], Update) self.assertEquals({"attr2": "final_value"}, call_list[0][0][0].value) call_list = sub_4.response_queue.put.call_args_list self.assertEquals(1, len(call_list)) self.assertIsInstance(call_list[0][0][0], Delta) self.assertEquals([[["attr2"], "final_value"]], call_list[0][0][0].changes)
def test_get(self): p = Process("proc", MagicMock()) block = MagicMock() block.name = "myblock" block.to_dict = MagicMock( return_value={"path_1": {"path_2": {"attr": "value"}}}) request = Get(MagicMock(), MagicMock(), ["myblock", "path_1", "path_2"]) p._handle_block_add(BlockAdd(block)) p.q.get = MagicMock(side_effect=[request, PROCESS_STOP]) p.recv_loop() response = request.response_queue.put.call_args[0][0] self.assertIsInstance(response, Return) self.assertEquals({"attr": "value"}, response.value)
def setUp(self): self.sync = SyncFactory("threads") self.process = Process("proc", self.sync) self.block = Block("block") self.host = socket.gethostname().split('.')[0] self.prefix = "%s-AD-SIM-01" % self.host pass
def setUp(self): s = SyncFactory("sync") self.p = Process("process", s) self.b = Block("blockname") self.comms = MagicMock() serialized = dict(say_hello=dict( description="Says hello", takes=dict( elements=dict(name=dict( description="A name", metaOf="malcolm:core/String:1.0", ), ), required=["name"], ), defaults={}, returns=dict( elements=dict(greeting=dict( description="A greeting", metaOf="malcolm:core/String:1.0", ), ), required=["response"], ), ), ) def f(request): request.respond_with_return(serialized) self.comms.q.put.side_effect = f self.cc = ClientController(self.p, self.b, self.comms)
def setUp(self): self.sf = SyncFactory("sync") self.process = Process("proc", self.sf) block = Block() HelloController(self.process, block,'hello') self.sc = WSServerComms("sc", self.process, self.socket) self.process.start() self.sc.start()
def test_add_block_calls_handle(self): s = SyncFactory("sched") p = Process("proc", s) b = Block() b.set_parent(p, "myblock") p.add_block(b) p.start() p.stop() self.assertEqual(len(p._blocks), 2) self.assertEqual(p._blocks, dict(myblock=b, proc=p.process_block))
def test_overlapped_changes(self): block = MagicMock( to_dict=MagicMock(return_value={"attr": "value", "attr2": "other"})) block.name = "block" sub_1 = MagicMock() sub_1.endpoint = ["block"] sub_1.delta = False sub_2 = MagicMock() sub_2.endpoint = ["block"] sub_2.delta = True changes_1 = [["block", "attr"], "changing_value"] changes_2 = [["block", "attr"], "final_value"] request_1 = BlockChanged(changes_1) request_2 = BlockChanged(changes_2) request_3 = BlockNotify(block.name) s = MagicMock() p = Process("proc", s) p._subscriptions["block"] = [sub_1, sub_2] p.q.get = MagicMock( side_effect=[request_1, request_2, request_3, PROCESS_STOP]) p._handle_block_add(BlockAdd(block)) p.recv_loop() self.assertEqual(sub_1.response_queue.put.call_count, 1) self.assertEqual(sub_2.response_queue.put.call_count, 1) response_1 = sub_1.response_queue.put.call_args[0][0] response_2 = sub_2.response_queue.put.call_args[0][0] self.assertEquals({"attr": "final_value", "attr2": "other"}, response_1.value) self.assertEquals( [[["attr"], "changing_value"], [["attr"], "final_value"]], response_2.changes)
def test_partial_structure_subscriptions(self): block_1 = MagicMock(to_dict=MagicMock(return_value={ "attr": "value", "inner": { "attr2": "value" } })) block_2 = MagicMock(to_dict=MagicMock(return_value={"attr": "value"})) sub_1 = MagicMock() sub_1.endpoint = ["block_1", "inner"] sub_1.delta = False sub_2 = MagicMock() sub_2.endpoint = ["block_1", "inner"] sub_2.delta = True changes_1 = [[["block_1", "inner", "attr2"], "new_value"], [["block_1", "attr"], "new_value"]] changes_2 = [[["block_2", "attr"], "block_2_value"]] request_1 = BlockChanges(changes_1) request_2 = BlockChanges(changes_2) p = Process("proc", MagicMock()) p.q.get = MagicMock(side_effect=[request_1, request_2, PROCESS_STOP]) p._subscriptions = [sub_1, sub_2] p._handle_block_add(BlockAdd(block_1, "block_1")) p._handle_block_add(BlockAdd(block_2, "block_2")) p.recv_loop() response_1 = sub_1.respond_with_update.call_args[0][0] response_2 = sub_2.respond_with_delta.call_args[0][0] self.assertEquals({"attr2": "new_value"}, response_1) self.assertEquals([[["attr2"], "new_value"]], response_2)
def test_hello_controller_with_process(self): sync_factory = SyncFactory("sched") process = Process("proc", sync_factory) block = Block("hello") HelloController(block) process.add_block(block) process.start() q = sync_factory.create_queue() req = Request.Post(response_queue=q, context="ClientConnection", endpoint=["hello", "say_hello"], parameters=dict(name="thing")) req.set_id(44) process.q.put(req) resp = q.get(timeout=1) self.assertEqual(resp.id_, 44) self.assertEqual(resp.context, "ClientConnection") self.assertEqual(resp.type_, "Return") self.assertEqual(resp.value, dict(greeting="Hello thing"))
def test_make_process_block(self): p = Process("proc", MagicMock()) p_block = p.process_block self.assertEquals(p_block.process_path, ["proc"]) self.assertEquals(NTScalarArray, type(p_block["blocks"])) self.assertEquals(StringArrayMeta, type(p_block["blocks"].meta)) self.assertEquals(("proc", ), p_block.blocks) self.assertEquals("Blocks hosted by this Process", p_block["blocks"].meta.description)
def setUp(self): # Spawn ds under cothread self.ds = DirectoryService(["zmq://ipc:///tmp/sock.ipc"]) self.ds.run(block=False) self.lp = Process( [], "Local Process", ds_string="zmq://ipc:///tmp/sock.ipc") self.lp.run(block=False) self.lp.ds.createCounter(name="The Counter") self.c = self.lp.get_device("The Counter")
def test_add_block_calls_handle(self): s = SyncFactory("sched") p = Process("proc", s) b = MagicMock() b.name = "myblock" p.add_block("myblock", b) p.start() p.stop() b.set_parent.assert_called_once_with(p, "myblock") self.assertEqual(len(p._blocks), 2) self.assertEqual(p._blocks, dict(myblock=b, proc=p.process_block))
class TestSystemWSCommsServerOnly(unittest.TestCase): socket = 8881 def setUp(self): self.sf = SyncFactory("sync") self.process = Process("proc", self.sf) block = Block() HelloController(self.process, block,'hello') self.sc = WSServerComms("sc", self.process, self.socket) self.process.start() self.sc.start() def tearDown(self): self.sc.stop() self.sc.wait() self.process.stop() @gen.coroutine def send_message(self): conn = yield websocket_connect("ws://localhost:%s/ws" % self.socket) req = dict( type="Post", id=0, endpoint=["hello", "say_hello"], parameters=dict( name="me" ) ) conn.write_message(json.dumps(req)) resp = yield conn.read_message() resp = json.loads(resp) self.assertEqual(resp, dict( id=0, type="Return", value=dict( greeting="Hello me" ) )) conn.close() def test_server_and_simple_client(self): self.send_message()
def test_get_block(self): p = Process("proc", MagicMock()) p.process_block["remoteBlocks"].set_value(['name1']) b1 = p.get_block("name1") self.assertEqual(b1.status, "Waiting for connection...") self.assertEqual(p.get_block("name1"), b1) b2 = Block() b2.set_process_path(p, ("name2", )) c = MagicMock() p.add_block(b2, c) self.assertEqual(p.get_block("name2"), b2) self.assertEqual(p.get_controller("name2"), c)
def test_partial_structure_subscriptions(self): block_1 = MagicMock( to_dict=MagicMock( return_value={"attr": "value", "inner": {"attr2": "value"}})) block_2 = MagicMock( to_dict=MagicMock(return_value={"attr": "value"})) sub_1 = Subscribe(None, MagicMock(), ["block_1", "inner"], delta=False) sub_1.set_id(1) sub_1.response_queue.qsize.return_value = 0 sub_2 = Subscribe(None, MagicMock(), ["block_1"], delta=True) sub_2.set_id(2) sub_2.response_queue.qsize.return_value = 0 sub_3 = Subscribe(None, MagicMock(), ["block_1", "inner", "attr2"], delta=False) sub_3.set_id(3) sub_3.response_queue.qsize.return_value = 0 changes_1 = [[["block_1", "inner", "attr2"], "new_value"], [["block_1", "attr"], "new_value"]] changes_2 = [[["block_2", "attr"], "block_2_value"]] request_1 = BlockChanges(changes_1) request_2 = BlockChanges(changes_2) p = Process("proc", MagicMock()) p.q.get = MagicMock(side_effect=[ sub_1, sub_2, sub_3, request_1, request_2, PROCESS_STOP]) p._handle_block_add(BlockAdd(block_1, "block_1", None)) p._handle_block_add(BlockAdd(block_2, "block_2", None)) p.recv_loop() response_1 = sub_1.response_queue.put.call_args_list[1][0][0]["value"] self.assertEquals({"attr2": "new_value"}, response_1) response_2 = sub_2.response_queue.put.call_args_list[1][0][0]["changes"] self.assertEquals([[["inner", "attr2"], "new_value"], [["attr"], "new_value"]], response_2) response_3 = sub_3.response_queue.put.call_args_list[1][0][0]["value"] self.assertEquals("new_value", response_3)
def test_starting_process(self): s = SyncFactory("sched") p = Process("proc", s) b = MagicMock() p._handle_block_add(BlockAdd(b, "myblock", None)) self.assertEqual(p._blocks, dict(myblock=b, proc=ANY)) p.start() request = Post(MagicMock(), MagicMock(), ["myblock", "foo"]) p.q.put(request) # wait for spawns to have done their job p.stop() b.handle_request.assert_called_once_with(request)
def test_make_process_block(self): p = Process("proc", MagicMock()) p_block = p.process_block self.assertEquals(p.name, p_block.name) self.assertEquals(Attribute, type(p_block.blocks)) self.assertEquals(StringArrayMeta, type(p_block.blocks.meta)) self.assertEquals("blocks", p_block.blocks.name) self.assertEquals("meta", p_block.blocks.meta.name) self.assertEquals("Blocks hosted by this Process", p_block.blocks.meta.description)
def test_hello_with_process(self): sync_factory = SyncFactory("sched") process = Process("proc", sync_factory) b = Hello(process, dict(mri="hello"))[0] process.start() # wait until block is Ready task = Task("hello_ready_task", process) task.when_matches(b["state"], "Ready", timeout=1) q = sync_factory.create_queue() req = Post(response_queue=q, context="ClientConnection", endpoint=["hello", "greet"], parameters=dict(name="thing")) req.set_id(44) process.q.put(req) resp = q.get(timeout=1) self.assertEqual(resp.id, 44) self.assertEqual(resp.context, "ClientConnection") self.assertEqual(resp.typeid, "malcolm:core/Return:1.0") self.assertEqual(resp.value["greeting"], "Hello thing") process.stop()
def test_subscribe(self): block = MagicMock(to_dict=MagicMock(return_value={ "attr": "value", "inner": { "attr2": "other" } })) p = Process("proc", MagicMock()) sub_1 = Subscribe(MagicMock(), MagicMock(), ["block"], False) sub_1.response_queue.qsize.return_value = 0 sub_2 = Subscribe(MagicMock(), MagicMock(), ["block", "inner"], True) sub_2.response_queue.qsize.return_value = 0 p.q.get = MagicMock(side_effect=[sub_1, sub_2, PROCESS_STOP]) p._handle_block_add(BlockAdd(block, "block", None)) p.recv_loop() self.assertEquals([sub_1, sub_2], list(p._subscriptions.values())) response_1 = sub_1.response_queue.put.call_args[0][0] response_2 = sub_2.response_queue.put.call_args[0][0] self.assertEquals({ "attr": "value", "inner": { "attr2": "other" } }, response_1.value) self.assertEquals([[[], {"attr2": "other"}]], response_2.changes)
def test_counter_subscribe(self): sync_factory = SyncFactory("sched") process = Process("proc", sync_factory) b = Counter(process, dict(mri="counting"))[0] process.start() # wait until block is Ready task = Task("counter_ready_task", process) task.when_matches(b["state"], "Ready", timeout=1) q = sync_factory.create_queue() sub = Subscribe(response_queue=q, context="ClientConnection", endpoint=["counting", "counter"], delta=False) process.q.put(sub) resp = q.get(timeout=1) self.assertIsInstance(resp, Update) attr = NTScalar.from_dict(resp.value) self.assertEqual(0, attr.value) post = Post(response_queue=q, context="ClientConnection", endpoint=["counting", "increment"]) process.q.put(post) resp = q.get(timeout=1) self.assertIsInstance(resp, Update) self.assertEqual(resp.value["value"], 1) resp = q.get(timeout=1) self.assertIsInstance(resp, Return) process.stop()
def make_client(): parser = argparse.ArgumentParser( description="Interactive client shell for malcolm") parser.add_argument('server', help="Server string for connection to malcolm " "directory server like 172.23.243.13:5600") parser.add_argument('--log', default="INFO", help="Lowest level of logs to see. One of: " "ERROR, WARNING, INFO, DEBUG. " "Default is INFO") args = parser.parse_args() # assuming loglevel is bound to the string value obtained from the # command line argument. Convert to upper case to allow the user to # specify --log=DEBUG or --log=debug numeric_level = getattr(logging, args.log.upper(), None) if not isinstance(numeric_level, int): raise ValueError('Invalid log level: %s' % args.log) logging.basicConfig(level=numeric_level) ds_string = "zmq://tcp://{}".format(args.server) client = Process([], "iMalcolmClient", ds_string=ds_string) client.DeviceClient = IDeviceClient return client
def test_subscribe(self): block = MagicMock( to_dict=MagicMock( return_value={"attr": "value", "inner": {"attr2": "other"}})) block.name = "block" p = Process("proc", MagicMock()) sub_1 = Subscribe( MagicMock(), MagicMock(), ["block"], False) sub_2 = Subscribe( MagicMock(), MagicMock(), ["block", "inner"], True) p.q.get = MagicMock(side_effect=[sub_1, sub_2, PROCESS_STOP]) p._handle_block_add(BlockAdd(block)) p.recv_loop() self.assertEquals(OrderedDict(block=[sub_1, sub_2]), p._subscriptions) response_1 = sub_1.response_queue.put.call_args[0][0] response_2 = sub_2.response_queue.put.call_args[0][0] self.assertEquals({"attr": "value", "inner": {"attr2": "other"}}, response_1.value) self.assertEquals([[[], {"attr2": "other"}]], response_2.changes)
class ZmqSystemTest(unittest.TestCase): # class ZmqSystemTest(object): def setUp(self): # Spawn ds under cothread self.ds = DirectoryService(["zmq://ipc:///tmp/sock.ipc"]) self.ds.run(block=False) self.lp = Process( [], "Local Process", ds_string="zmq://ipc:///tmp/sock.ipc") self.lp.run(block=False) self.lp.ds.createCounter(name="The Counter") self.c = self.lp.get_device("The Counter") def test_simple_function(self): import cothread cothread.Sleep(0.2) start = self.c.getCount() self.assertEqual(self.c.hello(), "world") # Hello world takes about 10 ticks self.assertAlmostEqual(self.c.getCount(), start + 10, delta=3) # Do a long running call s = cothread.Spawn(self.c.longHello) # Check it returns immediately self.assertAlmostEqual(self.c.getCount(), start + 10, delta=3) self.assertEqual(self.c.hello(), "world") # Hello world takes 10 ticks self.assertAlmostEqual(self.c.getCount(), start + 20, delta=3) self.assertEqual(s.Wait(), "long world") # Long hello takes about 50 ticks from send self.assertAlmostEqual(self.c.getCount(), start + 60, delta=8) s.Wait() def tearDown(self): self.c = None self.lp.ds.exit() self.lp.exit() self.lp = None self.ds.loop_wait() self.ds = None
def test_add_block_calls_handle(self): s = SyncFactory("sched") p = Process("proc", s) b = Block() c = MagicMock() b.set_process_path(p, ("myblock",)) p.add_block(b, c) p.start() p.stop() self.assertEqual(len(p._blocks), 2) self.assertEqual(p._blocks, dict(myblock=b, proc=p.process_block))
def test_get_block(self): p = Process("proc", MagicMock()) p.process_block["remoteBlocks"].set_value(['name1']) b1 = p.get_block("name1") self.assertEqual(b1.status, "Waiting for connection...") self.assertEqual(p.get_block("name1"), b1) b2 = Block() b2.set_process_path(p, ("name2",)) c = MagicMock() p.add_block(b2, c) self.assertEqual(p.get_block("name2"), b2) self.assertEqual(p.get_controller("name2"), c)
def test_unsubscribe(self): # Test that we remove the relevant subscription only and that # updates are no longer sent block = MagicMock( to_dict=MagicMock( return_value={"attr": "0", "inner": {"attr2": "other"}})) p = Process("proc", MagicMock()) sub_1 = Subscribe( MagicMock(), MagicMock(), ["block"], False) sub_1.response_queue.qsize.return_value = 0 sub_2 = Subscribe( MagicMock(), MagicMock(), ["block"], False) sub_2.response_queue.qsize.return_value = 0 sub_1.set_id(1234) sub_2.set_id(1234) change_1 = BlockChanges([[["block", "attr"], "1"]]) change_2 = BlockChanges([[["block", "attr"], "2"]]) unsub_1 = Unsubscribe(sub_1.context, sub_1.response_queue) unsub_1.set_id(sub_1.id) p.q.get = MagicMock(side_effect=[sub_1, sub_2, change_1, unsub_1, change_2, PROCESS_STOP]) p._handle_block_add(BlockAdd(block, "block", None)) p.recv_loop() self.assertEqual([sub_2], list(p._subscriptions.values())) sub_1_responses = sub_1.response_queue.put.call_args_list sub_2_responses = sub_2.response_queue.put.call_args_list self.assertEquals(3, len(sub_1_responses)) self.assertEquals(sub_1_responses[0][0][0].value["attr"], "0") self.assertEquals(sub_1_responses[1][0][0].value["attr"], "1") self.assertIsInstance(sub_1_responses[2][0][0], Return) self.assertEquals(3, len(sub_2_responses)) self.assertEquals(sub_2_responses[0][0][0].value["attr"], "0") self.assertEquals(sub_2_responses[1][0][0].value["attr"], "1") self.assertEquals(sub_2_responses[2][0][0].value["attr"], "2")