def setUp(self): self.cs = DummyClientSocket("cs", "csaddr") self.cs.open(self.cs.address) self.ss = DummyServerSocket("ss", "ssaddr", None) self.ss.open(self.ss.address) self.zebraClient = DeviceClient("zebra1", self.cs) self.dsClient = DeviceClient("DirectoryService", self.cs) self.ds = DirectoryService([]) self.zebra = self.ds.create_device(DummyZebra, "zebra1")
def register(self, device, serverStrings): # Store connection strings self._connection_strings[device] = serverStrings # Store a deviceClient dc = DeviceClient(device, self.get_client_sock(serverStrings), monitor=False, timeout=1) self.add_loop(dc) self._registered_devices[device] = dc # When its connection status changes, update our device list dc.add_listener( self.update_devices, "attributes.deviceClientConnected")
def setUp(self): self.sock = MagicMock() self.d = DeviceClient("D", self.sock) self.assertEqual(self.sock.mock_calls, [])
class DeviceTest(unittest.TestCase): def setUp(self): self.sock = MagicMock() self.d = DeviceClient("D", self.sock) self.assertEqual(self.sock.mock_calls, []) def test_run_calls_right_things(self): def side_effect(response, typ, kwargs): self.post = response response(SType.Return, value={}) self.sock.request.side_effect = side_effect self.d.loop_run() self.assertEqual(len(self.sock.mock_calls), 1) self.sock.request.assert_called_once_with( self.post, SType.Get, dict(endpoint="D")) def test_attribute_monitors(self): def side_effect(post, typ, kwargs): if kwargs["endpoint"] == "D": self.post = post bit = dict(type=VInt, descriptor="Desc", value=3, alarm=Alarm.ok().to_dict(), timeStamp=43.2) post(SType.Return, value=dict(attributes=dict(bit=bit))) elif kwargs["endpoint"] == "D.attributes.bit": self.spost = post self.sock.request.side_effect = side_effect self.d.loop_run() self.assertEqual(len(self.sock.mock_calls), 2) self.assertEqual(self.sock.request.call_args_list[0], call( self.post, SType.Get, dict(endpoint="D"))) self.assertEqual(self.sock.request.call_args_list[1], call( self.spost, SType.Subscribe, dict(endpoint="D.attributes.bit"))) self.assertEqual(self.d.bit, 3) self.assertEqual(type(self.d.attributes["bit"].typ), VInt) self.assertEqual(self.d.attributes["bit"].descriptor, "Desc") self.assertEqual(self.d.attributes["bit"].value, 3) self.assertEqual(self.d.attributes["bit"].alarm, Alarm.ok()) self.assertEqual(self.d.attributes["bit"].timeStamp, 43.2) def test_methods(self): def side_effect(response, typ, kwargs): self.post = response if typ == SType.Get and kwargs["endpoint"] == "D": run = dict(descriptor="Run") response(SType.Return, value=dict(methods=dict(run=run))) elif kwargs["method"] == "run": response(SType.Return, value=99) else: print kwargs self.sock.request.side_effect = side_effect self.d.loop_run() self.assertEqual(len(self.sock.mock_calls), 1) self.sock.request.assert_called_once_with( self.post, SType.Get, dict(endpoint="D")) self.assertIn("run", dir(self.d)) self.sock.request.reset_mock() self.assertEqual(self.d.run(), 99) self.sock.request.assert_called_once_with( self.post, SType.Call, dict(endpoint="D", method="run", arguments={})) def test_sm(self): def side_effect(post, typ, kwargs): if kwargs["endpoint"] == "D": self.post = post sm = dict( state="Running", states=[d.name for d in DState], message="foo", timeStamp=43.2) post(SType.Return, value=dict(stateMachine=sm)) elif kwargs["endpoint"] == "D.stateMachine": self.spost = post self.sock.request.side_effect = side_effect self.d.loop_run() self.assertEqual(len(self.sock.mock_calls), 2) self.assertEqual(self.sock.request.call_args_list[0], call( self.post, SType.Get, dict(endpoint="D"))) self.assertEqual(self.sock.request.call_args_list[1], call( self.spost, SType.Subscribe, dict(endpoint="D.stateMachine"))) self.assertEqual(self.d.stateMachine.state, DState.Running) self.assertEqual(self.d.stateMachine.message, "foo") self.assertEqual(self.d.stateMachine.timeStamp, 43.2) def tearDown(self): msgs = [] def log_debug(msg): msgs.append(msg) self.d.log_debug = log_debug self.d = None self.assertEqual(msgs, ['Garbage collecting loop', 'Stopping loop', 'Waiting for loop to finish', "Loop finished", 'Loop garbage collected'])
class ZmqDocsTest(unittest.TestCase): def setUp(self): self.cs = DummyClientSocket("cs", "csaddr") self.cs.open(self.cs.address) self.ss = DummyServerSocket("ss", "ssaddr", None) self.ss.open(self.ss.address) self.zebraClient = DeviceClient("zebra1", self.cs) self.dsClient = DeviceClient("DirectoryService", self.cs) self.ds = DirectoryService([]) self.zebra = self.ds.create_device(DummyZebra, "zebra1") def assertDocExample(self, fname, actual): expected = open( os.path.join(os.path.dirname(__file__), "..", "..", "docs", "comms", "zmqExamples", fname) ).read() prettyactual = json.dumps(json.loads(actual, object_pairs_hook=OrderedDict), indent=2) header = ".. code-block:: javascript\n\n" docactual = header + "\n".join(" " + x for x in prettyactual.splitlines()) + "\n" if expected != docactual: print print docactual message = "".join(difflib.unified_diff(expected.splitlines(True), docactual.splitlines(True))) self.fail("Output doesn't match docs: %s\n" % message) @patch("malcolm.core.deviceclient.ValueQueue") def test_call_zebra_configure(self, mock_vq): positions = [ ("y", VDouble, np.repeat(np.arange(6, 9), 5) * 0.1, "mm"), ("x", VDouble, np.tile(np.arange(5), 3) * 0.1, "mm"), ] self.zebraClient.do_call("configure", pcBitCap=1, pcTsPre="ms", positions=positions) self.assertDocExample("call_zebra_configure", self.cs.sendq.popleft()[0]) @patch("malcolm.core.deviceclient.ValueQueue") def test_get_DirectoryService_Device_instances(self, mock_vq): self.dsClient.do_get("attributes.Device_instances.value") self.assertDocExample("get_DirectoryService_Device_instances", self.cs.sendq.popleft()[0]) @patch("malcolm.core.deviceclient.ValueQueue") def test_get_zebra_status(self, mock_vq): self.zebraClient.do_get("stateMachine") self.assertDocExample("get_zebra_status", self.cs.sendq.popleft()[0]) @patch("malcolm.core.deviceclient.ValueQueue") def test_get_zebra(self, mock_vq): self.zebraClient.do_get() self.assertDocExample("get_zebra", self.cs.sendq.popleft()[0]) def test_subscribe_zebra_status(self): el = self.zebraClient.do_subscribe(lambda: None, "stateMachine") self.assertDocExample("subscribe_zebra_status", self.cs.sendq.popleft()[0]) el.loop_run() el.loop_stop() self.assertDocExample("unsubscribe_zebra_status", self.cs.sendq.popleft()[0]) def test_value_zebra_status(self): send = self.ss.make_send_function(dict(zmq_id=1, id=0)) sub = self.ds.do_subscribe(send, "zebra1.stateMachine") sub.inq = MagicMock() self.zebra.stateMachine.update(state=DState.Configuring, message="Configuring...", timeStamp=14419090000.2) send(*sub.inq.Signal.call_args[0][0][1]) self.assertDocExample("value_zebra_status", self.ss.sendq.popleft()[1]) def test_return_zebra_status(self): send = self.ss.make_send_function(dict(zmq_id=1, id=0)) self.zebra.stateMachine.update(state=DState.Configuring, message="Configuring...", timeStamp=14419090000.2) self.ds.do_get(send, "zebra1.stateMachine") self.assertDocExample("return_zebra_status", self.ss.sendq.popleft()[1]) def test_return_zebra(self): send = self.ss.make_send_function(dict(zmq_id=1, id=0)) self.zebra.stateMachine.update(state=DState.Configuring, message="Configuring...", timeStamp=14419090000.2) self.zebra.attributes["connected"].update( 0, Alarm(AlarmSeverity.invalidAlarm, AlarmStatus.UDF, "Disconnected"), timeStamp=14419091000.2 ) self.ds.do_get(send, "zebra1") self.assertDocExample("return_zebra", self.ss.sendq.popleft()[1]) def test_return_DirectoryService_Device_instances(self): send = self.ss.make_send_function(dict(zmq_id=1, id=0)) self.ds.do_get(send, "DirectoryService.attributes.instancesDevice.value") self.assertDocExample("return_DirectoryService_Device_instances", self.ss.sendq.popleft()[1]) # Mock out EventLoop so we don't log error @patch("malcolm.core.process.EventLoop") def test_error_foo(self, el): send = self.ss.make_send_function(dict(zmq_id=1, id=0)) try: self.ds.do_get(send, "foo.stateMachine") except Exception, e: self.ds.do_error(e, send) self.assertDocExample("error_foo", self.ss.sendq.popleft()[1])