Rewrite internal use of process flag

Author: AlexanderWells-diamond

softioc/device.py

@@ -178,7 +178,6 @@ def __init__(self, name, **kargs):
 
         self.__validate = kargs.pop('validate', None)
         self.__always_update = kargs.pop('always_update', False)
-        self.__enable_write = True
 
         if 'initial_value' in kargs:
             value = self._value_to_epics(kargs.pop('initial_value'))
@@ -239,8 +238,7 @@ def _process(self, record):
             return EPICS_OK
 
         python_value = self._epics_to_value(value)
-        if self.__enable_write and self.__validate and \
-                not self.__validate(self, python_value):
+        if self.__validate and not self.__validate(self, python_value):
             # Asynchronous validation rejects value, so restore the last good
             # value.
             self._write_value(record, self._value[0])
@@ -249,7 +247,7 @@ def _process(self, record):
             # Value is good.  Hang onto it, let users know the value has changed
             self._value = (value, severity, alarm)
             record.UDF = 0
-            if self.__on_update and self.__enable_write:
+            if self.__on_update:
                 record.PACT = self._blocking
                 dispatcher(
                     self.__on_update,
@@ -287,9 +285,15 @@ def set(self, value, process=True,
         else:
             # The array parameter is used to keep the raw pointer alive
             dbf_code, length, data, array = self._value_to_dbr(value)
-            self.__enable_write = process
+
+            # If we do process we instead do this inside _process, allowing
+            # validation to potentially refuse the update.
+            # However if we do not process, we must do this here to keep the
+            # Python and EPICS values in line
+            if not process:
+                self._value = (value, severity, alarm)
+
             db_put_field_process(_record.NAME, dbf_code, data, length, process)
-            self.__enable_write = True
 
     def get(self):
         return self._epics_to_value(self._value[0])

tests/test_records.py

@@ -381,10 +381,12 @@ def out_records(self, request):
 
     def validate_always_pass(self, record, new_val):
         """Validation method that always allows changes"""
+        log("VALIDATE: Returning True")
         return True
 
     def validate_always_fail(self, record, new_val):
         """Validation method that always rejects changes"""
+        log("VALIDATE: Returning False")
         return False
 
     def validate_ioc_test_func(
@@ -446,7 +448,6 @@ def validate_test_runner(
             # Wait for message that IOC has started
             select_and_recv(parent_conn, "R")
 
-
             # Suppress potential spurious warnings
             _channel_cache.purge()
 
@@ -1553,3 +1554,92 @@ def test_set_alarm_severity_status(self, set_enum):
             _channel_cache.purge()
             parent_conn.send("D")  # "Done"
             process.join(timeout=TIMEOUT)
+
+
+class TestProcess:
+    """Tests related to processing - checking values are as expected
+    between the EPICS and Python layers. """
+
+    test_result_rec = "TestResult"
+
+
+    def process_test_function(self, device_name, conn, process):
+        builder.SetDeviceName(device_name)
+
+        rec = builder.longOut("TEST", initial_value=5)
+
+        # Record to indicate success/failure
+        bi = builder.boolIn(self.test_result_rec, ZNAM="FAILED", ONAM="SUCCESS")
+
+        builder.LoadDatabase()
+        softioc.iocInit()
+
+        # Prove value changes from .set call
+        rec.set(10, process=process)
+
+        conn.send("R")  # "Ready"
+        log("CHILD: Sent R over Connection to Parent")
+
+        select_and_recv(conn, "R")
+
+        val = rec.get()
+        log(f"CHILD: record value is {val}")
+
+        # value should be that which was set by .set()
+        if val == 10:
+            bi.set(1)
+        else:
+            bi.set(0)
+
+        # Keep process alive while main thread works.
+        while (True):
+            if conn.poll(TIMEOUT):
+                val = conn.recv()
+                if val == "D":  # "Done"
+                    break
+
+    @requires_cothread
+    @pytest.mark.parametrize("process", [True, False])
+    def test_set_alarm_severity_status(self, process):
+        """Test that set_alarm function allows setting severity and status"""
+        ctx = get_multiprocessing_context()
+        parent_conn, child_conn = ctx.Pipe()
+
+        device_name = create_random_prefix()
+
+        process = ctx.Process(
+            target=self.process_test_function,
+            args=(device_name, child_conn, process),
+        )
+
+        process.start()
+
+        from cothread.catools import caget, _channel_cache
+        from cothread import Sleep
+
+        try:
+            # Wait for message that IOC has started
+            select_and_recv(parent_conn, "R")
+
+            # Suppress potential spurious warnings
+            _channel_cache.purge()
+
+            record = device_name + ":TEST"
+            val = caget(record, timeout=TIMEOUT)
+
+            assert val == 10
+
+            parent_conn.send("R")  # "Ready"
+
+            Sleep(0.5)  # Give child time to process update
+
+            result_record = device_name + f":{self.test_result_rec}"
+            val = caget(result_record)
+
+            assert val == 1, "Success record indicates failure"
+
+        finally:
+            # Suppress potential spurious warnings
+            _channel_cache.purge()
+            parent_conn.send("D")  # "Done"
+            process.join(timeout=TIMEOUT)