Attach request to response in client (#163)

* Fix #162 Attach original request to response in client

* fix #161 - Bad static type in send_request

Author: pylessard

test/client/test_client.py

@@ -5,6 +5,7 @@
 from test.ClientServerTest import ClientServerTest
 import time
 
+
 class TestClient(ClientServerTest):
     def __init__(self, *args, **kwargs):
         ClientServerTest.__init__(self, *args, **kwargs)
@@ -13,7 +14,7 @@ def test_timeout_override(self):
         pass
 
     def _test_timeout_override(self):
-        req = Request(service = services.TesterPresent, subfunction=0) 
+        req = Request(service=services.TesterPresent, subfunction=0)
         timeout = 0.5
         try:
             t1 = time.time()
@@ -22,43 +23,43 @@ def _test_timeout_override(self):
         except TimeoutException as e:
             diff = time.time() - t1
             self.assertGreater(diff, timeout, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
-            self.assertLess(diff, timeout+0.5, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
+            self.assertLess(diff, timeout + 0.5, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
 
     # Server does not respond. Overall timeout is set smaller than P2 timeout. Overall timeout should trig
     def test_no_response_overall_timeout(self):
         pass
 
     def _test_no_response_overall_timeout(self):
-        req = Request(service = services.TesterPresent, subfunction=0) 
+        req = Request(service=services.TesterPresent, subfunction=0)
         timeout = 0.5
-        self.udsclient.set_configs({'request_timeout': timeout, 'p2_timeout' : 2, 'p2_star_timeout':2})
+        self.udsclient.set_configs({'request_timeout': timeout, 'p2_timeout': 2, 'p2_star_timeout': 2})
         try:
             t1 = time.time()
             response = self.udsclient.send_request(req)
             raise Exception('Request did not raise a TimeoutException')
         except TimeoutException as e:
             diff = time.time() - t1
             self.assertGreater(diff, timeout, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
-            self.assertLess(diff, timeout+0.5, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
+            self.assertLess(diff, timeout + 0.5, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
 
     # Server does not respond. P2 timeout is smaller than overall timeout. P2 timeout should trig
     def test_no_response_p2_timeout(self):
         pass
 
     def _test_no_response_p2_timeout(self):
-        req = Request(service = services.TesterPresent, subfunction=0) 
+        req = Request(service=services.TesterPresent, subfunction=0)
         timeout = 0.5
-        self.udsclient.set_configs({'request_timeout': 2, 'p2_timeout' : timeout, 'p2_star_timeout':2})
+        self.udsclient.set_configs({'request_timeout': 2, 'p2_timeout': timeout, 'p2_star_timeout': 2})
         try:
             t1 = time.time()
             response = self.udsclient.send_request(req)
             raise Exception('Request did not raise a TimeoutException')
         except TimeoutException as e:
             diff = time.time() - t1
             self.assertGreater(diff, timeout, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
-            self.assertLess(diff, timeout+0.5, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
+            self.assertLess(diff, timeout + 0.5, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
 
-    # Overall timeout is set to 0.5. Server respond "pendingResponse" for 1 sec. 
+    # Overall timeout is set to 0.5. Server respond "pendingResponse" for 1 sec.
     # Client should timeout first as we are setting respect_overall_timeout True.
     def test_overall_timeout_pending_response(self):
         if not hasattr(self, 'completed'):
@@ -71,9 +72,9 @@ def test_overall_timeout_pending_response(self):
             time.sleep(0.1)
 
     def _test_overall_timeout_pending_response(self):
-        req = Request(service = services.TesterPresent, subfunction=0) 
+        req = Request(service=services.TesterPresent, subfunction=0)
         timeout = 0.5
-        self.udsclient.set_configs({'request_timeout': timeout, 'p2_timeout' : 2, 'p2_star_timeout':2})
+        self.udsclient.set_configs({'request_timeout': timeout, 'p2_timeout': 2, 'p2_star_timeout': 2})
         try:
             t1 = time.time()
             response = self.udsclient.send_request(req)
@@ -83,7 +84,7 @@ def _test_overall_timeout_pending_response(self):
             self.completed = True
             diff = time.time() - t1
             self.assertGreater(diff, timeout, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
-            self.assertLess(diff, timeout+0.5, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
+            self.assertLess(diff, timeout + 0.5, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
 
     #  Sends 2 "pending response" response to switch to P2* timeout.
     def test_p2_star_timeout(self):
@@ -94,9 +95,9 @@ def test_p2_star_timeout(self):
         self.conn.fromuserqueue.put(response.get_payload())
 
     def _test_p2_star_timeout(self):
-        req = Request(service = services.TesterPresent, subfunction=0) 
+        req = Request(service=services.TesterPresent, subfunction=0)
         timeout = 2
-        self.udsclient.set_configs({'request_timeout': 5, 'p2_timeout' : 0.5, 'p2_star_timeout':timeout})
+        self.udsclient.set_configs({'request_timeout': 5, 'p2_timeout': 0.5, 'p2_star_timeout': timeout})
         try:
             t1 = time.time()
             response = self.udsclient.send_request(req)
@@ -106,12 +107,12 @@ def _test_p2_star_timeout(self):
             self.completed = True
             diff = time.time() - t1
             self.assertGreater(diff, timeout, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
-            self.assertLess(diff, timeout+0.5, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
+            self.assertLess(diff, timeout + 0.5, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
 
     # send RequestCorrectlyReceived_ResponsePending responses until well beyond overall_timeout to check response
     # This function is used in 2 tests:
     #  * checking there is a timeout when the overall_timeout is repected
-    #  * checking that the full transaction is allowed to complete with the overall_timeout is ignored 
+    #  * checking that the full transaction is allowed to complete with the overall_timeout is ignored
     def RCRRP_responses(self):
         self.conn.touserqueue.get(timeout=0.2)
         response = Response(service=services.TesterPresent, code=Response.Code.RequestCorrectlyReceived_ResponsePending)
@@ -121,15 +122,15 @@ def RCRRP_responses(self):
             time.sleep(0.1)
         response = Response(service=services.TesterPresent, code=Response.Code.PositiveResponse, data=bytes(2))
         self.conn.fromuserqueue.put(response.get_payload())
-    
+
     def RCRRP_responses_check(self, respect_overall_timeout):
-        req = Request(service = services.TesterPresent, subfunction=0) 
+        req = Request(service=services.TesterPresent, subfunction=0)
         overall_timeout = 2.0
         if not respect_overall_timeout:
             overall_timeout = None
         p2_star_timeout = 1.0
 
-        self.udsclient.set_configs({'request_timeout': overall_timeout, 'p2_timeout' : 0.5, 'p2_star_timeout':p2_star_timeout})
+        self.udsclient.set_configs({'request_timeout': overall_timeout, 'p2_timeout': 0.5, 'p2_star_timeout': p2_star_timeout})
 
         # Record our expectation on how long the timeout wlil be
         if respect_overall_timeout:
@@ -145,7 +146,7 @@ def RCRRP_responses_check(self, respect_overall_timeout):
             if respect_overall_timeout:
                 diff = time.time() - t1
                 self.assertGreater(diff, timeout, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
-                self.assertLess(diff, timeout+0.5, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
+                self.assertLess(diff, timeout + 0.5, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
                 self.assertIsNotNone(self.udsclient.last_response, 'Client never received the PendingResponse message')
             else:
                 raise Exception('Request raised a TimeoutException')
@@ -170,15 +171,15 @@ def _test_RCRRP_no_overall_timeout(self):
     def test_p2_star_timeout_overrided_by_diagnostic_session_control(self):
         self.conn.touserqueue.get(timeout=0.2)
         self.conn.fromuserqueue.put(b"\x50\x01\x03\xE8\x00\xC8")  # Respond to diagnostic session control with timeout of 2 sec
-        
+
         response = Response(service=services.TesterPresent, code=Response.Code.RequestCorrectlyReceived_ResponsePending)
         self.conn.fromuserqueue.put(response.get_payload())
         time.sleep(0.1)
         self.conn.fromuserqueue.put(response.get_payload())
 
     def _test_p2_star_timeout_overrided_by_diagnostic_session_control(self):
-        req = Request(service = services.TesterPresent, subfunction=0) 
-        self.udsclient.set_configs({'request_timeout': 5, 'p2_timeout' : 0.5, 'p2_star_timeout':1})
+        req = Request(service=services.TesterPresent, subfunction=0)
+        self.udsclient.set_configs({'request_timeout': 5, 'p2_timeout': 0.5, 'p2_star_timeout': 1})
         self.udsclient.change_session(1)
         timeout = 2
         try:
@@ -190,20 +191,19 @@ def _test_p2_star_timeout_overrided_by_diagnostic_session_control(self):
             self.completed = True
             diff = time.time() - t1
             self.assertGreater(diff, timeout, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
-            self.assertLess(diff, timeout+0.5, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
+            self.assertLess(diff, timeout + 0.5, 'Timeout raised after %.3f seconds when it should be %.3f sec' % (diff, timeout))
 
     def test_payload_override_literal(self):
         request = self.conn.touserqueue.get(timeout=0.2)
         self.assertEqual(request, b'\x12\x34\x56\x78')
         self.conn.fromuserqueue.put(b"\x7E\x00")
 
     def _test_payload_override_literal(self):
-        req = Request(service = services.TesterPresent, subfunction=0) 
+        req = Request(service=services.TesterPresent, subfunction=0)
         with self.udsclient.payload_override(b'\x12\x34\x56\x78'):
             response = self.udsclient.send_request(req)
             self.assertEqual(response.original_payload, b'\x7E\x00')
 
-
     def test_payload_override_func(self):
         request = self.conn.touserqueue.get(timeout=0.2)
         self.assertEqual(request, b'\x99\x88\x77\x66')
@@ -213,7 +213,16 @@ def _test_payload_override_func(self):
         def func(payload):
             return b'\x99\x88\x77\x66'
 
-        req = Request(service = services.TesterPresent, subfunction=0) 
+        req = Request(service=services.TesterPresent, subfunction=0)
         with self.udsclient.payload_override(func):
             response = self.udsclient.send_request(req)
-            self.assertEqual(response.original_payload, b'\x7E\x00')
+            self.assertEqual(response.original_payload, b'\x7E\x00')
+
+    def test_request_in_response(self):
+        self.conn.touserqueue.get(timeout=0.2)
+        self.conn.fromuserqueue.put(b"\x7E\x00")
+
+    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)

udsoncan/Request.py

@@ -1,5 +1,4 @@
 from udsoncan.BaseService import BaseService
-import udsoncan.tools as tools
 import inspect
 import struct
 
@@ -121,7 +120,7 @@ def from_payload(cls, payload: bytes) -> "Request":
         req = cls()
 
         if len(payload) >= 1:
-            req.service = tools.cls_from_request_id(payload[0])
+            req.service = BaseService.from_request_id(payload[0])
             if req.service is not None:		# Invalid service ID will make service None
                 offset = 0
                 if req.service.use_subfunction():

udsoncan/Response.py

@@ -3,6 +3,8 @@
 import inspect
 import struct
 
+from udsoncan.Request import Request
+
 from typing import Type, Optional, Union
 
 
@@ -35,6 +37,10 @@ class Response:
 
             (boolean) True if the response code is 0 (PositiveResponse), False otherwise
 
+    .. data:: unexpected 
+
+            (boolean) Indicates that the response was unexpected. Set by an external source such as the :ref:`Client<Client>` object            
+
     .. data:: code 
 
             (int) The response code. 
@@ -58,11 +64,10 @@ class Response:
 
             (bytes) When the response is built with `Response.from_payload`, this property contains a copy of the payload used. None otherwise.
 
-    .. data:: unexpected 
+    .. data:: original_request 
 
-            (boolean) Indicates that the response was unexpected. Set by an external source such as the :ref:`Client<Client>` object
+            (Request) Optional reference to the request object that generated this response.  """
 
-    """
     Code = ResponseCode
 
     service: Optional[Type[BaseService]]
@@ -71,6 +76,7 @@ class Response:
     suppress_positive_response: bool
     original_payload: Optional[bytes]
     service_data: Optional[BaseResponseData]
+    original_request: Optional[Request]
 
     def __init__(self,
                  service: Optional[Union[BaseService, Type[BaseService]]] = None,
@@ -93,6 +99,7 @@ def __init__(self,
         self.service_data = None
         self.original_payload = None
         self.unexpected = False
+        self.original_request = None
 
         if data is not None:
             if not isinstance(data, bytes):

udsoncan/client.py

@@ -100,7 +100,7 @@ def get_overrided_payload(self, original_payload: bytes) -> bytes:
     session_timing: SessionTiming
     logger: logging.Logger
 
-    def __init__(self, conn: BaseConnection, config: ClientConfig = default_client_config, request_timeout: Optional[bool] = None):
+    def __init__(self, conn: BaseConnection, config: ClientConfig = default_client_config, request_timeout: Optional[float] = None):
         self.conn = conn
         self.config = cast(ClientConfig, dict(config))  # Makes a copy of given configuration
 
@@ -2207,4 +2207,7 @@ def send_request(self, request: Request, timeout: int = -1) -> Optional[Response
         assert response.service is not None
         self.logger.info('Received positive response for service %s (0x%02x) from server.' %
                          (response.service.get_name(), response.service.request_id()))
+
+        response.original_request = request
+
         return response

udsoncan/tools.py

@@ -60,11 +60,3 @@ def check_io_config(didlist: Union[int, List[int]], ioconfig: Dict[Any, Any]) ->
             }
 
     return ioconfig
-
-
-def cls_from_request_id(given_id: int) -> Optional[Type[BaseService]]:
-    return BaseService.from_request_id(given_id)
-
-
-def is_valid_service(service_cls: Type) -> bool:
-    return issubclass(service_cls, BaseService)