class MessageTestCase(unittest.TestCase): def setUp(self): # The following attributes must be overruled by child classes # The basics are tested with a simple UnknownMessage self.packet_fixture = bytes.fromhex('ff') + b'ThisIsAnUnknownMessage' self.message_fixture = UnknownMessage(255, b'ThisIsAnUnknownMessage') self.parse_packet() def parse_packet(self): self.length, self.message = Message.parse(self.packet_fixture) self.assertIsInstance(self.message, Message) self.message_class = type(self.message) def test_length(self): self.assertEqual(self.length, len(self.packet_fixture)) def test_parse(self): self.assertEqual(self.message, self.message_fixture) def test_save_parsed(self): self.assertEqual(self.packet_fixture, self.message.save()) def test_save_fixture(self): self.assertEqual(self.packet_fixture, self.message_fixture.save()) def test_validate(self): # This should be ok self.message.validate()
class MessageTestCase(unittest.TestCase): def setUp(self): # The following attributes must be overruled by child classes # The basics are tested with a simple UnknownMessage self.packet_fixture = bytes.fromhex('ff') + b'ThisIsAnUnknownMessage' self.message_fixture = UnknownMessage(255, b'ThisIsAnUnknownMessage') self.parse_packet() def parse_packet(self): self.length, self.message = Message.parse(self.packet_fixture) self.assertIsInstance(self.message, Message) self.message_class = type(self.message) def test_length(self): self.assertEqual(self.length, len(self.packet_fixture)) def test_parse(self): self.assertEqual(self.message, self.message_fixture) def test_save_parsed(self): self.assertEqual(self.packet_fixture, self.message.save()) def test_save_fixture(self): self.assertEqual(self.packet_fixture, self.message_fixture.save()) def test_validate(self): # This should be ok self.message.validate() def check_unsigned_integer_property(self, property_name: str, size: int = None): """ Perform basic verification of validation of an unsigned integer :param property_name: The property under test :param size: The number of bits of this integer field """ # Do the basic integer checks setattr(self.message, property_name, 0.1) with self.assertRaisesRegex(ValueError, 'integer'): self.message.validate() setattr(self.message, property_name, 0) self.message.validate() setattr(self.message, property_name, -1) with self.assertRaisesRegex(ValueError, 'unsigned .* integer'): self.message.validate() if not size: # We can't do any further tests without knowing the size return setattr(self.message, property_name, 2 ** size - 1) self.message.validate() setattr(self.message, property_name, 2 ** size) with self.assertRaisesRegex(ValueError, 'unsigned {} bit integer'.format(size)): self.message.validate()
def test_set_relayed_message(self): # Start with empty options self.message.options = [] self.assertEqual( len(self.message.get_options_of_type(RelayMessageOption)), 0) self.message.relayed_message = UnknownMessage( 255, b'ThisIsAnUnknownMessage') self.assertEqual( len(self.message.get_options_of_type(RelayMessageOption)), 1) self.assertEqual(self.message.relayed_message.message_data, b'ThisIsAnUnknownMessage') self.message.relayed_message = UnknownMessage( 255, b'ThisIsADifferentUnknownMessage') self.assertEqual( len(self.message.get_options_of_type(RelayMessageOption)), 1) self.assertEqual(self.message.relayed_message.message_data, b'ThisIsADifferentUnknownMessage')
class MessageTestCase(unittest.TestCase): def setUp(self): # The following attributes must be overruled by child classes # The basics are tested with a simple UnknownMessage self.packet_fixture = bytes.fromhex('ff') + b'ThisIsAnUnknownMessage' self.message_fixture = UnknownMessage(255, b'ThisIsAnUnknownMessage') self.parse_packet() def parse_packet(self): self.length, self.message = Message.parse(self.packet_fixture) self.assertIsInstance(self.message, Message) self.message_class = type(self.message) def test_length(self): self.assertEqual(self.length, len(self.packet_fixture)) def test_parse(self): self.assertEqual(self.message, self.message_fixture) def test_save_parsed(self): self.assertEqual(self.packet_fixture, self.message.save()) def test_save_fixture(self): self.assertEqual(self.packet_fixture, self.message_fixture.save()) def test_validate(self): # This should be ok self.message.validate() def check_unsigned_integer_property(self, property_name: str, size: int): """ Perform basic verification of validation of an unsigned integer :param property_name: The property under test :param size: The number of bits of this integer field """ # Do the basic integer checks setattr(self.message, property_name, 0.1) with self.assertRaisesRegex(ValueError, 'integer'): self.message.validate() setattr(self.message, property_name, 0) self.message.validate() setattr(self.message, property_name, -1) with self.assertRaisesRegex(ValueError, 'unsigned .* integer'): self.message.validate() setattr(self.message, property_name, 2**size - 1) self.message.validate() setattr(self.message, property_name, 2**size) with self.assertRaisesRegex(ValueError, 'unsigned {} bit integer'.format(size)): self.message.validate()
def setUp(self): # The following attributes must be overruled by child classes # The basics are tested with nested RelayForwardMessages self.packet_fixture = bytes.fromhex( '0c' # message_type: MSG_RELAY_FORW '02' # hop_count '20010db8000000000000000000020001' # link_address '20010db8000000000000000000020002' # peer_address '0009' # option_type: OPTION_RELAY_MSG '0051' # option_length '0c' # message_type: MSG_RELAY_FORW '01' # hop_count '20010db8000000000000000000010001' # link_address '20010db8000000000000000000010002' # peer_address '0009' # option_type: OPTION_RELAY_MSG '002b' # option_length '0c' # message_type: MSG_RELAY_FORW '00' # hop_count '20010db8000000000000000000000001' # link_address '20010db8000000000000000000000002' # peer_address '0009' # option_type: OPTION_RELAY_MSG '0005' # option_length 'ff' # some unknown message_type: 255 '41424344') # some random message_data: 'ABCD' self.message_fixture = RelayForwardMessage( hop_count=2, link_address=IPv6Address('2001:db8::2:1'), peer_address=IPv6Address('2001:db8::2:2'), options=[ RelayMessageOption(relayed_message=RelayForwardMessage( hop_count=1, link_address=IPv6Address('2001:db8::1:1'), peer_address=IPv6Address('2001:db8::1:2'), options=[ RelayMessageOption(relayed_message=RelayForwardMessage( hop_count=0, link_address=IPv6Address('2001:db8::1'), peer_address=IPv6Address('2001:db8::2'), options=[ RelayMessageOption( relayed_message=UnknownMessage( 255, b'ABCD')) ])) ])) ]) self.parse_packet()
def setUp(self): self.option_bytes = bytes.fromhex( '00090017ff') + b'ThisIsAnUnknownMessage' self.option_object = RelayMessageOption( relayed_message=UnknownMessage(255, b'ThisIsAnUnknownMessage')) self.parse_option()
def test_unknown_message(self): with self.assertLogs() as cm: TransactionBundle(UnknownMessage(1608, b'Unknown'), False) self.assertEqual(len(cm.output), 1) self.assertRegex(cm.output[0], 'unrecognised message')
def setUp(self): # The following attributes must be overruled by child classes # The basics are tested with a simple UnknownMessage self.packet_fixture = bytes.fromhex('ff') + b'ThisIsAnUnknownMessage' self.message_fixture = UnknownMessage(255, b'ThisIsAnUnknownMessage') self.parse_packet()
""" Test the UnknownMessage implementation """ import unittest from dhcpkit.ipv6.messages import UnknownMessage from dhcpkit.tests.ipv6.messages import test_message unknown_message = UnknownMessage(255, b'ThisIsAnUnknownMessage') unknown_packet = bytes.fromhex('ff') + b'ThisIsAnUnknownMessage' class UnknownMessageTestCase(test_message.MessageTestCase): def setUp(self): self.packet_fixture = unknown_packet self.message_fixture = unknown_message self.parse_packet() def parse_packet(self): super().parse_packet() self.assertIsInstance(self.message, UnknownMessage) def test_validate_message_type(self): self.check_unsigned_integer_property('message_type', size=8) def test_validate_data(self): # This should be ok self.message.message_data = b'' self.message.validate() # This shouldn't