def test_GIVEN_stream_with_one_pv_with_two_topics_WHEN_generating_forwarder_command_THEN_contains_one_converter_with_list(
file, ):
pv_name = "testPV"
topic1 = "topic1"
topic2 = "topic2"
writer_module = "f142"
group = file.create_group("test_group")
group.attrs["NX_class"] = "NCstream"
group.create_dataset("writer_module", data=writer_module)
group.create_dataset("source", data=pv_name)
group.create_dataset("topic", data=topic1)
group2 = file.create_group("test_group2")
group2.attrs["NX_class"] = "NCstream"
group2.create_dataset("writer_module", data=writer_module)
group2.create_dataset("topic", data=topic2)
group2.create_dataset("source", data=pv_name)
dummy_file = io.StringIO()
generate_forwarder_command(dummy_file, file, "ca", "")
streams_ = literal_eval(dummy_file.getvalue())["streams"]
assert len(streams_) == 1
assert isinstance(streams_[0]["converter"], list)
assert streams_[0]["channel"] == pv_name
assert streams_[0]["converter"][0]["topic"] == topic1
assert streams_[0]["converter"][1]["topic"] == topic2
def test_GIVEN_stream_with_f142_command_and_non_forwarder_modules_THEN_only_f142_is_contained(
file, ):
group = file.create_group("test_group")
group.attrs["NX_class"] = "NCstream"
group.create_dataset("writer_module", data="ev42")
group.create_dataset("source", data="source1")
group.create_dataset("topic", data="topic1")
group2 = file.create_group("test_group2")
group2.attrs["NX_class"] = "NCstream"
pv_name = "pv1"
topic = "localhost:9092/someTopic"
writer_module = "f142"
group2.create_dataset("writer_module", data=writer_module)
group2.create_dataset("topic", data=topic)
group2.create_dataset("source", data=pv_name)
dummy_file = io.StringIO()
generate_forwarder_command(dummy_file, file, "ca", "")
streams_ = literal_eval(dummy_file.getvalue())["streams"]
assert len(streams_) == 1
assert streams_[0]["channel"] == pv_name
assert streams_[0]["converter"]["topic"] == topic
assert streams_[0]["converter"]["schema"] == writer_module
def test_dependee_of_contains_both_components_when_generating_dependee_of_chain_with_mixture_of_absolute_and_relative_paths(
file, # noqa: F811
):
entry_group = file.create_group("entry")
entry_group.attrs["NX_class"] = "NXentry"
instrument_group = entry_group.create_group("instrument")
instrument_group.attrs["NX_class"] = "NXinstrument"
component_a = instrument_group.create_group("a")
component_a.attrs["NX_class"] = "NXaperture"
transforms_group = component_a.create_group("Transforms1")
transform_1 = transforms_group.create_dataset("transform1", data=1.0)
# Relative path to transform
component_a.create_dataset("depends_on", data="Transforms1/transform1")
component_b = instrument_group.create_group("b")
component_b.attrs["NX_class"] = "NXaperture"
# Absolute path to transform
component_b.create_dataset(
"depends_on", data="/entry/instrument/a/Transforms1/transform1")
nexus_wrapper = NexusWrapper("test_dependent_transforms_1")
nexus_wrapper.load_file(entry_group, file)
Instrument(nexus_wrapper, NX_CLASS_DEFINITIONS)
transform_1_loaded = Transformation(nexus_wrapper, transform_1)
# Check both relative and absolute are in dependee_of list
assert component_a.name in transform_1_loaded.dataset.attrs[
"NCdependee_of"]
assert component_b.name in transform_1_loaded.dataset.attrs[
"NCdependee_of"]
def test_GIVEN_stream_in_group_children_WHEN_handling_group_THEN_stream_is_appended_to_children(
file, ):
group_name = "test_group"
group = file.create_group(group_name)
group.attrs["NX_class"] = "NCstream"
group_contents = {
"writer_module": "f142",
"topic": "topic1",
"source": "SIMPLE:DOUBLE",
"type": "double",
"value_units": "cubits",
"array_size": 32,
}
for name, value in group_contents.items():
group.create_dataset(name, data=value)
converter = NexusToDictConverter()
root_dict = converter.convert(file)
assert len(root_dict["children"]) == 1, "The stream group has been omitted"
assert group_name == root_dict["children"][0]["name"]
assert group_contents == root_dict["children"][0]["children"][0]["stream"]
assert "attributes" not in root_dict["children"][0]
def test_GIVEN_stream_group_that_has_ev42_advanced_option_WHEN_filling_in_existing_field_widget_THEN_ev42_group_box_is_shown(
file, qtbot):
group = file.create_group("stream2")
group.attrs["NX_class"] = "NCstream"
vlen_str = h5py.special_dtype(vlen=str)
group.create_dataset("writer_module", dtype=vlen_str, data="ev42")
group.create_dataset("topic", dtype=vlen_str, data="topic1")
group.create_dataset("source", dtype=vlen_str, data="source1")
group.create_dataset(ADC_PULSE_DEBUG, dtype=bool, data=True)
wrapper = NexusWrapper()
wrapper.load_file(file, file)
instrument = Instrument(wrapper, {})
widget = FieldWidget(instrument=instrument)
qtbot.addWidget(widget)
update_existing_stream_field(group, widget)
# this would usually be done outside of the update_existing_stream_field
widget.name = get_name_of_node(group)
assert widget.streams_widget.ev42_advanced_group_box.isEnabled()
generated_group = widget.streams_widget.get_stream_group()
assert generated_group["writer_module"][()] == group["writer_module"][()]
assert generated_group["topic"][()] == group["topic"][()]
assert generated_group["source"][()] == group["source"][()]
assert generated_group[ADC_PULSE_DEBUG][()] == group[ADC_PULSE_DEBUG][()]
def test_GIVEN_field_without_advanced_option_WHEN_checking_if_advanced_options_should_be_enabled_THEN_returns_false(
file, ):
group = file.create_group("group")
field_name = "test"
advanced_options = ["not_test"]
group.create_dataset(name=field_name, data=1)
assert not check_if_advanced_options_should_be_enabled(
advanced_options, group)
def test_GIVEN_stream_with_no_forwarder_streams_WHEN_generating_forwarder_command_THEN_output_does_not_contain_any_pvs(
file, ):
group_name = "test_group"
group = file.create_group(group_name)
group.attrs["NX_class"] = "NCstream"
group.create_dataset("writer_module", data="ev42")
group.create_dataset("source", data="source1")
group.create_dataset("topic", data="topic1")
dummy_file = io.StringIO()
generate_forwarder_command(dummy_file, file, "ca", "")
assert not literal_eval(dummy_file.getvalue())["streams"]
def test_GIVEN_advanced_option_in_field_WHEN_filling_in_advanced_options_THEN_spinbox_is_created(
qtbot, file):
group = file.create_group("group")
field_name = "test"
advanced_options = [field_name]
spinner = QSpinBox()
items = {advanced_options[0]: spinner}.items()
value = 4
group.create_dataset(name=field_name, data=value)
fill_in_advanced_options(items, group)
assert spinner.value() == value
def test_GIVEN_group_with_multiple_attributes_WHEN_converting_nexus_to_dict_THEN_attributes_end_up_in_file(
file, ):
group_name = "test_group"
group = file.create_group(group_name)
group.attrs["NX_class"] = "NXgroup"
field1name = "field1"
field1value = "field1val"
field2name = "field2"
field2value = 3
arbitrary_field_name = "arbitrary_field"
arbitrary_field_value = "something"
field1 = group.create_dataset(field1name, data=field1value)
field1.attrs["NX_class"] = "NXfield"
field1.attrs[arbitrary_field_name] = arbitrary_field_value
field2 = group.create_dataset(field2name, data=field2value)
field2.attrs["NX_class"] = "NXfield"
converter = NexusToDictConverter()
root_dict = converter.convert(file)
assert group.name.split("/")[-1] == root_dict["children"][0]["name"]
assert field1.name.split(
"/")[-1] == root_dict["children"][0]["children"][0]["name"]
assert field1value == root_dict["children"][0]["children"][0]["values"]
assert ("NX_class" == root_dict["children"][0]["children"][0]["attributes"]
[0]["name"])
assert (field1.attrs["NX_class"] == root_dict["children"][0]["children"][0]
["attributes"][0]["values"])
assert (arbitrary_field_name == root_dict["children"][0]["children"][0]
["attributes"][1]["name"])
assert (field1.attrs[arbitrary_field_name] == root_dict["children"][0]
["children"][0]["attributes"][1]["values"])
assert field2.name.split(
"/")[-1] == root_dict["children"][0]["children"][1]["name"]
assert field2value == root_dict["children"][0]["children"][1]["values"]
def test_GIVEN_link_in_group_children_that_is_a_dataset_WHEN_handling_group_THEN_link_is_appended_to_children(
file, ):
root_group = file.create_group("root")
ds_to_be_linked_name = "test_linked_dataset"
dataset_to_be_linked = root_group.create_dataset(ds_to_be_linked_name,
data=1)
dataset_to_be_linked.attrs["NX_class"] = "NXgroup"
group_name = "test_group_with_link"
root_group[group_name] = h5py.SoftLink(dataset_to_be_linked.name)
root_group[group_name].attrs["NX_class"] = "NXgroup"
converter = NexusToDictConverter()
root_dict = converter.convert(file)
assert root_dict["children"][0]["children"][0]["type"] == "link"
assert (root_group[group_name].name.split("/")[-1] == root_dict["children"]
[0]["children"][0]["name"])
assert (dataset_to_be_linked.name == root_dict["children"][0]["children"]
[0]["target"])
def test_UI_GIVEN_stream_group_as_angle_WHEN_creating_rotation_THEN_ui_is_filled_correctly(
qtbot, file # noqa:F811
):
wrapper = NexusWrapper(filename="test")
instrument = Instrument(wrapper, {})
component = instrument.create_component("test", "NXaperture", "")
x = 0
y = 0
z = 0
transform = component.add_rotation(QVector3D(x, y, z), 0, name="test")
stream_group = file.create_group("stream_group")
stream_group.attrs["NX_class"] = "NCstream"
topic = "test_topic"
writer_module = "ev42"
source = "source1"
stream_group.create_dataset("topic", dtype=h5py.special_dtype(vlen=str), data=topic)
stream_group.create_dataset("writer_module", data=writer_module)
stream_group.create_dataset("source", data=source)
transform.dataset = stream_group
view = EditRotation(parent=None, transformation=transform, instrument=instrument)
qtbot.addWidget(view)
assert view.transformation_frame.x_spinbox.value() == x
assert view.transformation_frame.y_spinbox.value() == y
assert view.transformation_frame.z_spinbox.value() == z
assert view.transformation_frame.value_spinbox.value() == 0.0
assert (
view.transformation_frame.magnitude_widget.field_type == FieldType.kafka_stream
)
assert view.transformation_frame.magnitude_widget.value["topic"][()] == topic
assert (
view.transformation_frame.magnitude_widget.value["writer_module"][()]
== writer_module
)
assert view.transformation_frame.magnitude_widget.value["source"][()] == source
def test_GIVEN_link_in_group_children_WHEN_handling_group_THEN_link_is_appended_to_children(
file, ):
root_group = file.create_group("root")
group_to_be_linked_name = "test_linked_group"
group_to_be_linked = root_group.create_group(group_to_be_linked_name)
group_to_be_linked.attrs["NX_class"] = "NXgroup"
group_name = "test_group_with_link"
root_group[group_name] = h5py.SoftLink(group_to_be_linked.name)
root_group[group_name].attrs["NX_class"] = "NXgroup"
converter = NexusToDictConverter()
root_dict = converter.convert(file)
assert len(root_dict["children"]) == 1, "The link group has been omitted"
assert root_dict["children"][0]["children"][0]["type"] == "link"
assert (root_group[group_name].name.split("/")[-1] == root_dict["children"]
[0]["children"][0]["name"])
assert group_to_be_linked.name == root_dict["children"][0]["children"][0][
"target"]
def test_GIVEN_stream_with_topic_not_including_broker_and_default_broker_not_provided_WHEN_generating_forwarder_command_THEN_topic_does_not_include_broker(
file, ):
pv_name = "testPV"
topic = "topic1"
writer_module = "f142"
group = file.create_group("test_group")
group.attrs["NX_class"] = "NCstream"
group.create_dataset("writer_module", data=writer_module)
group.create_dataset("source", data=pv_name)
group.create_dataset("topic", data=topic)
dummy_file = io.StringIO()
generate_forwarder_command(dummy_file, file, "pva", "")
streams_ = literal_eval(dummy_file.getvalue())["streams"]
assert len(streams_) == 1
assert streams_[0]["converter"]["topic"] == topic
def test_GIVEN_stream_with_f142_command_WHEN_generating_forwarder_command_THEN_output_contains_pv(
file, ):
pv_name = "pv1"
topic = "someTopic"
writer_module = "f142"
group_name = "test_group"
group = file.create_group(group_name)
group.attrs["NX_class"] = "NCstream"
group.create_dataset("writer_module", data=writer_module)
group.create_dataset("topic", data=topic)
group.create_dataset("source", data=pv_name)
dummy_file = io.StringIO()
generate_forwarder_command(dummy_file, file, "ca", "")
streams_ = literal_eval(dummy_file.getvalue())["streams"]
assert len(streams_) == 1
assert streams_[0]["channel"] == pv_name
assert streams_[0]["converter"]["topic"] == topic
assert streams_[0]["converter"]["schema"] == writer_module
def test_dependent_is_created_by_instrument_if_depends_on_is_relative(
file, # noqa: F811
):
entry_group = file.create_group("entry")
entry_group.attrs["NX_class"] = "NXentry"
monitor_group = entry_group.create_group("monitor1")
monitor_group.attrs["NX_class"] = "NXmonitor"
monitor_group.create_dataset("depends_on",
data=b"transformations/translation1")
transformations_group = monitor_group.create_group("transformations")
transformations_group.attrs["NX_class"] = "NXtransformations"
transform_1 = transformations_group.create_dataset("translation1", data=1)
nexus_wrapper = NexusWrapper("test_file_with_transforms")
nexus_wrapper.load_file(entry_group, file)
Instrument(nexus_wrapper, NX_CLASS_DEFINITIONS)
transform_1_loaded = Transformation(nexus_wrapper, transform_1)
assert transform_1_loaded.dataset.attrs["NCdependee_of"][
0] == "/entry/monitor1"
def test_dependents_list_is_created_by_instrument(file): # noqa: F811
"""
The dependents list for transforms is stored in the "dependent_of" attribute,
which is not part of the NeXus standard,
we therefore cannot rely on it being present and correct in a file we load.
This test makes sure that instrument generates this information in the wrapped NeXus file it is given.
"""
# Create minimal test file with some transformations but no "dependent_of" attributes
entry_group = file.create_group("entry")
entry_group.attrs["NX_class"] = "NXentry"
instrument_group = entry_group.create_group("instrument")
instrument_group.attrs["NX_class"] = "NXinstrument"
transforms_group = instrument_group.create_group("transformations")
transforms_group.attrs["NX_class"] = "NXtransformations"
transform_1 = transforms_group.create_dataset("transform_1", data=42)
transform_2 = transforms_group.create_dataset("transform_2", data=42)
transform_3 = transforms_group.create_dataset("transform_3", data=42)
transform_4 = transforms_group.create_dataset("transform_4", data=42)
transform_2.attrs["depends_on"] = transform_1.name
transform_3.attrs["depends_on"] = transform_2.name
transform_4.attrs["depends_on"] = transform_2.name
nexus_wrapper = NexusWrapper("test_file_with_transforms")
nexus_wrapper.load_file(entry_group, file)
Instrument(nexus_wrapper, NX_CLASS_DEFINITIONS)
transform_1_loaded = Transformation(nexus_wrapper, transform_1)
assert (
len(transform_1_loaded.get_dependents()) == 1
), "Expected transform 1 to have a registered dependent (transform 2)"
transform_2_loaded = Transformation(nexus_wrapper, transform_2)
assert (
len(transform_2_loaded.get_dependents()) == 2
), "Expected transform 2 to have 2 registered dependents (transforms 3 and 4)"