fastcs/tests/backends/tango/test_dsr.py at 92f5e4689c727a9fd53a152540120b424c69567f · DiamondLightSource/fastcs · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
import pytest
from tango import DevState
from tango.test_context import DeviceTestContext

from fastcs.backends.tango.backend import TangoBackend


class TestTangoDevice:
    @pytest.fixture(scope="class")
    def tango_context(self, assertable_controller):
        # https://tango-controls.readthedocs.io/projects/pytango/en/v9.5.1/testing/test_context.html
        device = TangoBackend(assertable_controller)._dsr._device
        with DeviceTestContext(device) as proxy:
            yield proxy

    def test_list_attributes(self, tango_context):
        assert list(tango_context.get_attribute_list()) == [
            "BigEnum",
            "ReadBool",
            "ReadInt",
            "ReadWriteFloat",
            "ReadWriteInt",
            "StringEnum",
            "WriteBool",
            "SubController01_ReadInt",
            "SubController02_ReadInt",
            "State",
            "Status",
        ]

    def test_list_commands(self, tango_context):
        assert list(tango_context.get_command_list()) == [
            "Go",
            "Init",
            "State",
            "Status",
        ]

    def test_state(self, tango_context):
        assert tango_context.command_inout("State") == DevState.ON

    def test_status(self, tango_context):
        expect = "The device is in ON state."
        assert tango_context.command_inout("Status") == expect

    def test_read_int(self, assertable_controller, tango_context):
        expect = 0
        with assertable_controller.assert_read_here(["read_int"]):
            result = tango_context.read_attribute("ReadInt").value
        assert result == expect

    def test_read_write_int(self, assertable_controller, tango_context):
        expect = 0
        with assertable_controller.assert_read_here(["read_write_int"]):
            result = tango_context.read_attribute("ReadWriteInt").value
        assert result == expect
        new = 9
        with assertable_controller.assert_write_here(["read_write_int"]):
            tango_context.write_attribute("ReadWriteInt", new)
        assert tango_context.read_attribute("ReadWriteInt").value == new

    def test_read_write_float(self, assertable_controller, tango_context):
        expect = 0.0
        with assertable_controller.assert_read_here(["read_write_float"]):
            result = tango_context.read_attribute("ReadWriteFloat").value
        assert result == expect
        new = 0.5
        with assertable_controller.assert_write_here(["read_write_float"]):
            tango_context.write_attribute("ReadWriteFloat", new)
        assert tango_context.read_attribute("ReadWriteFloat").value == new

    def test_read_bool(self, assertable_controller, tango_context):
        expect = False
        with assertable_controller.assert_read_here(["read_bool"]):
            result = tango_context.read_attribute("ReadBool").value
        assert result == expect

    def test_write_bool(self, assertable_controller, tango_context):
        with assertable_controller.assert_write_here(["write_bool"]):
            tango_context.write_attribute("WriteBool", True)

    def test_string_enum(self, assertable_controller, tango_context):
        expect = ""
        with assertable_controller.assert_read_here(["string_enum"]):
            result = tango_context.read_attribute("StringEnum").value
        assert result == expect
        new = "new"
        with assertable_controller.assert_write_here(["string_enum"]):
            tango_context.write_attribute("StringEnum", new)
        assert tango_context.read_attribute("StringEnum").value == new

    def test_big_enum(self, assertable_controller, tango_context):
        expect = 0
        with assertable_controller.assert_read_here(["big_enum"]):
            result = tango_context.read_attribute("BigEnum").value
        assert result == expect

    def test_go(self, assertable_controller, tango_context):
        with assertable_controller.assert_execute_here(["go"]):
            tango_context.command_inout("Go")

    def test_read_child1(self, assertable_controller, tango_context):
        expect = 0
        with assertable_controller.assert_read_here(["SubController01", "read_int"]):
            result = tango_context.read_attribute("SubController01_ReadInt").value
        assert result == expect

    def test_read_child2(self, assertable_controller, tango_context):
        expect = 0
        with assertable_controller.assert_read_here(["SubController02", "read_int"]):
            result = tango_context.read_attribute("SubController02_ReadInt").value
        assert result == expect