def test_icon_url(self):
channel = hikari_test_helpers.mock_class_namespace(
channels.GroupDMChannel,
init_=False,
make_icon_url=mock.Mock(return_value="icon-url-here.com"))()
assert channel.icon_url == "icon-url-here.com"
channel.make_icon_url.assert_called_once()
def test___init___generates_default_settings(self):
cls = hikari_test_helpers.mock_class_namespace(
rest_bot_impl.RESTBot, print_banner=mock.Mock())
stack = contextlib.ExitStack()
stack.enter_context(mock.patch.object(ux, "init_logging"))
stack.enter_context(
mock.patch.object(rest_bot_impl.RESTBot, "print_banner"))
stack.enter_context(mock.patch.object(rest_impl, "RESTClientImpl"))
stack.enter_context(mock.patch.object(config, "HTTPSettings"))
stack.enter_context(mock.patch.object(config, "ProxySettings"))
with stack:
result = cls("token", "token_type")
rest_impl.RESTClientImpl.assert_called_once_with(
cache=None,
entity_factory=result.entity_factory,
executor=None,
http_settings=config.HTTPSettings.return_value,
max_rate_limit=300.0,
max_retries=3,
proxy_settings=config.ProxySettings.return_value,
rest_url=None,
token="token",
token_type="token_type",
)
config.HTTPSettings.assert_called_once()
config.ProxySettings.assert_called_once()
assert result.http_settings is config.HTTPSettings.return_value
assert result.proxy_settings is config.ProxySettings.return_value
def model(self, mock_app):
return hikari_test_helpers.mock_class_namespace(channels.TextChannel)(
app=mock_app,
id=snowflakes.Snowflake(12345679),
name="foo1",
type=channels.ChannelType.GUILD_TEXT,
)
def test_open_for_active_stream(self):
mock_manager = mock.Mock()
stream = hikari_test_helpers.mock_class_namespace(
event_manager_base.EventStream)(event_manager=mock_manager,
event_type=base_events.Event,
timeout=float("inf"))
stream._active = False
mock_listener = object()
mock_listener_ref = object()
with mock.patch.object(event_manager_base,
"_generate_weak_listener",
return_value=mock_listener):
with mock.patch.object(weakref,
"WeakMethod",
return_value=mock_listener_ref):
stream.open()
weakref.WeakMethod.assert_called_once_with(stream._listener)
event_manager_base._generate_weak_listener.assert_called_once_with(
mock_listener_ref)
mock_manager.subscribe.assert_called_once_with(base_events.Event,
mock_listener)
assert stream._active is True
assert stream._registered_listener is mock_listener
# Ensure we don't get a warning or error on del
stream._active = False
def event_manager(self, app):
obj = hikari_test_helpers.mock_class_namespace(
event_manager.EventManagerImpl, slots_=False)(app,
cache=mock.Mock())
obj.dispatch = mock.AsyncMock()
return obj
def mock_rest_bot(
self,
mock_interaction_server,
mock_rest_client,
mock_entity_factory,
mock_http_settings,
mock_proxy_settings,
mock_executor,
):
stack = contextlib.ExitStack()
stack.enter_context(mock.patch.object(ux, "init_logging"))
stack.enter_context(
mock.patch.object(rest_bot_impl.RESTBot, "print_banner"))
stack.enter_context(
mock.patch.object(entity_factory_impl,
"EntityFactoryImpl",
return_value=mock_entity_factory))
stack.enter_context(
mock.patch.object(rest_impl,
"RESTClientImpl",
return_value=mock_rest_client))
stack.enter_context(
mock.patch.object(interaction_server_impl,
"InteractionServer",
return_value=mock_interaction_server))
with stack:
return hikari_test_helpers.mock_class_namespace(
rest_bot_impl.RESTBot, slots_=False)(
"token",
http_settings=mock_http_settings,
proxy_settings=mock_proxy_settings,
executor=mock_executor,
max_retries=0,
)
async def test_throttle_sleeps_before_popping_queue(self, event_loop):
# GIVEN
slept_at = float("nan")
popped_at = []
async def mock_sleep(_):
nonlocal slept_at
slept_at = time.perf_counter()
class MockList(list):
def pop(self, _=-1):
popped_at.append(time.perf_counter())
return event_loop.create_future()
with hikari_test_helpers.mock_class_namespace(
rate_limits.ManualRateLimiter, slots_=False)() as limiter:
with mock.patch("asyncio.sleep", wraps=mock_sleep):
limiter.queue = MockList()
# WHEN
await limiter.unlock_later(5)
# THEN
for i, pop_time in enumerate(popped_at):
assert slept_at < pop_time, f"future {i} popped before initial sleep"
def model(self, mock_app):
return hikari_test_helpers.mock_class_namespace(channels.PartialChannel, rename_impl_=False)(
app=mock_app,
id=snowflakes.Snowflake(1234567),
name="foo",
type=channels.ChannelType.GUILD_NEWS,
)
def test_is_complete_when_complete(self):
obj = hikari_test_helpers.mock_class_namespace(
stateful_guild_chunker._TrackedRequests,
received_chunks=mock.PropertyMock(return_value=42),
init=False)()
obj.chunk_count = 42
assert obj.is_complete is True
def test_get_time_until_reset_if_rate_limited(self):
with hikari_test_helpers.mock_class_namespace(
rate_limits.WindowedBurstRateLimiter,
slots_=False)(__name__, 0.01, 1) as rl:
rl.is_rate_limited = mock.Mock(return_value=True)
rl.reset_at = 420.4
assert rl.get_time_until_reset(69.8) == 420.4 - 69.8
def test_GroupDMChannel_icon_url():
channel = hikari_test_helpers.mock_class_namespace(
channels.GroupDMChannel,
init=False,
format_icon=mock.Mock(return_value="icon"))()
assert channel.icon_url == "icon"
channel.format_icon.assert_called_once()
async def test_throttle_schedules_throttle(self):
with hikari_test_helpers.mock_class_namespace(
rate_limits.ManualRateLimiter, slots_=False)() as limiter:
limiter.unlock_later = mock.AsyncMock()
limiter.throttle(0)
await limiter.throttle_task
limiter.unlock_later.assert_called_once_with(0)
def test_guild_when_no_cache_trait(self):
event = hikari_test_helpers.mock_class_namespace(
member_events.MemberEvent,
app=None,
)()
assert event.get_guild() is None
def model(self):
return hikari_test_helpers.mock_class_namespace(
guilds.PartialApplication,
init_=False,
slots_=False,
id=123,
icon_hash="ahashicon",
)()
def event(self):
cls = hikari_test_helpers.mock_class_namespace(
member_events.MemberEvent,
slots_=False,
guild_id=mock.PropertyMock(return_value=snowflakes.Snowflake(123)),
user=mock.Mock(id=456),
)
return cls()
def test_is_for_emoji_when_emoji_miss_match(self, emoji_id, emoji_name,
emoji):
event = hikari_test_helpers.mock_class_namespace(
reaction_events.ReactionAddEvent,
emoji_id=emoji_id,
emoji_name=emoji_name)()
assert event.is_for_emoji(emoji) is False
def test_is_for_emoji_when_wrong_emoji_type(self, emoji_id, emoji_name,
emoji):
event = hikari_test_helpers.mock_class_namespace(
reaction_events.ReactionDeleteEmojiEvent,
emoji_id=emoji_id,
emoji_name=emoji_name)()
assert event.is_for_emoji(emoji) is False
def mock_interaction_server(
self, mock_entity_factory: interaction_server_impl.InteractionServer, mock_rest_client: rest_impl.RESTClientImpl
):
cls = hikari_test_helpers.mock_class_namespace(interaction_server_impl.InteractionServer, slots_=False)
stack = contextlib.ExitStack()
stack.enter_context(mock.patch.object(rest_impl, "RESTClientImpl", return_value=mock_rest_client))
with stack:
return cls(entity_factory=mock_entity_factory, rest_client=mock_rest_client)
async def test___anext___when_stream_closed(self):
streamer = hikari_test_helpers.mock_class_namespace(
event_stream.EventStream, _active=False)(app=mock.Mock(),
event_type=events.Event,
timeout=float("inf"))
# flake8 gets annoyed if we use "with" here so here's a hacky alternative
with pytest.raises(TypeError):
await streamer.__anext__()
def test___del___for_inactive_stream(self):
close_method = mock.Mock()
streamer = hikari_test_helpers.mock_class_namespace(
event_manager_base.EventStream, close=close_method, init_=False)()
streamer._event_type = base_events.Event
streamer._active = False
del streamer
close_method.assert_not_called()
def event(self):
cls = hikari_test_helpers.mock_class_namespace(
channel_events.GuildChannelEvent,
guild_id=mock.PropertyMock(
return_value=snowflakes.Snowflake(929292929)),
channel_id=mock.PropertyMock(
return_value=snowflakes.Snowflake(432432432)),
)
return cls()
def event(self):
cls = hikari_test_helpers.mock_class_namespace(
message_events.GuildMessageEvent,
guild_id=mock.PropertyMock(
return_value=snowflakes.Snowflake(342123123)),
channel_id=mock.PropertyMock(
return_value=snowflakes.Snowflake(54123123123)),
)
return cls()
def model(self):
return hikari_test_helpers.mock_class_namespace(
applications.Application,
init_=False,
slots_=False,
id=123,
icon_hash="ahashicon",
cover_image_hash="ahashcover",
)()
def test_compile_to_file_calls_compile(self, format, size):
with mock.patch.object(files, "URL", autospec=files.URL):
route = hikari_test_helpers.mock_class_namespace(routes.CDNRoute, slots_=False)(
"/hello/world", {"png", "jpg"}, sizable=True
)
route.compile = mock.Mock(spec_set=route.compile)
route.compile_to_file("https://blep.com", file_format=format, size=size, boop="oyy lumo", nya="weeb")
route.compile.assert_called_once_with(
"https://blep.com", file_format=format, size=size, boop="oyy lumo", nya="weeb"
)
async def test___exit__(self):
stub_stream = hikari_test_helpers.mock_class_namespace(
event_manager_base.EventStream)(mock_app,
base_events.Event,
timeout=None)
try:
await stub_stream.__aexit__(None, None, None)
except AttributeError as exc:
pytest.fail(exc)
def event(self):
cls = hikari_test_helpers.mock_class_namespace(
typing_events.TypingEvent,
channel_id=123,
user_id=456,
timestamp=object(),
shard=object(),
)
return cls()
async def test_fetch_parent_message(self):
stub_interaction = hikari_test_helpers.mock_class_namespace(
component_interactions.ComponentInteraction,
fetch_message=mock.AsyncMock(),
init_=False)()
stub_interaction.message = mock.Mock(id=3421)
assert await stub_interaction.fetch_parent_message(
) is stub_interaction.fetch_message.return_value
stub_interaction.fetch_message.assert_awaited_once_with(3421)
def event(self):
cls = hikari_test_helpers.mock_class_namespace(
typing_events.GuildTypingEvent)
return cls(
channel_id=123,
timestamp=object(),
shard=object(),
guild_id=789,
member=mock.Mock(id=456, app=mock.Mock(rest=mock.AsyncMock())),
)
def event(self):
cls = hikari_test_helpers.mock_class_namespace(
typing_events.DMTypingEvent)
return cls(
channel_id=123,
timestamp=object(),
shard=object(),
app=mock.Mock(rest=mock.AsyncMock()),
user_id=456,
)
async def test_gc_calls_do_pass(self):
with hikari_test_helpers.mock_class_namespace(
buckets.RESTBucketManager,
slots_=False)(max_rate_limit=float("inf")) as mgr:
mgr.do_gc_pass = mock.Mock()
mgr.start(0.01, 33)
try:
await hikari_test_helpers.idle()
mgr.do_gc_pass.assert_called_with(33)
finally:
mgr.gc_task.cancel()