async def test_aiter_when_newest_first(self): mock_payload_1 = {"id": "1213321123123"} mock_payload_2 = {"id": "1213321123666"} mock_payload_3 = {"id": "1213321124123"} mock_payload_4 = {"id": "1213321124567"} mock_payload_5 = {"id": "121332112432234"} mock_result_1 = mock.Mock() mock_result_2 = mock.Mock() mock_result_3 = mock.Mock() mock_result_4 = mock.Mock() mock_result_5 = mock.Mock() expected_route = routes.GET_MY_GUILDS.compile() mock_entity_factory = mock.Mock() mock_entity_factory.deserialize_own_guild.side_effect = [ mock_result_1, mock_result_2, mock_result_3, mock_result_4, mock_result_5, ] mock_request = mock.AsyncMock( side_effect=[[mock_payload_3, mock_payload_4, mock_payload_5], [mock_payload_1, mock_payload_2], []]) iterator = special_endpoints.OwnGuildIterator( mock_entity_factory, mock_request, True, first_id="55555555555555555") result = await iterator assert result == [ mock_result_1, mock_result_2, mock_result_3, mock_result_4, mock_result_5 ] mock_entity_factory.deserialize_own_guild.assert_has_calls([ mock.call(mock_payload_5), mock.call(mock_payload_4), mock.call(mock_payload_3), mock.call(mock_payload_2), mock.call(mock_payload_1), ]) mock_request.assert_has_awaits([ mock.call(compiled_route=expected_route, query={"before": "55555555555555555"}), mock.call(compiled_route=expected_route, query={"before": "1213321124123"}), mock.call(compiled_route=expected_route, query={"before": "1213321123123"}), ])
async def test_cancel_update_welcome_message(): guild = dpytest.get_config().guilds[0] old_message = IntroCog.get_guild_welcome_message(guild.id) new_message = "this is a non default message" msg_mock = dpytest.back.make_message('n', dpytest.get_config().members[0], dpytest.get_config().channels[0]) with mock.patch('cogs.IntroCog.wait_for_message', mock.AsyncMock(return_value=msg_mock)): await dpytest.message(KoalaBot.COMMAND_PREFIX + "update_welcome_message " + new_message) dpytest.verify_message(f"""Your current welcome message is:\n\r{old_message}""") dpytest.verify_message(f"""Your new welcome message will be:\n\r{new_message}\n\r{IntroCog.BASE_LEGAL_MESSAGE}""" + """\n\rWould you like to update the message? Y/N?""") dpytest.verify_message("Okay, I won't update the welcome message then.") dpytest.verify_message(assert_nothing=True) assert DBManager.fetch_guild_welcome_message(guild.id) != new_message
async def test_wrap_stream_errors_write(): grpc_error = RpcErrorImpl(grpc.StatusCode.INVALID_ARGUMENT) mock_call = mock.Mock(aio.StreamStreamCall, autospec=True) mock_call.write = mock.AsyncMock(side_effect=[None, grpc_error]) mock_call.done_writing = mock.AsyncMock(side_effect=[None, grpc_error]) multicallable = mock.Mock(return_value=mock_call) wrapped_callable = grpc_helpers_async._wrap_stream_errors(multicallable) wrapped_call = await wrapped_callable() await wrapped_call.write(mock.sentinel.request) with pytest.raises(exceptions.InvalidArgument) as exc_info: await wrapped_call.write(mock.sentinel.request) assert mock_call.write.call_count == 2 assert exc_info.value.response == grpc_error await wrapped_call.done_writing() with pytest.raises(exceptions.InvalidArgument) as exc_info: await wrapped_call.done_writing() assert mock_call.done_writing.call_count == 2 assert exc_info.value.response == grpc_error
async def test___call___and_execute_success(self, sleep): retry_ = retry_async.AsyncRetry() target = mock.AsyncMock(spec=["__call__"], return_value=42) # __name__ is needed by functools.partial. target.__name__ = "target" decorated = retry_(target) target.assert_not_called() result = await decorated("meep") assert result == 42 target.assert_called_once_with("meep") sleep.assert_not_called()
async def test_close_when_no_connections(self, voice_client, mock_app): voice_client._disconnect_all = mock.AsyncMock() voice_client._connections = {} voice_client._check_if_alive = mock.Mock() await voice_client.close() voice_client._check_if_alive.assert_called_once_with() mock_app.event_manager.unsubscribe.assert_called_once_with( voice_events.VoiceEvent, voice_client._on_voice_event ) voice_client._disconnect_all.assert_not_called() assert voice_client._is_alive is False assert voice_client._is_closing is False
async def test_get_state__no_state_load_state(mocker, pooler_mock): pooler = pooler_mock() manager = ClusterManager(["addr1", "addr2"], pooler) mocked_load_state = mocker.patch.object(manager, "_load_state", new=mock.AsyncMock()) state = await manager.get_state() assert state is mocked_load_state.return_value await asyncio.sleep(0) await manager.close()
async def test_rfr_edit_title(): config: dpytest.RunnerConfig = dpytest.get_config() guild: discord.Guild = config.guilds[0] channel: discord.TextChannel = guild.text_channels[0] embed: discord.Embed = discord.Embed(title="title", description="description") client: discord.Client = config.client message: discord.Message = await dpytest.message("rfr") msg_id = message.id DBManager.add_rfr_message(guild.id, channel.id, msg_id) assert embed.title == 'title' with mock.patch('koala.cogs.ReactForRole.get_rfr_message_from_prompts', mock.AsyncMock(return_value=(message, channel))): with mock.patch('koala.cogs.ReactForRole.prompt_for_input', mock.AsyncMock(side_effect=["new title", "Y"])): with mock.patch('koala.cogs.ReactForRole.get_embed_from_message', return_value=embed): await dpytest.message(koalabot.COMMAND_PREFIX + "rfr edit title") assert embed.title == 'new title' assert dpytest.verify().message() assert dpytest.verify().message() assert dpytest.verify().message()
async def test_init(mocker, pooler_mock): pooler = pooler_mock() manager = ClusterManager(["addr1", "addr2"], pooler) mocked_load_state = mocker.patch.object(manager, "_load_state", new=mock.AsyncMock()) await manager._init() mocked_load_state.assert_called_once() await asyncio.sleep(0) await manager.close()
async def test_edit_overwrite_target_type_none(self, model): model.app.rest.edit_permission_overwrites = mock.AsyncMock() user = mock.Mock(users.PartialUser) await model.edit_overwrite( user, allow=permissions.Permissions.BAN_MEMBERS, deny=permissions.Permissions.CONNECT, reason="vrooom vroom" ) model.app.rest.edit_permission_overwrites.assert_called_once_with( 69420, user, allow=permissions.Permissions.BAN_MEMBERS, deny=permissions.Permissions.CONNECT, reason="vrooom vroom", )
async def test_get_rfr_message_from_prompts(): config: dpytest.RunnerConfig = dpytest.get_config() guild: discord.Guild = config.guilds[0] channel: discord.TextChannel = guild.channels[0] member: discord.Member = config.members[0] msg: discord.Message = dpytest.back.make_message(".", member, channel) channel_id = msg.channel.id msg_id = msg.id await dpytest.message(KoalaBot.COMMAND_PREFIX + "store_ctx") ctx: commands.Context = utils_cog.get_last_ctx() with mock.patch('cogs.ReactForRole.ReactForRole.prompt_for_input', side_effect=[str(channel_id), str(546542131)]) as mock_input: with mock.patch('discord.abc.Messageable.fetch_message', mock.AsyncMock(return_value=None)): with pytest.raises(commands.CommandError) as exc: await rfr_cog.get_rfr_message_from_prompts(ctx) assert str(exc.value) == "Invalid Message ID given." with mock.patch('cogs.ReactForRole.ReactForRole.prompt_for_input', side_effect=[str(channel_id), str(msg_id)]) as mock_input: with mock.patch('discord.abc.Messageable.fetch_message', mock.AsyncMock(return_value=msg)): with pytest.raises(commands.CommandError) as exc: await rfr_cog.get_rfr_message_from_prompts(ctx) assert str( exc.value ) == "Message ID given is not that of a react for role message." DBManager.add_rfr_message(msg.guild.id, channel_id, msg_id) with mock.patch('cogs.ReactForRole.ReactForRole.prompt_for_input', side_effect=[str(channel_id), str(msg_id)]) as mock_input: with mock.patch('discord.abc.Messageable.fetch_message', mock.AsyncMock(return_value=msg)): rfr_msg, rfr_msg_channel = await rfr_cog.get_rfr_message_from_prompts( ctx) assert rfr_msg.id == msg.id assert rfr_msg_channel.id == channel_id
async def _consume_helper( self, stream=None, end=65536, headers=None, chunks=(), response_headers=None, checksum=None, timeout=None, ): download = download_mod.RawDownload( sync_test.EXAMPLE_URL, stream=stream, end=end, headers=headers ) transport = mock.AsyncMock(spec=["request"]) mockResponse = _mock_raw_response(chunks=chunks, headers=response_headers) transport.request = mock.AsyncMock(spec=["__call__"], return_value=mockResponse) assert not download.finished ret_val = await download.consume(transport) assert ret_val is transport.request.return_value if chunks: assert stream is not None transport.request.assert_called_once_with( u"GET", sync_test.EXAMPLE_URL, data=None, headers=download._headers, timeout=EXPECTED_TIMEOUT, ) range_bytes = u"bytes={:d}-{:d}".format(0, end) assert download._headers[u"range"] == range_bytes assert download.finished return transport
async def test_on_guild_create_stateful(self, event_manager, shard, app): payload = {} event = mock.Mock( guild=mock.Mock(id=123, is_large=False), channels={"TestChannel": 456}, emojis={"TestEmoji": 789}, roles={"TestRole": 1234}, members={"TestMember": 5678}, presences={"TestPresence": 9012}, voice_states={"TestState": 345}, chunk_nonce=None, ) event_manager._app.event_factory.deserialize_guild_create_event.return_value = event shard.request_guild_members = mock.AsyncMock() await event_manager.on_guild_create(shard, payload) assert event.chunk_nonce is None shard.request_guild_members.assert_not_called() event_manager._cache.update_guild.assert_called_once_with(event.guild) event_manager._cache.clear_guild_channels_for_guild.assert_called_once_with( 123) event_manager._cache.set_guild_channel.assert_called_once_with(456) event_manager._cache.clear_emojis_for_guild.assert_called_once_with( 123) event_manager._cache.set_emoji.assert_called_once_with(789) event_manager._cache.clear_roles_for_guild.assert_called_once_with(123) event_manager._cache.set_role.assert_called_once_with(1234) event_manager._cache.clear_members_for_guild.assert_called_once_with( 123) event_manager._cache.set_member.assert_called_once_with(5678) event_manager._cache.clear_presences_for_guild.assert_called_once_with( 123) event_manager._cache.set_presence.assert_called_once_with(9012) event_manager._cache.clear_voice_states_for_guild.assert_called_once_with( 123) event_manager._cache.set_voice_state.assert_called_once_with(345) event_manager._app.event_factory.deserialize_guild_create_event.assert_called_once_with( shard, payload) event_manager.dispatch.assert_awaited_once_with(event)
async def test_credentials_with_scopes_requested_refresh_success( self, unused_utcnow, refresh_grant): scopes = ["email", "profile"] token = "token" expiry = _helpers.utcnow() + datetime.timedelta(seconds=500) grant_response = {"id_token": mock.sentinel.id_token} refresh_grant.return_value = ( # Access token token, # New refresh token None, # Expiry, expiry, # Extra data grant_response, ) request = mock.AsyncMock(spec=["transport.Request"]) creds = _credentials_async.Credentials( token=None, refresh_token=self.REFRESH_TOKEN, token_uri=self.TOKEN_URI, client_id=self.CLIENT_ID, client_secret=self.CLIENT_SECRET, scopes=scopes, ) # Refresh credentials await creds.refresh(request) # Check jwt grant call. refresh_grant.assert_called_with( request, self.TOKEN_URI, self.REFRESH_TOKEN, self.CLIENT_ID, self.CLIENT_SECRET, scopes, ) # Check that the credentials have the token and expiry assert creds.token == token assert creds.expiry == expiry assert creds.id_token == mock.sentinel.id_token assert creds.has_scopes(scopes) # Check that the credentials are valid (have a token and are not # expired.) assert creds.valid
async def test_fetch_history(self, model): model.app.rest.fetch_messages = mock.AsyncMock() await model.fetch_history( before=datetime.datetime(2020, 4, 1, 1, 0, 0), after=datetime.datetime(2020, 4, 1, 0, 0, 0), around=datetime.datetime(2020, 4, 1, 0, 30, 0), ) model.app.rest.fetch_messages.assert_awaited_once_with( 12345679, before=datetime.datetime(2020, 4, 1, 1, 0, 0), after=datetime.datetime(2020, 4, 1, 0, 0, 0), around=datetime.datetime(2020, 4, 1, 0, 30, 0), )
async def get_web_interface(require_password): try: web_interface_instance = web_interface.WebInterface({}) web_interface_instance.port = PORT web_interface_instance.should_open_web_interface = False web_interface_instance.requires_password = require_password web_interface_instance.password_hash = configuration.get_password_hash(PASSWORD) interfaces.AbstractInterface.bot_api = (await _init_bot()).octobot_api with mock.patch.object(web_interface_instance, "_register_on_channels", new=mock.AsyncMock()): threading.Thread(target=_start_web_interface, args=(web_interface_instance,)).start() # ensure web interface had time to start or it can't be stopped at the moment await asyncio.sleep(1) yield web_interface_instance finally: await web_interface_instance.stop()
async def base_signer_setup() -> dict: emitter = mock.AsyncMock() emitter.emit_until_response.return_value = (None, None) credentials = aiobotocore.credentials.AioCredentials('key', 'secret') signer = aiobotocore.signers.AioRequestSigner(ServiceId('service_name'), 'region_name', 'signing_name', 'v4', credentials, emitter) return { 'credentials': credentials, 'emitter': emitter, 'signer': signer, 'fixed_credentials': await credentials.get_frozen_credentials(), 'request': AWSRequest() }
async def test__process_response_bad_content_range(self): download = _download.ChunkedDownload(EXAMPLE_URL, 256, None) _fix_up_virtual(download) # Check internal state before. assert not download.finished assert download.bytes_downloaded == 0 assert download.total_bytes is None assert not download.invalid # Actually call the method to update. data = b"stuff" headers = { u"content-length": u"{:d}".format(len(data)), u"content-range": u"kites x-y/58", } content_stream = mock.AsyncMock(spec=["__call", "read"]) content_stream.read = mock.AsyncMock(spec=["__call__"], return_value=data) response = mock.AsyncMock( content=content_stream, headers=headers, status=int(http_client.PARTIAL_CONTENT), spec=["content", "headers", "status"], ) with pytest.raises(common.InvalidResponse) as exc_info: await download._process_response(response) error = exc_info.value assert error.response is response assert len(error.args) == 3 assert error.args[1] == headers[u"content-range"] # Check internal state after. assert not download.finished assert download.bytes_downloaded == 0 assert download.total_bytes is None assert download.invalid
async def test_create_with_guild(self): builder = special_endpoints.ContextMenuCommandBuilder( commands.CommandType.MESSAGE, "we are number") mock_rest = mock.AsyncMock() result = await builder.create(mock_rest, 4444444, guild=765234123) assert result is mock_rest.create_context_menu_command.return_value mock_rest.create_context_menu_command.assert_awaited_once_with( 4444444, builder.type, builder.name, guild=765234123, default_permission=builder.default_permission, )
async def test_connect_to_falls_back_to_rest_to_get_own_user( self, voice_client, mock_app): voice_client._init_state_update_predicate = mock.Mock() voice_client._init_server_update_predicate = mock.Mock() mock_shard = mock.AsyncMock(is_alive=True) mock_app.event_manager.wait_for = mock.AsyncMock() mock_app.shard_count = 42 mock_app.shards = {0: mock_shard} mock_app.cache.get_me.return_value = None mock_app.rest = mock.AsyncMock() mock_connection_type = mock.AsyncMock() await voice_client.connect_to(123, 4532, mock_connection_type, deaf=False, mute=True) mock_app.event_manager.wait_for.assert_has_awaits([ mock.call( voice_events.VoiceStateUpdateEvent, timeout=None, predicate=voice_client._init_state_update_predicate. return_value, ), mock.call( voice_events.VoiceServerUpdateEvent, timeout=None, predicate=voice_client._init_server_update_predicate. return_value, ), ]) mock_app.cache.get_me.assert_called_once_with() mock_app.rest.fetch_my_user.assert_awaited_once_with() voice_client._init_state_update_predicate.assert_called_once_with( 123, mock_app.rest.fetch_my_user.return_value.id)
async def test_join(): # just test this does not throw an error on base consumers base_consumer = tests.EmptyTestConsumer(None) await base_consumer.join(1) supervised_consumer = tests.EmptyTestSupervisedConsumer(None) assert supervised_consumer.idle.is_set() with mock.patch.object(supervised_consumer.idle, "wait", mock.AsyncMock()) as wait_mock: await supervised_consumer.join(1) wait_mock.assert_not_called() supervised_consumer.idle.clear() await supervised_consumer.join(1) wait_mock.assert_called_once()
async def test_fetch_user_when_no_user(self): model = audit_logs.AuditLogEntry( app=mock.AsyncMock(), id=123, target_id=None, changes=[], user_id=None, action_type=0, options=None, reason=None, ) assert await model.fetch_user() is None model.app.rest.fetch_user.assert_not_called()
async def test_ensure_pool__identical_address(): mocked_create_pool = mock.AsyncMock( return_value=create_pool_mock(), ) pooler = Pooler(mocked_create_pool) result = await pooler.ensure_pool(Address("localhost", 1234)) assert result is mocked_create_pool.return_value mocked_create_pool.assert_called_once_with(("localhost", 1234)) result2 = await pooler.ensure_pool(Address("localhost", 1234)) assert result2 is result assert mocked_create_pool.call_count == 1
async def test_fetch_user_when_user(self): model = audit_logs.AuditLogEntry( app=mock.AsyncMock(), id=123, target_id=None, changes=[], user_id=456, action_type=0, options=None, reason=None, ) assert await model.fetch_user() is model.app.rest.fetch_user.return_value model.app.rest.fetch_user.assert_awaited_once_with(456)
async def test__heartbeat(self, client): client._last_heartbeat_sent = 5 client._logger = mock.Mock() client._closing = mock.Mock(is_set=mock.Mock(return_value=False)) client._closed = mock.Mock(is_set=mock.Mock(return_value=False)) client._send_heartbeat = mock.AsyncMock() with mock.patch.object(time, "monotonic", return_value=10): with mock.patch.object(asyncio, "wait_for", side_effect=[asyncio.TimeoutError, None]) as wait_for: assert await client._heartbeat(20) is False wait_for.assert_awaited_with(client._closing.wait(), timeout=20)
async def test_fetch_id_token_from_explicit_cred_json_file( mock_init, monkeypatch): monkeypatch.setenv(environment_vars.CREDENTIALS, test_id_token.SERVICE_ACCOUNT_FILE) async def mock_refresh(self, request): self.token = "id_token" with mock.patch.object( google.oauth2._service_account_async.IDTokenCredentials, "refresh", mock_refresh): request = mock.AsyncMock() token = await id_token.fetch_id_token(request, "https://pubsub.googleapis.com") assert token == "id_token"
async def test_is_compatible_account_with_unchecked_exchange( exchange_config, tentacles_setup_config): compatible, error = await exchanges.is_compatible_account( "hitbtc", exchange_config, tentacles_setup_config) assert compatible is False assert isinstance(error, str) with mock.patch.object( trading_backend.exchanges.Exchange, "is_valid_account", mock.AsyncMock(return_value=(True, "plop"))) as is_valid_account_mock: compatible, error = await exchanges.is_compatible_account( "hitbtc", exchange_config, tentacles_setup_config) assert compatible is True assert "plop" in error and len(error) > len("plop") is_valid_account_mock.assert_called_once()
async def test__on_connection_close(self, voice_client, mock_app): mock_other_connection = object() mock_shard = mock.AsyncMock() mock_app.shards = {69: mock_shard} voice_client._connections = { 65234123: mock_other_connection, 123123: object() } await voice_client._on_connection_close( mock.Mock(guild_id=123123, shard_id=69)) mock_shard.update_voice_state.assert_awaited_once_with(guild=123123, channel=None) assert voice_client._connections == {65234123: mock_other_connection}
async def test_create_with_guild(self): builder = special_endpoints.SlashCommandBuilder("we are number", "one") mock_rest = mock.AsyncMock() result = await builder.create(mock_rest, 54455445, guild=54123123321) assert result is mock_rest.create_slash_command.return_value mock_rest.create_slash_command.assert_awaited_once_with( 54455445, builder.name, builder.description, guild=54123123321, default_permission=builder.default_permission, options=builder.options, )
async def test__receive_and_check_when_buff_but_next_is_not_BINARY( self, transport_impl): response1 = self.StubResponse(type=aiohttp.WSMsgType.BINARY, data=b"some") response2 = self.StubResponse(type=aiohttp.WSMsgType.TEXT) transport_impl.receive = mock.AsyncMock( side_effect=[response1, response2]) with pytest.raises( errors.GatewayError, match="Unexpected message type received TEXT, expected BINARY" ): await transport_impl._receive_and_check(10) transport_impl.receive.assert_awaited_with(10)
async def test_fetch_id_token_no_cred_exists(monkeypatch): monkeypatch.delenv(environment_vars.CREDENTIALS, raising=False) with mock.patch( "google.auth.compute_engine._metadata.ping", side_effect=exceptions.TransportError(), ): with pytest.raises(exceptions.DefaultCredentialsError) as excinfo: request = mock.AsyncMock() await id_token.fetch_id_token(request, "https://pubsub.googleapis.com") assert excinfo.match( r"Neither metadata server or valid service account credentials are found." ) with mock.patch("google.auth.compute_engine._metadata.ping", return_value=False): with pytest.raises(exceptions.DefaultCredentialsError) as excinfo: request = mock.AsyncMock() await id_token.fetch_id_token(request, "https://pubsub.googleapis.com") assert excinfo.match( r"Neither metadata server or valid service account credentials are found." )