improve validate_member uses

slight improvement - taking advantage of a member value being returned by validate_member method

Author: mdabrowski1990

tests/software_tests/can/test_extended_addressing_information.py

@@ -71,7 +71,7 @@ def test_validate_packet_ai__valid(self, addressing_type, can_id, target_address
                                                                    can_id=can_id,
                                                                    target_address=target_address) == {
             AbstractCanAddressingInformation.ADDRESSING_FORMAT_NAME: CanAddressingFormat.EXTENDED_ADDRESSING,
-            AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: addressing_type,
+            AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: self.mock_validate_addressing_type.return_value,
             AbstractCanAddressingInformation.CAN_ID_NAME: can_id,
             AbstractCanAddressingInformation.TARGET_ADDRESS_NAME: target_address,
             AbstractCanAddressingInformation.SOURCE_ADDRESS_NAME: None,

tests/software_tests/can/test_normal_addressing_information.py

@@ -66,7 +66,7 @@ def test_validate_packet_ai__valid(self, addressing_type, can_id):
         assert Normal11BitCanAddressingInformation.validate_packet_ai(addressing_type=addressing_type,
                                                                       can_id=can_id) == {
                    AbstractCanAddressingInformation.ADDRESSING_FORMAT_NAME: CanAddressingFormat.NORMAL_11BIT_ADDRESSING,
-                   AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: addressing_type,
+                   AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: self.mock_validate_addressing_type.return_value,
                    AbstractCanAddressingInformation.CAN_ID_NAME: can_id,
                    AbstractCanAddressingInformation.TARGET_ADDRESS_NAME: None,
                    AbstractCanAddressingInformation.SOURCE_ADDRESS_NAME: None,
@@ -159,7 +159,7 @@ def test_validate_packet_ai__valid_without_can_id(self, addressing_type, target_
                                                                       target_address=target_address,
                                                                       source_address=source_address) == {
             AbstractCanAddressingInformation.ADDRESSING_FORMAT_NAME: CanAddressingFormat.NORMAL_FIXED_ADDRESSING,
-            AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: addressing_type,
+            AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: self.mock_validate_addressing_type.return_value,
             AbstractCanAddressingInformation.CAN_ID_NAME: self.mock_can_id_handler_class.encode_normal_fixed_addressed_can_id.return_value,
             AbstractCanAddressingInformation.TARGET_ADDRESS_NAME: target_address,
             AbstractCanAddressingInformation.SOURCE_ADDRESS_NAME: source_address,
@@ -170,7 +170,7 @@ def test_validate_packet_ai__valid_without_can_id(self, addressing_type, target_
         self.mock_can_id_handler_class.validate_can_id.assert_not_called()
         self.mock_can_id_handler_class.decode_normal_fixed_addressed_can_id.assert_not_called()
         self.mock_can_id_handler_class.encode_normal_fixed_addressed_can_id.assert_called_once_with(
-            addressing_type=addressing_type,
+            addressing_type=self.mock_validate_addressing_type.return_value,
             target_address=target_address,
             source_address=source_address
         )
@@ -187,7 +187,7 @@ def test_validate_packet_ai__valid_with_can_id(self, addressing_type, can_id, ta
         decoded_target_address = target_address or "ta"
         decoded_source_address = source_address or "sa"
         self.mock_can_id_handler_class.decode_normal_fixed_addressed_can_id.return_value = {
-            self.mock_can_id_handler_class.ADDRESSING_TYPE_NAME: addressing_type,
+            self.mock_can_id_handler_class.ADDRESSING_TYPE_NAME: self.mock_validate_addressing_type.return_value,
             self.mock_can_id_handler_class.TARGET_ADDRESS_NAME: decoded_target_address,
             self.mock_can_id_handler_class.SOURCE_ADDRESS_NAME: decoded_source_address,
         }
@@ -196,7 +196,7 @@ def test_validate_packet_ai__valid_with_can_id(self, addressing_type, can_id, ta
                                                                       target_address=target_address,
                                                                       source_address=source_address) == {
             AbstractCanAddressingInformation.ADDRESSING_FORMAT_NAME: CanAddressingFormat.NORMAL_FIXED_ADDRESSING,
-            AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: addressing_type,
+            AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: self.mock_validate_addressing_type.return_value,
             AbstractCanAddressingInformation.CAN_ID_NAME: can_id,
             AbstractCanAddressingInformation.TARGET_ADDRESS_NAME: decoded_target_address,
             AbstractCanAddressingInformation.SOURCE_ADDRESS_NAME: decoded_source_address,

tests/software_tests/packet/test_can_packet_type.py

@@ -24,10 +24,12 @@ def test_inheritance__abstract_packet_type(self):
 
     @pytest.mark.parametrize("value", [2, 3, CanPacketType.CONSECUTIVE_FRAME, CanPacketType.FLOW_CONTROL])
     def test_is_initial_packet_type__false(self, value):
+        self.mock_validate_member.side_effect = lambda arg: arg
         assert CanPacketType.is_initial_packet_type(value) is False
         self.mock_validate_member.assert_called_once_with(value)
 
     @pytest.mark.parametrize("value", [0, 1, CanPacketType.FIRST_FRAME, CanPacketType.SINGLE_FRAME])
     def test_is_initial_packet_type__true(self, value):
+        self.mock_validate_member.side_effect = lambda arg: arg
         assert CanPacketType.is_initial_packet_type(value) is True
         self.mock_validate_member.assert_called_once_with(value)

tests/software_tests/utilities/test_bytes_operations.py

@@ -40,6 +40,7 @@ def teardown_method(self):
         ([0x98, 0x76, 0x54, 0x32, 0x1F], Endianness.LITTLE_ENDIAN, 0x1F32547698),
     ])
     def test_bytes_list_to_int(self, bytes_list, endianness, expected_output):
+        self.mock_validate_endianness.side_effect = lambda arg: arg
         assert bytes_list_to_int(bytes_list=bytes_list, endianness=endianness) == expected_output
         self.mock_validate_raw_bytes.assert_called_once_with(bytes_list)
         self.mock_validate_endianness.assert_called_once_with(endianness)

uds/can/extended_addressing_information.py

@@ -46,7 +46,7 @@ def validate_packet_ai(cls,
         if (source_address, address_extension) != (None, None):
             raise UnusedArgumentError("Values of Source Address and Address Extension are not supported by "
                                       "Extended Addressing format and all must be None.")
-        AddressingType.validate_member(addressing_type)
+        addressing_type = AddressingType.validate_member(addressing_type)
         CanIdHandler.validate_can_id(can_id)  # type: ignore
         validate_raw_byte(target_address)  # type: ignore
         if not CanIdHandler.is_extended_addressed_can_id(can_id):  # type: ignore

uds/can/normal_addressing_information.py

@@ -46,7 +46,7 @@ def validate_packet_ai(cls,
         if (target_address, source_address, address_extension) != (None, None, None):
             raise UnusedArgumentError("Values of Target Address, Source Address and Address Extension are "
                                       "not supported by Normal 11-bit Addressing format and all must be None.")
-        AddressingType.validate_member(addressing_type)
+        addressing_type = AddressingType.validate_member(addressing_type)
         CanIdHandler.validate_can_id(can_id)  # type: ignore
         if not CanIdHandler.is_normal_11bit_addressed_can_id(can_id):  # type: ignore
             raise InconsistentArgumentsError(f"Provided value of CAN ID is not compatible with "
@@ -95,7 +95,7 @@ def validate_packet_ai(cls,
         if address_extension is not None:
             raise UnusedArgumentError("Values of TAddress Extension is not supported by Normal Fixed Addressing format "
                                       "and all must be None.")
-        AddressingType.validate_member(addressing_type)
+        addressing_type = AddressingType.validate_member(addressing_type)
         if can_id is None:
             if None in (target_address, source_address):
                 raise InconsistentArgumentsError(f"Values of target_address and source_address must be provided,"

uds/packet/can_packet_type.py

@@ -35,5 +35,4 @@ def is_initial_packet_type(cls, value: "CanPacketType") -> bool:
 
         :return: True if given argument is a packet type that initiates a diagnostic message, else False.
         """
-        cls.validate_member(value)
-        return value in (cls.SINGLE_FRAME, cls.FIRST_FRAME)
+        return cls.validate_member(value) in (cls.SINGLE_FRAME, cls.FIRST_FRAME)

uds/utilities/bytes_operations.py

@@ -36,8 +36,7 @@ def bytes_list_to_int(bytes_list: RawBytesAlias, endianness: Endianness = Endian
     :return: The integer value represented by provided list of bytes.
     """
     validate_raw_bytes(bytes_list)
-    Endianness.validate_member(endianness)
-    return int.from_bytes(bytes=bytes_list, byteorder=endianness)
+    return int.from_bytes(bytes=bytes_list, byteorder=Endianness.validate_member(endianness).value)
 
 
 def int_to_bytes_list(int_value: int,