Teststruct improvement application

pyof/foundation/basic_types.py

@@ -171,19 +171,8 @@ def unpack(self, buff, offset=0):
         self._value = ':'.join(hexas)
 
 
-class Char(GenericType):
-    """Build a double char type according to the length."""
-
-    def __init__(self, value=None, length=0):
-        """The constructor takes the optional parameters below.
-
-        Args:
-            value: The character to be build.
-            length (int): Character size.
-        """
-        super().__init__(value)
-        self.length = length
-        self._fmt = '!{}{}'.format(self.length, 's')
+class CharStringBase(GenericType):
+    """A null terminated ascii char string."""
 
     def pack(self, value=None):
         """Pack the value as a binary representation.
@@ -231,6 +220,19 @@ def unpack(self, buff, offset=0):
         self._value = unpacked_data.decode('ascii').rstrip('\0')
 
 
+def Char(value=None, length=0):
+    """Return a CharString class with given length and initial value."""
+    string_length = length
+
+    class CharString(CharStringBase):
+        """Class for null terminated ascii strings of fixed length."""
+
+        length = string_length
+        _fmt = '!{}{}'.format(length, 's')
+
+    return CharString(value)
+
+
 class IPAddress(GenericType):
     """Defines a IP address."""
 

pyof/utils.py

@@ -0,0 +1,37 @@
+"""General Unpack utils for python-openflow."""
+import pyof.v0x01.common.header
+import pyof.v0x01.common.utils
+import pyof.v0x04.common.header
+import pyof.v0x04.common.utils
+from pyof.foundation.exceptions import UnpackException
+
+pyof_version_libs = {0x01: pyof.v0x01,
+                     0x04: pyof.v0x04}
+
+
+def unpack(packet):
+    """Unpack the OpenFlow Packet and returns a message."""
+    try:
+        version = packet[0]
+    except IndexError:
+        raise UnpackException('null packet')
+
+    try:
+        pyof_lib = pyof_version_libs[version]
+    except KeyError:
+        raise UnpackException('Version not supported')
+
+    try:
+        header = pyof_lib.common.header.Header()
+        header.unpack(packet[:8])
+        message = pyof_lib.common.utils.new_message_from_header(header)
+        binary_data = packet[8:]
+        if binary_data:
+            if len(binary_data) == header.length - 8:
+                message.unpack(binary_data)
+            else:
+                raise UnpackException(
+                    'packet size does not match packet length field')
+        return message
+    except (UnpackException, ValueError) as e:
+        raise UnpackException(e)

tests/test_foundation/test_basic_types.py

@@ -3,152 +3,102 @@
 
 from pyof.foundation import basic_types
 from pyof.foundation.basic_types import BinaryData
+from tests.test_struct import TestStructDump
 
 
-class TestUBInt8(unittest.TestCase):
-    """Test of UBInt8 BasicType."""
+class TestUBInt8(TestStructDump):
+    """Test UBInt8."""
 
-    def setUp(self):
-        """Basic test setup."""
-        self.ubint8 = basic_types.UBInt8()
+    dump = b'\xff'
+    obj = basic_types.UBInt8(2**8 - 1)
+    min_size = 1
 
-    def test_get_size(self):
-        """[Foundation/BasicTypes/UBInt8] - size 1."""
-        self.assertEqual(self.ubint8.get_size(), 1)
 
-    @unittest.skip('Not yet implemented')
-    def test_pack(self):
-        """[Foundation/BasicTypes/UBInt8] - packing."""
-        pass
+class TestUBInt16(TestStructDump):
+    """Test UBInt16."""
 
-    @unittest.skip('Not yet implemented')
-    def test_unpack(self):
-        """[Foundation/BasicTypes/UBInt8] - unpacking."""
-        pass
+    dump = b'\xff\xff'
+    obj = basic_types.UBInt16(2**16 - 1)
+    min_size = 2
 
 
-class TestUBInt16(unittest.TestCase):
-    """Test of UBInt16 BasicType."""
+class TestUBInt32(TestStructDump):
+    """Test UBInt32."""
 
-    def setUp(self):
-        """Basic test setup."""
-        self.ubint16 = basic_types.UBInt16()
+    dump = b'\xff\xff\xff\xff'
+    obj = basic_types.UBInt32(2**32 - 1)
+    min_size = 4
 
-    def test_get_size(self):
-        """[Foundation/BasicTypes/UBInt16] - size 2."""
-        self.assertEqual(self.ubint16.get_size(), 2)
 
-    @unittest.skip('Not yet implemented')
-    def test_pack(self):
-        """[Foundation/BasicTypes/UBInt16] - packing."""
-        pass
+class TestChar3(TestStructDump):
+    """Test Char with length 3."""
 
-    @unittest.skip('Not yet implemented')
-    def test_unpack(self):
-        """[Foundation/BasicTypes/UBInt16] - unpacking."""
-        pass
+    dump = b'fo\x00'
+    obj = basic_types.Char('foo', length=3)
+    min_size = 3
 
 
-class TestUBInt32(unittest.TestCase):
-    """Test of UBInt32 BasicType."""
+class TestChar5(TestStructDump):
+    """Test Char with length 5."""
 
-    def setUp(self):
-        """Basic test setup."""
-        self.ubint32 = basic_types.UBInt32()
+    dump = b'foo\x00\x00'
+    obj = basic_types.Char('foo', length=5)
+    min_size = 5
 
-    def test_get_size(self):
-        """[Foundation/BasicTypes/UBInt32] - size 4."""
-        self.assertEqual(self.ubint32.get_size(), 4)
 
-    @unittest.skip('Not yet implemented')
-    def test_pack(self):
-        """[Foundation/BasicTypes/UBInt32] - packing."""
-        pass
+class TestHWAddressMac(TestStructDump):
+    """Test HWAddress mac value."""
 
-    @unittest.skip('Not yet implemented')
-    def test_unpack(self):
-        """[Foundation/BasicTypes/UBInt32] - unpacking."""
-        pass
+    mac = '0a:d3:98:a5:30:47'
+    dump = b'\x0a\xd3\x98\xa5\x30\x47'
+    obj = basic_types.HWAddress(mac)
+    min_size = 6
 
+    def test_address_value(self):
+        """Test HWAddress mac value."""
+        self.assertEqual(self.obj.value, self.mac)
 
-class TestChar(unittest.TestCase):
-    """Test of Char BasicType."""
 
-    def setUp(self):
-        """Basic test setup."""
-        self.char1 = basic_types.Char('foo', length=3)
-        self.char2 = basic_types.Char('foo', length=5)
+class TestIPAddressNetmask(TestStructDump):
+    """Test IPAddress and its default netmask value."""
 
-    def test_get_size(self):
-        """[Foundation/BasicTypes/Char] - get_size."""
-        self.assertEqual(self.char1.get_size(), 3)
-        self.assertEqual(self.char2.get_size(), 5)
+    dump = b'\xc0\xa8\x00\x01'
+    obj = basic_types.IPAddress('192.168.0.1')
+    netmask = 32
+    min_size = 4
 
-    def test_pack(self):
-        """[Foundation/BasicTypes/Char] - packing."""
-        self.assertEqual(self.char1.pack(), b'fo\x00')
-        self.assertEqual(self.char2.pack(), b'foo\x00\x00')
+    def test_netmask(self):
+        """Test IPAddress netmask value."""
+        self.assertEqual(self.obj.netmask, self.netmask)
 
-    def test_unpack(self):
-        """[Foundation/BasicTypes/Char] - unpacking."""
-        char1 = basic_types.Char(length=3)
-        char2 = basic_types.Char(length=5)
-        char1.unpack(b'fo\x00')
-        char2.unpack(b'foo\x00\x00')
 
-        self.assertEqual(char1.value, 'fo')
-        self.assertEqual(char2.value, 'foo')
+class TestIPAddressNoNetmask(TestIPAddressNetmask):
+    """Test IPAdress and netmask value 16."""
 
+    dump = b'\xc0\xa8\x00\x01'
+    obj = basic_types.IPAddress('192.168.0.1/16')
+    netmask = 16
+    min_size = 4
 
-class TestHWaddress(unittest.TestCase):
-    """Test of HWAddress BasicType."""
 
-    def test_unpack_packed(self):
-        """Testing unpack of packed HWAddress."""
-        mac = '0a:d3:98:a5:30:47'
-        hw_addr = basic_types.HWAddress(mac)
-        packed = hw_addr.pack()
-        unpacked = basic_types.HWAddress()
-        unpacked.unpack(packed)
-        self.assertEqual(mac, unpacked.value)
+class TestBinaryDataEmpty(TestStructDump):
+    """Test empty BinaryData."""
 
-    def test_default_value(self):
-        """Testing default_value for HWAddress."""
-        mac = '00:00:00:00:00:00'
-        hw_addr = basic_types.HWAddress()
-        packed = hw_addr.pack()
-        unpacked = basic_types.HWAddress()
-        unpacked.unpack(packed)
-        self.assertEqual(mac, unpacked.value)
+    dump = b''
+    obj = BinaryData()
+    min_size = 0
 
 
-class TestIPAddress(unittest.TestCase):
-    """Test of IPAddress BasicType."""
-
-    def test_unpack_packed(self):
-        """Test unpacking of packed IPAddress."""
-        ip_addr = basic_types.IPAddress('192.168.0.1')
-        packed = ip_addr.pack()
-        unpacked = basic_types.IPAddress()
-        unpacked.unpack(packed)
-        self.assertEqual(ip_addr.value, unpacked.value)
-
-    def test_unpack_packed_with_netmask(self):
-        """Testing unpack of packed IPAddress with netmask."""
-        ip_addr = basic_types.IPAddress('192.168.0.1/16')
-        packed = ip_addr.pack()
-        unpacked = basic_types.IPAddress()
-        unpacked.unpack(packed)
-        self.assertEqual(ip_addr.value, unpacked.value)
+class TestBinaryDataBytes(TestStructDump):
+    """Test 'bytes' BinaryData."""
+
+    dump = b'bytes'
+    obj = BinaryData(b'bytes')
+    min_size = 0
 
-    def test_netmask(self):
-        """Testing get netmask from IPAddress."""
-        ip_addr = basic_types.IPAddress('192.168.0.1/24')
-        self.assertEqual(ip_addr.netmask, 24)
-        ip_addr = basic_types.IPAddress('192.168.0.1/16')
-        self.assertEqual(ip_addr.netmask, 16)
-        ip_addr = basic_types.IPAddress('192.168.0.1')
-        self.assertEqual(ip_addr.netmask, 32)
+
+class TestIPAddress(unittest.TestCase):
+    """Test of IPAddress BasicType max_prefix."""
 
     def test_max_prefix(self):
         """Testing get max_prefix from IPAddress."""
@@ -157,32 +107,9 @@ def test_max_prefix(self):
         ip_addr = basic_types.IPAddress('192.168.0.35/16')
         self.assertEqual(ip_addr.max_prefix, 32)
 
-    def test_get_size(self):
-        """Testing get_size from IPAddress."""
-        ip_addr = basic_types.IPAddress('192.168.0.1/24')
-        self.assertEqual(ip_addr.get_size(), 4)
-
 
 class TestBinaryData(unittest.TestCase):
-    """Test Binary data type."""
-
-    def test_default_value(self):
-        """Default packed value should be an empty byte."""
-        expected = b''
-        actual = BinaryData().pack()
-        self.assertEqual(expected, actual)
-
-    def test_pack_bytes(self):
-        """Test packing some bytes."""
-        expected = b'forty two'
-        actual = BinaryData(expected).pack()
-        self.assertEqual(expected, actual)
-
-    def test_pack_empty_bytes(self):
-        """Test packing empty bytes."""
-        expected = b''
-        actual = BinaryData(expected).pack()
-        self.assertEqual(expected, actual)
+    """Test Binary data type cannot accept string."""
 
     def test_unexpected_value(self):
         """Should raise ValueError if constructor value is not bytes."""