Support wait NRC when suppress_positive_response is set (#174)

Fixes #174

Author: pylessard

doc/source/udsoncan/client.rst

@@ -256,12 +256,23 @@ The ``Client`` object lets you use that feature by using ``suppress_positive_res
 
 .. code-block:: python
 
-   with client.suppress_positive_response:
-      client.tester_present()
-
-When ``suppress_positive_response`` is asking for a service using a subfunction byte, the client will set suppressPosRspMsgIndicationBit before sending the request. The client will not wait for any response and will disregard negative responses if they happen. The response returned by the client function will always be ``None`` in that case.
-
-If ``suppress_positive_response`` is asking for a service with no subfunction byte, the directive will be ignored and a warning message will be logged.
+    with client.suppress_positive_response(wait_nrc=False):
+        client.tester_present()   # Will not wait for a response and always return None
+    
+    with client.suppress_positive_response(wait_nrc=True):
+        client.tester_present()   # Will wait in case an NRC is returned. 
+
+When ``suppress_positive_response`` is askied for a service using a subfunction byte, the client will set suppressPosRspMsgIndicationBit before sending the request. 
+If `wait_nrc` is `False` (default value), the client will not wait for any response and will disregard positive and negative responses if they happen. 
+The response returned by the client function will always be ``None`` in that case.
+
+If `wait_nrc` is `True`, the client will wait to see if a negative response is returned. In that scenario
+ - No timeout will be raised if no response is received
+ - If a positive response is received, it will not be validated and `None` will be returned
+ - If a negative response is received, the normal processing will happen. Meaning either the response will be returned or a `NegativeResponseException` 
+ will be raised, depending on :ref:`exception_on_negative_response<config_exception_on_negative_response>` parameter.
+
+If ``suppress_positive_response`` is askied for a service with no subfunction byte, the directive will be ignored and a warning message will be logged.
 
 -----
 

test/client/test_client.py

@@ -226,3 +226,58 @@ def _test_request_in_response(self):
         req = Request(service=services.TesterPresent, subfunction=0)
         response = self.udsclient.send_request(req)
         self.assertIs(response.original_request, req)
+
+    def test_suppress_positive_response(self):
+        self.conn.touserqueue.get(timeout=0.2)
+        self.conn.fromuserqueue.put(b"\x7E\x00")
+
+    def _test_suppress_positive_response(self):
+        req = Request(service=services.TesterPresent, subfunction=0)
+        with self.udsclient.suppress_positive_response:
+            response = self.udsclient.send_request(req)
+            self.assertIsNone(response)
+        self.conn.fromuserqueue.get()   # Make sure to not exit too quick
+
+    def test_suppress_positive_response_wait_nrc_case1(self):
+        self.conn.touserqueue.get(timeout=0.2)
+        self.conn.fromuserqueue.put(b"\x7E\x00")
+
+    def _test_suppress_positive_response_wait_nrc_case1(self):
+        # Case 1 - Positive
+        req = Request(service=services.TesterPresent, subfunction=0)
+        with self.udsclient.suppress_positive_response(wait_nrc=False):
+            response = self.udsclient.send_request(req)
+            self.assertIsNone(response)
+        self.conn.fromuserqueue.get()   # Make sure to not exit too quick
+
+    def test_suppress_positive_response_wait_nrc_case2(self):
+        self.conn.touserqueue.get(timeout=0.2)
+        self.conn.fromuserqueue.put(b"\x7E\x00")
+
+    def _test_suppress_positive_response_wait_nrc_case2(self):
+        # Case 2 - Negative no wait
+        req = Request(service=services.TesterPresent, subfunction=0)
+        with self.udsclient.suppress_positive_response(wait_nrc=False):
+            response = self.udsclient.send_request(req)
+            self.assertIsNone(response)
+        self.conn.fromuserqueue.get()   # Make sure to not exit too quick
+
+    def test_suppress_positive_response_wait_nrc_case3(self):
+        self.conn.touserqueue.get(timeout=0.2)
+        self.conn.fromuserqueue.put(b"\x7F\x3E\x31")
+
+    def _test_suppress_positive_response_wait_nrc_case3(self):
+        # Case 3 - Negative and wait
+        req = Request(service=services.TesterPresent, subfunction=0)
+        with self.assertRaises(NegativeResponseException):
+            with self.udsclient.suppress_positive_response(wait_nrc=True):
+                self.udsclient.send_request(req)
+
+    def test_suppress_positive_response_wait_nrc_case4(self):
+        pass
+
+    def _test_suppress_positive_response_wait_nrc_case4(self):
+        # Case 4 - No response is OK
+        req = Request(service=services.TesterPresent, subfunction=0)
+        with self.udsclient.suppress_positive_response(wait_nrc=True):
+            self.udsclient.send_request(req)

udsoncan/client.py

@@ -54,16 +54,23 @@ class Client:
 
     class SuppressPositiveResponse:
         enabled: bool
+        wait_nrc: bool
 
         def __init__(self):
             self.enabled = False
+            self.wait_nrc = False
+
+        def __call__(self, wait_nrc: bool = False):
+            self.wait_nrc = wait_nrc
+            return self
 
         def __enter__(self):
             self.enabled = True
             return self
 
         def __exit__(self, type, value, traceback):
             self.enabled = False
+            self.wait_nrc = None
 
     class PayloadOverrider:
         modifier: Optional[Union[Callable, bytes]]
@@ -2132,13 +2139,18 @@ def send_request(self, request: Request, timeout: int = -1) -> Optional[Response
 
         self.conn.send(payload)
 
-        if request.suppress_positive_response or override_suppress_positive_response:
+        spr_used = request.suppress_positive_response or override_suppress_positive_response
+        wait_nrc = self.suppress_positive_response.enabled and self.suppress_positive_response.wait_nrc
+
+        if spr_used and not wait_nrc:
             return None
 
         done_receiving = False
         if respect_overall_timeout:
             overall_timeout_time = time.time() + overall_timeout
-        while not done_receiving:
+
+        timed_out = False
+        while not done_receiving and not timed_out:
             done_receiving = True
             self.logger.debug("Waiting for server response")
 
@@ -2158,11 +2170,17 @@ def send_request(self, request: Request, timeout: int = -1) -> Optional[Response
                     timeout_name_to_report = 'Global request timeout'
                 else:  # Shouldn't go here.
                     timeout_name_to_report = 'Timeout'
-                raise TimeoutException('Did not receive response in time. %s time has expired (timeout=%.3f sec)' %
-                                       (timeout_name_to_report, timeout_value))
+                timed_out = True
+
             except Exception as e:
                 raise e
 
+            if timed_out:
+                if spr_used:
+                    return None
+                raise TimeoutException('Did not receive response in time. %s time has expired (timeout=%.3f sec)' %
+                                       (timeout_name_to_report, timeout_value))
+
             response = Response.from_payload(payload)
             self.last_response = response
             self.logger.debug("Received response from server")
@@ -2210,4 +2228,7 @@ def send_request(self, request: Request, timeout: int = -1) -> Optional[Response
 
         response.original_request = request
 
+        if spr_used:
+            return None
+
         return response