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()