Esempio n. 1
0
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()
Esempio n. 2
0
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()
Esempio n. 3
0
    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')
Esempio n. 4
0
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()
Esempio n. 5
0
    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()
Esempio n. 6
0
 def setUp(self):
     self.option_bytes = bytes.fromhex(
         '00090017ff') + b'ThisIsAnUnknownMessage'
     self.option_object = RelayMessageOption(
         relayed_message=UnknownMessage(255, b'ThisIsAnUnknownMessage'))
     self.parse_option()
Esempio n. 7
0
 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')
Esempio n. 8
0
 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()
Esempio n. 9
0
 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()
Esempio n. 10
0
"""
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