Changeset 1061

Timestamp:

09/13/07 21:16:52 (15 months ago)

Author:

wichert

Message:

Full test coverage for the client code and a single bugfix found in the tests

Location:

trunk

Files:

• CHANGES.txt (modified) (1 diff)
• pyrad/client.py (modified) (1 diff)
• pyrad/tests/testClient.py (modified) (3 diffs)

trunk/CHANGES.txt

@@ -2 +2 @@
 =========
 
- * Switch to setuptools, allowing pyrad to be distributed as an egg
-   via the python package index.
+* Fixed a timeout handling problem in the client: after receiving an
+  invalid reply the current time was not updated, possibly leading to
+  the client blocking forever.
 
- * Add unit tests
+* Switch to setuptools, allowing pyrad to be distributed as an egg
+  via the python package index.
 
- * Use absolute instead of relative imports.
+* Add unit tests.
+
+* Use absolute instead of relative imports.
+
+* Sockets are now opened with SO_REUSEADDR enabled to allow for faster
+  restarts.

trunk/pyrad/client.py

@@ -149 +149 @@
                                         pass
 
+                                now=time.time()
 
                 raise Timeout

trunk/pyrad/tests/testClient.py

@@ +1 @@
+import fcntl
+import os
 import socket
 import unittest
 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
+from pyrad.packet import PacketError
 
 BIND_IP = "127.0.0.1"
 BIND_PORT = 53535
 
+
+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 has_key(self, key):
+        return self.data.has_key(key)
+
+    def __setitem__(self, key, value):
+        self.data[key]=[value]
+
+    def __getitem__(self, key):
+        return self.data[key]
+
+
 class MockSocket:
-    def __init__(self, domain, type):
+    def __init__(self, domain, type, data=None):
         self.domain=domain
         self.type=type
@@ -15 +52 @@
         self.options=[]
         self.address=None
+        self.output=[]
+
+        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)
+            self.data=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 self.data[:buffer]
+
+    def sendto(self, data, target):
+        self.output.append((data, target))
 
     def setsockopt(self, level, opt, value):
@@ -109 +165 @@
 
         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.failIf(packet.has_key("Acct-Delay-Time"))
+
+
+    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, "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, "valid reply")
+        packet=MockPacket(AccountingRequest, verify=True)
+        reply=self.client._SendPacket(packet, 432)
+        self.failUnless(reply is packet.reply)
+
+
+    def testInvalidReply(self):
+        self.client.retries=1
+        self.client.timeout=1
+        self.client._socket=MockSocket(1, 2, "invalid reply")
+        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="zeer geheim")
+
+
+    def testCreateAuthPacket(self):
+        packet=self.client.CreateAuthPacket(id=15)
+        self.failUnless(isinstance(packet, AuthPacket))
+        self.failUnless(packet.dict is self.client.dict)
+        self.assertEqual(packet.id, 15)
+        self.assertEqual(packet.secret, "zeer geheim")
+
+
+    def testCreateAcctPacket(self):
+        packet=self.client.CreateAcctPacket(id=15)
+        self.failUnless(isinstance(packet, AcctPacket))
+        self.failUnless(packet.dict is self.client.dict)
+        self.assertEqual(packet.id, 15)
+        self.assertEqual(packet.secret, "zeer geheim")
+