async def test_handle_disallowed_admin_call():
# Given
message = "Command '/eternal-guess admin info' can only be used by admin users."
command_authorizer = FakeCommandAuthorizer(admin=False)
message_provider = MagicMock(MessageProvider)
message_provider.disallowed_admin_call.return_value = message
route_handler = _route_handler(
command_authorizer=command_authorizer,
message_provider=message_provider,
)
event = DiscordEvent()
route_definition = RouteDefinition(
route=AsyncMock(Route),
command="admin",
subcommand="info",
permission=PermissionSet.ADMIN,
)
# When
response = await route_handler.handle(event, route_definition)
# Then
assert response.response_type == ResponseType.CHANNEL_MESSAGE
assert response.is_ephemeral
assert response.content == message
async def test_admin_management_call():
# Given
guild_id = 1000
management_role = 2000
other_role = 2001
management_channel = 3000
other_channel = 3001
configs_repository = FakeConfigsRepository(
guild_id=guild_id,
management_channels=[management_channel],
management_roles=[management_role])
command_authorizer = CommandAuthorizerImpl(
configs_repository=configs_repository)
event = DiscordEvent(
guild_id=guild_id,
channel_id=other_channel,
member=DiscordMember(roles=[other_role], is_admin=True),
)
# When
allowed = await command_authorizer.authorize_management_call(event=event)
# Then
assert allowed
async def test_handle_disallowed_management_call():
# Given
message = "Command 'create' can only be used by management users."
command_authorizer = FakeCommandAuthorizer(management=False)
message_provider = MagicMock(MessageProvider)
message_provider.disallowed_management_call.return_value = message
route_handler = _route_handler(
command_authorizer=command_authorizer,
message_provider=message_provider,
)
event = DiscordEvent()
route_definition = RouteDefinition(
route=AsyncMock(Route),
command="create",
permission=PermissionSet.MANAGEMENT,
)
# When
response = await route_handler.handle(event, route_definition)
# Then
assert response.response_type == ResponseType.CHANNEL_MESSAGE
assert response.is_ephemeral
assert response.content == message
async def test_handle_raised_forbidden():
# Given
clientside_error_message = "The bot has insufficient permissions to do this."
message_provider = MagicMock(MessageProvider)
message_provider.bot_missing_access.return_value = clientside_error_message
route_handler = _route_handler(message_provider=message_provider)
event = DiscordEvent(command=DiscordCommand(command_name="ping", ))
mock_route = AsyncMock(Route)
mock_route.call.side_effect = discord.Forbidden(
MagicMock(aiohttp.ClientResponse), "Missing Access.")
route_definition = RouteDefinition(
route=mock_route,
command="ping",
)
# When
response = await route_handler.handle(event, route_definition)
# Then
assert response.is_ephemeral
assert response.content == clientside_error_message
async def test_handle():
# Given
command_name = "admin"
subcommand_name = "info"
event = DiscordEvent(command=DiscordCommand(
command_name=command_name,
subcommand_name=subcommand_name,
),
member=DiscordMember())
mock_response = DiscordResponse.ephemeral_channel_message(
"Well handled brother!")
mock_route_handler = AsyncMock(RouteHandler)
mock_route_handler.handle.return_value = mock_response
router = _router(route_handler=mock_route_handler, )
# When
response = await router.route(event)
# Then
mock_route_handler.handle.assert_called()
arguments = mock_route_handler.handle.call_args[0]
assert arguments[0] == event
assert arguments[1].command == command_name
if subcommand_name:
assert arguments[1].subcommand == subcommand_name
assert response.status_code == 200
assert json.loads(response.body) == mock_response.json()
def test_discord_event(mock_from_event):
# Given
test_authorizer = _TestAuthorizer(AuthorizationResult.PASS, None)
test_router = _TestRouter(LambdaResponse.success({'response': 'mocked'}))
event_body = {'type': 1}
discord_event = DiscordEvent(CommandType.COMMAND)
mock_from_event.return_value = discord_event
event = {
'body': json.dumps(event_body),
'headers': {
'x-signature-ed25519': '',
'x-signature-timestamp': '',
}
}
# When
discord_event_handler = DiscordEventHandler(router=test_router,
api_authorizer=test_authorizer)
response = discord_event_handler.handle(event)
# Then
assert response['statusCode'] == 200
assert json.loads(response['body']) == {'response': 'mocked'}
async def test_ping():
# Given
ping_route = PingRoute()
# When
response = await ping_route.call(DiscordEvent())
# Then
assert response.json() == {'type': InteractionType.PING}
def _make_event(guild_id: int = -1,
options: typing.Dict = None) -> DiscordEvent:
if options is None:
options = {}
return DiscordEvent(command=DiscordCommand(
command_name="admin",
subcommand_name="remove-management-role",
options=options),
guild_id=guild_id,
member=DiscordMember())
def _make_event(guild_id: int = -1,
options: typing.Dict = None) -> DiscordEvent:
if options is None:
options = {}
return DiscordEvent(command=DiscordCommand(
command_id=-1,
command_name="admin",
subcommand_name="does-not-matter",
options=options),
guild_id=guild_id,
member=DiscordMember())
async def test_authorized_admin_call():
# Given
guild_id = 1000
command_authorizer = CommandAuthorizerImpl(
configs_repository=FakeConfigsRepository(guild_id))
event = DiscordEvent(
guild_id=guild_id,
member=DiscordMember(is_admin=True),
)
# When
allowed = await command_authorizer.authorize_admin_call(event=event)
# Then
assert allowed
def _make_event(guild_id: int = -1, options: typing.Dict = None, discord_member: DiscordMember = None,
channel_id: int = -1):
if options is None:
options = {}
if discord_member is None:
discord_member = DiscordMember()
return DiscordEvent(
guild_id=guild_id,
channel_id=channel_id,
command=DiscordCommand(
command_name="manage",
subcommand_name="edit-guess",
options=options,
),
member=discord_member
)
async def test_handle():
# Given
route_handler = _route_handler()
event = DiscordEvent(command=DiscordCommand(command_name="ping", ))
response = DiscordResponse.ephemeral_channel_message(
"You handled it very well!")
mock_route = AsyncMock(Route)
mock_route.call.return_value = response
route_definition = RouteDefinition(
route=mock_route,
command="ping",
)
# When
response = await route_handler.handle(event, route_definition)
# Then
assert response == response
def _create_guess_event(guild_id: int,
game_id: str,
user_id: int = -1,
user_nickname: str = 'nickname',
guess: str = 'not-relevant',
event_channel_id: int = -1,
member: DiscordMember = None):
if member is None:
member = DiscordMember(user_id=user_id, nickname=user_nickname)
event = DiscordEvent(
channel_id=event_channel_id,
command=DiscordCommand(command_name="guess",
options={
'game-id': game_id,
'guess': guess,
}),
member=member,
guild_id=guild_id,
)
return event
