Remaining test fixes for async conversion

Awaited on functions where required. I also had to switch to
AsyncMock from MagicMock anywhere that a function needed
to return a coroutine.

Author: ptsOSL

tests/conftest.py

@@ -1,6 +1,3 @@
-import asyncio
-import sys
-import types
 from unittest import mock
 
 import pytest
@@ -28,15 +25,21 @@
 def x_device():
     x_device = mock.MagicMock()
     x_device.name = "x_device"
+    x_device.get_value = mock.AsyncMock()
     x_device.get_value.return_value = DUMMY_VALUE_1
+    x_device.set_value = mock.AsyncMock()
+
     return x_device
 
 
 @pytest.fixture
 def y_device():
     y_device = mock.MagicMock()
     y_device.name = "y_device"
+    y_device.get_value = mock.AsyncMock()
     y_device.get_pv_name.return_value = SP_PV
+    y_device.set_value = mock.AsyncMock()
+
     return y_device
 
 
@@ -45,7 +48,11 @@ def y_device():
 def mock_sim_data_source():
     mock_sim_data_source = mock.MagicMock()
     mock_sim_data_source.units = pytac.PHYS
+
+    mock_sim_data_source.get_value = mock.AsyncMock()
     mock_sim_data_source.get_value.return_value = DUMMY_VALUE_2
+    mock_sim_data_source.set_value = mock.AsyncMock()
+
     return mock_sim_data_source
 
 
@@ -108,8 +115,7 @@ async def diad_ring():
 
 @pytest.fixture
 async def lattice():
-    lat = await load_csv.load("dummy", mock.MagicMock(), CURRENT_DIR_PATH / "data", 2)
-    return lat
+    return await load_csv.load("dummy", mock.MagicMock(), CURRENT_DIR_PATH / "data", 2)
 
 
 def set_func(pvs, values, throw=None):
@@ -120,8 +126,11 @@ def set_func(pvs, values, throw=None):
 @pytest.fixture
 def mock_cs():
     cs = mock.MagicMock()
+    cs.get_single = mock.AsyncMock()
     cs.get_single.return_value = DUMMY_VALUE_1
+    cs.get_multiple = mock.AsyncMock()
     cs.get_multiple.return_value = DUMMY_ARRAY
+    cs.set_multiple = mock.AsyncMock()
     cs.set_multiple.side_effect = set_func
     return cs
 

tests/test_aioca_cs.py

@@ -1,35 +1,37 @@
-"""Tests for the AIOCAControlSystem class.
-"""
+"""Tests for the AIOCAControlSystem class."""
+
+from unittest.mock import MagicMock, patch
 
-from unittest.mock import patch, MagicMock
 import pytest
 from constants import RB_PV, SP_PV
 from testfixtures import LogCapture
 
 import pytac
 from pytac.aioca_cs import AIOCAControlSystem
 
+
 class CANothing(Exception):
     """A minimal mock of the cothread CANothing exception class."""
 
     def __init__(self, name, errorcode=True):
         self.ok = errorcode
         self.name = name
 
+
 @pytest.fixture
 def cs():
     return AIOCAControlSystem(wait=True, timeout=2.0)
 
 
 @patch("pytac.aioca_cs.caget")
-async def test_get_single_calls_caget_correctly(caget:MagicMock, cs):
+async def test_get_single_calls_caget_correctly(caget: MagicMock, cs):
     caget.return_value = 42
     assert (await cs.get_single(RB_PV)) == 42
     caget.assert_called_with(RB_PV, throw=True, timeout=2.0)
 
 
 @patch("pytac.aioca_cs.caget")
-async def test_get_multiple_calls_caget_correctly(caget:MagicMock, cs):
+async def test_get_multiple_calls_caget_correctly(caget: MagicMock, cs):
     """caget is called with throw=False despite throw=True being the default
     for get_multiple as we always want our get operation to fully complete,
     rather than being stopped halway through by an error raised from
@@ -42,13 +44,13 @@ async def test_get_multiple_calls_caget_correctly(caget:MagicMock, cs):
 
 
 @patch("pytac.aioca_cs.caput")
-async def test_set_single_calls_caput_correctly(caput:MagicMock, cs):
+async def test_set_single_calls_caput_correctly(caput: MagicMock, cs):
     assert await cs.set_single(SP_PV, 42) is True
     caput.assert_called_with(SP_PV, 42, throw=True, timeout=2.0, wait=True)
 
 
 @patch("pytac.aioca_cs.caput")
-async def test_set_multiple_calls_caput_correctly(caput:MagicMock, cs):
+async def test_set_multiple_calls_caput_correctly(caput: MagicMock, cs):
     """caput is called with throw=False despite throw=True being the default
     for set_multiple as we always want our set operation to fully complete,
     rather than being stopped halway through by an error raised from
@@ -63,7 +65,7 @@ async def test_set_multiple_calls_caput_correctly(caput:MagicMock, cs):
 
 @patch("pytac.aioca_cs.caget")
 @patch("pytac.aioca_cs.CANothing", CANothing)
-async def test_get_multiple_raises_ControlSystemException(caget:MagicMock, cs):
+async def test_get_multiple_raises_ControlSystemException(caget: MagicMock, cs):
     """Here we check that errors are thrown, suppressed and logged correctly."""
     caget.return_value = [12, CANothing("pv", False)]
     with pytest.raises(pytac.exceptions.ControlSystemException):
@@ -75,19 +77,22 @@ async def test_get_multiple_raises_ControlSystemException(caget:MagicMock, cs):
 
 @patch("pytac.aioca_cs.caput")
 @patch("pytac.aioca_cs.CANothing", CANothing)
-async def test_set_multiple_raises_ControlSystemException(caput:MagicMock, cs):
+async def test_set_multiple_raises_ControlSystemException(caput: MagicMock, cs):
     """Here we check that errors are thrown, suppressed and logged correctly."""
     caput.return_value = [CANothing("pv1", True), CANothing("pv2", False)]
     with pytest.raises(pytac.exceptions.ControlSystemException):
         await cs.set_multiple([RB_PV, SP_PV], [42, 6])
     with LogCapture() as log:
-        assert await cs.set_multiple([RB_PV, SP_PV], [42, 6], throw=False) == [True, False]
+        assert await cs.set_multiple([RB_PV, SP_PV], [42, 6], throw=False) == [
+            True,
+            False,
+        ]
     log.check(("root", "WARNING", "Cannot connect to pv2."))
 
 
 @patch("pytac.aioca_cs.caget")
 @patch("pytac.aioca_cs.CANothing", CANothing)
-async def test_get_single_raises_ControlSystemException(caget:MagicMock, cs):
+async def test_get_single_raises_ControlSystemException(caget: MagicMock, cs):
     """Here we check that errors are thrown, suppressed and logged correctly."""
     caget.side_effect = CANothing("pv", False)
     with LogCapture() as log:
@@ -99,7 +104,7 @@ async def test_get_single_raises_ControlSystemException(caget:MagicMock, cs):
 
 @patch("pytac.aioca_cs.caput")
 @patch("pytac.aioca_cs.CANothing", CANothing)
-async def test_set_single_raises_ControlSystemException(caput:MagicMock, cs):
+async def test_set_single_raises_ControlSystemException(caput: MagicMock, cs):
     """Here we check that errors are thrown, suppressed and logged correctly."""
     caput.side_effect = CANothing("pv", False)
     with LogCapture() as log:

tests/test_data_source.py

@@ -32,9 +32,9 @@ def test_get_fields(simple_object, request):
 @pytest.mark.parametrize(
     "simple_object", ["simple_element", "simple_lattice", "simple_data_source_manager"]
 )
-def test_set_value(simple_object, request):
+async def test_set_value(simple_object, request):
     simple_object = request.getfixturevalue(simple_object)
-    simple_object.set_value("x", DUMMY_VALUE_2, pytac.ENG, pytac.LIVE)
+    await simple_object.set_value("x", DUMMY_VALUE_2, pytac.ENG, pytac.LIVE)
     simple_object.get_device("x").set_value.assert_called_with(DUMMY_VALUE_2, True)
 
 
@@ -44,14 +44,15 @@ def test_set_value(simple_object, request):
 async def test_get_value_sim(simple_object, request):
     simple_object = request.getfixturevalue(simple_object)
     assert (
-        await simple_object.get_value("x", pytac.RB, pytac.PHYS, pytac.SIM) == DUMMY_VALUE_2
+        await simple_object.get_value("x", pytac.RB, pytac.PHYS, pytac.SIM)
+        == DUMMY_VALUE_2
     )
 
 
 @pytest.mark.parametrize(
     "simple_object", ["simple_element", "simple_lattice", "simple_data_source_manager"]
 )
-def test_unit_conversion(simple_object, double_uc, request):
+async def test_unit_conversion(simple_object, double_uc, request):
     simple_object = request.getfixturevalue(simple_object)
-    simple_object.set_value("y", DUMMY_VALUE_2, pytac.PHYS, pytac.LIVE)
+    await simple_object.set_value("y", DUMMY_VALUE_2, pytac.PHYS, pytac.LIVE)
     simple_object.get_device("y").set_value.assert_called_with(DUMMY_VALUE_2 / 2, True)

tests/test_device.py

@@ -10,6 +10,8 @@
 
 def create_epics_device(prefix=PREFIX, rb_pv=RB_PV, sp_pv=SP_PV, enabled=True):
     mock_cs = mock.MagicMock()
+    mock_cs.set_single = mock.AsyncMock()
+    mock_cs.get_single = mock.AsyncMock()
     mock_cs.get_single.return_value = 40.0
     device = EpicsDevice(prefix, mock_cs, enabled=enabled, rb_pv=rb_pv, sp_pv=sp_pv)
     return device
@@ -21,27 +23,27 @@ def create_simple_device(value=1.0, enabled=True):
 
 
 # Epics device specific tests.
-def test_set_epics_device_value():
+async def test_set_epics_device_value():
     device = create_epics_device()
-    device.set_value(40)
+    await device.set_value(40)
     device._cs.set_single.assert_called_with(SP_PV, 40, True)
 
 
-def test_get_epics_device_value():
+async def test_get_epics_device_value():
     device = create_epics_device()
-    assert device.get_value(pytac.SP) == 40.0
+    assert await device.get_value(pytac.SP) == 40.0
 
 
-def test_epics_device_invalid_sp_raises_exception():
+async def test_epics_device_invalid_sp_raises_exception():
     device2 = create_epics_device(PREFIX, RB_PV, None)
     with pytest.raises(pytac.exceptions.HandleException):
-        device2.set_value(40)
+        await device2.set_value(40)
 
 
-def test_get_epics_device_value_invalid_handle_raises_exception():
+async def test_get_epics_device_value_invalid_handle_raises_exception():
     device = create_epics_device()
     with pytest.raises(pytac.exceptions.HandleException):
-        device.get_value("non_existent")
+        await device.get_value("non_existent")
 
 
 # Simple device specific tests.
@@ -93,8 +95,8 @@ def test_device_is_enabled_returns_bool_value(device_creation_function):
 
 
 # PvEnabler test.
-def test_PvEnabler(mock_cs):
+async def test_PvEnabler(mock_cs):
     pve = PvEnabler("enable-pv", 40, mock_cs)
-    assert pve
+    assert await pve.is_enabled()
     mock_cs.get_single.return_value = 50
-    assert not pve
+    assert not await pve.is_enabled()

tests/test_element.py

@@ -96,49 +96,51 @@ async def test_get_value_uses_uc_if_necessary_for_cs_call(simple_element, double
     ) == (DUMMY_VALUE_1 * 2)
 
 
-def test_get_value_uses_uc_if_necessary_for_sim_call(simple_element, double_uc):
+async def test_get_value_uses_uc_if_necessary_for_sim_call(simple_element, double_uc):
     simple_element._data_source_manager._uc["x"] = double_uc
-    assert simple_element.get_value(
+    assert await simple_element.get_value(
         "x", handle=pytac.SP, units=pytac.ENG, data_source=pytac.SIM
     ) == (DUMMY_VALUE_2 / 2)
     simple_element._data_source_manager._data_sources[
         pytac.SIM
     ].get_value.assert_called_with("x", pytac.SP, True)
 
 
-def test_set_value_eng(simple_element):
-    simple_element.set_value("x", DUMMY_VALUE_2)
+async def test_set_value_eng(simple_element):
+    await simple_element.set_value("x", DUMMY_VALUE_2)
     # No conversion needed
     simple_element.get_device("x").set_value.assert_called_with(DUMMY_VALUE_2, True)
 
 
-def test_set_value_phys(simple_element, double_uc):
+async def test_set_value_phys(simple_element, double_uc):
     simple_element._data_source_manager._uc["x"] = double_uc
-    simple_element.set_value("x", DUMMY_VALUE_2, units=pytac.PHYS)
+    await simple_element.set_value("x", DUMMY_VALUE_2, units=pytac.PHYS)
     # Conversion fron physics to engineering units
     simple_element.get_device("x").set_value.assert_called_with(DUMMY_VALUE_2 / 2, True)
 
 
-def test_set_exceptions(simple_element, unit_uc):
+async def test_set_exceptions(simple_element, unit_uc):
     with pytest.raises(pytac.exceptions.FieldException):
-        simple_element.set_value("unknown_field", 40.0)
+        await simple_element.set_value("unknown_field", 40.0)
     with pytest.raises(pytac.exceptions.DataSourceException):
-        simple_element.set_value("y", 40.0, data_source="unknown_data_source")
+        await simple_element.set_value("y", 40.0, data_source="unknown_data_source")
     simple_element._data_source_manager._uc["uc_but_no_data_source"] = unit_uc
     with pytest.raises(pytac.exceptions.FieldException):
-        simple_element.set_value("uc_but_no_data_source", 40.0)
+        await simple_element.set_value("uc_but_no_data_source", 40.0)
 
 
-def test_get_exceptions(simple_element):
+async def test_get_exceptions(simple_element):
     with pytest.raises(pytac.exceptions.FieldException):
-        simple_element.get_value("unknown_field", "setpoint")
+        await simple_element.get_value("unknown_field", "setpoint")
     with pytest.raises(pytac.exceptions.DataSourceException):
-        simple_element.get_value("y", "setpoint", data_source="unknown_data_source")
+        await simple_element.get_value(
+            "y", "setpoint", data_source="unknown_data_source"
+        )
 
 
-def test_identity_conversion(simple_element):
-    value_physics = simple_element.get_value("x", "setpoint", pytac.PHYS)
-    value_machine = simple_element.get_value("x", "setpoint", pytac.ENG)
+async def test_identity_conversion(simple_element):
+    value_physics = await simple_element.get_value("x", "setpoint", pytac.PHYS)
+    value_machine = await simple_element.get_value("x", "setpoint", pytac.ENG)
     assert value_machine == DUMMY_VALUE_1
     assert value_physics == DUMMY_VALUE_1