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 test_increment_increments(self): c = CounterController(Mock(), Block(), 'block') self.assertEquals(0, c.counter.value) c.increment() self.assertEquals(1, c.counter.value) c.increment() self.assertEquals(2, c.counter.value)
def setUp(self): self.b = Block() self.b.name = "block" self.c = DummyController(MagicMock(), self.b, 'block') for attr in ["busy", "state", "status"]: attr = self.b.attributes[attr] attr.set_value = MagicMock(side_effect=attr.set_value)
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 __init__(self, process, parts, params): """ Args: process (Process): The process this should run under params (Map): The parameters specified in method_takes() parts (list): [Part] """ self.process = process self.params = params self.mri = params.mri controller_name = "%s(%s)" % (type(self).__name__, self.mri) self.set_logger_name(controller_name) self.block = Block() self.log_debug("Creating block %r as %r", self.block, self.mri) self.lock = process.create_lock() # {part: task} self.part_tasks = {} # dictionary of dictionaries # {state (str): {Meta/MethodMeta/Attribute: writeable (bool)} self.children_writeable = {} # dict {hook: name} self.hook_names = self._find_hooks() self.parts = self._setup_parts(parts, controller_name) self._set_block_children() self._do_transition(sm.DISABLED, "Disabled") self.block.set_process_path(process, [self.mri]) process.add_block(self.block, self) self.do_initial_reset()
def __init__(self, block_name, process, parts=None, params=None): """ Args: process (Process): The process this should run under """ controller_name = "%s(%s)" % (type(self).__name__, block_name) self.set_logger_name(controller_name) self.block = Block() self.log_debug("Creating block %r as %r" % (self.block, block_name)) self.block_name = block_name self.params = params self.process = process self.lock = process.create_lock() # {part: task} self.part_tasks = {} # dictionary of dictionaries # {state (str): {MethodMeta: writeable (bool)} self.methods_writeable = {} # dict {hook: name} self.hook_names = self._find_hooks() self.parts = self._setup_parts(parts, controller_name) self._set_block_children() self._do_transition(sm.DISABLED, "Disabled") self.block.set_parent(process, block_name) process.add_block(self.block) self.do_initial_reset()
def setUp(self): self.block = Block() self.block.set_parent(MagicMock(), "TestBlock") self.method = MagicMock() self.attribute = MagicMock() self.response = MagicMock() self.block.add_method('get_things', self.method) self.block.add_attribute('test_attribute', self.attribute)
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_attribute(self): b = Block("blockname") attr = MagicMock() attr.name = "attr" b.add_attribute(attr) attr.set_parent.assert_called_once_with(b) self.assertEqual({"attr": attr}, b._attributes) self.assertIs(attr, b.attr)
def test_put_changes_value(self): b = Block() b.on_changed = Mock(wraps=b.on_changed) c = CounterController(Mock(), b, 'block') b.on_changed.reset_mock() c.counter.put(32) self.assertEqual(c.counter.value, 32) c.block.on_changed.assert_called_once_with([["counter", "value"], 32], True)
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 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 create_process_block(self): self.process_block = Block() a = Attribute( StringArrayMeta(description="Blocks hosted by this Process")) self.process_block.add_attribute("blocks", a) a = Attribute( StringArrayMeta(description="Blocks reachable via ClientComms")) self.process_block.add_attribute("remoteBlocks", a) self.add_block(self.name, self.process_block)
def setUp(self): # Serialized version of the block we want source = Block() HelloController(MagicMock(), source, "blockname") self.serialized = source.to_dict() # Setup client controller prerequisites self.b = Block() self.b.name = "blockname" self.p = MagicMock() self.comms = MagicMock() self.cc = ClientController(self.p, self.b, "blockname") # get process to give us comms self.p.get_client_comms.return_value = self.comms # tell our controller which blocks the process can talk to response = MagicMock(id_=self.cc.REMOTE_BLOCKS_ID, value=["blockname"]) self.cc.put(response) # tell our controller the serialized state of the block response = MagicMock(id_=self.cc.BLOCK_ID, changes=[[[], self.serialized]]) self.cc.put(response)
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_add_method_registers(self): b = Block("blockname") m = MagicMock() m.name = "mymethod" b.add_method(m) self.assertEqual(b._methods.keys(), ["mymethod"]) self.assertFalse(m.called) m.return_value = 42 self.assertEqual(b.mymethod(), 42) m.assert_called_once_with()
def create_process_block(self): self.process_block = Block() # TODO: add a meta here children = OrderedDict() children["blocks"] = StringArrayMeta( description="Blocks hosted by this Process").make_attribute([]) children["remoteBlocks"] = StringArrayMeta( description="Blocks reachable via ClientComms").make_attribute([]) self.process_block.replace_endpoints(children) self.process_block.set_process_path(self, [self.name]) self.add_block(self.process_block, self)
def test_add_attribute(self): b = Block() b.name = 'block' b.on_changed = MagicMock(side_effect=b.on_changed) attr = MagicMock() b.add_attribute("attr", attr) attr.set_parent.assert_called_once_with(b, "attr") self.assertEqual({"attr": attr}, b.attributes) self.assertIs(attr, b.attr) b.on_changed.assert_called_with( [[attr.name], attr.to_dict.return_value], True)
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_add_method_registers(self): b = Block() b.on_changed = MagicMock(side_effect=b.on_changed) m = MagicMock() b.add_method("mymethod", m) self.assertEqual(list(b.methods), ["mymethod"]) self.assertFalse(m.called) b.on_changed.assert_called_with([[m.name], m.to_dict.return_value], True) m.return_value = 42 self.assertEqual(b.mymethod(), 42) m.assert_called_once_with()
def test_server_with_malcolm_client(self): self.cc = WSClientComms("cc", self.process, "ws://localhost:8888/ws") self.cc.start() # Wait for comms to be connected while not self.cc.conn.done(): time.sleep(0.001) # Don't add to process as we already have a block of that name block2 = Block("hello") ClientController(self.process, block2, self.cc) ret = block2.say_hello("me2") self.assertEqual(ret, dict(greeting="Hello me2")) self.cc.stop()
def test_init(self): block = Block() block.add_method = Mock(wraps=block.add_method) c = CounterController(Mock(), block, 'block') self.assertIs(block, c.block) self.assertEquals(3, len(block.add_method.call_args_list)) method_1 = block.add_method.call_args_list[0][0][1] method_2 = block.add_method.call_args_list[1][0][1] method_3 = block.add_method.call_args_list[2][0][1] self.assertEquals("disable", method_1.name) self.assertEquals(c.disable, method_1.func) self.assertEquals("increment", method_2.name) self.assertEquals(c.increment, method_2.func) self.assertEquals("reset", method_3.name) self.assertEquals(c.reset, method_3.func)
def test_configure(self): params = MagicMock() with patch("malcolm.vmetas.pointgeneratormeta.CompoundGenerator", spec=True) as cg_mock: params.generator = cg_mock() params.exposure = 1 params.axis_name = "x" block = MagicMock(wraps=Block()) sptc = ScanPointTickerController(MagicMock(), block, 'block') sptc.configure(params) self.assertEqual(params.generator, sptc.generator.value) self.assertEqual(params.axis_name, sptc.axis_name.value) self.assertEqual(params.exposure, sptc.exposure.value) block.notify_subscribers.assert_called_once_with()
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_lock_released(self): b = Block() b.name = "blockname" b.lock.acquire = MagicMock(wrap=b.lock.acquire) b.lock.release = MagicMock(wrap=b.lock.release) lock_methods = MagicMock() lock_methods.attach_mock(b.lock.acquire, "acquire") lock_methods.attach_mock(b.lock.release, "release") with b.lock: with b.lock_released(): pass self.assertEquals( [call.acquire(), call.release(), call.acquire(), call.release()], lock_methods.method_calls)
def test_returns_dict(self): method_dict = OrderedDict(takes=OrderedDict(one=OrderedDict()), returns=OrderedDict(one=OrderedDict()), defaults=OrderedDict()) m1 = MagicMock() m1.to_dict.return_value = method_dict m2 = MagicMock() m2.to_dict.return_value = method_dict a1 = MagicMock() a1dict = OrderedDict(value="test", meta=MagicMock()) a1.to_dict.return_value = a1dict a2 = MagicMock() a2dict = OrderedDict(value="value", meta=MagicMock()) a2.to_dict.return_value = a2dict block = Block() block.set_parent(MagicMock(), "Test") block.add_method('method_one', m1) block.add_method('method_two', m2) block.add_attribute('attr_one', a1) block.add_attribute('attr_two', a2) m1.reset_mock() m2.reset_mock() a1.reset_mock() a2.reset_mock() expected_dict = OrderedDict() expected_dict['typeid'] = "malcolm:core/Block:1.0" expected_dict['attr_one'] = a1dict expected_dict['attr_two'] = a2dict expected_dict['method_one'] = method_dict expected_dict['method_two'] = method_dict response = block.to_dict() m1.to_dict.assert_called_once_with() m2.to_dict.assert_called_once_with() self.assertEqual(expected_dict, response)
def test_replace_children(self): b = Block() b.name = "blockname" b.methods["m1"] = 2 b.attributes["a1"] = 3 setattr(b, "m1", 2) setattr(b, "a1", 3) attr_meta = StringMeta(description="desc") attr = Attribute(attr_meta) b.add_attribute('attr', attr) method = Method(description="desc") b.add_method('method', method) b.on_changed = MagicMock(wrap=b.on_changed) b.replace_children({'attr': attr, 'method': method}) self.assertEqual(b.attributes, dict(attr=attr)) self.assertEqual(b.methods, dict(method=method)) b.on_changed.assert_called_once_with([[], b.to_dict()], True) self.assertFalse(hasattr(b, "m1")) self.assertFalse(hasattr(b, "a1"))
def test_returns_dict(self): method_dict = OrderedDict(takes=OrderedDict(one=OrderedDict()), returns=OrderedDict(one=OrderedDict()), defaults=OrderedDict()) m1 = MagicMock() m1.name = "method_one" m1.to_dict.return_value = method_dict m2 = MagicMock() m2.name = "method_two" m2.to_dict.return_value = method_dict a1 = MagicMock() a1.name = "attr_one" a1dict = OrderedDict(value="test", meta=MagicMock()) a1.to_dict.return_value = a1dict a2 = MagicMock() a2.name = "attr_two" a2dict = OrderedDict(value="value", meta=MagicMock()) a2.to_dict.return_value = a2dict block = Block("Test") block.add_method(m1) block.add_method(m2) block.add_attribute(a1) block.add_attribute(a2) expected_dict = OrderedDict() expected_dict['attr_one'] = a1dict expected_dict['attr_two'] = a2dict expected_dict['method_one'] = method_dict expected_dict['method_two'] = method_dict response = block.to_dict() m1.to_dict.assert_called_once_with() m2.to_dict.assert_called_once_with() self.assertEqual(expected_dict, response)
def test_init(self, pgmd_mock, nmd_mock, smd_mock): del pgmd_mock.return_value.to_dict del nmd_mock.return_value.to_dict del smd_mock.return_value.to_dict attr_id = "epics:nt/NTAttribute:1.0" block = Block() sptc = ScanPointTickerController(MagicMock(), block, 'block') self.assertEqual(block, sptc.block) self.assertEqual(RunnableDeviceStateMachine, type(sptc.stateMachine)) self.assertEqual("RunnableDeviceStateMachine", sptc.stateMachine.name) self.assertEquals( {"value": None, "meta": nmd_mock.return_value, "typeid": attr_id}, sptc.value.to_dict()) self.assertEquals( {"value": None, "meta": pgmd_mock.return_value, "typeid": attr_id}, sptc.generator.to_dict()) self.assertEquals( {"value": None, "meta": smd_mock.return_value, "typeid": attr_id}, sptc.axis_name.to_dict()) self.assertEquals( {"value": None, "meta": nmd_mock.return_value, "typeid": attr_id}, sptc.exposure.to_dict())