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

pyrad/server_async.py

@@ -4,7 +4,6 @@
 
 import asyncio
 import logging
-import traceback
 
 from abc import abstractmethod, ABCMeta
 from enum import Enum
@@ -81,7 +80,7 @@ class DatagramProtocolServer(asyncio.Protocol):
                                  dict=self.server.dict,
                                  packet=data)
                 if self.server.enable_pkt_verify:
-                    if req.VerifyAuthRequest():
+                    if not req.VerifyAuthRequest():
                         raise PacketError('Packet verification failed')
 
             elif self.server_type == ServerType.Coa:
@@ -91,7 +90,7 @@ class DatagramProtocolServer(asyncio.Protocol):
                                 dict=self.server.dict,
                                 packet=data)
                 if self.server.enable_pkt_verify:
-                    if req.VerifyCoARequest():
+                    if not req.VerifyCoARequest():
                         raise PacketError('Packet verification failed')
 
             elif self.server_type == ServerType.Acct:
@@ -102,7 +101,7 @@ class DatagramProtocolServer(asyncio.Protocol):
                                  dict=self.server.dict,
                                  packet=data)
                 if self.server.enable_pkt_verify:
-                    if req.VerifyAcctRequest():
+                    if not req.VerifyAcctRequest():
                         raise PacketError('Packet verification failed')
 
             # Call request callback

pyrad/tests/__init__.py

@@ -0,0 +1,5 @@
+import pyrad
+import os
+
+pyrad  # keep pyflakes happy
+home = os.path.dirname(os.path.realpath(__file__))

pyrad/tests/mock.py

@@ -0,0 +1,145 @@
+import fcntl
+import os
+from pyrad.packet import PacketError
+
+
+class MockPacket:
+    reply = object()
+
+    def __init__(self, code, verify=False, error=False):
+        self.code = code
+        self.data = {}
+        self.verify = verify
+        self.error = error
+
+    def CreateReply(self, packet=None):
+        if self.error:
+            raise PacketError
+        return self.reply
+
+    def VerifyReply(self, reply, rawreply):
+        return self.verify
+
+    def RequestPacket(self):
+        return "request packet"
+
+    def __contains__(self, key):
+        return key in self.data
+    has_key = __contains__
+
+    def __setitem__(self, key, value):
+        self.data[key] = [value]
+
+    def __getitem__(self, key):
+        return self.data[key]
+
+
+class MockSocket:
+    def __init__(self, domain, type, data=None):
+        self.domain = domain
+        self.type = type
+        self.closed = False
+        self.options = []
+        self.address = None
+        self.output = []
+
+        # Always initialize data so recv() never fails.
+        # If data is provided, use it; otherwise behave like "no data available".
+        self.data = data if data is not None else b""
+
+        if data is not None:
+            (self.read_end, self.write_end) = os.pipe()
+            fcntl.fcntl(self.write_end, fcntl.F_SETFL, os.O_NONBLOCK)
+            os.write(self.write_end, data)
+        else:
+            self.read_end = 1
+            self.write_end = None
+
+    def fileno(self):
+        return self.read_end
+
+    def bind(self, address):
+        self.address = address
+
+    def recv(self, buffer):
+        # Return up to `buffer` bytes; if empty, return b"" (no data).
+        return self.data[:buffer]
+
+    def sendto(self, data, target):
+        self.output.append((data, target))
+
+    def setsockopt(self, level, opt, value):
+        self.options.append((level, opt, value))
+
+    def close(self):
+        self.closed = True
+
+
+class MockFinished(Exception):
+    pass
+
+
+class MockPoll:
+    results = []
+
+    def __init__(self):
+        self.registry = {}
+
+    def register(self, fd, options):
+        self.registry[fd] = options
+
+    def unregister(self, fd):
+        try:
+            del self.registry[fd]
+        except KeyError:
+            pass
+
+    def poll(self, timeout=None):
+        for result in self.results:
+            yield result
+        raise MockFinished
+
+
+def origkey(klass):
+    return "_originals_" + klass.__name__
+
+
+def MockClassMethod(klass, name, myfunc=None):
+    def func(self, *args, **kwargs):
+        if not hasattr(self, "called"):
+            self.called = []
+        self.called.append((name, args, kwargs))
+
+    key = origkey(klass)
+    if not hasattr(klass, key):
+        setattr(klass, key, {})
+    getattr(klass, key)[name] = getattr(klass, name)
+    if myfunc is None:
+        setattr(klass, name, func)
+    else:
+        setattr(klass, name, myfunc)
+
+
+def UnmockClassMethods(klass):
+    key = origkey(klass)
+    if not hasattr(klass, key):
+        return
+    for (name, func) in getattr(klass, key).items():
+        setattr(klass, name, func)
+
+    delattr(klass, key)
+
+
+class MockFd:
+    data = object()
+    source = object()
+
+    def __init__(self, fd=0):
+        self.fd = fd
+
+    def fileno(self):
+        return self.fd
+
+    def recvfrom(self, size):
+        self.size = size
+        return (self.data, self.source)

pyrad/tests/test_bidict.py

@@ -0,0 +1,56 @@
+import operator
+import unittest
+from pyrad.bidict import BiDict
+
+
+class BiDictTests(unittest.TestCase):
+    def setUp(self):
+        self.bidict = BiDict()
+
+    def testStartEmpty(self):
+        self.assertEqual(len(self.bidict), 0)
+        self.assertEqual(len(self.bidict.forward), 0)
+        self.assertEqual(len(self.bidict.backward), 0)
+
+    def testLength(self):
+        self.assertEqual(len(self.bidict), 0)
+        self.bidict.Add("from", "to")
+        self.assertEqual(len(self.bidict), 1)
+        del self.bidict["from"]
+        self.assertEqual(len(self.bidict), 0)
+
+    def testDeletion(self):
+        self.assertRaises(KeyError, operator.delitem, self.bidict, "missing")
+        self.bidict.Add("missing", "present")
+        del self.bidict["missing"]
+
+    def testBackwardDeletion(self):
+        self.assertRaises(KeyError, operator.delitem, self.bidict, "missing")
+        self.bidict.Add("missing", "present")
+        del self.bidict["present"]
+        self.assertEqual(self.bidict.HasForward("missing"), False)
+
+    def testForwardAccess(self):
+        self.bidict.Add("shake", "vanilla")
+        self.bidict.Add("pie", "custard")
+        self.assertEqual(self.bidict.HasForward("shake"), True)
+        self.assertEqual(self.bidict.GetForward("shake"), "vanilla")
+        self.assertEqual(self.bidict.HasForward("pie"), True)
+        self.assertEqual(self.bidict.GetForward("pie"), "custard")
+        self.assertEqual(self.bidict.HasForward("missing"), False)
+        self.assertRaises(KeyError, self.bidict.GetForward, "missing")
+
+    def testBackwardAccess(self):
+        self.bidict.Add("shake", "vanilla")
+        self.bidict.Add("pie", "custard")
+        self.assertEqual(self.bidict.HasBackward("vanilla"), True)
+        self.assertEqual(self.bidict.GetBackward("vanilla"), "shake")
+        self.assertEqual(self.bidict.HasBackward("missing"), False)
+        self.assertRaises(KeyError, self.bidict.GetBackward, "missing")
+
+    def testItemAccessor(self):
+        self.bidict.Add("shake", "vanilla")
+        self.bidict.Add("pie", "custard")
+        self.assertRaises(KeyError, operator.getitem, self.bidict, "missing")
+        self.assertEqual(self.bidict["shake"], "vanilla")
+        self.assertEqual(self.bidict["pie"], "custard")

pyrad/tests/test_client.py

@@ -0,0 +1,183 @@
+import select
+import socket
+import unittest
+from .mock import MockPacket
+from .mock import MockPoll
+from .mock import MockSocket
+from pyrad.client import Client
+from pyrad.client import Timeout
+from pyrad.packet import AuthPacket
+from pyrad.packet import AcctPacket
+from pyrad.packet import AccessRequest
+from pyrad.packet import AccountingRequest
+
+BIND_IP = "127.0.0.1"
+BIND_PORT = 53535
+
+
+class ConstructionTests(unittest.TestCase):
+    def setUp(self):
+        self.server = object()
+
+    def testSimpleConstruction(self):
+        client = Client(self.server)
+        self.assertTrue(client.server is self.server)
+        self.assertEqual(client.authport, 1812)
+        self.assertEqual(client.acctport, 1813)
+        self.assertEqual(client.secret, b'')
+        self.assertEqual(client.retries, 3)
+        self.assertEqual(client.timeout, 5)
+        self.assertTrue(client.dict is None)
+
+    def testParameterOrder(self):
+        marker = object()
+        client = Client(self.server, 123, 456, 789, "secret", marker)
+        self.assertTrue(client.server is self.server)
+        self.assertEqual(client.authport, 123)
+        self.assertEqual(client.acctport, 456)
+        self.assertEqual(client.coaport, 789)
+        self.assertEqual(client.secret, "secret")
+        self.assertTrue(client.dict is marker)
+
+    def testNamedParameters(self):
+        marker = object()
+        client = Client(server=self.server, authport=123, acctport=456,
+                        secret="secret", dict=marker)
+        self.assertTrue(client.server is self.server)
+        self.assertEqual(client.authport, 123)
+        self.assertEqual(client.acctport, 456)
+        self.assertEqual(client.secret, "secret")
+        self.assertTrue(client.dict is marker)
+
+
+class SocketTests(unittest.TestCase):
+    def setUp(self):
+        self.server = object()
+        self.client = Client(self.server)
+        self.orgsocket = socket.socket
+        socket.socket = MockSocket
+
+    def tearDown(self):
+        socket.socket = self.orgsocket
+
+    def testReopen(self):
+        self.client._SocketOpen()
+        sock = self.client._socket
+        self.client._SocketOpen()
+        self.assertTrue(sock is self.client._socket)
+
+    def testBind(self):
+        self.client.bind((BIND_IP, BIND_PORT))
+        self.assertEqual(self.client._socket.address, (BIND_IP, BIND_PORT))
+        self.assertEqual(self.client._socket.options,
+                         [(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)])
+
+    def testBindClosesSocket(self):
+        s = MockSocket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.client._socket = s
+        self.client._poll = MockPoll()
+        self.client.bind((BIND_IP, BIND_PORT))
+        self.assertEqual(s.closed, True)
+
+    def testSendPacket(self):
+        def MockSend(self, pkt, port):
+            self._mock_pkt = pkt
+            self._mock_port = port
+
+        _SendPacket = Client._SendPacket
+        Client._SendPacket = MockSend
+
+        self.client.SendPacket(AuthPacket())
+        self.assertEqual(self.client._mock_port, self.client.authport)
+
+        self.client.SendPacket(AcctPacket())
+        self.assertEqual(self.client._mock_port, self.client.acctport)
+
+        Client._SendPacket = _SendPacket
+
+    def testNoRetries(self):
+        self.client.retries = 0
+        self.assertRaises(Timeout, self.client._SendPacket, None, None)
+
+    def testSingleRetry(self):
+        self.client.retries = 1
+        self.client.timeout = 0
+        packet = MockPacket(AccessRequest)
+        self.assertRaises(Timeout, self.client._SendPacket, packet, 432)
+        self.assertEqual(self.client._socket.output,
+                         [("request packet", (self.server, 432))])
+
+    def testDoubleRetry(self):
+        self.client.retries = 2
+        self.client.timeout = 0
+        packet = MockPacket(AccessRequest)
+        self.assertRaises(Timeout, self.client._SendPacket, packet, 432)
+        self.assertEqual(self.client._socket.output,
+                         [("request packet", (self.server, 432)),
+                          ("request packet", (self.server, 432))])
+
+    def testAuthDelay(self):
+        self.client.retries = 2
+        self.client.timeout = 1
+        packet = MockPacket(AccessRequest)
+        self.assertRaises(Timeout, self.client._SendPacket, packet, 432)
+        self.assertFalse("Acct-Delay-Time" in packet)
+
+    def testSingleAccountDelay(self):
+        self.client.retries = 2
+        self.client.timeout = 1
+        packet = MockPacket(AccountingRequest)
+        self.assertRaises(Timeout, self.client._SendPacket, packet, 432)
+        self.assertEqual(packet["Acct-Delay-Time"], [1])
+
+    def testDoubleAccountDelay(self):
+        self.client.retries = 3
+        self.client.timeout = 1
+        packet = MockPacket(AccountingRequest)
+        self.assertRaises(Timeout, self.client._SendPacket, packet, 432)
+        self.assertEqual(packet["Acct-Delay-Time"], [2])
+
+    def testIgnorePacketError(self):
+        self.client.retries = 1
+        self.client.timeout = 1
+        self.client._socket = MockSocket(1, 2, b'valid reply')
+        packet = MockPacket(AccountingRequest, verify=True, error=True)
+        self.assertRaises(Timeout, self.client._SendPacket, packet, 432)
+
+    def testValidReply(self):
+        self.client.retries = 1
+        self.client.timeout = 1
+        self.client._socket = MockSocket(1, 2, b'valid reply')
+        self.client._poll = MockPoll()
+        MockPoll.results = [(1, select.POLLIN)]
+        packet = MockPacket(AccountingRequest, verify=True)
+        reply = self.client._SendPacket(packet, 432)
+        self.assertTrue(reply is packet.reply)
+
+    def testInvalidReply(self):
+        self.client.retries = 1
+        self.client.timeout = 1
+        self.client._socket = MockSocket(1, 2, b'invalid reply')
+        MockPoll.results = [(1, select.POLLIN)]
+        packet = MockPacket(AccountingRequest, verify=False)
+        self.assertRaises(Timeout, self.client._SendPacket, packet, 432)
+
+
+class OtherTests(unittest.TestCase):
+    def setUp(self):
+        self.server = object()
+        self.client = Client(self.server, secret=b'zeer geheim')
+
+    def testCreateAuthPacket(self):
+        packet = self.client.CreateAuthPacket(id=15)
+        self.assertTrue(isinstance(packet, AuthPacket))
+        self.assertTrue(packet.dict is self.client.dict)
+        self.assertEqual(packet.id, 15)
+        self.assertEqual(packet.secret, b'zeer geheim')
+
+    def testCreateAcctPacket(self):
+        packet = self.client.CreateAcctPacket(id=15)
+        self.assertTrue(isinstance(packet, AcctPacket))
+        self.assertTrue(packet.dict is self.client.dict)
+        self.assertEqual(packet.id, 15)
+        self.assertEqual(packet.secret, b'zeer geheim')