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