pyrad 2.3__py3-none-any.whl → 2.5.0__py3-none-any.whl

pyrad/tests/{testProxy.py → test_proxy.py}

@@ -1,16 +1,16 @@
 import select
 import socket
 import unittest
+from .mock import MockFd
+from .mock import MockPoll
+from .mock import MockSocket
+from .mock import MockClassMethod
+from .mock import UnmockClassMethods
 from pyrad.proxy import Proxy
 from pyrad.packet import AccessAccept
 from pyrad.packet import AccessRequest
 from pyrad.server import ServerPacketError
 from pyrad.server import Server
-from pyrad.tests.mock import MockFd
-from pyrad.tests.mock import MockPoll
-from pyrad.tests.mock import MockSocket
-from pyrad.tests.mock import MockClassMethod
-from pyrad.tests.mock import UnmockClassMethods
 
 
 class TrivialObject:
@@ -30,10 +30,10 @@ class SocketTests(unittest.TestCase):
     def testProxyFd(self):
         self.proxy._poll = MockPoll()
         self.proxy._PrepareSockets()
-        self.failUnless(isinstance(self.proxy._proxyfd, MockSocket))
+        self.assertTrue(isinstance(self.proxy._proxyfd, MockSocket))
         self.assertEqual(list(self.proxy._fdmap.keys()), [1])
         self.assertEqual(self.proxy._poll.registry,
-                {1: select.POLLIN | select.POLLPRI | select.POLLERR})
+                         {1: select.POLLIN | select.POLLPRI | select.POLLERR})
 
 
 class ProxyPacketHandlingTests(unittest.TestCase):
@@ -50,7 +50,7 @@ class ProxyPacketHandlingTests(unittest.TestCase):
         try:
             self.proxy._HandleProxyPacket(self.packet)
         except ServerPacketError as e:
-            self.failUnless('unknown host' in str(e))
+            self.assertTrue('unknown host' in str(e))
         else:
             self.fail()
 
@@ -63,7 +63,7 @@ class ProxyPacketHandlingTests(unittest.TestCase):
         try:
             self.proxy._HandleProxyPacket(self.packet)
         except ServerPacketError as e:
-            self.failUnless('non-response' in str(e))
+            self.assertTrue('non-response' in str(e))
         else:
             self.fail()
 
@@ -82,14 +82,14 @@ class OtherTests(unittest.TestCase):
         MockClassMethod(Server, '_ProcessInput')
         self.proxy._ProcessInput(fd)
         self.assertEqual(self.proxy.called,
-                [('_ProcessInput', (fd,), {})])
+                         [('_ProcessInput', (fd,), {})])
 
     def testProcessInput(self):
         MockClassMethod(Proxy, '_GrabPacket')
         MockClassMethod(Proxy, '_HandleProxyPacket')
         self.proxy._ProcessInput(self.proxy._proxyfd)
         self.assertEqual([x[0] for x in self.proxy.called],
-                ['_GrabPacket', '_HandleProxyPacket'])
+                         ['_GrabPacket', '_HandleProxyPacket'])
 
 
 if not hasattr(select, 'poll'):

pyrad/tests/{testServer.py → test_server.py}

@@ -1,16 +1,16 @@
 import select
 import socket
 import unittest
+from .mock import MockFinished
+from .mock import MockFd
+from .mock import MockPoll
+from .mock import MockSocket
+from .mock import MockClassMethod
+from .mock import UnmockClassMethods
 from pyrad.packet import PacketError
 from pyrad.server import RemoteHost
 from pyrad.server import Server
 from pyrad.server import ServerPacketError
-from pyrad.tests.mock import MockFinished
-from pyrad.tests.mock import MockFd
-from pyrad.tests.mock import MockPoll
-from pyrad.tests.mock import MockSocket
-from pyrad.tests.mock import MockClassMethod
-from pyrad.tests.mock import UnmockClassMethods
 from pyrad.packet import AccessRequest
 from pyrad.packet import AccountingRequest
 
@@ -31,7 +31,7 @@ class RemoteHostTests(unittest.TestCase):
 
     def testNamedConstruction(self):
         host = RemoteHost(address='address', secret='secret', name='name',
-               authport='authport', acctport='acctport', coaport='coaport')
+                          authport='authport', acctport='acctport', coaport='coaport')
         self.assertEqual(host.address, 'address')
         self.assertEqual(host.secret, 'secret')
         self.assertEqual(host.name, 'name')
@@ -39,6 +39,7 @@ class RemoteHostTests(unittest.TestCase):
         self.assertEqual(host.acctport, 'acctport')
         self.assertEqual(host.coaport, 'coaport')
 
+
 class ServerConstructiontests(unittest.TestCase):
     def testSimpleConstruction(self):
         server = Server()
@@ -50,7 +51,7 @@ class ServerConstructiontests(unittest.TestCase):
         self.assertEqual(server.hosts, {})
 
     def testParameterOrder(self):
-        server = Server([], 'authport', 'acctport', 'coaport','hosts', 'dict')
+        server = Server([], 'authport', 'acctport', 'coaport', 'hosts', 'dict')
         self.assertEqual(server.authfds, [])
         self.assertEqual(server.acctfds, [])
         self.assertEqual(server.authport, 'authport')
@@ -85,21 +86,21 @@ class SocketTests(unittest.TestCase):
         self.server.BindToAddress('192.168.13.13')
         self.assertEqual(len(self.server.authfds), 1)
         self.assertEqual(self.server.authfds[0].address,
-                ('192.168.13.13', 1812))
+                         ('192.168.13.13', 1812))
 
         self.assertEqual(len(self.server.acctfds), 1)
         self.assertEqual(self.server.acctfds[0].address,
-                ('192.168.13.13', 1813))
+                         ('192.168.13.13', 1813))
 
     def testBindv6(self):
         self.server.BindToAddress('2001:db8:123::1')
         self.assertEqual(len(self.server.authfds), 1)
         self.assertEqual(self.server.authfds[0].address,
-                ('2001:db8:123::1', 1812))
+                         ('2001:db8:123::1', 1812))
 
         self.assertEqual(len(self.server.acctfds), 1)
         self.assertEqual(self.server.acctfds[0].address,
-                ('2001:db8:123::1', 1813))
+                         ('2001:db8:123::1', 1813))
 
     def testGrabPacket(self):
         def gen(data):
@@ -110,10 +111,10 @@ class SocketTests(unittest.TestCase):
         fd = MockFd()
         fd.source = object()
         pkt = self.server._GrabPacket(gen, fd)
-        self.failUnless(isinstance(pkt, TrivialObject))
-        self.failUnless(pkt.fd is fd)
-        self.failUnless(pkt.source is fd.source)
-        self.failUnless(pkt.data is fd.data)
+        self.assertTrue(isinstance(pkt, TrivialObject))
+        self.assertTrue(pkt.fd is fd)
+        self.assertTrue(pkt.source is fd.source)
+        self.assertTrue(pkt.data is fd.data)
 
     def testPrepareSocketNoFds(self):
         self.server._poll = MockPoll()
@@ -131,8 +132,8 @@ class SocketTests(unittest.TestCase):
 
         self.assertEqual(list(self.server._fdmap.keys()), [12, 14])
         self.assertEqual(self.server._poll.registry,
-                {12: select.POLLIN | select.POLLPRI | select.POLLERR,
-                 14: select.POLLIN | select.POLLPRI | select.POLLERR})
+                         {12: select.POLLIN | select.POLLPRI | select.POLLERR,
+                          14: select.POLLIN | select.POLLPRI | select.POLLERR})
 
     def testPrepareSocketAcctFds(self):
         self.server._poll = MockPoll()
@@ -142,8 +143,8 @@ class SocketTests(unittest.TestCase):
 
         self.assertEqual(list(self.server._fdmap.keys()), [12, 14])
         self.assertEqual(self.server._poll.registry,
-                {12: select.POLLIN | select.POLLPRI | select.POLLERR,
-                 14: select.POLLIN | select.POLLPRI | select.POLLERR})
+                         {12: select.POLLIN | select.POLLPRI | select.POLLERR,
+                          14: select.POLLIN | select.POLLPRI | select.POLLERR})
 
 
 class AuthPacketHandlingTests(unittest.TestCase):
@@ -160,7 +161,7 @@ class AuthPacketHandlingTests(unittest.TestCase):
         try:
             self.server._HandleAuthPacket(self.packet)
         except ServerPacketError as e:
-            self.failUnless('unknown host' in str(e))
+            self.assertTrue('unknown host' in str(e))
         else:
             self.fail()
 
@@ -169,7 +170,7 @@ class AuthPacketHandlingTests(unittest.TestCase):
         try:
             self.server._HandleAuthPacket(self.packet)
         except ServerPacketError as e:
-            self.failUnless('port' in str(e))
+            self.assertTrue('port' in str(e))
         else:
             self.fail()
 
@@ -180,7 +181,7 @@ class AuthPacketHandlingTests(unittest.TestCase):
         Server.HandleAuthPacket = HandleAuthPacket
 
         self.server._HandleAuthPacket(self.packet)
-        self.failUnless(self.server.handled is self.packet)
+        self.assertTrue(self.server.handled is self.packet)
 
         Server.HandleAuthPacket = hap
 
@@ -199,7 +200,7 @@ class AcctPacketHandlingTests(unittest.TestCase):
         try:
             self.server._HandleAcctPacket(self.packet)
         except ServerPacketError as e:
-            self.failUnless('unknown host' in str(e))
+            self.assertTrue('unknown host' in str(e))
         else:
             self.fail()
 
@@ -208,7 +209,7 @@ class AcctPacketHandlingTests(unittest.TestCase):
         try:
             self.server._HandleAcctPacket(self.packet)
         except ServerPacketError as e:
-            self.failUnless('port' in str(e))
+            self.assertTrue('port' in str(e))
         else:
             self.fail()
 
@@ -219,7 +220,7 @@ class AcctPacketHandlingTests(unittest.TestCase):
         Server.HandleAcctPacket = HandleAcctPacket
 
         self.server._HandleAcctPacket(self.packet)
-        self.failUnless(self.server.handled is self.packet)
+        self.assertTrue(self.server.handled is self.packet)
 
         Server.HandleAcctPacket = hap
 
@@ -241,9 +242,9 @@ class OtherTests(unittest.TestCase):
                 return reply
 
         reply = self.server.CreateReplyPacket(TrivialPacket(),
-                one='one', two='two')
-        self.failUnless(isinstance(reply, TrivialObject))
-        self.failUnless(reply.source is TrivialPacket.source)
+                                              one='one', two='two')
+        self.assertTrue(isinstance(reply, TrivialObject))
+        self.assertTrue(reply.source is TrivialPacket.source)
         self.assertEqual(reply.kw, dict(one='one', two='two'))
 
     def testAuthProcessInput(self):
@@ -254,7 +255,7 @@ class OtherTests(unittest.TestCase):
 
         self.server._ProcessInput(fd)
         self.assertEqual([x[0] for x in self.server.called],
-                ['_GrabPacket', '_HandleAuthPacket'])
+                         ['_GrabPacket', '_HandleAuthPacket'])
         self.assertEqual(self.server.called[0][1][1], fd)
 
     def testAcctProcessInput(self):
@@ -266,7 +267,7 @@ class OtherTests(unittest.TestCase):
 
         self.server._ProcessInput(fd)
         self.assertEqual([x[0] for x in self.server.called],
-                ['_GrabPacket', '_HandleAcctPacket'])
+                         ['_GrabPacket', '_HandleAcctPacket'])
         self.assertEqual(self.server.called[0][1][1], fd)
 
 
@@ -285,8 +286,8 @@ class ServerRunTests(unittest.TestCase):
         MockClassMethod(Server, '_PrepareSockets')
         self.assertRaises(MockFinished, self.server.Run)
         self.assertEqual(self.server.called, [('_PrepareSockets', (), {})])
-        self.failUnless(isinstance(self.server._fdmap, dict))
-        self.failUnless(isinstance(self.server._poll, MockPoll))
+        self.assertTrue(isinstance(self.server._fdmap, dict))
+        self.assertTrue(isinstance(self.server._poll, MockPoll))
 
     def testRunIgnoresPollErrors(self):
         self.server.authfds = [MockFd()]
@@ -316,6 +317,7 @@ class ServerRunTests(unittest.TestCase):
         self.assertRaises(MockFinished, self.server.Run)
         self.assertEqual(self.server.called, [('_ProcessInput', (fd[0],), {})])
 
+
 if not hasattr(select, 'poll'):
     del SocketTests
     del ServerRunTests

pyrad/tests/test_tools.py

@@ -0,0 +1,126 @@
+from pyrad import tools
+import unittest
+
+
+class EncodingTests(unittest.TestCase):
+    def testStringEncoding(self):
+        self.assertRaises(ValueError, tools.EncodeString, 'x' * 254)
+        self.assertEqual(
+                tools.EncodeString('1234567890'),
+                b'1234567890')
+
+    def testInvalidStringEncodingRaisesTypeError(self):
+        self.assertRaises(TypeError, tools.EncodeString, 1)
+
+    def testAddressEncoding(self):
+        self.assertRaises((ValueError, Exception), tools.EncodeAddress, 'TEST123')
+        self.assertEqual(
+                tools.EncodeAddress('192.168.0.255'),
+                b'\xc0\xa8\x00\xff')
+
+    def testInvalidAddressEncodingRaisesTypeError(self):
+        self.assertRaises(TypeError, tools.EncodeAddress, 1)
+
+    def testIntegerEncoding(self):
+        self.assertEqual(tools.EncodeInteger(0x01020304), b'\x01\x02\x03\x04')
+
+    def testInteger64Encoding(self):
+        self.assertEqual(
+            tools.EncodeInteger64(0xFFFFFFFFFFFFFFFF), b'\xff' * 8
+        )
+
+    def testUnsignedIntegerEncoding(self):
+        self.assertEqual(tools.EncodeInteger(0xFFFFFFFF), b'\xff\xff\xff\xff')
+
+    def testInvalidIntegerEncodingRaisesTypeError(self):
+        self.assertRaises(TypeError, tools.EncodeInteger, 'ONE')
+
+    def testDateEncoding(self):
+        self.assertEqual(tools.EncodeDate(0x01020304), b'\x01\x02\x03\x04')
+
+    def testInvalidDataEncodingRaisesTypeError(self):
+        self.assertRaises(TypeError, tools.EncodeDate, '1')
+
+    def testEncodeAscendBinary(self):
+        self.assertEqual(
+            tools.EncodeAscendBinary('family=ipv4 action=discard direction=in dst=10.10.255.254/32'),
+            b'\x01\x00\x01\x00\x00\x00\x00\x00\n\n\xff\xfe\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
+
+    def testStringDecoding(self):
+        self.assertEqual(
+                tools.DecodeString(b'1234567890'),
+                '1234567890')
+
+    def testAddressDecoding(self):
+        self.assertEqual(
+                tools.DecodeAddress(b'\xc0\xa8\x00\xff'),
+                '192.168.0.255')
+
+    def testIntegerDecoding(self):
+        self.assertEqual(
+                tools.DecodeInteger(b'\x01\x02\x03\x04'),
+                0x01020304)
+
+    def testInteger64Decoding(self):
+        self.assertEqual(
+            tools.DecodeInteger64(b'\xff' * 8), 0xFFFFFFFFFFFFFFFF
+        )
+
+    def testDateDecoding(self):
+        self.assertEqual(
+                tools.DecodeDate(b'\x01\x02\x03\x04'),
+                0x01020304)
+
+    def testOctetsEncoding(self):
+        self.assertEqual(tools.EncodeOctets('0x01020304'), b'\x01\x02\x03\x04')
+        self.assertEqual(tools.EncodeOctets(b'0x01020304'), b'\x01\x02\x03\x04')
+        self.assertEqual(tools.EncodeOctets('16909060'), b'\x01\x02\x03\x04')
+        # encodes to 253 bytes
+        self.assertEqual(tools.EncodeOctets('0x0102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D'), b'\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r')
+        self.assertRaisesRegex(ValueError, 'Can only encode strings of <= 253 characters', tools.EncodeOctets, '0x0102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E0F100102030405060708090A0B0C0D0E')
+
+    def testUnknownTypeEncoding(self):
+        self.assertRaises(ValueError, tools.EncodeAttr, 'unknown', None)
+
+    def testUnknownTypeDecoding(self):
+        self.assertRaises(ValueError, tools.DecodeAttr, 'unknown', None)
+
+    def testEncodeFunction(self):
+        self.assertEqual(
+                tools.EncodeAttr('string', 'string'),
+                b'string')
+        self.assertEqual(
+                tools.EncodeAttr('octets', b'string'),
+                b'string')
+        self.assertEqual(
+                tools.EncodeAttr('ipaddr', '192.168.0.255'),
+                b'\xc0\xa8\x00\xff')
+        self.assertEqual(
+                tools.EncodeAttr('integer', 0x01020304),
+                b'\x01\x02\x03\x04')
+        self.assertEqual(
+                tools.EncodeAttr('date', 0x01020304),
+                b'\x01\x02\x03\x04')
+        self.assertEqual(
+                tools.EncodeAttr('integer64', 0xFFFFFFFFFFFFFFFF),
+                b'\xff'*8)
+
+    def testDecodeFunction(self):
+        self.assertEqual(
+                tools.DecodeAttr('string', b'string'),
+                'string')
+        self.assertEqual(
+                tools.EncodeAttr('octets', b'string'),
+                b'string')
+        self.assertEqual(
+                tools.DecodeAttr('ipaddr', b'\xc0\xa8\x00\xff'),
+                '192.168.0.255')
+        self.assertEqual(
+                tools.DecodeAttr('integer', b'\x01\x02\x03\x04'),
+                0x01020304)
+        self.assertEqual(
+                tools.DecodeAttr('integer64', b'\xff'*8),
+                0xFFFFFFFFFFFFFFFF)
+        self.assertEqual(
+                tools.DecodeAttr('date', b'\x01\x02\x03\x04'),
+                0x01020304)