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