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."
)
