Add tests for derived signal

src/ophyd_async/core/_derived_signal.py

@@ -234,7 +234,7 @@ def derived_signal_rw(
     if raw_to_derived_datatype != set_derived_datatype:
         msg = (
             f"{raw_to_derived} has datatype {raw_to_derived_datatype} "
-            f"!= {set_derived_datatype} dataype {set_derived_datatype}"
+            f"!= {set_derived_datatype} datatype {set_derived_datatype}"
         )
         raise TypeError(msg)
 

src/ophyd_async/core/_derived_signal_backend.py

@@ -61,7 +61,7 @@ def derived_to_raw(self, *, derived1: float, derived2: float) -> MyRaw:
 TransformT = TypeVar("TransformT", bound=Transform)
 
 
-def filter_by_type(raw_devices: Mapping[str, Any], type_: type[T]) -> dict[str, T]:
+def validate_by_type(raw_devices: Mapping[str, Any], type_: type[T]) -> dict[str, T]:
     filtered_devices: dict[str, T] = {}
     for name, device in raw_devices.items():
         if not isinstance(device, type_):
@@ -91,21 +91,21 @@ def __init__(
 
     @cached_property
     def raw_locatables(self) -> dict[str, AsyncLocatable]:
-        return filter_by_type(self._raw_devices, AsyncLocatable)
+        return validate_by_type(self._raw_devices, AsyncLocatable)
 
     @cached_property
     def transform_readables(self) -> dict[str, AsyncReadable]:
-        return filter_by_type(self._transform_devices, AsyncReadable)
+        return validate_by_type(self._transform_devices, AsyncReadable)
 
     @cached_property
     def raw_and_transform_readables(self) -> dict[str, AsyncReadable]:
-        return filter_by_type(
+        return validate_by_type(
             self._raw_devices | self._transform_devices, AsyncReadable
         )
 
     @cached_property
     def raw_and_transform_subscribables(self) -> dict[str, Subscribable]:
-        return filter_by_type(self._raw_devices | self._transform_devices, Subscribable)
+        return validate_by_type(self._raw_devices | self._transform_devices, Subscribable)
 
     def _complete_cached_reading(self) -> dict[str, Reading] | None:
         if self._cached_readings and len(self._cached_readings) == len(

src/ophyd_async/epics/testing/_example_ioc.py

@@ -48,6 +48,7 @@ class EpicsTestCaDevice(EpicsDevice):
     longstr: A[SignalRW[str], PvSuffix("longstr")]
     longstr2: A[SignalRW[str], PvSuffix("longstr2.VAL$")]
     a_bool: A[SignalRW[bool], PvSuffix("bool")]
+    slowseq: A[SignalRW[int], PvSuffix("slowseq")]
     enum: A[SignalRW[EpicsTestEnum], PvSuffix("enum")]
     enum2: A[SignalRW[EpicsTestEnum], PvSuffix("enum2")]
     subset_enum: A[SignalRW[EpicsTestSubsetEnum], PvSuffix("subset_enum")]

src/ophyd_async/epics/testing/test_records.db

@@ -112,6 +112,11 @@ record(mbbo, "$(device)enum_str_fallback") {
   field(PINI, "YES")
 }
 
+record(seq, "$(device)slowseq") {
+  field(DLY1, "0.5")
+  field(LNK1, "$(device)slowseq.DESC")
+}
+
 record(waveform, "$(device)uint8a") {
   field(NELM, "3")
   field(FTVL, "UCHAR")

tests/core/test_multi_derived_signal.py

@@ -10,6 +10,13 @@
     DerivedSignalFactory,
     soft_signal_rw,
 )
+from ophyd_async.core._derived_signal_backend import (
+    DerivedSignalBackend,  # noqa: PLC2701
+    SignalTransformer,  # noqa: PLC2701
+    Transform,  # noqa: PLC2701
+)
+from ophyd_async.core._signal import SignalRW  # noqa: PLC2701
+from ophyd_async.core._table import Table  # noqa: PLC2701
 from ophyd_async.sim import (
     HorizontalMirror,
     HorizontalMirrorDerived,
@@ -128,3 +135,47 @@ def test_mismatching_args():
             jack22=soft_signal_rw(float),
             distance=soft_signal_rw(float),
         )
+
+
+@pytest.fixture
+def derived_signal_backend() -> DerivedSignalBackend:
+    return DerivedSignalBackend(Table, "derived_backend",
+                                SignalTransformer(Transform, None, None))
+
+
+async def test_derived_signal_backend_connect_pass(
+    derived_signal_backend: DerivedSignalBackend
+) -> None:
+    result = await derived_signal_backend.connect(0.0)
+    assert result is None
+
+
+def test_derived_signal_backend_set_value(
+    derived_signal_backend: DerivedSignalBackend
+) -> None:
+    with pytest.raises(RuntimeError):
+        derived_signal_backend.set_value(0.0)
+
+
+async def test_derived_signal_backend_put_fails(
+    derived_signal_backend: DerivedSignalBackend
+) -> None:
+    with pytest.raises(RuntimeError):
+        await derived_signal_backend.put(value=None, wait=False)
+    with pytest.raises(RuntimeError):
+        await derived_signal_backend.put(value=None, wait=True)
+
+
+def test_make_rw_signal_type_mismatch():
+    factory = DerivedSignalFactory(
+            TwoJackTransform,
+            set_derived=None,
+            distance=soft_signal_rw(float),
+            jack1=soft_signal_rw(float),
+            jack2=soft_signal_rw(float),
+        )
+    with pytest.raises(
+        ValueError,
+        match=re.escape("Must define a set_derived method to support derived")
+        ):
+        factory._make_signal(signal_cls=SignalRW, datatype=Table, name="")

tests/core/test_single_derived_signal.py

@@ -1,13 +1,26 @@
 import asyncio
 import re
-from unittest.mock import call
+from unittest.mock import call, patch
 
 import pytest
+from bluesky.protocols import Reading
 
 from ophyd_async.core import (
     derived_signal_r,
     soft_signal_rw,
 )
+from ophyd_async.core._derived_signal import (
+    _get_first_arg_datatype,  # noqa: PLC2701
+    _get_return_datatype,  # noqa: PLC2701
+    derived_signal_rw,  # noqa: PLC2701
+)
+from ophyd_async.core._derived_signal_backend import (
+    SignalTransformer,  # noqa: PLC2701
+    Transform,  # noqa: PLC2701
+    validate_by_type,  # noqa: PLC2701
+)
+from ophyd_async.core._signal import SignalR  # noqa: PLC2701
+from ophyd_async.core._utils import StrictEnumMeta  # noqa: PLC2701
 from ophyd_async.testing import (
     BeamstopPosition,
     Exploder,
@@ -20,6 +33,16 @@
 )
 
 
+@pytest.fixture
+def movable_beamstop() -> MovableBeamstop:
+    return MovableBeamstop("device")
+
+
+@pytest.fixture
+def readonly_beamstop() -> ReadOnlyBeamstop:
+    return ReadOnlyBeamstop("device")
+
+
 @pytest.mark.parametrize(
     "x, y, position",
     [
@@ -70,19 +93,18 @@ async def test_monitoring_position(cls: type[ReadOnlyBeamstop | MovableBeamstop]
     assert results.empty()
 
 
-async def test_setting_position():
-    inst = MovableBeamstop("inst")
+async def test_setting_position(movable_beamstop: MovableBeamstop):
     # Connect in mock mode so we can see what would have been set
-    await inst.connect(mock=True)
-    m = get_mock(inst)
-    await inst.position.set(BeamstopPosition.OUT_OF_POSITION)
+    await movable_beamstop.connect(mock=True)
+    m = get_mock(movable_beamstop)
+    await movable_beamstop.position.set(BeamstopPosition.OUT_OF_POSITION)
     assert m.mock_calls == [
         call.position.put(BeamstopPosition.OUT_OF_POSITION, wait=True),
         call.x.put(3, wait=True),
         call.y.put(5, wait=True),
     ]
     m.reset_mock()
-    await inst.position.set(BeamstopPosition.IN_POSITION)
+    await movable_beamstop.position.set(BeamstopPosition.IN_POSITION)
     assert m.mock_calls == [
         call.position.put(BeamstopPosition.IN_POSITION, wait=True),
         call.x.put(0, wait=True),
@@ -118,3 +140,105 @@ def _get_position(x: float, y: float) -> BeamstopPosition:
         derived_signal_r(
             _get_position, foo=soft_signal_rw(float), bar=soft_signal_rw(float)
         )
+
+
+@patch("ophyd_async.core._derived_signal_backend.TYPE_CHECKING", True)
+def test_validate_by_type(
+    movable_beamstop: MovableBeamstop,
+    readonly_beamstop: ReadOnlyBeamstop
+) -> None:
+    invalid_devices_dict = {device.name: device for device in [movable_beamstop,
+                                                               readonly_beamstop]}
+    with pytest.raises(TypeError):
+        validate_by_type(invalid_devices_dict, MovableBeamstop)
+    with pytest.raises(TypeError):
+        validate_by_type({movable_beamstop.name: movable_beamstop}, ReadOnlyBeamstop)
+    valid_devices_dict = {device.name: device for device in [movable_beamstop,
+                                                             MovableBeamstop("mvb2")]}
+    assert validate_by_type(valid_devices_dict, MovableBeamstop) == valid_devices_dict
+
+
+@pytest.fixture
+def null_transformer() -> SignalTransformer:
+    return SignalTransformer(Transform, None, None)
+
+
+@pytest.fixture
+def new_readings() -> dict[str, Reading]:
+    return {"device-position": Reading(value=0.0, timestamp=0.0)}
+
+
+async def test_set_derived_not_initialized(null_transformer: SignalTransformer):
+    with pytest.raises(RuntimeError):
+        await null_transformer.set_derived("name", None)
+
+
+async def test_get_transform_cached(
+    null_transformer: SignalTransformer,
+    new_readings: dict[str, Reading]
+) -> None:
+    with patch.object(null_transformer, '_cached_readings', new_readings):
+        with patch.object(null_transformer, 'raw_and_transform_subscribables', {"device": SignalR}):  # noqa: E501
+            assert null_transformer._cached_readings == new_readings
+            r = await null_transformer.get_transform()
+            assert isinstance(r, Transform)
+
+
+def test_update_cached_reading_non_initialized(
+    null_transformer: SignalTransformer,
+    new_readings: dict[str, Reading]
+) -> None:
+    with pytest.raises(RuntimeError):
+        null_transformer._update_cached_reading(new_readings)
+
+
+def test_update_cached_reading_initialized(
+    null_transformer: SignalTransformer,
+    new_readings: dict[str, Reading]
+) -> None:
+    null_transformer._cached_readings = {}
+    null_transformer._update_cached_reading(new_readings)
+    assert null_transformer._cached_readings == new_readings
+
+
+@patch("ophyd_async.core._utils.Callback")
+def test_set_callback_already_set(
+    mock_class,
+    null_transformer: SignalTransformer
+) -> None:
+    device_name = "device"
+    with patch.object(null_transformer, '_derived_callbacks', {device_name: mock_class}):
+        with pytest.raises(
+            RuntimeError,
+            match=re.escape(f"Callback already set for {device_name}")
+            ):
+            null_transformer.set_callback(device_name, mock_class)
+
+
+@patch("ophyd_async.core._derived_signal.get_type_hints", return_value={})
+def test_get_return_datatype_no_type(movable_beamstop: MovableBeamstop):
+    with pytest.raises(
+        TypeError,
+        match=re.escape("does not have a type hint for it's return value")
+        ):
+        _get_return_datatype(movable_beamstop._get_position)
+
+
+def test_get_return_datatype(movable_beamstop: MovableBeamstop):
+    result = _get_return_datatype(movable_beamstop._get_position)
+    assert isinstance(result, StrictEnumMeta)
+
+
+@patch("ophyd_async.core._derived_signal.get_type_hints", return_value={})
+def test_get_first_arg_datatype_no_type(movable_beamstop: MovableBeamstop):
+    with pytest.raises(
+        TypeError,
+        match=re.escape("does not have a type hinted argument")
+        ):
+        _get_first_arg_datatype(movable_beamstop._set_from_position)
+
+
+def test_derived_signal_rw_type_error(movable_beamstop: MovableBeamstop):
+    with patch.object(movable_beamstop, '_set_from_position', movable_beamstop._get_position):  # noqa: E501
+        with pytest.raises(TypeError):
+            derived_signal_rw(movable_beamstop._get_position, movable_beamstop._set_from_position)  # noqa: E501

tests/epics/signal/test_signals.py

@@ -766,3 +766,25 @@ def a_plan():
                 assert yaml.safe_load(actual_file) == yaml.safe_load(expected_file)
 
     RE(a_plan())
+
+
+@pytest.mark.parametrize("protocol", get_args(Protocol))
+async def test_put_completion(
+    RE, ioc_devices: EpicsTestIocAndDevices, protocol: Protocol
+):
+    # Check that we can put to an epics signal and wait for put completion
+    slow_seq_pv = ioc_devices.get_pv(protocol, "slowseq")
+    slow_seq = epics_signal_rw(int, slow_seq_pv)
+    await slow_seq.connect()
+
+    # First, do a set with blocking and make sure it takes a while
+    start = time.time()
+    await slow_seq.set(1, wait=True)
+    stop = time.time()
+    assert stop - start == pytest.approx(0.5, rel=0.1)
+
+    # Then, make sure if we don't wait it returns ~instantly
+    start = time.time()
+    await slow_seq.set(2, wait=False)
+    stop = time.time()
+    assert stop - start < 0.1

tests/epics/signal/test_yaml_save_ca.yaml

@@ -2,6 +2,7 @@ bool_unnamed: true
 enum: Bbb
 enum2: Bbb
 enum_str_fallback: Bbb
+slowseq: 0
 float32a: [1.9999999949504854e-06, -123.12300109863281]
 float64a: [0.1, -12345678.123]
 float_prec_0: 3

tests/epics/signal/test_yaml_save_pva.yaml

@@ -4,6 +4,7 @@ enum2: Bbb
 enum_str_fallback: Bbb
 float32a: [1.9999999949504854e-06, -123.12300109863281]
 float64a: [0.1, -12345678.123]
+slowseq: 0
 float_prec_0: 3.0
 int16a: [-32768, 32767]
 int32a: [-2147483648, 2147483647]