Example #1
0
    def test_listener_creator_backlog(self, mock_TCPTendril,
                                      mock_track_tendril, mock_socket,
                                      mock_sleep):
        acceptor = mock.Mock()
        manager = tcp.TCPTendrilManager()
        manager.running = True

        with self.assertRaises(TestException):
            manager.listener(acceptor, None)

        self.assertFalse(mock_sleep.called)
        mock_socket.assert_called_once_with(socket.AF_INET, socket.SOCK_STREAM)
        mock_socket.return_value.assert_has_calls([
            mock.call.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1),
            mock.call.bind(('', 0)),
            mock.call.getsockname(),
            mock.call.listen(4096),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.close(),
        ])
        self.assertEqual(manager.local_addr, ('127.0.0.1', 8080))
        self.assertFalse(mock_TCPTendril.called)
        self.assertFalse(acceptor.called)
        self.assertFalse(mock_track_tendril.called)
Example #2
0
    def test_listener_noacceptor(self, mock_TCPTendril, mock_track_tendril,
                                 mock_socket, mock_sleep):
        manager = tcp.TCPTendrilManager()

        with self.assertRaises(TestException):
            manager.listener(None, None)

        mock_sleep.assert_called_once_with(600)
        self.assertFalse(mock_socket.called)
Example #3
0
    def test_connect_failure(self, mock_TCPTendril, mock_track_tendril,
                             mock_connect, mock_socket):
        acceptor = mock.Mock(side_effect=TestException())
        manager = tcp.TCPTendrilManager()

        with self.assertRaises(TestException):
            tend = manager.connect(('127.0.0.1', 8080), acceptor)

        mock_connect.assert_called_once_with(('127.0.0.1', 8080), acceptor,
                                             None)
        mock_socket.assert_called_once_with(socket.AF_INET, socket.SOCK_STREAM)
        mock_socket.return_value.assert_has_calls([
            mock.call.bind(('', 0)),
            mock.call.connect(('127.0.0.1', 8080)),
            mock.call.close(),
        ])
        mock_TCPTendril.assert_called_once_with(manager,
                                                mock_socket.return_value)
        acceptor.assert_called_once_with(mock_TCPTendril.return_value)
        self.assertFalse(mock_track_tendril.called)
        self.assertFalse(mock_TCPTendril.return_value._start.called)
Example #4
0
    def test_connect_basic(self, mock_TCPTendril, mock_track_tendril,
                           mock_connect, mock_socket):
        acceptor = mock.Mock()
        manager = tcp.TCPTendrilManager()

        tend = manager.connect(('127.0.0.1', 8080), acceptor)

        mock_connect.assert_called_once_with(('127.0.0.1', 8080), acceptor,
                                             None)
        mock_socket.assert_called_once_with(socket.AF_INET, socket.SOCK_STREAM)
        mock_socket.return_value.assert_has_calls([
            mock.call.bind(('', 0)),
            mock.call.connect(('127.0.0.1', 8080)),
        ])
        mock_TCPTendril.assert_called_once_with(manager,
                                                mock_socket.return_value)
        acceptor.assert_called_once_with(mock_TCPTendril.return_value)
        mock_track_tendril.assert_called_once_with(
            mock_TCPTendril.return_value)
        mock_TCPTendril.return_value._start.assert_called_once_with()
        self.assertEqual(id(tend), id(mock_TCPTendril.return_value))
Example #5
0
    def test_listener_wrapper(self, mock_TCPTendril, mock_track_tendril,
                              mock_socket, mock_sleep):
        wrapped_sock = mock.Mock(**{
            'accept.side_effect': TestException(),
        })
        wrapper = mock.Mock(return_value=wrapped_sock)
        acceptor = mock.Mock()
        manager = tcp.TCPTendrilManager()
        manager.running = True

        with self.assertRaises(TestException):
            manager.listener(acceptor, wrapper)

        self.assertFalse(mock_sleep.called)
        mock_socket.assert_called_once_with(socket.AF_INET, socket.SOCK_STREAM)
        mock_socket.return_value.assert_has_calls([
            mock.call.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1),
            mock.call.bind(('', 0)),
            mock.call.getsockname(),
        ])
        wrapper.assert_called_once_with(mock_socket.return_value)
        wrapped_sock.assert_has_calls([
            mock.call.listen(1024),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.close(),
        ])
        self.assertEqual(manager.local_addr, ('127.0.0.1', 8080))
        self.assertFalse(mock_TCPTendril.called)
        self.assertFalse(acceptor.called)
        self.assertFalse(mock_track_tendril.called)
Example #6
0
    def test_connect_reject_connection(self, mock_TCPTendril,
                                       mock_track_tendril, mock_connect,
                                       mock_socket):
        acceptor = mock.Mock(side_effect=application.RejectConnection)
        manager = tcp.TCPTendrilManager()

        tend = manager.connect(('127.0.0.1', 8080), acceptor)

        self.assertEqual(tend, None)
        mock_connect.assert_called_once_with(('127.0.0.1', 8080), acceptor,
                                             None)
        mock_socket.assert_called_once_with(socket.AF_INET, socket.SOCK_STREAM)
        mock_socket.return_value.assert_has_calls([
            mock.call.bind(('', 0)),
            mock.call.connect(('127.0.0.1', 8080)),
            mock.call.close(),
        ])
        mock_TCPTendril.assert_called_once_with(manager,
                                                mock_socket.return_value)
        acceptor.assert_called_once_with(mock_TCPTendril.return_value)
        self.assertFalse(mock_track_tendril.called)
        self.assertFalse(mock_TCPTendril.return_value._start.called)
Example #7
0
    def test_listener_acceptor_badclose(self, mock_TCPTendril,
                                        mock_track_tendril, mock_socket,
                                        mock_sleep):
        clis = [
            mock.Mock(**{
                'close.side_effect': socket.error(),
            }),
            mock.Mock(**{
                'close.side_effect': socket.error(),
            }),
            mock.Mock(**{
                'close.side_effect': socket.error(),
            })
        ]
        mock_socket.return_value.accept.side_effect = [
            (clis[0], ('127.0.0.2', 8082)),
            (clis[1], ('127.0.0.3', 8083)),
            (clis[2], ('127.0.0.4', 8084)),
            TestException(),
            TestException(),
            TestException(),
            TestException(),
            TestException(),
            TestException(),
            TestException(),
            TestException(),
            TestException(),
            TestException(),
            TestException(),
        ]
        tendrils = [mock.Mock(), mock.Mock(), mock.Mock()]
        mock_TCPTendril.side_effect = tendrils[:]
        acceptor = mock.Mock(side_effect=[
            mock.Mock(),
            TestException(),
            mock.Mock(),
        ])
        manager = tcp.TCPTendrilManager()
        manager.running = True

        with self.assertRaises(TestException):
            manager.listener(acceptor, None)

        self.assertFalse(mock_sleep.called)
        mock_socket.assert_called_once_with(socket.AF_INET, socket.SOCK_STREAM)
        mock_socket.return_value.assert_has_calls([
            mock.call.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1),
            mock.call.bind(('', 0)),
            mock.call.getsockname(),
            mock.call.listen(1024),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.accept(),
            mock.call.close(),
        ])
        self.assertEqual(manager.local_addr, ('127.0.0.1', 8080))
        mock_TCPTendril.assert_has_calls([
            mock.call(manager, clis[0], ('127.0.0.2', 8082)),
            mock.call(manager, clis[1], ('127.0.0.3', 8083)),
            mock.call(manager, clis[2], ('127.0.0.4', 8084)),
        ])
        acceptor.assert_has_calls([
            mock.call(tendrils[0]),
            mock.call(tendrils[1]),
            mock.call(tendrils[2]),
        ])
        self.assertFalse(clis[0].close.called)
        clis[1].close.assert_called_once_with()
        self.assertFalse(clis[2].close.called)
        mock_track_tendril.assert_has_calls([
            mock.call(tendrils[0]),
            mock.call(tendrils[2]),
        ])
        tendrils[0]._start.assert_called_once_with()
        self.assertFalse(tendrils[1]._start.called)
        tendrils[2]._start.assert_called_once_with()