|
@@ -19,6 +19,37 @@ import unittest
|
|
|
import isc
|
|
|
import ddns
|
|
|
import isc.config
|
|
|
+import select
|
|
|
+import errno
|
|
|
+import isc.util.io.socketsession
|
|
|
+import socket
|
|
|
+import os.path
|
|
|
+
|
|
|
+class FakeSocket:
|
|
|
+ """
|
|
|
+ A fake socket. It only provides a file number, peer name and accept method.
|
|
|
+ """
|
|
|
+ def __init__(self, fileno):
|
|
|
+ self.__fileno = fileno
|
|
|
+ def fileno(self):
|
|
|
+ return self.__fileno
|
|
|
+ def getpeername(self):
|
|
|
+ return "fake_unix_socket"
|
|
|
+ def accept(self):
|
|
|
+ return FakeSocket(self.__fileno + 1)
|
|
|
+
|
|
|
+class FakeSessionReceiver:
|
|
|
+ """
|
|
|
+ A fake socket session receiver, for our tests.
|
|
|
+ """
|
|
|
+ def __init__(self, socket):
|
|
|
+ self._socket = socket
|
|
|
+ def socket(self):
|
|
|
+ """
|
|
|
+ This method is not present in the real receiver, but we use it to
|
|
|
+ inspect the socket passed to the constructor.
|
|
|
+ """
|
|
|
+ return self._socket
|
|
|
|
|
|
class MyCCSession(isc.config.ConfigData):
|
|
|
'''Fake session with minimal interface compliance'''
|
|
@@ -32,6 +63,12 @@ class MyCCSession(isc.config.ConfigData):
|
|
|
'''Called by DDNSServer initialization, but not used in tests'''
|
|
|
self._started = True
|
|
|
|
|
|
+ def get_socket(self):
|
|
|
+ """
|
|
|
+ Used to get the file number for select.
|
|
|
+ """
|
|
|
+ return FakeSocket(1)
|
|
|
+
|
|
|
class MyDDNSServer():
|
|
|
'''Fake DDNS server used to test the main() function'''
|
|
|
def __init__(self):
|
|
@@ -63,7 +100,41 @@ class TestDDNSServer(unittest.TestCase):
|
|
|
cc_session = MyCCSession()
|
|
|
self.assertFalse(cc_session._started)
|
|
|
self.ddns_server = ddns.DDNSServer(cc_session)
|
|
|
+ self.__cc_session = cc_session
|
|
|
self.assertTrue(cc_session._started)
|
|
|
+ self.__select_expected = None
|
|
|
+ self.__select_answer = None
|
|
|
+ self.__select_exception = None
|
|
|
+ self.__hook_called = False
|
|
|
+ self.ddns_server._listen_socket = FakeSocket(2)
|
|
|
+ ddns.select.select = self.__select
|
|
|
+
|
|
|
+ def tearDown(self):
|
|
|
+ ddns.select.select = select.select
|
|
|
+ ddns.isc.util.io.socketsession.SocketSessionReceiver = \
|
|
|
+ isc.util.io.socketsession.SocketSessionReceiver
|
|
|
+
|
|
|
+ def test_listen(self):
|
|
|
+ '''
|
|
|
+ Test the old socket file is removed (if any) and a new socket
|
|
|
+ is created when the ddns server is created.
|
|
|
+ '''
|
|
|
+
|
|
|
+ ddns.clear_socket()
|
|
|
+
|
|
|
+ orig_clear = ddns.clear_socket
|
|
|
+ ddns.clear_socket = self.__hook
|
|
|
+
|
|
|
+ ddnss = ddns.DDNSServer(MyCCSession())
|
|
|
+ ddns.clear_socket = orig_clear
|
|
|
+
|
|
|
+ self.assertTrue(os.path.exists(ddns.SOCKET_FILE))
|
|
|
+ self.assertTrue(isinstance(ddnss._listen_socket, socket.socket))
|
|
|
+
|
|
|
+ self.assertIsNone(self.__hook_called)
|
|
|
+
|
|
|
+ ddns.clear_socket()
|
|
|
+ self.assertFalse(os.path.exists(ddns.SOCKET_FILE))
|
|
|
|
|
|
def test_config_handler(self):
|
|
|
|
|
@@ -93,14 +164,215 @@ class TestDDNSServer(unittest.TestCase):
|
|
|
signal_handler(None, None)
|
|
|
self.assertTrue(self.ddns_server._shutdown)
|
|
|
|
|
|
+ def __select(self, reads, writes, exceptions, timeout=None):
|
|
|
+ """
|
|
|
+ A fake select. It checks it was called with the correct parameters and
|
|
|
+ returns a preset answer.
|
|
|
+
|
|
|
+ If there's an exception stored in __select_exception, it is raised
|
|
|
+ instead and the exception is cleared.
|
|
|
+ """
|
|
|
+ self.assertEqual(self.__select_expected, (reads, writes, exceptions,
|
|
|
+ timeout))
|
|
|
+ if self.__select_exception is not None:
|
|
|
+ (self.__select_exception, exception) = (None,
|
|
|
+ self.__select_exception)
|
|
|
+ raise exception
|
|
|
+ answer = self.__select_answer
|
|
|
+ self.__select_answer = None
|
|
|
+ self.ddns_server._shutdown = True
|
|
|
+ return answer
|
|
|
+
|
|
|
+ def __hook(self, param=None):
|
|
|
+ """
|
|
|
+ A hook that can be installed to any nullary or unary function and see
|
|
|
+ if it was really called.
|
|
|
+ """
|
|
|
+ self.__hook_called = param
|
|
|
+
|
|
|
+ def test_accept_called(self):
|
|
|
+ """
|
|
|
+ Test we call the accept function when a new connection comes.
|
|
|
+ """
|
|
|
+ self.ddns_server.accept = self.__hook
|
|
|
+ self.__select_expected = ([1, 2], [], [], None)
|
|
|
+ self.__select_answer = ([2], [], [])
|
|
|
+ self.__hook_called = "Not called"
|
|
|
+ self.ddns_server.run()
|
|
|
+ self.assertTrue(self.ddns_server._shutdown)
|
|
|
+
|
|
|
+ self.assertIsNone(self.__select_answer)
|
|
|
+
|
|
|
+ self.assertIsNone(self.__hook_called)
|
|
|
+
|
|
|
+ def test_check_command_called(self):
|
|
|
+ """
|
|
|
+ Test the check_command is called when there's something on the
|
|
|
+ socket.
|
|
|
+ """
|
|
|
+ self.__cc_session.check_command = self.__hook
|
|
|
+ self.__select_expected = ([1, 2], [], [], None)
|
|
|
+ self.__select_answer = ([1], [], [])
|
|
|
+ self.ddns_server.run()
|
|
|
+ self.assertTrue(self.ddns_server._shutdown)
|
|
|
+
|
|
|
+ self.assertIsNone(self.__select_answer)
|
|
|
+
|
|
|
+
|
|
|
+ self.assertTrue(self.__hook_called)
|
|
|
+
|
|
|
+ def test_accept(self):
|
|
|
+ """
|
|
|
+ Test that we can accept a new connection.
|
|
|
+ """
|
|
|
+
|
|
|
+ ddns.isc.util.io.socketsession.SocketSessionReceiver = \
|
|
|
+ FakeSessionReceiver
|
|
|
+ self.assertEqual({}, self.ddns_server._socksession_receivers)
|
|
|
+ self.ddns_server.accept()
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ self.assertEqual([3],
|
|
|
+ list(self.ddns_server._socksession_receivers.keys()))
|
|
|
+ (socket, receiver) = self.ddns_server._socksession_receivers[3]
|
|
|
+ self.assertTrue(isinstance(socket, FakeSocket))
|
|
|
+ self.assertEqual(3, socket.fileno())
|
|
|
+ self.assertTrue(isinstance(receiver, FakeSessionReceiver))
|
|
|
+ self.assertEqual(socket, receiver.socket())
|
|
|
+
|
|
|
+ def test_accept_fail(self):
|
|
|
+ """
|
|
|
+ Test we don't crash if an accept fails and that we don't modify the
|
|
|
+ internals.
|
|
|
+ """
|
|
|
+
|
|
|
+ def accept_failure():
|
|
|
+ raise socket.error(errno.ECONNABORTED)
|
|
|
+ orig = self.ddns_server._listen_socket.accept
|
|
|
+ self.ddns_server._listen_socket.accept = accept_failure
|
|
|
+ self.assertEqual({}, self.ddns_server._socksession_receivers)
|
|
|
+
|
|
|
+ self.ddns_server.accept()
|
|
|
+
|
|
|
+ self.assertEqual({}, self.ddns_server._socksession_receivers)
|
|
|
+
|
|
|
+ self.ddns_server._listen_socket.accept = orig
|
|
|
+ def receiver_failure(sock):
|
|
|
+ raise isc.util.io.socketsession.SocketSessionError('Test error')
|
|
|
+ ddns.isc.util.io.socketsession.SocketSessionReceiver = \
|
|
|
+ receiver_failure
|
|
|
+
|
|
|
+ self.ddns_server.accept()
|
|
|
+
|
|
|
+ self.assertEqual({}, self.ddns_server._socksession_receivers)
|
|
|
+
|
|
|
+ def unexpected_failure(sock):
|
|
|
+ raise Exception('Test error')
|
|
|
+ ddns.isc.util.io.socketsession.SocketSessionReceiver = \
|
|
|
+ unexpected_failure
|
|
|
+
|
|
|
+ self.assertRaises(Exception, self.ddns_server.accept)
|
|
|
+
|
|
|
+ self.assertEqual({}, self.ddns_server._socksession_receivers)
|
|
|
+
|
|
|
+ def test_session_called(self):
|
|
|
+ """
|
|
|
+ Test the run calls handle_session when there's something on the
|
|
|
+ socket.
|
|
|
+ """
|
|
|
+ socket = FakeSocket(3)
|
|
|
+ self.ddns_server._socksession_receivers = \
|
|
|
+ {3: (socket, FakeSessionReceiver(socket))}
|
|
|
+ self.ddns_server.handle_session = self.__hook
|
|
|
+ self.__select_expected = ([1, 2, 3], [], [], None)
|
|
|
+ self.__select_answer = ([3], [], [])
|
|
|
+ self.ddns_server.run()
|
|
|
+ self.assertTrue(self.ddns_server._shutdown)
|
|
|
+ self.assertIsNone(self.__select_answer)
|
|
|
+ self.assertEqual(3, self.__hook_called)
|
|
|
+
|
|
|
+ def test_handle_session_ok(self):
|
|
|
+ """
|
|
|
+ Test the handle_session pops the receiver and calls handle_request
|
|
|
+ when everything is OK.
|
|
|
+ """
|
|
|
+ socket = FakeSocket(3)
|
|
|
+ receiver = FakeSessionReceiver(socket)
|
|
|
+
|
|
|
+
|
|
|
+ param = (FakeSocket(4), ('127.0.0.1', 1234), ('127.0.0.1', 1235),
|
|
|
+ 'Some data')
|
|
|
+ def pop():
|
|
|
+ return param
|
|
|
+
|
|
|
+ receiver.pop = pop
|
|
|
+ self.ddns_server._socksession_receivers = {3: (socket, receiver)}
|
|
|
+ self.ddns_server.handle_request = self.__hook
|
|
|
+
|
|
|
+ self.ddns_server.handle_session(3)
|
|
|
+
|
|
|
+ self.assertEqual(param, self.__hook_called)
|
|
|
+
|
|
|
+ self.assertEqual({3: (socket, receiver)},
|
|
|
+ self.ddns_server._socksession_receivers)
|
|
|
+
|
|
|
+ def test_handle_session_fail(self):
|
|
|
+ """
|
|
|
+ Test the handle_session removes (and closes) the socket and receiver
|
|
|
+ when the receiver complains.
|
|
|
+ """
|
|
|
+ socket = FakeSocket(3)
|
|
|
+ receiver = FakeSessionReceiver(socket)
|
|
|
+ def pop():
|
|
|
+ raise isc.util.io.socketsession.SocketSessionError('Test error')
|
|
|
+ receiver.pop = pop
|
|
|
+ socket.close = self.__hook
|
|
|
+ self.__hook_called = False
|
|
|
+ self.ddns_server._socksession_receivers = {3: (socket, receiver)}
|
|
|
+ self.ddns_server.handle_session(3)
|
|
|
+
|
|
|
+ self.assertEqual({}, self.ddns_server._socksession_receivers)
|
|
|
+
|
|
|
+ self.assertIsNone(self.__hook_called)
|
|
|
+
|
|
|
+ def test_select_exception_ignored(self):
|
|
|
+ """
|
|
|
+ Test that the EINTR is ignored in select.
|
|
|
+ """
|
|
|
+
|
|
|
+ self.__select_exception = select.error(errno.EINTR)
|
|
|
+
|
|
|
+
|
|
|
+ self.test_check_command_called()
|
|
|
+
|
|
|
+ def test_select_exception_fatal(self):
|
|
|
+ """
|
|
|
+ Test that other exceptions are fatal to the run.
|
|
|
+ """
|
|
|
+
|
|
|
+ self.__select_exception = select.error(errno.EBADF)
|
|
|
+ self.__select_expected = ([1, 2], [], [], None)
|
|
|
+ self.assertRaises(select.error, self.ddns_server.run)
|
|
|
+
|
|
|
class TestMain(unittest.TestCase):
|
|
|
def setUp(self):
|
|
|
self._server = MyDDNSServer()
|
|
|
+ self.__orig_clear = ddns.clear_socket
|
|
|
+ ddns.clear_socket = self.__clear_socket
|
|
|
+ self.__clear_called = False
|
|
|
+
|
|
|
+ def tearDown(self):
|
|
|
+ ddns.clear_socket = self.__orig_clear
|
|
|
|
|
|
def test_main(self):
|
|
|
self.assertFalse(self._server.run_called)
|
|
|
ddns.main(self._server)
|
|
|
self.assertTrue(self._server.run_called)
|
|
|
+ self.assertTrue(self.__clear_called)
|
|
|
+
|
|
|
+ def __clear_socket(self):
|
|
|
+ self.__clear_called = True
|
|
|
|
|
|
def check_exception(self, ex):
|
|
|
'''Common test sequence to see if the given exception is caused.
|
|
@@ -135,7 +407,6 @@ class TestMain(unittest.TestCase):
|
|
|
self._server.set_exception(BaseException("error"))
|
|
|
self.assertRaises(BaseException, ddns.main, self._server)
|
|
|
self.assertTrue(self._server.exception_raised)
|
|
|
-
|
|
|
|
|
|
if __name__== "__main__":
|
|
|
isc.log.resetUnitTestRootLogger()
|