pyrad 2.4__py3-none-any.whl → 2.5.1__py3-none-any.whl

pyrad/tests/test_proxy.py

@@ -0,0 +1,96 @@
+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
+
+
+class TrivialObject:
+    """dummy object"""
+
+
+class SocketTests(unittest.TestCase):
+    def setUp(self):
+        self.orgsocket = socket.socket
+        socket.socket = MockSocket
+        self.proxy = Proxy()
+        self.proxy._fdmap = {}
+
+    def tearDown(self):
+        socket.socket = self.orgsocket
+
+    def testProxyFd(self):
+        self.proxy._poll = MockPoll()
+        self.proxy._PrepareSockets()
+        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})
+
+
+class ProxyPacketHandlingTests(unittest.TestCase):
+    def setUp(self):
+        self.proxy = Proxy()
+        self.proxy.hosts['host'] = TrivialObject()
+        self.proxy.hosts['host'].secret = 'supersecret'
+        self.packet = TrivialObject()
+        self.packet.code = AccessAccept
+        self.packet.source = ('host', 'port')
+
+    def testHandleProxyPacketUnknownHost(self):
+        self.packet.source = ('stranger', 'port')
+        try:
+            self.proxy._HandleProxyPacket(self.packet)
+        except ServerPacketError as e:
+            self.assertTrue('unknown host' in str(e))
+        else:
+            self.fail()
+
+    def testHandleProxyPacketSetsSecret(self):
+        self.proxy._HandleProxyPacket(self.packet)
+        self.assertEqual(self.packet.secret, 'supersecret')
+
+    def testHandleProxyPacketHandlesWrongPacket(self):
+        self.packet.code = AccessRequest
+        try:
+            self.proxy._HandleProxyPacket(self.packet)
+        except ServerPacketError as e:
+            self.assertTrue('non-response' in str(e))
+        else:
+            self.fail()
+
+
+class OtherTests(unittest.TestCase):
+    def setUp(self):
+        self.proxy = Proxy()
+        self.proxy._proxyfd = MockFd()
+
+    def tearDown(self):
+        UnmockClassMethods(Proxy)
+        UnmockClassMethods(Server)
+
+    def testProcessInputNonProxyPort(self):
+        fd = MockFd(fd=111)
+        MockClassMethod(Server, '_ProcessInput')
+        self.proxy._ProcessInput(fd)
+        self.assertEqual(self.proxy.called,
+                         [('_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'])
+
+
+if not hasattr(select, 'poll'):
+    del SocketTests

pyrad/tests/test_server.py

@@ -0,0 +1,323 @@
+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.packet import AccessRequest
+from pyrad.packet import AccountingRequest
+
+
+class TrivialObject:
+    """dummy objec"""
+
+
+class RemoteHostTests(unittest.TestCase):
+    def testSimpleConstruction(self):
+        host = RemoteHost('address', 'secret', 'name', 'authport', 'acctport', 'coaport')
+        self.assertEqual(host.address, 'address')
+        self.assertEqual(host.secret, 'secret')
+        self.assertEqual(host.name, 'name')
+        self.assertEqual(host.authport, 'authport')
+        self.assertEqual(host.acctport, 'acctport')
+        self.assertEqual(host.coaport, 'coaport')
+
+    def testNamedConstruction(self):
+        host = RemoteHost(address='address', secret='secret', name='name',
+                          authport='authport', acctport='acctport', coaport='coaport')
+        self.assertEqual(host.address, 'address')
+        self.assertEqual(host.secret, 'secret')
+        self.assertEqual(host.name, 'name')
+        self.assertEqual(host.authport, 'authport')
+        self.assertEqual(host.acctport, 'acctport')
+        self.assertEqual(host.coaport, 'coaport')
+
+
+class ServerConstructiontests(unittest.TestCase):
+    def testSimpleConstruction(self):
+        server = Server()
+        self.assertEqual(server.authfds, [])
+        self.assertEqual(server.acctfds, [])
+        self.assertEqual(server.authport, 1812)
+        self.assertEqual(server.acctport, 1813)
+        self.assertEqual(server.coaport, 3799)
+        self.assertEqual(server.hosts, {})
+
+    def testParameterOrder(self):
+        server = Server([], 'authport', 'acctport', 'coaport', 'hosts', 'dict')
+        self.assertEqual(server.authfds, [])
+        self.assertEqual(server.acctfds, [])
+        self.assertEqual(server.authport, 'authport')
+        self.assertEqual(server.acctport, 'acctport')
+        self.assertEqual(server.coaport, 'coaport')
+        self.assertEqual(server.dict, 'dict')
+
+    def testBindDuringConstruction(self):
+        def BindToAddress(self, addr):
+            self.bound.append(addr)
+        bta = Server.BindToAddress
+        Server.BindToAddress = BindToAddress
+
+        Server.bound = []
+        server = Server(['one', 'two', 'three'])
+        self.assertEqual(server.bound, ['one', 'two', 'three'])
+        del Server.bound
+
+        Server.BindToAddress = bta
+
+
+class SocketTests(unittest.TestCase):
+    def setUp(self):
+        self.orgsocket = socket.socket
+        socket.socket = MockSocket
+        self.server = Server()
+
+    def tearDown(self):
+        socket.socket = self.orgsocket
+
+    def testBind(self):
+        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))
+
+        self.assertEqual(len(self.server.acctfds), 1)
+        self.assertEqual(self.server.acctfds[0].address,
+                         ('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))
+
+        self.assertEqual(len(self.server.acctfds), 1)
+        self.assertEqual(self.server.acctfds[0].address,
+                         ('2001:db8:123::1', 1813))
+
+    def testGrabPacket(self):
+        def gen(data):
+            res = TrivialObject()
+            res.data = data
+            return res
+
+        fd = MockFd()
+        fd.source = object()
+        pkt = self.server._GrabPacket(gen, fd)
+        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()
+        self.server._PrepareSockets()
+
+        self.assertEqual(self.server._poll.registry, {})
+        self.assertEqual(self.server._realauthfds, [])
+        self.assertEqual(self.server._realacctfds, [])
+
+    def testPrepareSocketAuthFds(self):
+        self.server._poll = MockPoll()
+        self.server._fdmap = {}
+        self.server.authfds = [MockFd(12), MockFd(14)]
+        self.server._PrepareSockets()
+
+        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})
+
+    def testPrepareSocketAcctFds(self):
+        self.server._poll = MockPoll()
+        self.server._fdmap = {}
+        self.server.acctfds = [MockFd(12), MockFd(14)]
+        self.server._PrepareSockets()
+
+        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})
+
+
+class AuthPacketHandlingTests(unittest.TestCase):
+    def setUp(self):
+        self.server = Server()
+        self.server.hosts['host'] = TrivialObject()
+        self.server.hosts['host'].secret = 'supersecret'
+        self.packet = TrivialObject()
+        self.packet.code = AccessRequest
+        self.packet.source = ('host', 'port')
+
+    def testHandleAuthPacketUnknownHost(self):
+        self.packet.source = ('stranger', 'port')
+        try:
+            self.server._HandleAuthPacket(self.packet)
+        except ServerPacketError as e:
+            self.assertTrue('unknown host' in str(e))
+        else:
+            self.fail()
+
+    def testHandleAuthPacketWrongPort(self):
+        self.packet.code = AccountingRequest
+        try:
+            self.server._HandleAuthPacket(self.packet)
+        except ServerPacketError as e:
+            self.assertTrue('port' in str(e))
+        else:
+            self.fail()
+
+    def testHandleAuthPacket(self):
+        def HandleAuthPacket(self, pkt):
+            self.handled = pkt
+        hap = Server.HandleAuthPacket
+        Server.HandleAuthPacket = HandleAuthPacket
+
+        self.server._HandleAuthPacket(self.packet)
+        self.assertTrue(self.server.handled is self.packet)
+
+        Server.HandleAuthPacket = hap
+
+
+class AcctPacketHandlingTests(unittest.TestCase):
+    def setUp(self):
+        self.server = Server()
+        self.server.hosts['host'] = TrivialObject()
+        self.server.hosts['host'].secret = 'supersecret'
+        self.packet = TrivialObject()
+        self.packet.code = AccountingRequest
+        self.packet.source = ('host', 'port')
+
+    def testHandleAcctPacketUnknownHost(self):
+        self.packet.source = ('stranger', 'port')
+        try:
+            self.server._HandleAcctPacket(self.packet)
+        except ServerPacketError as e:
+            self.assertTrue('unknown host' in str(e))
+        else:
+            self.fail()
+
+    def testHandleAcctPacketWrongPort(self):
+        self.packet.code = AccessRequest
+        try:
+            self.server._HandleAcctPacket(self.packet)
+        except ServerPacketError as e:
+            self.assertTrue('port' in str(e))
+        else:
+            self.fail()
+
+    def testHandleAcctPacket(self):
+        def HandleAcctPacket(self, pkt):
+            self.handled = pkt
+        hap = Server.HandleAcctPacket
+        Server.HandleAcctPacket = HandleAcctPacket
+
+        self.server._HandleAcctPacket(self.packet)
+        self.assertTrue(self.server.handled is self.packet)
+
+        Server.HandleAcctPacket = hap
+
+
+class OtherTests(unittest.TestCase):
+    def setUp(self):
+        self.server = Server()
+
+    def tearDown(self):
+        UnmockClassMethods(Server)
+
+    def testCreateReplyPacket(self):
+        class TrivialPacket:
+            source = object()
+
+            def CreateReply(self, **kw):
+                reply = TrivialObject()
+                reply.kw = kw
+                return reply
+
+        reply = self.server.CreateReplyPacket(TrivialPacket(),
+                                              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):
+        fd = MockFd(1)
+        self.server._realauthfds = [1]
+        MockClassMethod(Server, '_GrabPacket')
+        MockClassMethod(Server, '_HandleAuthPacket')
+
+        self.server._ProcessInput(fd)
+        self.assertEqual([x[0] for x in self.server.called],
+                         ['_GrabPacket', '_HandleAuthPacket'])
+        self.assertEqual(self.server.called[0][1][1], fd)
+
+    def testAcctProcessInput(self):
+        fd = MockFd(1)
+        self.server._realauthfds = []
+        self.server._realacctfds = [1]
+        MockClassMethod(Server, '_GrabPacket')
+        MockClassMethod(Server, '_HandleAcctPacket')
+
+        self.server._ProcessInput(fd)
+        self.assertEqual([x[0] for x in self.server.called],
+                         ['_GrabPacket', '_HandleAcctPacket'])
+        self.assertEqual(self.server.called[0][1][1], fd)
+
+
+class ServerRunTests(unittest.TestCase):
+    def setUp(self):
+        self.server = Server()
+        self.origpoll = select.poll
+        select.poll = MockPoll
+
+    def tearDown(self):
+        MockPoll.results = []
+        select.poll = self.origpoll
+        UnmockClassMethods(Server)
+
+    def testRunInitializes(self):
+        MockClassMethod(Server, '_PrepareSockets')
+        self.assertRaises(MockFinished, self.server.Run)
+        self.assertEqual(self.server.called, [('_PrepareSockets', (), {})])
+        self.assertTrue(isinstance(self.server._fdmap, dict))
+        self.assertTrue(isinstance(self.server._poll, MockPoll))
+
+    def testRunIgnoresPollErrors(self):
+        self.server.authfds = [MockFd()]
+        MockPoll.results = [(0, select.POLLERR)]
+        self.assertRaises(MockFinished, self.server.Run)
+
+    def testRunIgnoresServerPacketErrors(self):
+        def RaisePacketError(self, fd):
+            raise ServerPacketError
+        MockClassMethod(Server, '_ProcessInput', RaisePacketError)
+        self.server.authfds = [MockFd()]
+        MockPoll.results = [(0, select.POLLIN)]
+        self.assertRaises(MockFinished, self.server.Run)
+
+    def testRunIgnoresPacketErrors(self):
+        def RaisePacketError(self, fd):
+            raise PacketError
+        MockClassMethod(Server, '_ProcessInput', RaisePacketError)
+        self.server.authfds = [MockFd()]
+        MockPoll.results = [(0, select.POLLIN)]
+        self.assertRaises(MockFinished, self.server.Run)
+
+    def testRunRunsProcessInput(self):
+        MockClassMethod(Server, '_ProcessInput')
+        self.server.authfds = fd = [MockFd()]
+        MockPoll.results = [(0, select.POLLIN)]
+        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)