async def test_deliver_with_message_translator(dummy_provider): mock_handler = CoroutineMock(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', {})
async def test_error_handler_coroutine(dummy_provider): error_handler = CoroutineMock(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')
async def test_007_on_direct_message(self): cb = CoroutineMock() self.bus.direct_subscribe(cb) msg = self.bus.client.Message() msg['type'] = 'message' msg['from'] = JID('other@localhost') msg['body'] = '{"key": "value"}' await self.bus._on_direct_message(msg) cb.assert_called_once_with('other', {'key': 'value'})
def test_main_async(mocker, event_loop): COMMANDS = [] mocker.patch('jenkins_epo.main.COMMANDS', COMMANDS) command = CoroutineMock() command.__name__ = 'bot' command.__code__ = Mock(co_varnames=(), co_argcount=0) COMMANDS.append(command) from jenkins_epo.main import main main(argv=['bot'], loop=event_loop) assert command.mock_calls
async def test_002_on_event(self): cb = CoroutineMock() with patch.object(self.bus._mucs, 'joinMUC') as join_mock: self.bus._connected.set() await self.bus.subscribe('other', cb) join_mock.assert_called_once_with('*****@*****.**', 'login') msg = self.bus.client.Message() msg['type'] = 'groupchat' msg['from'] = JID('other@localhost') msg['body'] = '{"key": "value"}' await self.bus._on_event(msg) cb.assert_called_once_with({'key': 'value'})
def test_main_async_exception(mocker, event_loop): COMMANDS = [] mocker.patch('jenkins_epo.main.COMMANDS', COMMANDS) command = CoroutineMock() command.__name__ = 'bot' command.__code__ = Mock(co_varnames=(), co_argcount=0) command.side_effect = ValueError() COMMANDS.append(command) from jenkins_epo.main import main with pytest.raises(ValueError): main(argv=['bot'], loop=event_loop) assert command.mock_calls assert event_loop.is_closed()
async def test_resolve_request_with_last_falsy_matcher(self): handler = CoroutineMock(return_value=sentinel.response) matcher1 = CoroutineMock(return_value=True) matcher2 = CoroutineMock(return_value=False) self.resolver.register_matcher(matcher1, handler) self.resolver.register_matcher(matcher2, handler) request = Mock() response = await self.resolver.resolve(request, self.default_app) self.assertEqual(response, self.default_handler) matcher1.assert_called_once_with(request) matcher2.assert_called_once_with(request) handler.assert_not_called()
async def test_resolve_request_priority(self): matcher = CoroutineMock(side_effect=(True, True)) handler1 = CoroutineMock(return_value=sentinel.response1) handler2 = CoroutineMock(return_value=sentinel.response2) self.resolver.register_matcher(matcher, handler1) self.resolver.register_matcher(matcher, handler2) request = Mock() response = await self.resolver.resolve(request, self.default_app) self.assertEqual(response, handler1) handler1.assert_not_called() handler2.assert_not_called() matcher.assert_called_once_with(request)
async def test_resolve_request_with_multiple_handlers(self): matcher = CoroutineMock(side_effect=(False, True)) handler1 = CoroutineMock(return_value=sentinel.response1) handler2 = CoroutineMock(return_value=sentinel.response2) self.resolver.register_matcher(matcher, handler1) self.resolver.register_matcher(matcher, handler2) request = Mock() response = await self.resolver.resolve(request, self.default_app) self.assertEqual(response, handler2) handler1.assert_not_called() handler2.assert_not_called() matcher.assert_has_calls([call(request)] * 2) self.assertEqual(matcher.call_count, 2)
async def test_get_image_new(ota, image, key, image_with_version, monkeypatch): newer = image_with_version(image.version + 1) ota.async_event = CoroutineMock(return_value=[None, image, newer]) assert len(ota._image_cache) == 0 res = await ota.get_ota_image(MANUFACTURER_ID, IMAGE_TYPE) # got new image in the cache assert len(ota._image_cache) == 1 assert res.header == newer.header assert res.subelements == newer.subelements assert ota.async_event.call_count == 1 assert ota.async_event.call_args[0][0] == "get_image" assert ota.async_event.call_args[0][1] == key ota.async_event.reset_mock() assert len(ota._image_cache) == 1 res = await ota.get_ota_image(MANUFACTURER_ID, IMAGE_TYPE) # should get just the cached image assert len(ota._image_cache) == 1 assert res.header == newer.header assert res.subelements == newer.subelements assert ota.async_event.call_count == 0 # on cache expiration, ping listeners ota.async_event.reset_mock() assert len(ota._image_cache) == 1 monkeypatch.setattr( zigpy.ota, "TIMEDELTA_0", zigpy.ota.CachedImage.DEFAULT_EXPIRATION + datetime.timedelta(seconds=1), ) res = await ota.get_ota_image(MANUFACTURER_ID, IMAGE_TYPE) assert len(ota._image_cache) == 1 assert res.header == newer.header assert res.subelements == newer.subelements assert ota.async_event.call_count == 1
async def test_single_wrong_report_still_rated_correctly( game: Game, player_factory): # based on replay with UID 11255492 # Mocking out database calls, since not all player IDs exist. game.update_game_player_stats = CoroutineMock() game.state = GameState.LOBBY # Loading log data with open("tests/data/uid11255492.log.json", "r") as f: log_dict = json.load(f) old_rating = 1500 players = { player_id: player_factory( login=f"{player_id}", player_id=player_id, global_rating=Rating(old_rating, 250), with_lobby_connection=False, ) for team in log_dict["teams"].values() for player_id in team } add_connected_players(game, list(players.values())) for team_id, team_list in log_dict["teams"].items(): for player_id in team_list: game.set_player_option(player_id, "Team", team_id) game.set_player_option(player_id, "Army", player_id - 1) await game.launch() for reporter, reportee, outcome, score in log_dict["results"]: await game.add_result(players[reporter], reportee, outcome, score) result = game.compute_rating() winning_ids = log_dict["teams"][str(log_dict["winning_team"])] for team in result: for player, new_rating in team.items(): assert player in game.players player_is_on_winning_team = player.id in winning_ids rating_improved = new_rating.mu > old_rating assert rating_improved is player_is_on_winning_team
async def test_play_track_list_loops(self, example_music_manager, monkeypatch): """ The _play_track_list() method should call _play_track() for every track in it. If all tracks have been played and the `loop` attribute is set on the track_list, repeat. """ play_track_mock = CoroutineMock() monkeypatch.setattr("src.music.music_manager.MusicManager._play_track", play_track_mock) group = example_music_manager.groups[0] track_list = MagicMock() track_list.tracks = [Track("track-1.mp3"), Track("track-2.mp3")] loop_property = PropertyMock(side_effect=[True, False]) type(track_list).loop = loop_property group.track_lists = [track_list] await example_music_manager._play_track_list(request=None, group_index=0, track_list_index=0) assert play_track_mock.await_count == 4 # loops once again over two tracks assert loop_property.call_count == 2
async def test_subscription_keepalive_count(mocker): """ Check the subscription parameter MaxKeepAliveCount value with various publishInterval and session_timeout values. """ mock_subscription = mocker.patch( "asyncua.common.subscription.Subscription.init", new=CoroutineMock()) c = Client("opc.tcp://fake") # session timeout < publish_interval c.session_timeout = 30000 # ms publish_interval = 1000 # ms handler = 123 sub = await c.create_subscription(publish_interval, handler) assert sub.parameters.RequestedMaxKeepAliveCount == 22 # session_timeout > publish_interval c.session_timeout = 30000 publish_interval = 75000 sub = await c.create_subscription(publish_interval, handler) assert sub.parameters.RequestedMaxKeepAliveCount == 0
async def test_it_calls_handler_error_if_emit_fails(self): temp_file = NamedTemporaryFile(delete=False) handler = AsyncFileHandler(temp_file.name) log_record = LogRecord( name="Xablau", level=20, pathname="/aiologger/tests/test_logger.py", lineno=17, msg="Xablau!", exc_info=None, args=None, ) await handler._init_writer() exc = Exception("Xablau") with patch.object(handler.stream, "write", side_effect=exc), patch.object( handler, "handle_error", CoroutineMock()) as handle_error: await handler.emit(log_record) handle_error.assert_awaited_once_with(log_record, exc)
async def test_emit_awaits_for_handle_error_is_an_exceptions_is_raised( self): handler = BaseAsyncRotatingFileHandler(filename=self.temp_file.name) handler.should_rollover = Mock(return_value=False) exc = OSError() with patch("aiologger.handlers.files.AsyncFileHandler.emit", side_effect=exc), patch.object( handler, "handle_error", CoroutineMock()) as handleError: log_record = LogRecord( name="Xablau", level=20, pathname="/aiologger/tests/test_logger.py", lineno=17, msg="Xablau!", exc_info=None, args=None, ) await handler.emit(log_record) handleError.assert_awaited_once_with(log_record, exc)
async def test_getby_url(self): summarized_at = datetime.now() self.mock_cursor.fetchone = CoroutineMock( return_value=("document_id", "user_id", "www.test.com", "contents", summarized_at)) doc = DocumentRepository(self.postgres_pool_mock) obtained_doc = await doc.getby_url("www.test.com") self.postgres_pool_mock.acquire.assert_called_once() self.postgres_pool_mock.release.assert_called_once() self.mock_cursor.execute.assert_called_once() self.mock_cursor.fetchone.assert_called_once() self.assertIsInstance(obtained_doc, DocumentRepository.DocumentView) self.assertEqual(obtained_doc.document_id, "document_id") self.assertEqual(obtained_doc.user_id, "user_id") self.assertEqual(obtained_doc.url, "www.test.com") self.assertEqual(obtained_doc.contents, "contents") self.assertIs(obtained_doc.summarized_at, summarized_at)
async def test_command_game_join_game_not_found( lobbyconnection, game_service, test_game_info, players ): lobbyconnection.send = CoroutineMock() lobbyconnection.game_service = game_service lobbyconnection.player = players.hosting test_game_info["uid"] = 42 await lobbyconnection.on_message_received({ "command": "game_join", **test_game_info }) lobbyconnection.send.assert_called_once_with({ "command": "notice", "style": "info", "text": "The host has left the game." })
def test_request(mock_post): mock_post.return_value.__aenter__.return_value.json = CoroutineMock( side_effect=[{ "ok": True, "result": 1 }, { "ok": False }]) async def test(): telegram = Telegram(token="token") assert await telegram._request("method1", {"arg": "val1"}) == 1 with pytest.raises(RequestException): await telegram._request("method2", {"arg": "val2"}) await telegram.session.close() asyncio.get_event_loop().run_until_complete(test())
async def test_send_code_changed_flag(self, mocked_socketio, app): self.mocked_mappings[self.sid] = 1 self.game_api.worker_manager.add_new_worker( self.mocked_mappings[self.sid]) worker = self.game_api.worker_manager.player_id_to_worker[ self.mocked_mappings[self.sid]] worker.has_code_updated = True with mock.patch('service.socketio_server.emit', new=CoroutineMock()) as mocked_emit: await self.game_api.send_updates() user_game_state_call = mock.call('game-state', {'foo': 'bar'}, room=self.sid) user_game_code_changed_call = mock.call('feedback-avatar-updated', room=self.sid) mocked_emit.assert_has_calls( [user_game_state_call, user_game_code_changed_call], any_order=True)
async def test_can_handle_connected_frame_with_heartbeat_disabled( self, heartbeater_klass_mock): frame = Frame('CONNECTED', { 'heart-beat': '1000,1000', }, '{}') heartbeater_mock = heartbeater_klass_mock.return_value heartbeater_mock.start = CoroutineMock() stomp = StompReader(None, self.loop, heartbeat={ 'enabled': False, 'cx': 0, 'cy': 0 }) stomp._transport = Mock() await stomp._handle_connect(frame) heartbeater_klass_mock.assert_not_called
async def test_ok(self, mocker: MockFixture, fake_data_provider: BaseDataProvider): fake_data = mocker.Mock() fake_include_name = 'foo' fake_include_params = mocker.Mock() mocker.patch.object(fake_data_provider, '_available_includes', {fake_include_name: 'bar'}) mocked_update_with_include_data = mocker.patch.object( fake_data_provider, 'update_with_include_data') mocked_get_list_include_data = mocker.patch.object( fake_data_provider, 'get_list_include_data', CoroutineMock()) await fake_data_provider.extend_data_with_includes( fake_data, fake_include_name, fake_include_params) mocked_get_list_include_data.assert_called_once_with( fake_data, 'bar', fake_include_params) mocked_update_with_include_data.assert_called_once_with( fake_data, fake_include_name, mocked_get_list_include_data.return_value)
async def test_interval_functions(http_redirect, ssl_certificate): with patch("asyncio.sleep", new=CoroutineMock()): async with CaseControlledTestServer( ssl=ssl_certificate.server_context()) as server: controller = await setup_multi_session(server, http_redirect) INVALID_NEW_INTERVAL = 25 VALID_NEW_INTERVAL = 500 assert controller.get_update_interval() == sc.DEFAULT_UPDATE_INTERVAL controller.set_update_interval(INVALID_NEW_INTERVAL) assert controller.get_update_interval() == sc.DEFAULT_UPDATE_INTERVAL controller.set_update_interval(VALID_NEW_INTERVAL) assert controller.get_update_interval() == VALID_NEW_INTERVAL assert controller.get_fetch_interval() == sc.DEFAULT_FETCH_INTERVAL controller.set_fetch_interval(INVALID_NEW_INTERVAL) assert controller.get_fetch_interval() == sc.DEFAULT_FETCH_INTERVAL controller.set_fetch_interval(VALID_NEW_INTERVAL) assert controller.get_fetch_interval() == VALID_NEW_INTERVAL
def test_register_failure(mocker, SETTINGS, WORKERS): SETTINGS.GITHUB_SECRET = 'notasecret' from concurrent.futures import Future future = Future() future.set_exception(Exception()) register_webhook = mocker.patch( 'jenkins_epo.main.register_webhook', CoroutineMock(return_value=[future]), ) mocker.patch('jenkins_epo.main.WORKERS', WORKERS) from jenkins_epo.main import register with pytest.raises(SystemExit): yield from register() assert WORKERS.start.mock_calls assert register_webhook.mock_calls assert WORKERS.terminate.mock_calls
async def test_execute_query_with_headers(self, mock_post): """Sends a graphql POST request with headers.""" mock_post.return_value.__aenter__.return_value.json = CoroutineMock() client = GraphqlClient( endpoint="http://www.test-api.com/", headers={"Content-Type": "application/json", "Existing": "123",}, ) query = "" await client.execute_async("", headers={"Existing": "456", "New": "foo"}) mock_post.assert_called_once_with( "http://www.test-api.com/", json={"query": query}, headers={ "Content-Type": "application/json", "Existing": "456", "New": "foo", }, )
async def test_set_indexes(self, *args): mock_ctx = { '_id': 'some-value', 'path': 'some-path', 'host': 'some-host', 'status_code': 'some-value', 'rule_id': 'some-value', } mock_db = MagicMock() mock_hset = CoroutineMock() mock_db.hset = mock_hset await RateLimiter._set_indexes(mock_ctx, mock_db) args[0].assert_awaited() for call in mock_hset.await_args_list: expect([ rule_status_code_index, entry_rule_id_index, entry_host_index ]).to(contain(call[0][0])) expect(call[0][1]).to(equal(mock_ctx['_id'])) expect([mock_ctx[key] for key in mock_ctx.keys()]).to(contain(call[0][2]))
async def nbu_converter() -> NBUConverter: crawler = Crawler() await crawler.prepare() crawler.get_json = CoroutineMock(return_value=[{ "r030": 840, "txt": "Долар США", "rate": 26.619328, "cc": "USD", "exchangedate": "13.05.2019" }, { "r030": 978, "txt": "Євро", "rate": 29.608679, "cc": "EUR", "exchangedate": "13.05.2019" }]) converter = NBUConverter(crawler) await converter.prepare() yield converter await crawler.spare()
async def test_on_gmail(): handler = CallbackHandler(MagicMock(), MagicMock()) with mock.patch(SEND_TO_TELEGRAM, new=CoroutineMock()) as send: await handler.on_mail_choice({ 'callback_query': { 'message': { 'chat': { 'id': 12 } }, 'data': '/gmail', } }) args, _ = send.call_args send.assert_called_once() assert args[0] == 'sendMessage' assert args[1]['chat_id'] == 12 assert args[1]['text'][57:62] == 'Gmail' assert args[1]['parse_mode'] == 'Markdown' assert args[1]['disable_web_page_preview'] is True
def test_from_address(self, peering): peering.return_value.get = CoroutineMock(return_value={ "version": 2, "currency": "meta_brouzouf", "endpoints": [ "BASIC_MERKLED_API duniter.inso.ovh 80" ], "block": "48698-000005E0F228038E4DDD4F6CA4ACB01EC88FBAF8", "signature": "82o1sNCh1bLpUXU6nacbK48HBcA9Eu2sPkL1/3c2GtDPxBUZd2U2sb7DxwJ54n6ce9G0Oy7nd1hCxN3fS0oADw==", "raw": "Version: 2\nType: Peer\nCurrency: meta_brouzouf\nPublicKey: 8Fi1VSTbjkXguwThF4v2ZxC5whK7pwG2vcGTkPUPjPGU\nBlock: 48698-000005E0F228038E4DDD4F6CA4ACB01EC88FBAF8\nEndpoints:\nBASIC_MERKLED_API duniter.inso.ovh 80\n", "pubkey": "8Fi1VSTbjkXguwThF4v2ZxC5whK7pwG2vcGTkPUPjPGU" }) async def exec_test(): node = await Node.from_address("meta_brouzouf", "127.0.0.1", 9000, Mock("aiohttp.ClientSession")) self.assertEqual(node.pubkey, "8Fi1VSTbjkXguwThF4v2ZxC5whK7pwG2vcGTkPUPjPGU") self.assertEqual(node.endpoint.inline(), "BASIC_MERKLED_API duniter.inso.ovh 80") self.assertEqual(node.currency, "meta_brouzouf") self.lp.run_until_complete(exec_test())
async def test_bulk_flushes_on_timeout_even_with_bucket_not_full(self): class MyBucket(Bucket): def pop_all(self): global items items = self._items self._items = [] return items handler_mock = CoroutineMock(__name__="handler") self.one_route_fixture["handler"] = handler_mock self.one_route_fixture["options"]["bulk_size"] = 3 consumer = Consumer( self.one_route_fixture, *self.connection_parameters, bucket_class=MyBucket, ) msgs = [ self._make_msg(delivery_tag=10), self._make_msg(delivery_tag=11), ] await consumer.on_queue_message(msgs[0]) handler_mock.assert_not_awaited() await consumer.on_queue_message(msgs[1]) handler_mock.assert_not_awaited() self.loop.create_task(consumer._flush_clocked()) # Realizando sleep para devolver o loop para o clock await asyncio.sleep(0.1) handler_mock.assert_awaited_once_with(items) msgs[0].ack.assert_awaited_once() msgs[1].ack.assert_awaited_once() msgs[0].reject.assert_not_awaited() msgs[1].reject.assert_not_awaited()
async def test_lock_expire_retries_for_timeouts(self, lock_manager_redis_patched, locked_lock): lock_manager, redis = lock_manager_redis_patched redis.set_lock = CoroutineMock(side_effect=[(True, 1100), (True, 1001), (True, 2000)]) lock = await lock_manager.lock('resource') calls = [ call('resource', ANY), call('resource', ANY), call('resource', ANY) ] redis.set_lock.assert_has_calls(calls) assert lock.resource == 'resource' assert lock.id == ANY assert lock.valid is False
async def test_get_is_bad_url_true(): url = str(HOSTNAME + "/" + PATH) #TODO: This line is ridiculously long, shorten it expected_response_body = str({ url: { url: True } }).lower().replace("\'", "\"").replace(" ", "").encode('ascii') expected_response_code = 200 request_data = {"hostname_port": HOSTNAME, "path_query": PATH} main.datastore = CoroutineMock(Datastore) main.datastore.get_is_url_bad.return_value = {url: True} request = Mock(path_params=request_data) response = await main.get_is_url_bad(request) assert response.body == expected_response_body assert response.status_code == expected_response_code
async def test_run_dispatches_a_new_task_for_each_valid_clock_tick(self): clock = asynctest.MagicMock() clock.__aiter__.return_value = range(3) wrapped_task = Mock() with patch.multiple( self.task_runner, clock=clock, _wrapped_task=wrapped_task, can_dispatch_task=CoroutineMock(side_effect=[True, False, True]), ), patch( "asyncworker.task_runners.asyncio.ensure_future" ) as ensure_future: await self.task_runner._run() self.assertEqual( ensure_future.call_args_list, [ call(wrapped_task.return_value), call(wrapped_task.return_value), ], )
async def test_can_open_browser(self, browser_open_mock): storage = Mock() storage.load.return_value = None site = Mock() site.stop = CoroutineMock() token_waiter = Future() token_waiter.set_result({'access_token': '1234'}) app = {'port': 30000, 'token_waiter': token_waiter} self.manager.storage = storage self.manager.app = app self.manager.site = site token = await self.manager.get_token() self.assertEqual(token, '1234') browser_open_mock.assert_called_with( 'http://endpoint/authorize?response_type=token&client_id=client_id&redirect_uri=http%3A//localhost%3A30000' ) # noqa
async def test_cache(config, http, cache): """ Make sure an API method, when called more than once with the same parameters, only results in one HTTP call, since the second time it gets the data from the cache. """ http.get = CoroutineMock() text = '{}' http.get.return_value = {'status': 200, 'text': text} api = Api(config, http, cache) user = '******' params = {'limit': 10} await api.purchases_by_user(params, username=user) await api.purchases_by_user(params, username=user) path = api._paths['purchases_by_user'].format(username=user) url = config['API_BASE_URL'] + path + '?limit=10' api.http.get.assert_called_once_with(url)
async def test_request(nw: Network): class MagicMockContext(MagicMock): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) type(self).__aenter__ = CoroutineMock(return_value='response data') type(self).__aexit__ = CoroutineMock(return_value=MagicMock()) method = HttpMethod.POST url = 'someurl' data = {'some': 'data'} nw._handle_response = CoroutineMock() nw._handle_response.return_value = 'some value' with patch('aiohttp.ClientSession.post', new_callable=MagicMockContext) as m: result = await nw._request(method, url, data) m.assert_called_once_with(url, data=data) nw._handle_response.assert_awaited_once_with('response data') assert result == 'some value'
async def test_async_error_wrapper(): async def tmp(): 1 / 0 f = WrappedFunction(tmp) WrappedFunction._EVENT_LOOP = asyncio.get_event_loop() err_func = CoroutineMock() err_listener = HABApp.core.EventBusListener( 'HABApp.Errors', WrappedFunction(err_func, name='ErrMock')) HABApp.core.EventBus.add_listener(err_listener) f.run() await asyncio.sleep(0.05) assert err_func.called err = err_func.call_args[0][0] assert isinstance(err, HABApp.core.events.habapp_events.HABAppError) assert err.func_name == 'tmp' assert isinstance(err.exception, ZeroDivisionError) assert err.traceback.startswith('Traceback (most recent call last):')
async def test_lock_expire_retries_for_timeouts(self, lock_manager_redis_patched, locked_lock): lock_manager, redis = lock_manager_redis_patched redis.set_lock = CoroutineMock(side_effect=[ 1.100, 1.001, 2.000 ]) with pytest.raises(LockError): await lock_manager.lock('resource', 1.0) await real_sleep(0.1) # wait until cleaning is completed calls = [ call('resource', ANY, 1.0), call('resource', ANY, 1.0), call('resource', ANY, 1.0) ] redis.set_lock.assert_has_calls(calls) redis.unset_lock.assert_called_once_with('resource', ANY)
async def test_auth_exception_no_handler(mock_httpclient, caplog): async_client = mock_httpclient.AsyncHTTPClient.return_value # No body, so _write_key will raise exception async_client.fetch = CoroutineMock(return_value=Mock( spec=['code'], **{'code': 200}, )) authenticator = SSHAPIAuthenticator() authenticator.server = 'http://localhost:9999' authenticator.skey = '' data = {'username': '******', 'password': '******'} assert_keys_do_not_exist() resp = await authenticator.authenticate(None, data) assert_keys_do_not_exist() assert resp is None logs = caplog.record_tuples assert len(logs) == 1 _, _, message = logs[0] expected_message = 'SSH Auth API Authentication failed for user "tester"' assert message == expected_message
async def test_write_rating_progress_message(ladder_service: LadderService, player_factory): player = player_factory(ladder_rating=(1500, 500)) player.write_message = CoroutineMock() ladder_service.write_rating_progress(player, RatingType.LADDER_1V1) player.write_message.assert_called_once_with({ "command": "notice", "style": "info", "text": ("<i>Welcome to the matchmaker</i><br><br><b>Until " "you've played enough games for the system to learn " "your skill level, you'll be matched randomly.</b><br>" "Afterwards, you'll be more reliably matched up with " "people of your skill level: so don't worry if your " "first few games are uneven. This will improve as you " "play!</b>") })