async def test_remove_status_code(self, *args):
mock_cache = {
'endpoint': 'some-endpoint',
'timeout': 10,
'_id': 'some-id'
}
mock_status_codes = [200]
mock_id = 'some-value'
mock_db = MagicMock()
mock_hgetall = CoroutineMock()
mock_srem = CoroutineMock()
mock_hgetall.return_value = mock_cache
mock_db.hgetall = mock_hgetall
mock_db.srem = mock_srem
try:
await EndpointCacher.remove_status_codes(mock_status_codes,
mock_id, mock_db)
except Exception as err:
mock_hgetall.assert_awaited()
expect(mock_hgetall.await_args[0][0]).to(equal(mock_id))
mock_cache = pydash.merge(mock_cache, {'response_codes': 'some-value'})
await EndpointCacher.remove_status_codes(mock_status_codes, mock_id,
mock_db)
expect(mock_srem.await_count).to(equal(len(mock_status_codes)))
async def test_play_track_list_creates_a_task_to_play_the_track_list(
self, example_music_manager, monkeypatch):
"""
Calling play_track_list() should create a task for running _play_track_list() and set the currently_playing
attribute.
"""
cancel_mock = CoroutineMock()
play_track_list_mock = CoroutineMock()
monkeypatch.setattr("src.music.music_manager.asyncio.sleep",
CoroutineMock())
monkeypatch.setattr("src.music.music_manager.MusicManager.cancel",
cancel_mock)
monkeypatch.setattr(
"src.music.music_manager.MusicManager._play_track_list",
play_track_list_mock)
assert example_music_manager._currently_playing is None
await example_music_manager.play_track_list(request=None,
group_index=0,
track_list_index=0)
cancel_mock.assert_awaited()
assert example_music_manager._currently_playing is not None
assert isinstance(example_music_manager._currently_playing,
CurrentlyPlaying)
assert example_music_manager._currently_playing.group_index == 0
assert example_music_manager._currently_playing.track_list_index == 0
assert isinstance(example_music_manager._currently_playing.task,
asyncio.Task)
async def test_get_by_id(self, *args):
response_codes_id = 'some-id'
expected_cache = {
'endpoint': 'some-endpoint',
'timeout': 10,
'response_codes': response_codes_id,
'_id': 'some-id'
}
expected_response_codes = [200, 300]
mock_id = 'some-value'
mock_db = MagicMock()
mock_hgetall = CoroutineMock()
mock_smembers = CoroutineMock()
mock_hgetall.return_value = expected_cache
mock_smembers.return_value = expected_response_codes
mock_db.hgetall = mock_hgetall
mock_db.smembers = mock_smembers
cache = await EndpointCacher.get_by_id(mock_id, mock_db)
mock_hgetall.assert_awaited()
expect(mock_hgetall.await_args[0][0]).to(equal(mock_id))
mock_smembers.assert_awaited()
expect(mock_smembers.await_args[0][0]).to(equal(response_codes_id))
expect(cache).to(
equal(
pydash.merge(expected_cache,
{'response_codes': expected_response_codes})))
async def test_get_all(self, *args):
with asynctest.patch.object(DB, 'fetch_members') as fetch_members_mock:
response_codes_id = 'some-id'
expected_cache = {
'endpoint': 'some-endpoint',
'timeout': 10,
'response_codes': response_codes_id,
'_id': 'some-id'
}
expected_response_codes = [200, 300]
mock_keys = ['some-id']
mock_db = MagicMock()
mock_hgetall = CoroutineMock()
mock_smembers = CoroutineMock()
fetch_members_mock.return_value = mock_keys
mock_hgetall.return_value = expected_cache
mock_db.hgetall = mock_hgetall
mock_db.smembers = mock_smembers
mock_smembers.return_value = expected_response_codes
caches = await EndpointCacher.get_all(mock_db)
fetch_members_mock.assert_awaited()
mock_hgetall.assert_awaited()
mock_smembers.assert_awaited()
expect(mock_smembers.await_args[0][0]).to(equal(response_codes_id))
expect(caches).to(have_len(1))
expect(caches[0]).to(
equal(
pydash.merge(expected_cache,
{'response_codes': expected_response_codes})))
async def test_worker_exception_failed_to_send_message(mock_aioredis,
monkeypatch,
mock_redis_db):
send_mock = CoroutineMock()
def raise_connect_error(*_, **__):
raise FailedToSendMessage("")
send_mock.side_effect = raise_connect_error
stopped_event = Event()
monkeypatch.setattr(pyuubin.connectors.smtp, "send", send_mock)
await mock_redis_db.connect()
[await mock_redis_db.add_mail(mail) for mail in mail_generator(4)]
await worker("test", "redis://localhost", stopped_event=stopped_event)
send_mock.assert_awaited()
assert not stopped_event.is_set()
assert (await
mock_aioredis.llen(f"{settings.redis_mail_queue}::failed") == 4)
failed_msg = unpack(
await
mock_aioredis.rpop(f"{settings.redis_mail_queue}::failed"))["mail"]
assert failed_msg["parameters"]["secret_data"] == "XXXXXX"
async def test__search_indexes(self, *args):
expected_id = 'some-id'
mock_index = 'some-index'
mock_search = 'some-search'
mock_db = MagicMock()
mock_hscan = CoroutineMock()
mock_hscan.return_value = (None, [(expected_id.encode('utf-8'),
mock_search.encode('utf-8'))])
mock_db.hscan = mock_hscan
keys = await RateLimiter._search_indexes(mock_index, mock_search,
mock_db)
mock_hscan.assert_awaited()
expect(keys).to(contain(expected_id))
async def test_delete_entry(self, *args):
with asynctest.patch.object(RateLimiter,
'_clear_indexes') as _clear_indexes_mock:
mock_id = 'some-value'
mock_db = MagicMock()
mock_delete = CoroutineMock()
mock_sadd = CoroutineMock()
mock_db.delete = mock_delete
mock_db.srem = mock_sadd
await RateLimiter.delete_entry(mock_id, mock_db)
mock_delete.assert_awaited_with(mock_id)
_clear_indexes_mock.assert_awaited_with(mock_id, mock_db)
mock_sadd.assert_awaited()
expect(mock_sadd.await_args[0][1]).to(equal(mock_id))
async def test_get_entry_by_id(self, *args):
expected_entry = {
'rule_id': 'some-id',
'host': 'some-host',
'timeout': 1,
}
mock_id = 'some-value'
mock_db = MagicMock()
mock_hgetall = CoroutineMock()
mock_hgetall.return_value = expected_entry
mock_db.hgetall = mock_hgetall
cache = await RateLimiter.get_entry_by_id(mock_id, mock_db)
mock_hgetall.assert_awaited()
expect(mock_hgetall.await_args[0][0]).to(equal(mock_id))
expect(cache).to(equal(expected_entry))
async def test_worker(mock_aioredis, monkeypatch, mock_redis_db):
send_mock = CoroutineMock()
monkeypatch.setattr(pyuubin.connectors.smtp, "send", send_mock)
await mock_redis_db.connect()
[await mock_redis_db.add_mail(mail) for mail in mail_generator(4)]
await worker("test", "redis://localhost")
assert await mock_aioredis.llen(get_consumer_queue_name("test")) == 0
assert await mock_redis_db.mail_queue_size() == 0
send_mock.assert_awaited()
assert send_mock.await_count == 4
async def test_call_rpc_successful_response(self):
method = "method"
expected = {"Action": method}
mock_send = CoroutineMock()
self._client.send = mock_send
mock_wait = CoroutineMock()
asyncio.wait_for = mock_wait
await self._client.call_rpc(method)
mock_send.assert_awaited()
handlers = self._client._handlers
self.assertIn(method, handlers)
self.assertFalse(handlers[method])
async def test_get_rule_by_id(self, *args):
expected_rule = {
'path': 'some-path',
'max_requests': 1,
'timeout': 1,
'host': 'some-host',
'message': 'some-message'
}
mock_id = 'some-value'
mock_db = MagicMock()
mock_hgetall = CoroutineMock()
mock_hgetall.return_value = expected_rule
mock_db.hgetall = mock_hgetall
cache = await RateLimiter.get_rule_by_id(mock_id, mock_db)
mock_hgetall.assert_awaited()
expect(mock_hgetall.await_args[0][0]).to(equal(mock_id))
expect(cache).to(equal(expected_rule))
async def test_get_all_entries(self, *args):
with asynctest.patch.object(DB, 'fetch_members') as fetch_members_mock:
mock_entry = {
'rule_id': 'some-id',
'host': 'some-host',
'timeout': 1,
}
mock_keys = ['some-value']
mock_db = MagicMock()
mock_hgetall = CoroutineMock()
mock_db.hgetall = mock_hgetall
fetch_members_mock.return_value = mock_keys
mock_hgetall.return_value = mock_entry
entries = await RateLimiter.get_all_entries(mock_db)
fetch_members_mock.assert_awaited()
mock_hgetall.assert_awaited()
expect(mock_hgetall.await_args[0][0]).to(equal(mock_keys[0]))
expect(entries).to(contain(mock_entry))
async def test_get_entry_by_host(self, *args):
with asynctest.patch.object(RateLimiter,
'_search_indexes') as _search_indexes_mock:
mock_rule = {
'rule_id': 'some-id',
'host': 'some-host',
'timeout': 1,
}
mock_host = 'some-value'
mock_keys = ['some-value']
mock_db = MagicMock()
mock_hgetall = CoroutineMock()
mock_db.hgetall = mock_hgetall
_search_indexes_mock.return_value = mock_keys
mock_hgetall.return_value = mock_rule
rules = await RateLimiter.get_entry_by_host(mock_host, mock_db)
_search_indexes_mock.assert_awaited()
mock_hgetall.assert_awaited()
expect(mock_hgetall.await_args[0][0]).to(equal(mock_keys[0]))
expect(rules).to(contain(mock_rule))
async def test_get_all_rules(self, *args):
with asynctest.patch.object(DB, 'fetch_members') as fetch_members_mock:
mock_rule = {
'path': 'some-path',
'max_requests': 1,
'timeout': 1,
'host': 'some-host',
'message': 'some-message'
}
mock_keys = ['some-value']
mock_db = MagicMock()
mock_hgetall = CoroutineMock()
mock_db.hgetall = mock_hgetall
fetch_members_mock.return_value = mock_keys
mock_hgetall.return_value = mock_rule
rules = await RateLimiter.get_all_rules(mock_db)
fetch_members_mock.assert_awaited()
mock_hgetall.assert_awaited()
expect(mock_hgetall.await_args[0][0]).to(equal(mock_keys[0]))
expect(rules).to(contain(mock_rule))
async def test_worker_exception_cannot_send_messages(mock_aioredis,
monkeypatch,
mock_redis_db):
send_mock = CoroutineMock()
def raise_connect_error(*_, **__):
raise CannotSendMessages("")
send_mock.side_effect = raise_connect_error
stopped_event = Event()
monkeypatch.setattr(pyuubin.connectors.smtp, "send", send_mock)
await mock_redis_db.connect()
[await mock_redis_db.add_mail(mail) for mail in mail_generator(4)]
await worker("test", "redis://localhost", stopped_event=stopped_event)
send_mock.assert_awaited()
assert stopped_event.is_set()
async def test_create_rule(self, *args):
with asynctest.patch.object(RateLimiter,
'_set_indexes') as _set_indexes_mock:
mock_ctx = {
'path': 'some-path',
'max_requests': 1,
'timeout': 1,
'host': 'some-host',
'message': 'some-message'
}
mock_db = MagicMock()
mock_service_db = MagicMock()
mock_sadd = CoroutineMock()
mock_hmset_dict = CoroutineMock()
mock_db.sadd = mock_sadd
mock_db.hmset_dict = mock_hmset_dict
await RateLimiter.create_rule(mock_ctx, mock_db)
_set_indexes_mock.assert_called()
mock_sadd.assert_awaited()
for key in mock_ctx.keys():
expect(mock_hmset_dict.await_args[0][1]).to(have_key(key))
expect(mock_hmset_dict.await_args[0][1][key]).to(
equal(mock_ctx[key]))
async def test_create_entry(self, *args):
with asynctest.patch.object(RateLimiter,
'_set_indexes') as _set_indexes_mock:
mock_ctx = {
'rule_id': 'some-id',
'host': 'some-host',
'timeout': 1,
}
mock_db = MagicMock()
mock_service_db = MagicMock()
mock_sadd = CoroutineMock()
mock_hmset_dict = CoroutineMock()
mock_expire = CoroutineMock()
mock_db.sadd = mock_sadd
mock_db.hmset_dict = mock_hmset_dict
mock_db.expire = mock_expire
await RateLimiter.create_entry(mock_ctx, mock_db)
_set_indexes_mock.assert_called()
mock_sadd.assert_awaited()
for key in mock_ctx.keys():
expect(mock_hmset_dict.await_args[0][1]).to(have_key(key))
expect(mock_hmset_dict.await_args[0][1][key]).to(
equal(mock_ctx[key]))
