class TestHelloPart(unittest.TestCase):
def setUp(self):
self.p = Process("proc")
c = BasicController("mri")
c.add_part(HelloPart(name='block'))
self.p.add_controller(c)
self.p.start()
def tearDown(self):
self.p.stop()
def test_say_hello(self):
b = self.p.block_view("mri")
expected = "Hello test_name"
response = b.greet("test_name", 0)
assert expected == response
def test_method_meta(self):
b = self.p.block_view("mri")
method = b.greet
assert list(method.to_dict()) == [
'typeid', 'takes', 'defaults', 'description', 'tags', 'writeable',
'label', 'returns'
]
assert method.defaults == dict(sleep=0.0)
assert list(method.takes["elements"]) == ["name", "sleep"]
assert list(method.returns["elements"]) == ["return"]
assert method.tags == ["method:return:unpacked"]
assert method.writeable
class TestMotorPreMovePart(ChildTestCase):
def setUp(self):
self.process = Process("test_process")
self.context = Context(self.process)
# Create a raw motor mock to handle axis request
self.child = self.create_child_block(raw_motor_block,
self.process,
mri="BS",
pv_prefix="PV:PRE")
# Add Beam Selector object
self.o = MotorPreMovePart(name="MotorPreMovePart", mri="BS", demand=50)
controller = RunnableController("SCAN", "/tmp")
controller.add_part(self.o)
self.process.add_controller(controller)
self.process.start()
def tearDown(self):
del self.context
self.process.stop(timeout=1)
def test_bs(self):
b = self.context.block_view("SCAN")
generator = CompoundGenerator([LineGenerator("x", "mm", 0, 1, 10)], [],
[], 0.1)
b.configure(generator)
self.o.on_configure(self.context)
assert self.child.handled_requests.mock_calls == [
call.put("demand", 50)
]
class TestCSOutlinksPart(unittest.TestCase):
@patch("malcolm.modules.ca.util.catools")
def setUp(self, catools):
self.catools = catools
catools.caget.side_effect = [[castr("BRICK1CS1")]]
self.process = Process("proc")
self.o = CSSourcePortsPart("cs", "PV:PRE:Port")
c = StatefulController("mri")
c.add_part(self.o)
self.process.add_controller(c)
self.b = self.process.block_view("mri")
self.process.start()
self.addCleanup(self.process.stop)
def test_init(self):
self.catools.caget.assert_called_once_with(
["PV:PRE:Port"],
datatype=self.catools.DBR_STRING,
format=self.catools.FORMAT_CTRL)
assert list(self.b) == [
'meta', 'health', 'state', 'disable', 'reset', 'cs', 'a', 'b', 'c',
'u', 'v', 'w', 'x', 'y', 'z', 'i'
]
assert self.b.cs.value == "BRICK1CS1"
assert self.b.a.value == ""
assert self.b.a.meta.tags == ["sourcePort:motor:BRICK1CS1,A"]
assert self.b.v.value == ""
assert self.b.v.meta.tags == ["sourcePort:motor:BRICK1CS1,V"]
assert self.b.i.value == ""
assert self.b.i.meta.tags == ["sourcePort:motor:BRICK1CS1,I"]
class TestUnrollingPartInitialVisibilityFalse(unittest.TestCase):
def setUp(self):
self.o = UnrollingPart(name="Unroll",
mri="mri",
initial_visibility=False)
self.process = Process("proc")
self.process.start()
self.addCleanup(self.process.stop, 2)
self.config_dir = tmp_dir("config_dir")
c = RunnableController("mri", self.config_dir.value)
c.add_part(self.o)
self.process.add_controller(c)
self.b = c.block_view()
def tearDown(self):
shutil.rmtree(self.config_dir.value)
def test_2d_no_changes_when_initial_visibility_is_False(self):
generator_before = make_generator()
results = self.b.validate(generator_before, ["x", "y"])
generator_after = results["generator"]
generator_before.prepare()
generator_after.prepare()
assert generator_before == generator_after
assert len(generator_after.dimensions) == 2
assert len(generator_after.excluders) == 0
def test_on_validate_returns_None_when_not_visible(self):
generator_before = make_generator()
assert self.o.visible is False
results = self.o.on_validate(generator_before, ["x", "y"])
assert results is None
class TestCounterPart(unittest.TestCase):
def setUp(self):
self.p = Process("proc")
c = BasicController("mri")
c.add_part(CounterPart(name='counting'))
self.p.add_controller(c)
self.p.start()
self.b = self.p.block_view("mri")
def tearDown(self):
self.p.stop()
def test_increment_increments(self):
assert 0 == self.b.counter.value
self.b.increment()
assert 1 == self.b.counter.value
self.b.increment()
assert 2 == self.b.counter.value
def test_reset_sets_zero(self):
self.b.counter.put_value(1234)
assert 1234 == self.b.counter.value
self.b.zero()
assert 0 == self.b.counter.value
def test_caput_status_pv_message(self, catools):
p = self.create_part(
dict(
name="mname",
description="desc",
pv="pv",
status_pv="spv",
good_status="All Good",
message_pv="mpv",
)
)
catools.caget.return_value = [caint(4)]
c = StatefulController("mri")
c.add_part(p)
proc = Process("proc")
proc.add_controller(c)
proc.start()
self.addCleanup(proc.stop)
b = proc.block_view("mri")
self.make_camonitor_return(catools, "No Good")
catools.caget.return_value = "Bad things happened"
with self.assertRaises(AssertionError) as cm:
b.mname()
assert (
str(cm.exception) == "Status No Good: Bad things happened: "
"while performing 'caput pv 1'"
)
class TestBasicController(unittest.TestCase):
def setUp(self):
self.process = Process("proc")
self.o = BasicController("MyMRI")
self.process.add_controller(self.o)
self.process.start()
self.b = self.process.block_view("MyMRI")
def tearDown(self):
self.process.stop(timeout=2)
def update_health(self, num, alarm=Alarm.ok):
self.o.update_health(num, HealthInfo(alarm))
def test_set_health(self):
self.update_health(1, Alarm(severity=AlarmSeverity.MINOR_ALARM))
self.update_health(2, Alarm(severity=AlarmSeverity.MAJOR_ALARM))
assert self.b.health.alarm.severity == AlarmSeverity.MAJOR_ALARM
self.update_health(1, Alarm(severity=AlarmSeverity.UNDEFINED_ALARM))
self.update_health(2, Alarm(severity=AlarmSeverity.INVALID_ALARM))
assert self.b.health.alarm.severity == AlarmSeverity.UNDEFINED_ALARM
self.update_health(1)
self.update_health(2)
assert self.o.health.value == "OK"
class TestCompoundMotorCSPart(unittest.TestCase):
@patch("malcolm.modules.ca.util.catools")
def setUp(self, catools):
self.catools = catools
catools.caget.side_effect = [[castr("@asyn(BRICK1CS1,2)")]]
self.process = Process("proc")
self.o = CompoundMotorCSPart("cs", "PV:PRE.OUT")
c = StatefulController("mri")
c.add_part(self.o)
self.process.add_controller(c)
self.b = self.process.block_view("mri")
self.process.start()
self.addCleanup(self.process.stop)
def test_init(self):
self.catools.caget.assert_called_once_with(
["PV:PRE.OUT"], format=self.catools.FORMAT_CTRL)
assert list(
self.b) == ['meta', 'health', 'state', 'disable', 'reset', 'cs']
assert self.b.cs.value == "BRICK1CS1,B"
def test_update_good(self):
update = castr("@asyn(BRICK1CS1, 3)")
self.o._update_value(update)
assert self.b.cs.value == "BRICK1CS1,C"
def test_update_bad(self):
update = castr("@asyn(BRICK1CS1, 3)")
update.ok = False
self.o._update_value(update)
assert self.b.cs.value == ""
assert self.b.cs.alarm.severity == AlarmSeverity.INVALID_ALARM
class TestCSPart(ChildTestCase):
def setUp(self):
self.process = Process("Process")
self.child = self.create_child_block(cs_block,
self.process,
mri="PMAC:CS1",
pv_prefix="PV:PRE")
self.set_attributes(self.child, port="PMAC2CS1")
c = ManagerController("PMAC", "/tmp")
c.add_part(CSPart(mri="PMAC:CS1", cs=1))
self.process.add_controller(c)
self.process.start()
self.b = c.block_view()
def tearDown(self):
self.process.stop(timeout=1)
def test_init(self):
assert "moveCS1" in self.b
def test_move(self):
self.mock_when_value_matches(self.child)
# Move time is converted into milliseconds
move_time = 2.3
expected_move_time = move_time * 1000.0
self.b.moveCS1(a=32, c=19.1, moveTime=move_time)
assert self.child.handled_requests.mock_calls == [
call.put("deferMoves", True),
call.put("csMoveTime", expected_move_time),
call.put("demandA", 32),
call.put("demandC", 19.1),
call.when_value_matches("demandA", 32, None),
call.when_value_matches("demandC", 19.1, None),
call.put("deferMoves", False),
]
class TestProcessController(unittest.TestCase):
prefix = f"unitTest:{floor(time.time()).__repr__()[:-2]}"
def setUp(self):
self.config_dir = tmp_dir("config_dir")
self.process = Process("proc")
self.o = ProcessController("MyMRI", self.prefix, self.config_dir.value)
self.process.add_controller(self.o)
self.process.start()
self.b = self.process.block_view("MyMRI")
def tearDown(self):
self.process.stop(timeout=2)
shutil.rmtree(self.config_dir.value)
def test_sets_stats(self):
# In unit tests, this depends on where the test-runner is run from
assert self.b.pymalcolmVer.value in ["work", __version__]
hostname = os.uname()[1]
hostname = hostname if len(hostname) < 39 else hostname[:35] + "..."
assert self.b.hostname.value == hostname
def test_starts_ioc(self):
cothread.Sleep(5)
assert catools.caget(self.prefix + ":PYMALCOLM:VER") in ["work", __version__]
def test_ioc_ticks(self):
cothread.Sleep(5)
uptime = catools.caget(self.prefix + ":UPTIME:RAW")
assert uptime >= 0
time.sleep(5)
assert catools.caget(self.prefix + ":UPTIME:RAW") >= uptime + 5
def prepare_locals(args):
from malcolm.core import Process
from malcolm.yamlutil import make_include_creator
if args.yaml:
proc_name = os.path.basename(args.yaml).split(".")[-2]
proc = Process(proc_name)
controllers, parts = make_include_creator(args.yaml)()
assert not parts, "%s defines parts" % (args.yaml, )
for controller in controllers:
proc.add_controller(controller)
proc_name = "%s - imalcolm" % proc_name
else:
proc = Process("Process")
proc_name = "imalcolm"
# set terminal title
sys.stdout.write("\x1b]0;%s\x07" % proc_name)
if args.client:
if args.client.startswith("ws://"):
from malcolm.modules.web.controllers import WebsocketClientComms
hostname, port = args.client[5:].split(":")
comms = WebsocketClientComms(mri="%s:%s" % (hostname, port),
hostname=hostname,
port=int(port))
elif args.client == "pva":
from malcolm.modules.pva.controllers import PvaClientComms
comms = PvaClientComms(mri="pva")
else:
raise ValueError("Don't know how to create client to %s" %
args.client)
proc.add_controller(comms)
proc.start(timeout=60)
return proc
class TestHelloBlock(unittest.TestCase):
def setUp(self):
self.p = Process("proc")
for c in hello_block("mri"):
self.p.add_controller(c)
self.p.start()
def tearDown(self):
self.p.stop()
def test_say_hello(self):
b = self.p.block_view("mri")
expected = "Hello test_name"
response = b.greet("test_name", 0)
assert expected == response
def test_method_meta(self):
b = self.p.block_view("mri")
method = b.greet.meta
assert list(method.to_dict()) == [
"typeid",
"takes",
"defaults",
"description",
"tags",
"writeable",
"label",
"returns",
]
assert method.defaults == dict(sleep=0.0)
assert list(method.takes["elements"]) == ["name", "sleep"]
assert list(method.returns["elements"]) == ["return"]
assert method.tags == ["method:return:unpacked"]
assert method.writeable
class TestLabelPart(unittest.TestCase):
def setUp(self):
self.o = call_with_params(LabelPart,
initialValue="My label",
group="mygroup")
self.p = Process("proc")
self.c = Controller(self.p, "mri", [self.o])
self.p.add_controller("mri", self.c)
self.p.start()
self.b = self.c.block_view()
def tearDown(self):
self.p.stop(1)
def test_init(self):
assert self.o.name == "label"
assert self.o.attr.value == "My label"
assert self.o.attr.meta.tags == ("widget:textinput", "config",
"group:mygroup")
assert self.b.meta.label == "My label"
def test_setter(self):
self.b.label.put_value("My label2")
assert self.b.label.value == "My label2"
assert self.b.meta.label == "My label2"
class TestProcess(unittest.TestCase):
def setUp(self):
self.o = Process("proc")
self.o.start()
def tearDown(self):
self.o.stop(timeout=1)
def test_init(self):
assert self.o.name == "proc"
def test_add_controller(self):
controller = MagicMock(mri="mri")
self.o.add_controller(controller)
assert self.o.get_controller("mri") == controller
def test_init_controller(self):
class InitController(Controller):
init = False
def on_hook(self, hook):
if isinstance(hook, ProcessStartHook):
self.init = True
c = InitController("mri")
self.o.add_controller(c)
assert c.init == True
def test_publish_controller(self):
class PublishController(Controller):
published = []
def on_hook(self, hook):
if isinstance(hook, ProcessPublishHook):
hook(self.do_publish)
@add_call_types
def do_publish(self, published):
# type: (APublished) -> None
self.published = published
class UnpublishableController(Controller):
def on_hook(self, hook):
if isinstance(hook, ProcessStartHook):
hook(self.on_start)
def on_start(self):
return UnpublishedInfo(self.mri)
c = PublishController("mri")
self.o.add_controller(c)
assert c.published == ["mri"]
self.o.add_controller(Controller(mri="mri2"))
assert c.published == ["mri", "mri2"]
self.o.add_controller(UnpublishableController("mri3"))
assert c.published == ["mri", "mri2"]
class TestCounterDemoSystem(unittest.TestCase):
def setUp(self):
self.process = Process("proc")
self.controller = Controller("counting")
self.controller.add_part(CounterPart("cpart"))
self.process.add_controller(self.controller)
self.process.start()
def tearDown(self):
self.process.stop(timeout=1)
def test_counter_subscribe(self):
q = Queue()
# Subscribe to the value
sub = Subscribe(id=20, path=["counting", "counter"], delta=False)
sub.set_callback(q.put)
self.controller.handle_request(sub)
# Check initial return
response = q.get(timeout=1.0)
self.assertIsInstance(response, Update)
assert response.id == 20
assert response.value["typeid"] == "epics:nt/NTScalar:1.0"
assert response.value["value"] == 0
# Post increment()
post = Post(id=21, path=["counting", "increment"])
post.set_callback(q.put)
self.controller.handle_request(post)
# Check the value updates...
response = q.get(timeout=1)
self.assertIsInstance(response, Update)
assert response.id == 20
assert response.value["value"] == 1
# ... then we get the return
response = q.get(timeout=1)
self.assertIsInstance(response, Return)
assert response.id == 21
assert response.value is None
# Check we can put too
put = Put(id=22, path=["counting", "counter", "value"], value=31)
put.set_callback(q.put)
self.controller.handle_request(put)
# Check the value updates...
response = q.get(timeout=1)
self.assertIsInstance(response, Update)
assert response.id == 20
assert response.value["value"] == 31
# ... then we get the return
response = q.get(timeout=1)
self.assertIsInstance(response, Return)
assert response.id == 22
assert response.value is None
# And that there isn't anything else
with self.assertRaises(TimeoutError):
q.get(timeout=0.05)
class TestSystemMotionPVA(unittest.TestCase):
def setUp(self):
self.process = Process("proc")
self.config_dir = tmp_dir("config_dir")
for controller in motion_block(
mri="TESTMOTION",
config_dir=self.config_dir.value) + pva_server_block(
mri="PVA-SERVER"):
self.process.add_controller(controller)
self.process.start()
self.process2 = Process("proc2")
for controller in pva_client_block(mri="PVA-CLIENT") + proxy_block(
mri="TESTMOTION", comms="PVA-CLIENT"):
self.process2.add_controller(controller)
self.process2.start()
def tearDown(self):
shutil.rmtree(self.config_dir.value)
def test_exports(self):
block = self.process2.block_view("TESTMOTION")
fields = [
"meta",
"health",
"state",
"disable",
"reset",
"mri",
"layout",
"design",
"exports",
"modified",
"save",
"xMove",
"yMove",
]
assert list(block) == fields
block.xMove(2)
block.yMove(3)
# Export X
t = ExportTable(source=["x.counter"], export=["xValue"])
block.exports.put_value(t)
assert list(block) == fields + ["xValue"]
assert block.xValue.value == 2.0
# Export Y
t = ExportTable(source=["y.counter"], export=["yValue"])
block.exports.put_value(t)
assert list(block) == fields + ["yValue"]
assert block.yValue.value == 3.0
# Export Nothing
t = ExportTable(source=[], export=[])
block.exports.put_value(t)
assert list(block) == fields
class TestProxyController(unittest.TestCase):
def setUp(self):
self.process = Process("proc")
self.comms = MagicMock()
self.comms.mri = "comms"
self.process.add_controller(self.comms)
self.o = ProxyController(mri="mri", comms="comms")
self.process.add_controller(self.o)
def test_init(self):
assert self.o.mri == "mri"
assert self.o.comms == "comms"
assert self.o.client_comms is None
class TestSystemWSCommsServerAndClient(unittest.TestCase):
socket = 8883
def setUp(self):
self.process = Process("proc")
for controller in (hello_block(mri="hello") +
counter_block(mri="counter") +
web_server_block(mri="server", port=self.socket)):
self.process.add_controller(controller)
self.process.start()
self.process2 = Process("proc2")
for controller in (
websocket_client_block(mri="client", port=self.socket) +
proxy_block(mri="hello", comms="client") +
proxy_block(mri="counter", comms="client")):
self.process2.add_controller(controller)
self.process2.start()
def tearDown(self):
self.socket += 1
self.process.stop(timeout=1)
self.process2.stop(timeout=1)
def test_server_hello_with_malcolm_client(self):
block2 = self.process2.block_view("hello")
ret = block2.greet("me2")
assert ret == "Hello me2"
with self.assertRaises(ResponseError):
block2.error()
def test_server_counter_with_malcolm_client(self):
block1 = self.process.block_view("counter")
block2 = self.process2.block_view("counter")
assert block2.counter.value == 0
block2.increment()
assert block2.counter.timeStamp.to_time(
) == block1.counter.timeStamp.to_time()
assert block2.counter.value == 1
block2.zero()
assert block2.counter.value == 0
assert self.process2.block_view("client").remoteBlocks.value.mri == [
"hello",
"counter",
"server",
]
def test_server_blocks(self):
block = self.process.block_view("server")
assert block.blocks.value.mri == ["hello", "counter", "server"]
assert block.blocks.value.label == ["hello", "counter", "server"]
assert block.blocks.meta.writeable is False
class TestStatefulController(unittest.TestCase):
def setUp(self):
self.process = Process("proc")
self.params = Mock()
self.params.mri = "MyMRI"
self.params.description = "My description"
self.part = MyPart("testpart")
self.o = StatefulController(self.process, [self.part], self.params)
self.process.add_controller(self.params.mri, self.o)
def start_process(self):
self.process.start()
self.addCleanup(self.stop_process)
def stop_process(self):
if self.process.started:
self.process.stop(timeout=1)
def test_process_init(self, ):
assert not hasattr(self.part, "started")
self.start_process()
assert self.part.started
def test_process_stop(self):
self.start_process()
assert not hasattr(self.part, "halted")
self.process.stop(timeout=1)
assert self.part.halted
def test_init(self):
assert self.o.state.value == "Disabled"
self.start_process()
assert self.o.state.value == "Ready"
def test_reset_fails_from_ready(self):
self.start_process()
with self.assertRaises(TypeError):
self.o.reset()
assert not hasattr(self.part, "reset_done")
def test_disable(self):
self.start_process()
assert not hasattr(self.part, "disable_done")
self.o.disable()
assert self.part.disable_done
assert self.o.state.value == "Disabled"
assert not hasattr(self.part, "reset_done")
self.o.reset()
assert self.part.reset_done
assert self.o.state.value == "Ready"
class TestCSOutlinksPart(unittest.TestCase):
@patch("malcolm.modules.ca.util.catools")
def setUp(self, catools):
self.catools = catools
catools.caget.side_effect = [[castr("BRICK1CS1")]]
self.process = Process("proc")
self.o = CSSourcePortsPart("cs", "PV:PRE:Port")
c = StatefulController("mri")
c.add_part(self.o)
self.process.add_controller(c)
self.b = self.process.block_view("mri")
self.process.start()
self.addCleanup(self.process.stop)
def test_init(self):
self.catools.caget.assert_called_once_with(
["PV:PRE:Port"],
datatype=self.catools.DBR_STRING,
format=self.catools.FORMAT_CTRL,
throw=True,
)
assert list(self.b) == [
"meta",
"health",
"state",
"disable",
"reset",
"cs",
"a",
"b",
"c",
"u",
"v",
"w",
"x",
"y",
"z",
"i",
]
assert self.b.cs.value == "BRICK1CS1"
assert self.b.a.value == ""
assert self.b.a.meta.tags == ["sourcePort:motor:BRICK1CS1,A"]
assert self.b.v.value == ""
assert self.b.v.meta.tags == ["sourcePort:motor:BRICK1CS1,V"]
assert self.b.i.value == ""
assert self.b.i.meta.tags == ["sourcePort:motor:BRICK1CS1,I"]
def create_child_block(child_block: Callable, process: Process,
**params: Any) -> Controller:
"""Creates an instance of child_block with CA calls mocked out.
Args:
child_block (callable): The function to call to get the block
process (Process): The process to run under
**params: Parameters to pass to child_block()
Returns:
child: The child object with an attribute mock_requests that will
have a call.put(attr_name, value) or
a call.post(method_name, params) for anything the child is
asked to handle
"""
controllers = child_block(**params)
for controller in controllers:
process.add_controller(controller)
if not isinstance(controller,
builtin.controllers.ManagerController):
# We've already setup the CAParts and added to the block, so we
# can safely delete them so they don't try to connect
controller.parts = {}
child = controllers[-1]
child.handled_requests = Mock(return_value=None)
def handle_put(request):
attr_name = request.path[1]
# store values sent to the mocked block so that tests can check them
child.attributes[attr_name] = request.value
child.handled_requests.put(attr_name, request.value)
return [request.return_response()]
def handle_post(request):
method_name = request.path[1]
value = child.handled_requests.post(method_name,
**request.parameters)
return [request.return_response(value)]
child._handle_put = handle_put
child._handle_post = handle_post
child.attributes = {}
return child
class TestSimultaneousAxesPart(unittest.TestCase):
def setUp(self):
self.o = SimultaneousAxesPart(value=["x", "y"])
self.process = Process("proc")
self.process.start()
self.addCleanup(self.process.stop, 2)
c = RunnableController("mri", "/tmp")
c.add_part(self.o)
self.process.add_controller(c)
self.b = c.block_view()
def test_good(self):
self.b.simultaneousAxes.put_value(["x", "y"])
self.b.validate(make_generator(), ["x", "y"])
def test_bad(self):
self.b.simultaneousAxes.put_value(["x", "z"])
with self.assertRaises(AssertionError):
self.b.validate(make_generator(), ["x", "y"])
class TestMotionBlock(unittest.TestCase):
def setUp(self):
self.p = Process("proc")
for c in motion_block("mri", config_dir="/tmp"):
self.p.add_controller(c)
self.p.start()
self.b = self.p.block_view("mri")
self.bx = self.p.block_view("mri:COUNTERX")
self.by = self.p.block_view("mri:COUNTERY")
def tearDown(self):
self.p.stop()
def test_move(self):
assert self.bx.counter.value == 0
self.b.xMove(32)
assert self.bx.counter.value == 32
assert self.by.counter.value == 0
self.b.yMove(31)
assert self.by.counter.value == 31
class TestPmacStatusPart(ChildTestCase):
def setUp(self):
self.process = Process("Process")
child = self.create_child_block(
pmac_status_block, self.process, mri="my_mri", pv_prefix="PV:PRE"
)
self.set_attributes(child, servoFreq=2500.04)
c = ManagerController("PMAC", "/tmp")
self.o = PmacStatusPart(name="part", mri="my_mri", initial_visibility=True)
c.add_part(self.o)
self.process.add_controller(c)
self.process.start()
self.b = c.block_view()
def tearDown(self):
self.process.stop(timeout=1)
def test_servo_freq(self):
freq = self.b.servoFrequency()
assert freq == 2500.04
class TestHelloDemoSystem(unittest.TestCase):
def setUp(self):
self.process = Process("proc")
self.controller = Controller("hello_block")
self.controller.add_part(HelloPart("hpart"))
self.process.add_controller(self.controller)
self.process.start()
def tearDown(self):
self.process.stop(timeout=1)
def test_hello_good_input(self):
q = Queue()
request = Post(id=44,
path=["hello_block", "greet"],
parameters=dict(name="thing"))
request.set_callback(q.put)
self.controller.handle_request(request)
response = q.get(timeout=1.0)
self.assertIsInstance(response, Return)
assert response.id == 44
assert response.value == "Hello thing"
def test_concurrent(self):
q = Queue()
request = Post(id=44,
path=["hello_block", "greet"],
parameters=dict(name="me", sleep=1))
request.set_callback(q.put)
self.controller.handle_request(request)
request = Post(id=45, path=["hello_block", "error"])
request.set_callback(q.put)
self.controller.handle_request(request)
response = q.get(timeout=1.0)
self.assertIsInstance(response, Error)
assert response.id == 45
response = q.get(timeout=3.0)
self.assertIsInstance(response, Return)
assert response.id == 44
assert response.value == "Hello me"
class TestMethod(unittest.TestCase):
def setUp(self):
self.process = Process("proc")
self.part = MyPart("test_part")
self.controller = Controller("mri")
self.controller.add_part(self.part)
self.process.add_controller(self.controller)
self.block = self.controller.block_view()
self.process.start()
def tearDown(self):
self.process.stop(timeout=1)
def test_post(self):
method_view = self.block.myMethod
result = method_view.post(param1="testPost", param2="y")
assert result == "testPosty"
def test_post_async(self):
method_view = self.block.myMethod
f = method_view.post_async("testAsync", "y")
assert f.result() == "testAsyncy"
class TestRunnableControllerCollectsAllParams(unittest.TestCase):
def setUp(self):
self.p = Process('process1')
self.context = Context(self.p)
def tearDown(self):
self.p.stop(timeout=1)
def test_no_hook_passes(self):
# create a root block for the RunnableController block to reside in
self.c = call_with_params(
RunnableController,
self.p, [PartTester1("1"), PartTester2("2")],
mri='mainBlock',
configDir="/tmp",
axesToMove=["x"])
self.p.add_controller('mainBlock', self.c)
self.b = self.context.block_view("mainBlock")
# start the process off
self.p.start()
takes = list(self.b.configure.takes.elements)
self.assertEqual(takes, ["size", "generator", "axesToMove"])
def test_hook_fails(self):
# create a root block for the RunnableController block to reside in
self.c = call_with_params(
RunnableController,
self.p, [PartTester1("1"), PartTester3("2")],
mri='mainBlock',
configDir="/tmp",
axesToMove=["x"])
self.p.add_controller('mainBlock', self.c)
self.b = self.context.block_view("mainBlock")
# start the process off
self.p.start()
takes = list(self.b.configure.takes.elements)
self.assertEqual(takes, ["size", "generator", "axesToMove"])
def test_hook_plus_method_takes_nothing_passes(self):
# create a root block for the RunnableController block to reside in
self.c = call_with_params(
RunnableController,
self.p, [PartTester1("1"), PartTester4("2")],
mri='mainBlock',
configDir="/tmp",
axesToMove=["x"])
self.p.add_controller('mainBlock', self.c)
self.b = self.context.block_view("mainBlock")
# start the process off
self.p.start()
takes = list(self.b.configure.takes.elements)
self.assertEqual(takes, ["size", "generator", "axesToMove"])
class TestCounterBlock(unittest.TestCase):
def setUp(self):
self.p = Process("proc")
for c in counter_block("mri"):
self.p.add_controller(c)
self.p.start()
self.b = self.p.block_view("mri")
def tearDown(self):
self.p.stop()
def test_increment_increments(self):
assert 0 == self.b.counter.value
self.b.increment()
assert 1 == self.b.counter.value
self.b.increment()
assert 2 == self.b.counter.value
def test_reset_sets_zero(self):
self.b.counter.put_value(1234)
assert 1234 == self.b.counter.value
self.b.zero()
assert 0 == self.b.counter.value
class TestProcess(unittest.TestCase):
def setUp(self):
self.o = Process("proc")
self.o.start()
def tearDown(self):
self.o.stop(timeout=1)
def test_init(self):
assert self.o.name == "proc"
def test_add_controller(self):
controller = MagicMock(mri="mri")
self.o.add_controller(controller)
assert self.o.get_controller("mri") == controller
def test_init_controller(self):
class InitController(Controller):
init = False
def on_hook(self, hook):
if isinstance(hook, ProcessStartHook):
self.init = True
c = InitController("mri")
self.o.add_controller(c)
assert c.init is True
def test_publish_controller(self):
c = PublishController("mri")
self.o.add_controller(c)
assert c.published == ["mri"]
self.o.add_controller(Controller(mri="mri2"))
assert c.published == ["mri", "mri2"]
self.o.add_controller(UnpublishableController("mri3"))
assert c.published == ["mri", "mri2"]
