def test___copy___when_missing_chunks_is_none(self): obj = hikari_test_helpers.stub_class( stateful_guild_chunker._TrackedRequests, missing_chunk_indexes=None, not_found_ids=[2, 4, 6, 7, 8]) new_obj = hikari_test_helpers.stub_class( stateful_guild_chunker._TrackedRequests) with mock.patch.object(attr_extensions, "copy_attrs", return_value=new_obj): result = copy.copy(obj) attr_extensions.copy_attrs.assert_called_once_with(obj) assert result.missing_chunk_indexes is None
async def test___anext___when_stream_closed(self): streamer = hikari_test_helpers.stub_class(event_stream.EventStream, _active=False) # flake8 gets annoyed if we use "with" here so here's a hacky alternative with pytest.raises(TypeError): await streamer.__anext__()
def test_received_chunks(self): obj = hikari_test_helpers.stub_class( stateful_guild_chunker._TrackedRequests, chunk_count=25, missing_chunk_indexes=[15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], ) assert obj.received_chunks == 14
async def test___anext___when_stream_not_active(self): stream = hikari_test_helpers.stub_class( stateful_guild_chunker.ChunkStream, _active=False) # flake8 gets annoyed if we use "with" here so here's a hacky alternative with pytest.raises(TypeError): await stream.__anext__()
async def test_open_for_inactive_stream(self, mock_app): stream = hikari_test_helpers.stub_class( stateful_guild_chunker.ChunkStream, _active=False, _app=mock_app, _guild_id=snowflakes.Snowflake(35412312312), _event_type=shard_events.MemberChunkEvent, _include_presences=True, _query="a query", _limit=42, _users=[snowflakes.Snowflake(431223), 54234], _nonce="AnOnCe", ) with mock.patch.object(event_stream.EventStream, "open") as patched_super: assert await stream.open() is None patched_super.assert_called_once() mock_app.shards[2].request_guild_members.assert_awaited_once_with( guild=snowflakes.Snowflake(35412312312), include_presences=True, query="a query", limit=42, users=[snowflakes.Snowflake(431223), 54234], nonce="AnOnCe", )
async def test_open_for_active_stream(self, mock_app): stream = hikari_test_helpers.stub_class( event_stream.EventStream, _app=mock_app, _event_type=events.Event, _active=False, ) mock_listener = object() mock_listener_ref = object() with mock.patch.object(event_stream, "_generate_weak_listener", return_value=mock_listener): with mock.patch.object(weakref, "WeakMethod", return_value=mock_listener_ref): await stream.open() weakref.WeakMethod.assert_called_once_with(stream._listener) event_stream._generate_weak_listener.assert_called_once_with( mock_listener_ref) mock_app.dispatcher.subscribe.assert_called_once_with( 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
async def test_on_chunk_event_for_unknown_shard(self, mock_chunker): event = hikari_test_helpers.stub_class(shard_events.MemberChunkEvent, shard=mock.Mock( shard.GatewayShardImpl, id=42), nonce="42.hiebye") assert await mock_chunker.consume_chunk_event(event) is None assert mock_chunker._tracked == {}
def test___len___(self): event = hikari_test_helpers.stub_class(shard_events.MemberChunkEvent, members={ 1: object(), 55: object(), 99: object(), 455: object() }) assert len(event) == 4
async def test___anext___when_chunks_depleted(self): stream = hikari_test_helpers.stub_class( stateful_guild_chunker.ChunkStream, _active=True, _queue=asyncio.Queue(), _missing_chunks=[]) async for _ in stream: pytest.fail("stream shouldn't have yielded anything.")
async def test__listener_when_fails_filter(self, stub_chunk_event, mock_app): stream = hikari_test_helpers.stub_class( stateful_guild_chunker.ChunkStream, _filters=iterators.All(()), _active=False, _app=mock_app) stream.filter(lambda _: False) await stream._listener(stub_chunk_event) mock_app.dispatcher.unsubscribe.assert_not_called()
async def test___anext___handles_time_out(self): stream = hikari_test_helpers.stub_class( stateful_guild_chunker.ChunkStream, _active=True, _queue=asyncio.Queue(), _missing_chunks=None, _timeout=hikari_test_helpers.REASONABLE_QUICK_RESPONSE_TIME, ) async for _ in stream: pytest.fail("stream shouldn't have returned anything.")
def test___getitem___with_invalid_index(self): event = hikari_test_helpers.stub_class(shard_events.MemberChunkEvent, members={ 1: object(), 55: object(), 99: object(), 455: object() }) with pytest.raises(IndexError): assert event[55]
def test___iter___(self): member_0 = object() member_1 = object() member_2 = object() event = hikari_test_helpers.stub_class(shard_events.MemberChunkEvent, members={ 234: member_0, 76: member_1, 999: member_2 }) assert list(event) == [member_0, member_1, member_2]
def obj(self): class StubGuild(guilds.Guild): emojis = None get_emoji = None get_role = None roles = None return hikari_test_helpers.stub_class(StubGuild, id=123, splash_hash=None, discovery_splash_hash=None, banner_hash=None)
async def test___anext___times_out(self): streamer = hikari_test_helpers.stub_class( event_stream.EventStream, _active=True, _queue=asyncio.Queue(), _timeout=hikari_test_helpers.REASONABLE_QUICK_RESPONSE_TIME, ) async for _ in streamer: pytest.fail("streamer shouldn't have yielded anything") else: # Ensure we don't get a warning or error on del streamer._active = False
def test___getitem___with_slice(self): mock_member_0 = object() mock_member_1 = object() event = hikari_test_helpers.stub_class( shard_events.MemberChunkEvent, members={ 1: object(), 55: object(), 99: mock_member_0, 455: object(), 5444: mock_member_1 }, ) assert event[2:5:2] == (mock_member_0, mock_member_1)
async def test_close_for_active_stream(self, mock_app): mock_registered_listener = object() stream = hikari_test_helpers.stub_class( event_stream.EventStream, _app=mock_app, _event_type=events.Event, _active=True, _registered_listener=mock_registered_listener, ) await stream.close() mock_app.dispatcher.unsubscribe.assert_called_once_with( events.Event, mock_registered_listener) assert stream._active is False assert stream._registered_listener is None
async def test_open_for_active_stream(self, mock_app): stream = hikari_test_helpers.stub_class( stateful_guild_chunker.ChunkStream, _active=True, _app=mock_app, _guild_id=snowflakes.Snowflake(35412312312), _event_type=shard_events.MemberChunkEvent, ) with mock.patch.object(event_stream.EventStream, "open") as patched_super: assert await stream.open() is None patched_super.assert_called_once() mock_app.shards[2].request_guild_members.assert_not_called()
async def test___anext___uses_queue_entry(self): stream = hikari_test_helpers.stub_class( stateful_guild_chunker.ChunkStream, _active=True, _queue=asyncio.Queue(), _missing_chunks=None, _timeout=hikari_test_helpers.REASONABLE_QUICK_RESPONSE_TIME, ) mock_chunk = object() stream._queue.put_nowait(mock_chunk) async for event in stream: assert event is mock_chunk return pytest.fail("stream should've yielded something")
async def test__listener_when_fails_passes(self, stub_chunk_event, mock_app): stream = hikari_test_helpers.stub_class( stateful_guild_chunker.ChunkStream, _filters=iterators.All(()), _active=False, _missing_chunks=[2, 3, 4, 5, 6, 7, 9], _queue=asyncio.Queue(), _app=mock_app, ) stream.filter(lambda _: True) await stream._listener(stub_chunk_event) assert stream._missing_chunks == [2, 3, 4, 6, 7, 9] assert stream._queue.qsize() == 1 assert stream._queue.get_nowait() is stub_chunk_event mock_app.dispatcher.unsubscribe.assert_not_called()
async def test__listener_when_chunks_finished(self, stub_chunk_event, mock_app): stream = hikari_test_helpers.stub_class( stateful_guild_chunker.ChunkStream, _filters=iterators.All(()), _active=False, _missing_chunks=[5], _queue=asyncio.Queue(), _registered_listener=object(), _app=mock_app, ) stream.filter(lambda _: True) await stream._listener(stub_chunk_event) assert stream._missing_chunks == [] assert stream._queue.qsize() == 1 assert stream._queue.get_nowait() is stub_chunk_event mock_app.dispatcher.unsubscribe.assert_called_once_with( shard_events.MemberChunkEvent, stream._registered_listener)
def test_filter_for_inactive_stream(self): stream = hikari_test_helpers.stub_class(event_stream.EventStream, _filters=iterators.All(()), _active=False) first_pass = mock.Mock(attr=True) second_pass = mock.Mock(attr=True) first_fails = mock.Mock(attr=True) second_fail = mock.Mock(attr=False) def predicate(obj): return obj in (first_pass, second_pass) stream.filter(predicate, attr=True) assert stream._filters(first_pass) is True assert stream._filters(first_fails) is False assert stream._filters(second_pass) is True assert stream._filters(second_fail) is False
async def test___anext__(self): mock_event = object() streamer = hikari_test_helpers.stub_class( event_stream.EventStream, _active=True, _queue=asyncio.Queue(), _timeout=hikari_test_helpers.REASONABLE_QUICK_RESPONSE_TIME, ) streamer._queue.put_nowait(mock_event) async for event in streamer: assert event is mock_event # Ensure we don't get a warning or error on del streamer._active = False return pytest.fail("streamer should've yielded something")
async def test_filter_for_active_stream(self): stream = hikari_test_helpers.stub_class( event_stream.EventStream, _active=True, ) mock_wrapping_iterator = object() predicate = object() with mock.patch.object(iterators.LazyIterator, "filter", return_value=mock_wrapping_iterator): assert stream.filter(predicate, name="OK") is mock_wrapping_iterator iterators.LazyIterator.filter.assert_called_once_with(predicate, name="OK") # Ensure we don't get a warning or error on del stream._active = False
async def test___anext___waits_for_initial_chunk(self): stream = hikari_test_helpers.stub_class( stateful_guild_chunker.ChunkStream, _active=True, _queue=asyncio.Queue(), _missing_chunks=None, _timeout=hikari_test_helpers.REASONABLE_SLEEP_TIME * 2, ) mock_chunk = object() async def add_chunk(): await asyncio.sleep(hikari_test_helpers.REASONABLE_SLEEP_TIME) stream._queue.put_nowait(mock_chunk) asyncio.create_task(add_chunk()) async for event in stream: assert event is mock_chunk return pytest.fail("stream should have yielded an event")
def obj(self): return hikari_test_helpers.stub_class( guilds.Member, user=mock.Mock( users.User, id=123, username="******", discriminator="0001", avatar_url="avatar", avatar_hash="a_12asfdjk1213", default_avatar="default avatar", format_avatar=mock.Mock(return_value="formated avatar"), is_bot=False, is_system=True, flags="flags", mention="<@123>", __str__=mock.Mock(return_value="davfsa#0001"), ), nickname="davb", guild_id=456, )
async def test_on_chunk_event_when_initial_tracking_information_set( self, mock_chunker): event = hikari_test_helpers.stub_class( shard_events.MemberChunkEvent, shard=mock.Mock(shard.GatewayShardImpl, id=4), nonce="4.hiebye", not_found=[ snowflakes.Snowflake(54123123), snowflakes.Snowflake(65234) ], chunk_index=6, ) tracker = stateful_guild_chunker._TrackedRequests( nonce="4.hiebye", guild_id=snowflakes.Snowflake(140502780547694592), average_chunk_size=150, chunk_count=11, last_received=53123123, missing_chunk_indexes=[2, 5, 6, 7, 8, 9], not_found_ids=[snowflakes.Snowflake(54123)], ) mock_chunker._tracked[4] = {"4.hiebye": tracker, "4.eee": object()} with mock.patch.object(time, "monotonic_ns", return_value=5555555555): assert await mock_chunker.consume_chunk_event(event) is None time.monotonic_ns.assert_called_once() assert mock_chunker._tracked[4]["4.hiebye"].average_chunk_size == 150 assert mock_chunker._tracked[4]["4.hiebye"].chunk_count == 11 assert mock_chunker._tracked[4]["4.hiebye"].missing_chunk_indexes == [ 2, 5, 7, 8, 9 ] assert mock_chunker._tracked[4][ "4.hiebye"]._mono_last_received == 5555555555 assert mock_chunker._tracked[4]["4.hiebye"].not_found_ids == [ snowflakes.Snowflake(54123), snowflakes.Snowflake(54123123), snowflakes.Snowflake(65234), ]
async def test___anext___waits_for_next_event(self): mock_event = object() streamer = hikari_test_helpers.stub_class( event_stream.EventStream, _active=True, _queue=asyncio.Queue(), _timeout=hikari_test_helpers.REASONABLE_SLEEP_TIME * 3, ) async def add_event(): await asyncio.sleep(hikari_test_helpers.REASONABLE_SLEEP_TIME) streamer._queue.put_nowait(mock_event) asyncio.create_task(add_event()) async for event in streamer: assert event is mock_event # Ensure we don't get a warning or error on del streamer._active = False return pytest.fail("streamer should've yielded something")
def model(self): klass = hikari_test_helpers.unslot_class(applications.Team) return hikari_test_helpers.stub_class(klass, id=123, icon_hash="ahashicon")
def model(self): klass = hikari_test_helpers.unslot_class(applications.Application) return hikari_test_helpers.stub_class(klass, id=123, icon_hash="ahashicon", cover_image_hash="ahashcover")