def test_hello_good_input(self): p = MagicMock() part = HelloPart(p, None) block = DefaultController("hello", p, parts={"hello": part}).block block.reset() result = block.say_hello(name="me") self.assertEquals(result.greeting, "Hello me")
def setUp(self): self.process = MagicMock() part = HelloPart(self.process, None) self.block = DefaultController("hello", self.process, parts={ "hello": part }).block self.block.name = "hello" self.m = BlockModel(self.process, self.block)
def setUp(self): self.sf = SyncFactory("sync") self.process = Process("proc", self.sf) DefaultController("hello", self.process, parts=dict(hello=HelloPart(self.process, None))) DefaultController("counter", self.process, parts=dict(counter=CounterPart(self.process, None))) WebsocketServerComms(self.process, dict(port=self.socket)) self.process.start() self.process2 = Process("proc2", self.sf) WebsocketClientComms(self.process2, dict(hostname="localhost", port=self.socket)) self.process2.start()
def setUp(self): self.sf = SyncFactory("sync") self.process = Process("proc", self.sf) part = HelloPart(self.process, None) DefaultController("hello", self.process, parts={"hello": part}) WebsocketServerComms(self.process, dict(port=self.socket)) self.process.start()
def make_panda_block(self, mri, block_name, block_data, parts=None, area_detector=False): # Validate and store block_data self._store_block_data(block_name, block_data) # Defer creation of parts to a block maker maker = PandABoxBlockMaker(self.process, self.control, block_name, block_data, area_detector) # Add in any extras we are passed if parts: for part in parts: maker.parts[part.name] = part # Make a controller params = DefaultController.MethodMeta.prepare_input_map(mri=mri) controller = DefaultController( self.process, maker.parts.values(), params) block = controller.block self._parts[block_name] = maker.parts # Set the initial block_url self._set_icon_url(block_name) return block
def setUp(self): p = MagicMock() part = HelloPart(p, None) # Serialized version of the block we want source = DefaultController("blockname", p, parts={"hello": part}).block self.serialized = source.to_dict() # Setup client controller prerequisites self.p = MagicMock() self.p.name = "process" self.comms = MagicMock() self.cc = ClientController("blockname", self.p) self.b = self.cc.block # 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 makeChildBlock(self, blockMri): params = PortsPart.MethodMeta.prepare_input_map(name='Connector') port_part = PortsPart(self.p, params) partName = 'part%s' % blockMri params = DefaultController.MethodMeta.prepare_input_map(mri=blockMri) controller = DefaultController(self.p, [port_part], params) params = ChildPart.MethodMeta.prepare_input_map(mri=blockMri, name=partName) part = ChildPart(self.p, params) return part, controller
class TestBlockModel(unittest.TestCase): def setUp(self): self.process = MagicMock() part = HelloPart(self.process, None) self.block = DefaultController("hello", self.process, parts={ "hello": part }).block self.block.name = "hello" self.m = BlockModel(self.process, self.block) def test_init(self): self.assertEqual(self.process.q.put.call_count, 2) req = self.process.q.put.call_args_list[0][0][0] self.assertEqual(req.endpoint, ['hello', 'reset']) req = self.process.q.put.call_args_list[1][0][0] self.assertEqual(req.endpoint, ['hello']) self.assertEqual(self.m.root_item.endpoint, ('hello', )) self.assertEqual(len(self.m.root_item.children), 0) def test_find_item(self): m1, m2 = MagicMock(), MagicMock() BlockItem.items[("foo", "bar")] = m1 BlockItem.items[("foo", )] = m2 item, path = self.m.find_item(('foo', 'bar', 'bat')) self.assertEqual(item, m1) self.assertEqual(path, ['bat']) def test_update_root(self): d = self.block.to_dict() self.m.handle_changes([[[], d]]) b_item = self.m.root_item self.assertEqual(len(b_item.children), 6) m_item = b_item.children[5] self.assertEqual(m_item.endpoint, ('hello', 'say_hello')) self.assertEqual(len(m_item.children), 2) n_item = m_item.children[0] self.assertEqual(n_item.endpoint, ('hello', 'say_hello', 'takes', 'elements', 'name')) self.assertEqual(n_item.children, []) n_item = m_item.children[1] self.assertEqual(n_item.endpoint, ('hello', 'say_hello', 'takes', 'elements', 'sleep')) self.assertEqual(n_item.children, [])
def make_panda_block(self, malcolm_name, block_name, block_data): # Validate and store block_data self._store_block_data(block_name, block_data) # Defer creation of parts to a block maker maker = PandABoxBlockMaker(self.process, self.control, block_name, block_data) # Make a controller controller = DefaultController(malcolm_name, self.process, maker.parts) block = controller.block self._blocks[block_name] = block self._parts[block_name] = maker.parts # Set the initial block_url self._set_icon_url(block_name) return block
def test_hello_with_process(self): sync_factory = SyncFactory("sched") process = Process("proc", sync_factory) part = HelloPart(process, None) b = DefaultController("hello", process, parts={"hello": part}).block process.start() # wait until block is Ready task = Task("hello_ready_task", process) futures = task.when_matches(b["state"], "Ready") task.wait_all(futures, timeout=1) q = sync_factory.create_queue() req = 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.typeid, "malcolm:core/Return:1.0") self.assertEqual(resp.value["greeting"], "Hello thing") process.stop()
def test_counter_subscribe(self): sync_factory = SyncFactory("sched") process = Process("proc", sync_factory) part = CounterPart(process, None) b = DefaultController("counting", process, parts={ "counter": part }).block process.start() # wait until block is Ready task = Task("counter_ready_task", process) futures = task.when_matches(b["state"], "Ready") task.wait_all(futures, 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()