diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index abf2102..740f098 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -40,6 +40,9 @@ can also install the Measurement Data Services installer on a test machine. If t is not running, these tests will fail. To run the acceptance tests, run this command: `poetry run pytest tests\acceptance` +> Warning! Running the acceptance tests will publish data and metadata to the default global +> MDS data store location in the Documents folder. + # Publishing on PyPI diff --git a/tests/acceptance/schemas/extensions.toml b/tests/acceptance/schemas/extensions.toml new file mode 100644 index 0000000..cae3dd0 --- /dev/null +++ b/tests/acceptance/schemas/extensions.toml @@ -0,0 +1,41 @@ +id = "https://acceptancetests.com/custommetadata.schema.toml" + +[uut] +u1 = "*" +u2 = "*" + +[uut_instance] +ui1 = "*" +ui2 = "*" + +[operator] +o1 = "*" +o2 = "*" + +[test_station] +ts1 = "*" +ts2 = "*" + +[test_description] +td1 = "*" +td2 = "*" + +[software_item] +sw1 = "*" +sw2 = "*" + +[hardware_item] +hw1 = "*" +hw2 = "*" + +[test_result] +tr1 = "*" +tr2 = "*" + +[step] +s1 = "*" +s2 = "*" + +[test] +t1 = "*" +t2 = "*" \ No newline at end of file diff --git a/tests/acceptance/test_publish_condition_and_read_data.py b/tests/acceptance/test_publish_condition_and_read_data.py new file mode 100644 index 0000000..ded9955 --- /dev/null +++ b/tests/acceptance/test_publish_condition_and_read_data.py @@ -0,0 +1,105 @@ +"""Acceptance tests that publish various condition values then read the data back.""" + +from ni.datastore.data import ( + DataStoreClient, + Step, + TestResult, +) +from nitypes.scalar import Scalar +from nitypes.vector import Vector + + +def test___publish_float_condition___read_data_returns_vector() -> None: + with DataStoreClient() as data_store_client: + step_id = _create_step(data_store_client, "float condition") + published_condition = data_store_client.publish_condition( + condition_name="python float condition", + type="Upper Limit", + value=123.45, + step_id=step_id, + ) + + # A published float will be read back as a Vector. + vector = data_store_client.read_data(published_condition, expected_type=Vector) + assert len(vector) == 1 + assert vector[0] == 123.45 + assert vector.units == "" + + +def test___publish_integer_condition___read_data_returns_vector() -> None: + with DataStoreClient() as data_store_client: + step_id = _create_step(data_store_client, "integer condition") + published_condition = data_store_client.publish_condition( + condition_name="python integer condition", + type="Lower Limit", + value=123, + step_id=step_id, + ) + + # A published integer will be read back as a Vector. + vector = data_store_client.read_data(published_condition, expected_type=Vector) + assert len(vector) == 1 + assert vector[0] == 123 + assert vector.units == "" + + +def test___publish_bool_condition___read_data_returns_vector() -> None: + with DataStoreClient() as data_store_client: + step_id = _create_step(data_store_client, "bool condition") + published_condition = data_store_client.publish_condition( + condition_name="python bool condition", + type="Flag", + value=True, + step_id=step_id, + ) + + # A published bool will be read back as a Vector. + vector = data_store_client.read_data(published_condition, expected_type=Vector) + assert len(vector) == 1 + assert vector[0] is True + assert vector.units == "" + + +def test___publish_str_condition___read_data_returns_vector() -> None: + with DataStoreClient() as data_store_client: + step_id = _create_step(data_store_client, "str condition") + published_condition = data_store_client.publish_condition( + condition_name="python str condition", + type="Environment", + value="condition value", + step_id=step_id, + ) + + # A published str will be read back as a Vector. + vector = data_store_client.read_data(published_condition, expected_type=Vector) + assert len(vector) == 1 + assert vector[0] == "condition value" + assert vector.units == "" + + +def test___publish_scalar_condition___read_data_returns_vector() -> None: + with DataStoreClient() as data_store_client: + step_id = _create_step(data_store_client, "scalar condition") + expected_scalar = Scalar(value=25, units="Volts") + published_condition = data_store_client.publish_condition( + condition_name="python scalar condition", + type="Lower Limit", + value=expected_scalar, + step_id=step_id, + ) + + # A published Scalar will be read back as a Vector. + vector = data_store_client.read_data(published_condition, expected_type=Vector) + assert vector[0] == expected_scalar.value + assert vector.units == expected_scalar.units + + +def _create_step(data_store_client: DataStoreClient, datatype_string: str) -> str: + test_result_name = f"python publish {datatype_string} acceptance test" + test_result = TestResult(test_result_name=test_result_name) + test_result_id = data_store_client.create_test_result(test_result) + + # Publish the waveform data + step = Step(step_name=f"Initial step: {datatype_string}", test_result_id=test_result_id) + step_id = data_store_client.create_step(step) + return step_id diff --git a/tests/acceptance/test_publish_condition_batch_and_read_data.py b/tests/acceptance/test_publish_condition_batch_and_read_data.py new file mode 100644 index 0000000..e50d900 --- /dev/null +++ b/tests/acceptance/test_publish_condition_batch_and_read_data.py @@ -0,0 +1,103 @@ +"""Acceptance tests that publish various batch condition values then read the data back.""" + +from ni.datastore.data import ( + DataStoreClient, + Step, + TestResult, +) +from nitypes.vector import Vector + + +def test___publish_batch_float_condition___read_data_returns_vector() -> None: + expected_value = [1.0, 2.0, 3.0] + with DataStoreClient() as data_store_client: + step_id = _create_step(data_store_client, "float condition batch") + published_condition = data_store_client.publish_condition_batch( + condition_name="python float condition batch", + type="Upper Limits", + values=expected_value, + step_id=step_id, + ) + + # A batch published float will be read back as a Vector. + vector = data_store_client.read_data(published_condition, expected_type=Vector) + assert vector._values == expected_value + assert vector.units == "" + + +def test___publish_batch_integer_condition___read_data_returns_vector() -> None: + expected_value = [5, 6, 7, 8] + with DataStoreClient() as data_store_client: + step_id = _create_step(data_store_client, "integer condition batch") + published_condition = data_store_client.publish_condition_batch( + condition_name="python integer condition batch", + type="Lower Limits", + values=expected_value, + step_id=step_id, + ) + + # A batch published integer will be read back as a Vector. + vector = data_store_client.read_data(published_condition, expected_type=Vector) + assert vector._values == expected_value + assert vector.units == "" + + +def test___publish_batch_bool_condition___read_data_returns_vector() -> None: + expected_value = [True, False, True] + with DataStoreClient() as data_store_client: + step_id = _create_step(data_store_client, "bool condition batch") + published_condition = data_store_client.publish_condition_batch( + condition_name="python bool condition batch", + type="Flags", + values=expected_value, + step_id=step_id, + ) + + # A batch published bool will be read back as a Vector. + vector = data_store_client.read_data(published_condition, expected_type=Vector) + assert vector._values == expected_value + assert vector.units == "" + + +def test___publish_batch_str_condition___read_data_returns_vector() -> None: + expected_value = ["one", "two", "three"] + with DataStoreClient() as data_store_client: + step_id = _create_step(data_store_client, "str condition batch") + published_condition = data_store_client.publish_condition_batch( + condition_name="python str condition batch", + type="Environments", + values=expected_value, + step_id=step_id, + ) + + # A published str will be read back as a Vector. + vector = data_store_client.read_data(published_condition, expected_type=Vector) + assert vector._values == expected_value + assert vector.units == "" + + +def test___publish_batch_vector_condition___read_data_returns_vector() -> None: + with DataStoreClient() as data_store_client: + step_id = _create_step(data_store_client, "scalar condition batch") + expected_vector = Vector(values=[25, 50, 75], units="Amps") + published_condition = data_store_client.publish_condition_batch( + condition_name="python vector condition batch", + type="Upper Limit", + values=expected_vector, + step_id=step_id, + ) + + # A batch published Vector will be read back as a Vector. + vector = data_store_client.read_data(published_condition, expected_type=Vector) + assert vector == expected_vector + + +def _create_step(data_store_client: DataStoreClient, datatype_string: str) -> str: + test_result_name = f"python publish {datatype_string} acceptance test" + test_result = TestResult(test_result_name=test_result_name) + test_result_id = data_store_client.create_test_result(test_result) + + # Publish the waveform data + step = Step(step_name=f"Initial step: {datatype_string}", test_result_id=test_result_id) + step_id = data_store_client.create_step(step) + return step_id diff --git a/tests/acceptance/test_publish_measurement_and_read_data.py b/tests/acceptance/test_publish_measurement_and_read_data.py index e5faa79..2c4ba00 100644 --- a/tests/acceptance/test_publish_measurement_and_read_data.py +++ b/tests/acceptance/test_publish_measurement_and_read_data.py @@ -3,7 +3,6 @@ import numpy as np from ni.datastore.data import ( DataStoreClient, - PublishedMeasurement, Step, TestResult, ) @@ -22,12 +21,8 @@ def test___publish_float___read_data_returns_vector() -> None: step_id=step_id, ) - found_measurement = _get_first_measurement( - data_store_client, published_measurement.published_measurement_id - ) - # A published integer will be read back as a Vector. - vector = data_store_client.read_data(found_measurement, expected_type=Vector) + vector = data_store_client.read_data(published_measurement, expected_type=Vector) assert vector[0] == 123.45 assert vector.units == "" @@ -42,12 +37,8 @@ def test___publish_scalar___read_data_returns_vector() -> None: step_id=step_id, ) - found_measurement = _get_first_measurement( - data_store_client, published_measurement.published_measurement_id - ) - # A published Scalar will be read back as a Vector. - vector = data_store_client.read_data(found_measurement, expected_type=Vector) + vector = data_store_client.read_data(published_measurement, expected_type=Vector) assert vector[0] == expected_scalar.value assert vector.units == expected_scalar.units @@ -68,10 +59,7 @@ def test___publish_xydata___read_data_returns_xydata() -> None: step_id=step_id, ) - found_measurement = _get_first_measurement( - data_store_client, published_measurement.published_measurement_id - ) - xydata = data_store_client.read_data(found_measurement, expected_type=XYData) + xydata = data_store_client.read_data(published_measurement, expected_type=XYData) assert xydata == expected_xydata @@ -91,10 +79,7 @@ def test___publish_spectrum___read_data_returns_spectrum() -> None: step_id=step_id, ) - found_measurement = _get_first_measurement( - data_store_client, published_measurement.published_measurement_id - ) - spectrum = data_store_client.read_data(found_measurement, expected_type=Spectrum) + spectrum = data_store_client.read_data(published_measurement, expected_type=Spectrum) assert spectrum == expected_spectrum @@ -112,10 +97,7 @@ def test___publish_analog_waveform___read_data_returns_analog_waveform() -> None step_id=step_id, ) - found_measurement = _get_first_measurement( - data_store_client, published_measurement.published_measurement_id - ) - waveform = data_store_client.read_data(found_measurement, expected_type=AnalogWaveform) + waveform = data_store_client.read_data(published_measurement, expected_type=AnalogWaveform) assert waveform == expected_waveform @@ -129,10 +111,7 @@ def test___publish_digital_waveform___read_data_returns_digital_waveform() -> No step_id=step_id, ) - found_measurement = _get_first_measurement( - data_store_client, published_measurement.published_measurement_id - ) - waveform = data_store_client.read_data(found_measurement, expected_type=DigitalWaveform) + waveform = data_store_client.read_data(published_measurement, expected_type=DigitalWaveform) assert waveform == expected_waveform @@ -146,10 +125,7 @@ def test___publish_complex_waveform___read_data_returns_complex_waveform() -> No step_id=step_id, ) - found_measurement = _get_first_measurement( - data_store_client, published_measurement.published_measurement_id - ) - waveform = data_store_client.read_data(found_measurement, expected_type=ComplexWaveform) + waveform = data_store_client.read_data(published_measurement, expected_type=ComplexWaveform) assert waveform == expected_waveform @@ -162,15 +138,3 @@ def _create_step(data_store_client: DataStoreClient, datatype_string: str) -> st step = Step(step_name=f"Initial step: {datatype_string}", test_result_id=test_result_id) step_id = data_store_client.create_step(step) return step_id - - -def _get_first_measurement( - data_store_client: DataStoreClient, published_measurement_id: str -) -> PublishedMeasurement: - # Query for the measurement id and read/validate data - published_measurements = data_store_client.query_measurements( - odata_query=f"$filter=id eq {published_measurement_id}" - ) - found_measurement = next(iter(published_measurements), None) - assert found_measurement is not None - return found_measurement diff --git a/tests/acceptance/test_publish_measurement_batch_and_read_data.py b/tests/acceptance/test_publish_measurement_batch_and_read_data.py new file mode 100644 index 0000000..5eb0d7d --- /dev/null +++ b/tests/acceptance/test_publish_measurement_batch_and_read_data.py @@ -0,0 +1,58 @@ +"""Acceptance tests that publish various batch measurement values then reads the data back.""" + +from ni.datastore.data import ( + DataStoreClient, + Step, + TestResult, +) +from nitypes.vector import Vector + + +def test___publish_float___read_data_returns_vector() -> None: + with DataStoreClient() as data_store_client: + # Create TestResult metadata + test_result_name = "python batch publish float acceptance test" + test_result = TestResult(test_result_name=test_result_name) + test_result_id = data_store_client.create_test_result(test_result) + + # Publish the waveform data + step = Step(step_name="Initial step", test_result_id=test_result_id) + step_id = data_store_client.create_step(step) + published_measurements = data_store_client.publish_measurement_batch( + measurement_name="python batch publish float", + values=[1.0, 2.0, 3.0, 4.0], + step_id=step_id, + ) + published_measurement = next(iter(published_measurements), None) + assert published_measurement is not None + + # A published batch floats will be read back as a Vector. + vector = data_store_client.read_data(published_measurement, expected_type=Vector) + assert vector._values == [1.0, 2.0, 3.0, 4.0] + assert vector.units == "" + + +def test___publish_batch_vector___read_data_returns_vector() -> None: + with DataStoreClient() as data_store_client: + # Create TestResult metadata + test_result_name = "python publish scalar acceptance test" + test_result = TestResult(test_result_name=test_result_name) + test_result_id = data_store_client.create_test_result(test_result) + + # Create a Vector data to publish + expected_vector = Vector(values=[1, 2, 3], units="Volts") + + # Batch publish the vector + step = Step(step_name="Initial step", test_result_id=test_result_id) + step_id = data_store_client.create_step(step) + published_measurements = data_store_client.publish_measurement_batch( + measurement_name="python publish scalar", + values=expected_vector, + step_id=step_id, + ) + published_measurement = next(iter(published_measurements), None) + assert published_measurement is not None + + # A batch published Vector will be read back as a Vector. + vector = data_store_client.read_data(published_measurement, expected_type=Vector) + assert vector == expected_vector diff --git a/tests/acceptance/test_publish_with_metadata.py b/tests/acceptance/test_publish_with_metadata.py index fde1983..2a7bf1c 100644 --- a/tests/acceptance/test_publish_with_metadata.py +++ b/tests/acceptance/test_publish_with_metadata.py @@ -1,15 +1,25 @@ """Acceptance test that publishes then queries waveform data and metadata.""" +import datetime as dt +import os + +import hightime as ht import numpy as np from ni.datastore.data import ( DataStoreClient, + ErrorInformation, + Outcome, Step, TestResult, ) from ni.datastore.metadata import ( + HardwareItem, MetadataStoreClient, Operator, SoftwareItem, + Test, + # TestAdapter, + TestDescription, TestStation, Uut, UutInstance, @@ -17,55 +27,174 @@ from nitypes.waveform import AnalogWaveform -def test___waveform_with_metadata___publish___query_read_returns_correct_data() -> None: +def test___waveform_with_all_metadata___publish___query_read_returns_correct_data() -> None: with MetadataStoreClient() as metadata_store_client, DataStoreClient() as data_store_client: - # Create UUT instance - uut = Uut(model_name="NI-9205", family="Analog") + # Load the extensions schema + current_directory = os.path.dirname(os.path.abspath(__file__)) + schema_id = metadata_store_client.register_schema_from_file( + os.path.join(current_directory, "schemas", "extensions.toml") + ) + + # Metadata: UUT + uut = Uut( + model_name="NI-9205", + family="Analog", + manufacturers=["Manufacturer A", "Manufacturer B"], + part_number="Part Number", + link="Uut Link", + extensions={"u1": "one", "u2": "two"}, + schema_id=schema_id, + ) uut_id = metadata_store_client.create_uut(uut) - uut_instance = UutInstance(uut_id=uut_id, serial_number="A861-12345") + + # Metadata: UUTInstance + uut_instance = UutInstance( + uut_id=uut_id, + serial_number="A861-12345", + manufacture_date="Manufacture Date", + firmware_version="Firmware Version", + hardware_version="Hardware Version", + link="UutInstance Link", + extensions={"ui1": "one", "ui2": "two"}, + schema_id=schema_id, + ) uut_instance_id = metadata_store_client.create_uut_instance(uut_instance=uut_instance) - # Create Operator metadata + # Metadata: Operator operator_name = "John Bowery" operator_role = "Test Operator II" - operator = Operator(operator_name=operator_name, role=operator_role) + operator = Operator( + operator_name=operator_name, + role=operator_role, + extensions={"o1": "one", "o2": "two"}, + schema_id=schema_id, + ) operator_id = metadata_store_client.create_operator(operator) - # Create TestStation metadata - test_station = TestStation(test_station_name="TestStation_12") + # Metadata: TestStation + test_station = TestStation( + test_station_name="TestStation_12", + asset_identifier="Test Station Asset Identifier", + link="Test Station Link", + extensions={"ts1": "one", "ts2": "two"}, + schema_id=schema_id, + ) test_station_id = metadata_store_client.create_test_station(test_station) - # Create SoftwareItem metadata - software_item = SoftwareItem(product="Windows", version="10.0.19044") + # Metadata: TestDescription + test_description = TestDescription( + uut_id=uut_id, + test_description_name="Metadata Acceptance Test", + link="Test Description Link", + extensions={"td1": "one", "td2": "two"}, + schema_id=schema_id, + ) + test_description_id = metadata_store_client.create_test_description(test_description) + + # Metadata: SoftwareItem + software_item = SoftwareItem( + product="Windows", + version="10.0.19044", + link="Windows Link", + extensions={"sw1": "one", "sw2": "two"}, + schema_id=schema_id, + ) software_item_id = metadata_store_client.create_software_item(software_item) - software_item_2 = SoftwareItem(product="Python", version="3.12") - software_item_2_id = metadata_store_client.create_software_item(software_item_2) + software_item_ids = [software_item_id] + + # Metadata: HardwareItem + hardware_item = HardwareItem( + manufacturer="Test Manufacturer", + model="Test Model", + serial_number="Test Serial Number", + part_number="Test Part Number", + asset_identifier="Test Asset Identifier", + calibration_due_date="Test Calibration Due Date", + link="Hardware Item Link", + extensions={"hw1": "one", "hw2": "two"}, + schema_id=schema_id, + ) + hardware_item_id = metadata_store_client.create_hardware_item(hardware_item) + hardware_item_ids = [hardware_item_id] - # Create TestResult metadata + # Metadata: TestAdapter + # test_adapter=TestAdapter( + # test_adapter_name="Test Adapter Name", + # manufacturer="Test Adapter Manufacturer", + # serial_number="Test Adapter Serial Number", + # part_number="Test Adapter Part Number", + # asset_identifier="Test Adapter Asset Identifier", + # calibration_due_date="Test Adapter Calibration Due Date", + # link="Test Adapter Link", + # ) + # test_adapter_id = metadata_store_client.create_test_adapter(test_adapter) + # test_adapter_ids = [test_adapter_id] + + # Metadata: TestResult test_result_name = "sample test result" - queried_test_result = TestResult( - test_result_name=test_result_name, + test_result = TestResult( + uut_instance_id=uut_instance_id, operator_id=operator_id, test_station_id=test_station_id, - software_item_ids=[software_item_id, software_item_2_id], - uut_instance_id=uut_instance_id, + test_description_id=test_description_id, + software_item_ids=software_item_ids, + hardware_item_ids=hardware_item_ids, + # test_adapter_ids=test_adapter_ids, + test_result_name=test_result_name, + link="Test Result Link", + extensions={"tr1": "one", "tr2": "two"}, + schema_id=schema_id, ) - test_result_id = data_store_client.create_test_result(queried_test_result) + test_result_id = data_store_client.create_test_result(test_result) - name = "data publish sample" - # Create waveform data to publish + # Data: Waveform data to publish expected_waveform = AnalogWaveform( sample_count=3, raw_data=np.array([1.0, 2.0, 3.0]), ) - # Publish the waveform data - step = Step(step_name="Initial step", test_result_id=test_result_id) + # Metadata: Test + test = Test( + test_name="Test Name", + description="Test Description", + link="Test Link", + extensions={"t1": "one", "t2": "two"}, + schema_id=schema_id, + ) + test_id = metadata_store_client.create_test(test) + + # Data: Step + parent_step = Step(step_name="Parent Step") + step = Step( + parent_step_id=parent_step.step_id, + test_result_id=test_result_id, + test_id=test_id, + step_name="Step Name", + step_type="Step Type", + notes="Step Notes", + link="Step Link", + extensions={"s1": "one", "s2": "two"}, + schema_id=schema_id, + ) step_id = data_store_client.create_step(step) + + timestamp = ht.datetime.now(tz=dt.timezone.utc) + error_information = ErrorInformation( + error_code=123, message="Error Message", source="Error Source" + ) + + # Perform publish operation published_measurement = data_store_client.publish_measurement( - measurement_name=name, + measurement_name="Measurement Name", value=expected_waveform, step_id=step_id, + timestamp=timestamp, + outcome=Outcome.OUTCOME_PASSED, + error_information=error_information, + hardware_item_ids=hardware_item_ids, + # test_adapter_ids=test_adapter_ids, + software_item_ids=software_item_ids, + notes="Measurement Notes", ) published_measurements = data_store_client.query_measurements( @@ -74,12 +203,117 @@ def test___waveform_with_metadata___publish___query_read_returns_correct_data() found_measurement = next(iter(published_measurements), None) assert found_measurement is not None - queried_test_result = data_store_client.get_test_result(found_measurement.test_result_id) - assert queried_test_result.test_result_name == test_result_name + # Check PublishedMeasurement + assert found_measurement.measurement_notes == "Measurement Notes" + assert found_measurement.measurement_name == "Measurement Name" + assert sorted(found_measurement.software_item_ids) == sorted(software_item_ids) + assert sorted(found_measurement.hardware_item_ids) == sorted(hardware_item_ids) + # assert found_measurement.test_adapter_ids == test_adapter_ids + assert found_measurement.error_information == error_information + assert found_measurement.outcome == Outcome.OUTCOME_PASSED + assert isinstance(found_measurement.start_date_time, ht.datetime) + # We can't directly compare these datetimes because of bruising when converting + # to bintime and back. + assert found_measurement.start_date_time.day == timestamp.day + + # Check TestResult + found_test_result = data_store_client.get_test_result(found_measurement.test_result_id) + assert found_test_result.test_result_name == test_result_name + assert found_test_result.operator_id == operator_id + assert sorted(found_test_result.software_item_ids) == sorted(software_item_ids) + assert sorted(found_test_result.hardware_item_ids) == sorted(hardware_item_ids) + # assert sorted(queried_test_result.test_adapter_ids) == sorted(test_adapter_ids) + assert found_test_result.test_description_id == test_description_id + assert found_test_result.test_station_id == test_station_id + assert found_test_result.uut_instance_id == uut_instance_id + assert found_test_result.extensions == test_result.extensions + + # Check Step + found_step = data_store_client.get_step(found_measurement.step_id) + assert found_step.parent_step_id == step.parent_step_id + assert found_step.test_result_id == step.test_result_id + assert found_step.test_id == step.test_id + assert found_step.step_name == step.step_name + # TODO: File an issue that found_step.step_type is blank. + # assert found_step.step_type == step.step_type + assert found_step.notes == step.notes + assert found_step.link == step.link + assert found_step.extensions == step.extensions + + # Check Test + found_test = metadata_store_client.get_test(found_step.test_id) + assert found_test.description == test.description + assert found_test.test_name == test.test_name + assert found_test.link == test.link + assert found_test.extensions == test.extensions + + # Check Operator + found_operator = metadata_store_client.get_operator(found_test_result.operator_id) + assert found_operator.operator_name == operator.operator_name + assert found_operator.role == operator.role + assert found_operator.extensions == operator.extensions + + # Check UutInstance + found_uut_instance = metadata_store_client.get_uut_instance( + found_test_result.uut_instance_id + ) + assert found_uut_instance.serial_number == uut_instance.serial_number + assert found_uut_instance.uut_id == uut_instance.uut_id + assert found_uut_instance.firmware_version == uut_instance.firmware_version + assert found_uut_instance.manufacture_date == uut_instance.manufacture_date + assert found_uut_instance.hardware_version == uut_instance.hardware_version + assert found_uut_instance.extensions == uut_instance.extensions - operator = metadata_store_client.get_operator(queried_test_result.operator_id) - assert operator.operator_name == operator_name - assert operator.role == operator_role + # Check Uut + found_uut = metadata_store_client.get_uut(found_uut_instance.uut_id) + assert found_uut.model_name == uut.model_name + assert found_uut.family == uut.family + # TODO: File an issue about found_uut.manufacturers being a blank list. + # assert found_uut.manufacturers == uut.manufacturers + assert found_uut.part_number == uut.part_number + assert found_uut.link == uut.link + assert found_uut.extensions == uut.extensions + + # Check TestStation + found_test_station = metadata_store_client.get_test_station( + found_test_result.test_station_id + ) + assert found_test_station.test_station_name == test_station.test_station_name + assert found_test_station.asset_identifier == test_station.asset_identifier + assert found_test_station.link == test_station.link + assert found_test_station.extensions == test_station.extensions + + # Check TestDescription + found_test_description = metadata_store_client.get_test_description( + found_test_result.test_description_id + ) + assert ( + found_test_description.test_description_name == test_description.test_description_name + ) + assert found_test_description.link == test_description.link + assert found_test_description.extensions == test_description.extensions + + # Check SoftwareItem + found_sw_item = metadata_store_client.get_software_item( + found_test_result.software_item_ids[0] + ) + assert found_sw_item.product == software_item.product + assert found_sw_item.version == software_item.version + assert found_sw_item.link == software_item.link + assert found_sw_item.extensions == software_item.extensions + + # Check HardwareItem + found_hw_item = metadata_store_client.get_hardware_item( + found_test_result.hardware_item_ids[0] + ) + assert found_hw_item.manufacturer == hardware_item.manufacturer + assert found_hw_item.model == hardware_item.model + assert found_hw_item.serial_number == hardware_item.serial_number + assert found_hw_item.part_number == hardware_item.part_number + assert found_hw_item.asset_identifier == hardware_item.asset_identifier + assert found_hw_item.calibration_due_date == hardware_item.calibration_due_date + assert found_hw_item.link == hardware_item.link + assert found_hw_item.extensions == hardware_item.extensions waveform = data_store_client.read_data(found_measurement, expected_type=AnalogWaveform) assert waveform == expected_waveform