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"
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 setUp(self):
self.o = LabelPart(value="My label")
self.p = Process("proc")
self.c = BasicController("mri")
self.c.add_part(self.o)
self.p.add_controller(self.c)
self.p.start()
self.b = self.p.block_view(self.c.mri)
def makeChildBlock(self, block_mri):
controller = BasicController(block_mri)
controller.add_part(PortsPart(name='Connector%s' % block_mri[-1]))
part = ChildPart(mri=block_mri,
name='part%s' % block_mri,
stateful=False,
initial_visibility=True)
self.p.add_controller(controller)
return part, controller
def makeChildBlock(self, block_mri):
controller = BasicController(block_mri)
controller.add_part(PortsPart(name=f"Connector{block_mri[-1]}"))
part = ChildPart(
mri=block_mri,
name=f"part{block_mri}",
stateful=False,
)
self.p.add_controller(controller)
return part, controller
def _make_child_controller(self, parts, mri):
controller = BasicController(mri=mri)
if mri.endswith("PCAP"):
parts.append(PandABlocksActionPart(
self.client, "*PCAP", "ARM", "Arm position capture", []))
parts.append(PandABlocksActionPart(
self.client, "*PCAP", "DISARM", "Disarm position capture", []))
for part in parts:
controller.add_part(part)
return controller
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
# Create a fake PandA with a pulse block
self.panda = ManagerController("PANDA", "/tmp")
controller = BasicController("PANDA:PULSE3")
self.pulse_part = PulsePart("part")
controller.add_part(self.pulse_part)
self.process.add_controller(controller)
self.panda.add_part(
ChildPart("PULSE3",
"PANDA:PULSE3",
initial_visibility=True,
stateful=False))
self.process.add_controller(self.panda)
# And the detector
self.config_dir = tmp_dir("config_dir")
for c in detector_block("DET", config_dir=self.config_dir.value):
self.process.add_controller(c)
# Make the child block holding panda and pmac mri
self.child = self.create_child_block(
panda_pulse_trigger_block,
self.process,
mri="SCAN:PULSE",
panda="PANDA",
detector="DET",
)
# And our part under test
self.o = PandAPulseTriggerPart("detTrigger", "SCAN:PULSE")
# Add in a scan block
self.scan = RunnableController("SCAN", "/tmp")
self.scan.add_part(DetectorChildPart("det", "DET", True))
self.scan.add_part(self.o)
self.process.add_controller(self.scan)
# Now start the process off and tell the panda which sequencer tables
# to use
self.process.start()
exports = ExportTable.from_rows([
("PULSE3.width", "detTriggerWidth"),
("PULSE3.step", "detTriggerStep"),
("PULSE3.delay", "detTriggerDelay"),
("PULSE3.pulses", "detTriggerPulses"),
])
self.panda.set_exports(exports)
self.tmpdir = tempfile.mkdtemp()
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
# Make 2 sequencers we can prod
self.seq_parts = {}
for i in (1, 2):
controller = BasicController("TEST:SEQ%d" % i)
self.seq_parts[i] = SequencerPart("part")
controller.add_part(self.seq_parts[i])
self.process.add_controller(controller)
# Now start the process off
self.process.start()
self.seq1_block = self.context.block_view("TEST:SEQ1")
self.seq2_block = self.context.block_view("TEST:SEQ2")
self.db = DoubleBuffer(self.context, self.seq1_block, self.seq2_block)
def test_init(self):
params = Mock()
params.mri = "MyMRI"
params.description = "My description"
process = Mock()
o = BasicController(process, [], params)
assert o.mri == params.mri
assert o.params is params
assert o.process is process
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")
class TestLabelPart(unittest.TestCase):
def setUp(self):
self.o = LabelPart(value="My label")
self.p = Process("proc")
self.c = BasicController("mri")
self.c.add_part(self.o)
self.p.add_controller(self.c)
self.p.start()
self.b = self.p.block_view(self.c.mri)
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:1"]
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"
def test_concurrency(self):
q = Queue()
# Subscribe to the whole block
sub = Subscribe(id=0, path=["mri"], delta=True)
sub.set_callback(q.put)
self.c.handle_request(sub)
# We should get first Delta through with initial value
r = q.get().to_dict()
assert r["id"] == 0
assert len(r["changes"]) == 1
assert len(r["changes"][0]) == 2
assert r["changes"][0][0] == []
assert r["changes"][0][1]["meta"]["label"] == "My label"
assert r["changes"][0][1]["label"]["value"] == "My label"
# Do a Put on the label
put = Put(id=2, path=["mri", "label", "value"], value="New", get=True)
put.set_callback(q.put)
self.c.handle_request(put)
# Check we got two updates before the return
r = q.get().to_dict()
assert r["id"] == 0
assert len(r["changes"]) == 2
assert len(r["changes"][0]) == 2
assert r["changes"][0][0] == ["label", "value"]
assert r["changes"][0][1] == "New"
assert len(r["changes"][0]) == 2
assert r["changes"][1][0] == ["label", "timeStamp"]
r = q.get().to_dict()
assert r["id"] == 0
assert len(r["changes"]) == 1
assert len(r["changes"][0]) == 2
assert r["changes"][0][0] == ["meta", "label"]
assert r["changes"][0][1] == "New"
# Then the return
r3 = q.get().to_dict()
assert r3["id"] == 2
assert r3["value"] == "New"
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
# Create a fake PandA
self.panda = ManagerController("PANDA", "/tmp", use_git=False)
self.busses = PositionsPart("busses")
self.panda.add_part(self.busses)
# Make 2 sequencers we can prod
self.seq_parts = {}
for i in (1, 2):
controller = BasicController("PANDA:SEQ%d" % i)
self.seq_parts[i] = SequencerPart("part")
controller.add_part(self.seq_parts[i])
self.process.add_controller(controller)
self.panda.add_part(
ChildPart(
"SEQ%d" % i,
"PANDA:SEQ%d" % i,
initial_visibility=True,
stateful=False,
))
self.child_seq1 = self.process.get_controller("PANDA:SEQ1")
self.child_seq2 = self.process.get_controller("PANDA:SEQ2")
# And an srgate
controller = BasicController("PANDA:SRGATE1")
self.gate_part = GatePart("part")
controller.add_part(self.gate_part)
self.process.add_controller(controller)
self.panda.add_part(
ChildPart("SRGATE1",
"PANDA:SRGATE1",
initial_visibility=True,
stateful=False))
self.process.add_controller(self.panda)
# And the PMAC
pmac_block = make_block_creator(
os.path.join(os.path.dirname(__file__), "..", "test_pmac", "blah"),
"test_pmac_manager_block.yaml",
)
self.config_dir = tmp_dir("config_dir")
self.pmac = self.create_child_block(
pmac_block,
self.process,
mri_prefix="PMAC",
config_dir=self.config_dir.value,
)
# These are the motors we are interested in
self.child_x = self.process.get_controller("BL45P-ML-STAGE-01:X")
self.child_y = self.process.get_controller("BL45P-ML-STAGE-01:Y")
self.child_cs1 = self.process.get_controller("PMAC:CS1")
# CS1 needs to have the right port otherwise we will error
self.set_attributes(self.child_cs1, port="CS1")
# Make the child block holding panda and pmac mri
self.child = self.create_child_block(
panda_seq_trigger_block,
self.process,
mri="SCAN:PCOMP",
panda="PANDA",
pmac="PMAC",
)
# And our part under test
self.o = PandASeqTriggerPart("pcomp", "SCAN:PCOMP")
# Now start the process off and tell the panda which sequencer tables
# to use
self.process.start()
exports = ExportTable.from_rows([
("SEQ1.table", "seqTableA"),
("SEQ2.table", "seqTableB"),
("SRGATE1.forceSet", "seqSetEnable"),
("SRGATE1.forceReset", "seqReset"),
])
self.panda.set_exports(exports)
def setUp(self):
self.p = Process("proc")
c = BasicController("mri")
c.add_part(HelloPart(name='block'))
self.p.add_controller(c)
self.p.start()
