Exemplo n.º 1
0
async def test_dispatch_message_task_error(route):
    exc = Exception()
    route.deliver = AsyncMock(side_effect=exc)
    route.error_handler = AsyncMock(return_value="confirmation")
    dispatcher = LoaferDispatcher([route])

    message = "message"
    confirmation = await dispatcher.dispatch_message(message, route)
    assert confirmation == "confirmation"

    assert route.deliver.called is True
    route.deliver.assert_called_once_with(message)
    assert route.error_handler.called is True
Exemplo n.º 2
0
def client(client_class):
    client = AsyncMock()
    client_class.return_value = client

    if sys.version_info[:2] < (3, 8):
        client.read_gatt_char = CoroutineMock()
        client.write_gatt_char = CoroutineMock()

    connected = False

    async def is_connected():
        nonlocal connected
        return connected

    async def connect():
        nonlocal connected
        connected = True

    async def disconnect():
        nonlocal connected
        connected = False

    client.is_connected.side_effect = is_connected
    client.connect.side_effect = connect
    client.disconnect.side_effect = disconnect

    yield client
Exemplo n.º 3
0
async def test_dispatch_invalid_message(route, message):
    route.deliver = AsyncMock()
    dispatcher = LoaferDispatcher([route])

    confirmation = await dispatcher.dispatch_message(message, route)
    assert confirmation is False
    assert route.deliver.called is False
Exemplo n.º 4
0
 async def test_receive_with_timeout(self):
     message = Message(MessageType.WEBSOCKET_INACTIVE)
     data = message.to_json()
     websocket = AsyncMock()
     websocket.recv = CoroutineMock()
     websocket.recv.return_value = data
     assert await receive(websocket, timeout_sec=3) == message
Exemplo n.º 5
0
async def test_deliver_with_coroutine(dummy_provider):
    mock_handler = AsyncMock(return_value=False)
    route = Route(dummy_provider, mock_handler)
    message = "test"
    result = await route.deliver(message)
    assert result is False
    assert mock_handler.called
    assert message in mock_handler.call_args[0]
Exemplo n.º 6
0
def route(provider):
    message_translator = Mock(translate=Mock(
        return_value={'content': 'message'}))
    route = AsyncMock(provider=provider,
                      handler=Mock(),
                      message_translator=message_translator,
                      spec=Route)
    return route
Exemplo n.º 7
0
async def test_dispatch_providers(route, event_loop):
    dispatcher = LoaferDispatcher([route])
    dispatcher._dispatch_tasks = AsyncMock()
    dispatcher.stop_providers = Mock()
    await dispatcher.dispatch_providers(forever=False)

    assert dispatcher._dispatch_tasks.called
    dispatcher._dispatch_tasks.assert_called_once_with()
Exemplo n.º 8
0
async def test_dispatch_without_tasks(route, event_loop):
    route.provider.fetch_messages = AsyncMock(return_value=[])
    dispatcher = LoaferDispatcher([route])
    await dispatcher._dispatch_tasks()

    assert route.provider.fetch_messages.called
    assert route.provider.confirm_message.called is False
    assert route.provider.message_not_processed.called is False
Exemplo n.º 9
0
async def test_error_handler_coroutine(dummy_provider):
    error_handler = AsyncMock(return_value=True)
    route = Route(dummy_provider, mock.Mock(), error_handler=error_handler)
    exc = TypeError()
    exc_info = (type(exc), exc, "traceback")
    result = await route.error_handler(exc_info, "whatever")
    assert result is True
    assert error_handler.called
    error_handler.assert_called_once_with(exc_info, "whatever")
Exemplo n.º 10
0
 async def test_handle_exception_value_error(self, send, close):
     exception = ValueError("Hello!")
     websocket = AsyncMock()
     context = RequestFailedContext(FailureReason.INVALID_REQUEST, "Hello!")
     message = Message(MessageType.REQUEST_FAILED, context=context)
     json = message.to_json()
     await _handle_exception(exception, websocket)
     send.assert_awaited_once_with(websocket, json)
     close.assert_not_awaited()
Exemplo n.º 11
0
 async def test_schedule_obsolete_game_check(self, periodic, config):
     p = AsyncMock()
     p.start = CoroutineMock()
     periodic.return_value = p
     config.return_value = MagicMock(obsolete_game_check_period_sec=1,
                                     obsolete_game_check_delay_sec=2)
     await _schedule_obsolete_game_check()
     p.start.assert_awaited_once_with(delay=2)
     periodic.assert_called_once_with(1, _execute_obsolete_game_check)
Exemplo n.º 12
0
async def test_message_processing(route):
    dispatcher = LoaferDispatcher([route])
    dispatcher.dispatch_message = AsyncMock()
    await dispatcher._process_message("message", route)

    assert dispatcher.dispatch_message.called
    dispatcher.dispatch_message.assert_called_once_with("message", route)
    assert route.provider.confirm_message.called
    assert route.provider.message_not_processed.called is False
    route.provider.confirm_message.assert_called_once_with("message")
Exemplo n.º 13
0
 async def test_handle_exception_processing_error_comment(
         self, send, close):
     exception = ProcessingError(FailureReason.INVALID_PLAYER, "comment")
     websocket = AsyncMock()
     context = RequestFailedContext(FailureReason.INVALID_PLAYER, "comment")
     message = Message(MessageType.REQUEST_FAILED, context=context)
     json = message.to_json()
     await _handle_exception(exception, websocket)
     send.assert_awaited_once_with(websocket, json)
     close.assert_not_awaited()
Exemplo n.º 14
0
async def test_dispatch_message_task_cancel(route):
    route.deliver = AsyncMock(side_effect=asyncio.CancelledError)
    dispatcher = LoaferDispatcher([route])

    message = "message"
    confirmation = await dispatcher.dispatch_message(message, route)
    assert confirmation is False

    assert route.deliver.called
    route.deliver.assert_called_once_with(message)
Exemplo n.º 15
0
async def test_dispatch_message_task_delete_message(route):
    route.deliver = AsyncMock(side_effect=DeleteMessage)
    dispatcher = LoaferDispatcher([route])

    message = "rejected-message"
    confirmation = await dispatcher.dispatch_message(message, route)
    assert confirmation is True

    assert route.deliver.called
    route.deliver.assert_called_once_with(message)
Exemplo n.º 16
0
async def test_dispatch_message(route):
    route.deliver = AsyncMock(return_value="confirmation")
    dispatcher = LoaferDispatcher([route])

    message = "foobar"
    confirmation = await dispatcher.dispatch_message(message, route)
    assert confirmation == "confirmation"

    assert route.deliver.called
    route.deliver.assert_called_once_with(message)
Exemplo n.º 17
0
 async def test_handle_connection(self, handle_data, handle_exception,
                                  handle_connect, handle_disconnect):
     data = b"test data"
     websocket = AsyncMock()
     websocket.__aiter__.return_value = [data]
     await _handle_connection(websocket, "path")  # path is unused
     handle_data.assert_called_once_with(data, websocket)
     handle_connect.assert_called_once_with(websocket)
     handle_disconnect.assert_called_once_with(websocket)
     handle_exception.assert_not_called()
Exemplo n.º 18
0
 async def test_handle_exception_processing_error_websocket_limit(
         self, send, close):
     exception = ProcessingError(FailureReason.WEBSOCKET_LIMIT)
     websocket = AsyncMock()
     context = RequestFailedContext(FailureReason.WEBSOCKET_LIMIT,
                                    FailureReason.WEBSOCKET_LIMIT.value)
     message = Message(MessageType.REQUEST_FAILED, context=context)
     json = message.to_json()
     await _handle_exception(exception, websocket)
     send.assert_awaited_once_with(websocket, json)
     close.assert_awaited_once_with(websocket)
Exemplo n.º 19
0
 async def test_handle_disconnect(self, manager, event_handler):
     handler = mock_handler()
     manager.return_value = handler.manager
     event_handler.return_value = handler
     websocket = AsyncMock()
     await _handle_disconnect(websocket)
     event_handler.assert_called_once_with(manager.return_value)
     handler.manager.lock.assert_awaited()
     handler.handle_websocket_disconnected_event.assert_called_once_with(
         websocket)
     handler.execute_tasks.assert_awaited_once()
Exemplo n.º 20
0
 async def test_handle_exception_fail(self, send, close):
     # this just confirms that send failures aren't propogated to the caller (we intentionally ignore them)
     exception = ProcessingError(FailureReason.INVALID_PLAYER)
     websocket = AsyncMock()
     send.side_effect = Exception("Send failed!")
     context = RequestFailedContext(FailureReason.INVALID_PLAYER,
                                    FailureReason.INVALID_PLAYER.value)
     message = Message(MessageType.REQUEST_FAILED, context=context)
     json = message.to_json()
     await _handle_exception(exception, websocket)
     send.assert_awaited_once_with(websocket, json)
     close.assert_not_awaited()
Exemplo n.º 21
0
async def test_deliver_with_message_translator(dummy_provider):
    mock_handler = AsyncMock(return_value=True)
    route = Route(dummy_provider, mock_handler)
    route.apply_message_translator = mock.Mock(return_value={
        "content": "whatever",
        "metadata": {}
    })
    result = await route.deliver("test")
    assert result is True
    assert route.apply_message_translator.called
    assert mock_handler.called
    mock_handler.assert_called_once_with("whatever", {})
Exemplo n.º 22
0
 async def test_handle_connection_shutdown(self, handle_data,
                                           handle_exception, handle_connect,
                                           handle_disconnect):
     websocket = AsyncMock()
     exception = ConnectionClosed(None, None)
     websocket.__aiter__.side_effect = exception  # the wait on the websocket is what throws the connection closed
     handle_data.side_effect = exception
     await _handle_connection(websocket, "path")  # path is unused
     handle_data.assert_not_called()
     handle_connect.assert_called_once_with(websocket)
     handle_disconnect.assert_called_once_with(websocket)
     handle_exception.assert_not_called()
Exemplo n.º 23
0
 async def test_handle_data(self, manager, event_handler, handle_message,
                            data):
     handler = mock_handler()
     manager.return_value = handler.manager
     event_handler.return_value = handler
     websocket = AsyncMock()
     json = data["list.json"]
     message = Message.for_json(json)
     await _handle_data(json, websocket)
     event_handler.assert_called_once_with(manager.return_value)
     handler.manager.lock.assert_awaited()
     handle_message.assert_called_once_with(handler, message, websocket)
     handler.execute_tasks.assert_awaited_once()
Exemplo n.º 24
0
 async def test_handle_connection_exception(self, handle_data,
                                            handle_exception,
                                            handle_connect,
                                            handle_disconnect):
     data = b"test data"
     websocket = AsyncMock()
     websocket.__aiter__.return_value = [data]
     exception = ProcessingError(FailureReason.INTERNAL_ERROR)
     handle_data.side_effect = exception
     await _handle_connection(websocket, "path")  # path is unused
     handle_data.assert_called_once_with(data, websocket)
     handle_connect.assert_called_once_with(websocket)
     handle_disconnect.assert_called_once_with(websocket)
     handle_exception.assert_called_once_with(exception, websocket)
Exemplo n.º 25
0
 def test_add_signal_handlers(self, signaler):
     stop = AsyncMock()
     set_result = AsyncMock()
     stop.set_result = set_result
     loop = AsyncMock()
     loop.create_future.return_value = stop
     assert _add_signal_handlers(loop) is stop
     if sys.platform == "win32":
         assert [signal.SIGTERM, signal.SIGINT
                 ] == [c.args[0] for c in signaler.call_args_list
                       ]  # confirm all signals are handled
         signaler.call_args_list[0].args[1](
             "x", "y"
         )  # execute the handler with dummy arguments (which are ignored)
         stop.set_result.assert_called_once_with(
             None
         )  # confirm that the handler sets the stop future result properly
     else:
         loop.add_signal_handler.assert_has_calls([
             call(signal.SIGHUP, set_result, None),  # pylint: disable=no-member
             call(signal.SIGTERM, set_result, None),
             call(signal.SIGINT, set_result, None),
         ])
Exemplo n.º 26
0
def boto_client_sqs(queue_url, sqs_message):
    mock_client = mock.Mock()
    mock_client.get_queue_url = AsyncMock(return_value=queue_url)
    mock_client.delete_message = AsyncMock()
    mock_client.receive_message = AsyncMock(return_value=sqs_message)
    mock_client.send_message = AsyncMock(return_value=sqs_send_message)
    mock_client.change_message_visibility = AsyncMock()
    mock_client.close = AsyncMock()
    return mock_client
Exemplo n.º 27
0
 def test_run_server(self, websocket_server, config):
     # I'm not entirely sure I'm testing this properly.
     # I can't find a good way to prove that _websocket_server(stop) was passed to run_until_complete
     # But, the function is so short that I can eyeball it, and it will either work or it won't when run by hand
     config.return_value = MagicMock(server_host="host",
                                     server_port=1234,
                                     close_timeout_sec=8)
     stop = asyncio.Future()
     stop.set_result(None)
     loop = AsyncMock()
     _run_server(loop, stop)
     loop.run_until_complete.assert_called_once()
     websocket_server.assert_called_once_with(stop=stop,
                                              host="host",
                                              port=1234,
                                              close_timeout_sec=2)
     loop.stop.assert_called_once()
     loop.close.assert_called_once()
Exemplo n.º 28
0
    async def mocked_connect_robust(loop=None, host=None):
        conn_mock = AsyncMock(spec=aio_pika.robust_connection.RobustConnection)
        conn_mock.loop = loop
        conn_mock.is_closed = closed

        chan_mock = CoroutineMock()
        exchange_mock = CoroutineMock()
        queue_mock = CoroutineMock()

        queue_mock.bind = CoroutineMock()
        queue_mock.consume = CoroutineMock()

        exchange_mock.publish = CoroutineMock()

        chan_mock.declare_exchange = CoroutineMock(return_value=exchange_mock)
        chan_mock.declare_queue = CoroutineMock(return_value=queue_mock)

        conn_mock.close = CoroutineMock()
        conn_mock.channel = CoroutineMock(return_value=chan_mock)

        return conn_mock
Exemplo n.º 29
0
def _session_app() -> Quart:
    app = Quart(__name__)
    app.session_interface = AsyncMock(spec=SessionInterface)
    app.session_interface.open_session.return_value = SecureCookieSession()  # type: ignore
    app.session_interface.is_null_session.return_value = False  # type: ignore

    @app.route("/")
    async def route() -> str:
        session["a"] = "b"
        return ""

    @app.websocket("/ws/")
    async def ws() -> None:
        session["a"] = "b"
        await websocket.accept()
        await websocket.send("")

    @app.websocket("/ws_return/")
    async def ws_return() -> str:
        session["a"] = "b"
        return ""

    return app
Exemplo n.º 30
0
def boto_client_sns(sns_publish, sns_list_topics):
    mock_client = mock.Mock()
    mock_client.publish = AsyncMock(return_value=sns_publish)
    mock_client.close = AsyncMock()
    return mock_client