Fill out the rest of the metadata test functionality and add publish batch/condition tests

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
 

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 = "*"

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

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

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