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"]