def test_send_message_without_sender():
class SendBehaviour(OneShotBehaviour):
async def run(self):
msg = Message()
await self.send(msg)
self.kill()
agent = make_connected_agent()
agent.start()
agent.aiothread.stream = MagicMock()
agent.stream.send = CoroutineMock()
behaviour = SendBehaviour()
agent.add_behaviour(behaviour)
wait_for_behaviour_is_killed(behaviour)
msg_arg = agent.stream.send.await_args[0][0]
assert msg_arg.from_ == aioxmpp.JID.fromstr("fake@jid")
agent.stop()
async def test_can_handle_connected_frame_with_heartbeat(
self, heartbeater_klass_mock):
frame = Frame('CONNECTED', {
'heart-beat': '1000,1000',
}, '{}')
heartbeater_mock = heartbeater_klass_mock.return_value
heartbeater_mock.start = CoroutineMock()
stomp = StompReader(None,
self.loop,
heartbeat={
'enabled': True,
'cx': 1000,
'cy': 1000
})
stomp._transport = Mock()
await stomp._handle_connect(frame)
heartbeater_klass_mock.assert_called_with(stomp._transport, 1000)
heartbeater_mock.start.assert_called_once()
async def test_get_entry_by_rule_id(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_rule_id = '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_rule_id(
mock_rule_id, 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 async_test_transition_to_validation_reported_exception(self):
"""Set up the test for transitioning to validation reported."""
self.report_record.state = Report.VALIDATED
self.report_record.retry_count = 0
self.report_record.report_platform_id = self.uuid
self.report_record.upload_ack_status = report_processor.SUCCESS_CONFIRM_STATUS
self.report_record.save()
self.processor.report_or_slice = self.report_record
self.processor.status = report_processor.SUCCESS_CONFIRM_STATUS
self.processor.upload_message = {'hash': self.uuid}
def report_side_effect():
"""Transition the state to validation_reported."""
raise Exception('Test')
self.processor._send_confirmation = CoroutineMock(
side_effect=report_side_effect)
await self.processor.transition_to_validation_reported()
self.assertEqual(self.report_record.state, Report.VALIDATED)
self.assertEqual(self.report_record.retry_count, 1)
self.check_variables_are_reset()
async def test_game_connection_not_restored_if_no_such_game_exists(
lobbyconnection: LobbyConnection, mocker):
del lobbyconnection.player.game_connection
lobbyconnection.send = CoroutineMock()
lobbyconnection.player.state = PlayerState.IDLE
await lobbyconnection.on_message_received({
"command": "restore_game_session",
"game_id": 123
})
assert not lobbyconnection.player.game_connection
assert lobbyconnection.player.state == PlayerState.IDLE
lobbyconnection.send.assert_any_call({
"command":
"notice",
"style":
"info",
"text":
"The game you were connected to does no longer exist"
})
async def test_can_handle_message_can_nack(self, send_frame_mock):
frame = Frame('MESSAGE', {
'subscription': '123',
'message-id': '321'
}, 'blah')
handler = CoroutineMock()
handler.return_value = False
subscription = Subscription('123', 1, 'client-individual', {}, handler)
frame_handler = Mock()
frame_handler.get.return_value = subscription
stomp = StompReader(frame_handler, self.loop)
await stomp._handle_message(frame)
handler.assert_called_with(frame, frame.body)
send_frame_mock.assert_called_with('NACK', {
'subscription': '123',
'message-id': '321'
})
def test_get_devices_cache(self, mock_get):
# arrange
loop = asyncio.get_event_loop()
mock_get.return_value.__aenter__.return_value.status = 200
mock_get.return_value.__aenter__.return_value.json = CoroutineMock(
return_value=JSON_DEVICES
)
# act
async def getDevices():
async with Govee(API_KEY) as govee:
result, err = await govee.get_devices()
assert not err
cache = govee.devices
return result, cache
result, cache = loop.run_until_complete(getDevices())
# assert
assert mock_get.call_count == 1
assert len(result) == 2
assert result == cache
async def test_set_publishing_mode(opc, mocker):
"""
test flipping the publishing parameter for an existing subscription
"""
myhandler = MySubHandler()
o = opc.opc.nodes.objects
publishing_mode = ua.SetPublishingModeParameters()
mock_set_monitoring = mocker.patch.object(ua,
"SetPublishingModeParameters",
return_value=publishing_mode)
mock_client_monitoring = mocker.patch(
"asyncua.client.ua_client.UaClient.set_publishing_mode",
new=CoroutineMock())
v = await o.add_variable(3, 'SubscriptionVariable3', 123)
sub = await opc.opc.create_subscription(100, myhandler)
await sub.set_publishing_mode(False)
assert publishing_mode.PublishingEnabled == False
await sub.set_publishing_mode(True)
assert publishing_mode.PublishingEnabled == True
def dummy_zmq_server(monkeypatch):
"""
A fixture which provides a dummy zero mq
socket which records the json it is asked
to send.
Parameters
----------
monkeypatch
Yields
------
asynctest.CoroutineMock
Coroutine mocking for the recv_json method of the socket
"""
dummy = Mock()
dummy.return_value.socket.return_value.recv_json = CoroutineMock()
monkeypatch.setattr(zmq.asyncio.Context, "instance", dummy)
yield dummy.return_value.socket.return_value.recv_json
async def test_add_connection_record(node_instance, message_instance):
node_instance.connections = [{
'addr': '1.1.1.1',
'port': '1111',
'reader': 'reader1',
'writer': 'writer1'
}]
with patch('asyncio.open_connection', new=CoroutineMock()) as mocked_open:
mocked_open.return_value = 'reader2', 'writer2'
await node_instance.add_connection_record(message_instance, 'reader3')
assert node_instance.connections == [{
'addr': '1.1.1.1',
'port': '1111',
'reader': 'reader1',
'writer': 'writer1'
}, {
'addr': '127.0.0.1',
'port': '54321',
'reader': 'reader3',
'writer': 'writer2'
}]
async def test_load_from_database_new_data(ladder_service, database):
async with database.acquire() as conn:
result = await conn.execute(matchmaker_queue.insert().values(
technical_name="test",
featured_mod_id=1,
leaderboard_id=1,
name_key="test.name"))
await conn.execute(matchmaker_queue_map_pool.insert().values(
matchmaker_queue_id=result.lastrowid, map_pool_id=1))
await ladder_service.update_data()
test_queue = ladder_service.queues["test"]
assert test_queue.name == "test"
assert test_queue._is_running
# Queue pop times are 1 second for tests
test_queue.find_matches = CoroutineMock()
await asyncio.sleep(1.5)
test_queue.find_matches.assert_called()
async def test_decorator_default():
mock = CoroutineMock()
@async_reduceable()
async def foo(arg, *, kw):
"""My foo doc"""
await mock(arg, kw=kw)
return 'result {} {}'.format(arg, kw)
assert foo.__name__ == 'foo'
assert foo.__doc__ == 'My foo doc'
coros = [
foo('arg', kw='kw'),
foo('arg', kw='kw')
]
done, pending = await asyncio.wait(coros)
assert not pending
mock.assert_awaited_once_with('arg', kw='kw')
assert all(f.result() == 'result arg kw' for f in done)
def test_create_agent(mocker):
mocker.patch("spade.agent.AioThread.connect")
agent = Agent("jid@server", "fake_password")
assert agent.is_alive() is False
agent.start(auto_register=False)
assert agent.is_alive() is True
agent.aiothread.connect.assert_called_once()
assert agent.stream is None
agent.aiothread.conn_coro = mocker.Mock()
agent.aiothread.conn_coro.__aexit__ = CoroutineMock()
agent.stop()
agent.aiothread.conn_coro.__aexit__.assert_called_once()
assert agent.is_alive() is False
async def test_set_monitoring_mode(opc, mocker):
"""
test set_monitoring_mode parameter for all MIs of a subscription
"""
myhandler = MySubHandler()
o = opc.opc.nodes.objects
monitoring_mode = ua.SetMonitoringModeParameters()
mock_set_monitoring = mocker.patch.object(ua,
"SetMonitoringModeParameters",
return_value=monitoring_mode)
mock_client_monitoring = mocker.patch(
"asyncua.client.ua_client.UaClient.set_monitoring_mode",
new=CoroutineMock())
v = await o.add_variable(3, 'SubscriptionVariable2', 123)
sub = await opc.opc.create_subscription(100, myhandler)
await sub.set_monitoring_mode(ua.MonitoringMode.Disabled)
assert monitoring_mode.MonitoringMode == ua.MonitoringMode.Disabled
await sub.set_monitoring_mode(ua.MonitoringMode.Reporting)
assert monitoring_mode.MonitoringMode == ua.MonitoringMode.Reporting
async def test_create_connection_max_observed_latencies(
self, event_loop, mocker, not_closed_connection):
mocker.patch("emcache.connection_pool.create_protocol",
CoroutineMock(return_value=not_closed_connection))
connection_pool = ConnectionPool("localhost", 11211, 1, 1, None, None,
lambda _: _, False, False, None)
# Perform twice operations than the maximum observed latencies by removing
# the connection at each operation
for i in range(_MAX_CREATE_CONNECTION_LATENCIES_OBSERVED * 2):
async with connection_pool.create_connection_context():
pass
# remove the connection explicitly, behind the scenes connection pool
# will be forced to create a new one
connection_pool._close_connection(not_closed_connection)
# We should never have more than the maximum number of latencies observed
assert len(connection_pool._create_connection_latencies
) == _MAX_CREATE_CONNECTION_LATENCIES_OBSERVED
async def test_command_game_join_game_not_found(lobbyconnection, game_service,
test_game_info, players):
lobbyconnection.send = CoroutineMock()
lobbyconnection.game_service = game_service
lobbyconnection.player = players.hosting
players.hosting.in_game = False
players.hosting.state = PlayerState.IDLE
test_game_info["uid"] = 42
await lobbyconnection.on_message_received({
"command": "game_join",
**test_game_info
})
lobbyconnection.send.assert_called_once_with({
"command":
"notice",
"style":
"info",
"text":
"The host has left the game."
})
async def test_post_handler(self, *args):
with patch.object(DB, 'get') as get_mock:
with patch('json.loads') as loads_mock:
with patch.object(Insights, 'create') as create_mock:
with patch.object(Error, 'handle') as handle_mock:
with patch.object(
Validate,
'validate_schema') as validate_schem_mock:
mock_req = MagicMock()
mock_req.text = CoroutineMock()
await post_handler(mock_req)
mock_req.text.assert_called()
loads_mock.assert_called()
validate_schem_mock.assert_called()
get_mock.assert_called()
create_mock.assert_called()
mock_err = Exception()
create_mock.side_effect = mock_err
await post_handler(mock_req)
handle_mock.assert_called_with(mock_err)
def test_ping(self, mock_get):
# arrange
loop = asyncio.get_event_loop()
mock_get.return_value.__aenter__.return_value.status = 200
mock_get.return_value.__aenter__.return_value.text = CoroutineMock(
return_value="Pong"
)
# act
async def ping():
async with Govee(API_KEY) as govee:
return await govee.ping()
result, err = loop.run_until_complete(ping())
# assert
assert not err
assert result
assert mock_get.call_count == 1
assert (
mock_get.call_args.kwargs["url"] == "https://developer-api.govee.com/ping"
)
async def test_ok(self, mocker: MockFixture,
fake_model_data_provider: ModelDataProvider):
data_length = 10
fake_data = [mocker.Mock() for _ in range(0, data_length)]
fake_include_settings = mocker.Mock()
fake_include_params = mocker.Mock()
fake_item_include_data = mocker.Mock()
mocked_get_item_include_data = mocker.patch.object(
fake_model_data_provider, 'get_item_include_data',
CoroutineMock(return_value=fake_item_include_data))
result = await fake_model_data_provider.get_list_include_data(
fake_data, fake_include_settings, fake_include_params)
mocked_get_item_include_data.assert_has_calls([
mocker.call(fake_data[i], fake_include_settings,
fake_include_params) for i in range(0, data_length)
])
assert result == [
fake_item_include_data for _ in range(0, data_length)
]
async def test_subscribe_rid(sm: SubscriptionManager):
send_mock = CoroutineMock()
send_mock.return_value = 'some return value'
sm._ds.send_message = send_mock
sm._sub_payload = Mock()
sub_payload_value = 'some value'
sm._sub_payload.return_value = sub_payload_value
sub = Subscription(category=Category.MARKET,
events=[MarketEvents.CANCELS, MarketEvents.ORDERS],
topics=['ETH_AURA', 'ETH_ZRX'])
result = await sm.subscribe(sub, 'some rid')
sm._sub_payload.assert_called_once_with(Action.SUBSCRIBE,
topics=sub.topics,
events=sub.events)
send_mock.assert_awaited_once_with(sub.category.value, sub_payload_value,
'some rid')
assert result == 'some return value'
async def test_waitfor(self):
scansapi = self.api.scans
scanschema = module.ScanSchema()
scansapi.get = CoroutineMock(side_effect=(
scanschema.load(
{"id": "127d134f-0e1e-4238-87b4-29ee87ebe60a", "status": 30}
),
scanschema.load(
{"id": "127d134f-0e1e-4238-87b4-29ee87ebe60a", "status": 40}
),
scanschema.load(
{"id": "127d134f-0e1e-4238-87b4-29ee87ebe60a", "status": 50}
),
scanschema.load(
{"id": "127d134f-0e1e-4238-87b4-29ee87ebe60a", "status": 50}
),
))
await scansapi.waitfor("127d134f-0e1e-4238-87b4-29ee87ebe60a")
self.assertEqual(scansapi.get.call_count, 4)
async def test_get_token():
endpoint = 'http://*****:*****@localhost:7000/oauth/token'
f'?grant_type=password&username={username}&password={password}',
ag.aiohttp.ClientSession.post)
async def test_can_handle_connected_frame_with_heartbeat(
self, heartbeater_klass_mock):
frame = Frame("CONNECTED", {"heart-beat": "1000,1000"}, "{}")
heartbeater_mock = heartbeater_klass_mock.return_value
heartbeater_mock.start = CoroutineMock()
stomp = StompReader(None,
self.loop,
heartbeat={
"enabled": True,
"cx": 1000,
"cy": 1000
})
stomp._transport = Mock()
await stomp._handle_connect(frame)
heartbeater_klass_mock.assert_called_with(stomp._transport,
interval=1000,
loop=self.loop)
heartbeater_mock.start.assert_called_once()
async def test_send_code_changed_flag(self, mocked_socketio, app):
self.mocked_mappings[self.sid] = 1
self.game_api.worker_manager.add_new_worker(
self.mocked_mappings[self.sid])
worker = self.game_api.worker_manager.player_id_to_worker[
self.mocked_mappings[self.sid]]
worker.has_code_updated = True
with mock.patch("service.socketio_server.emit",
new=CoroutineMock()) as mocked_emit:
await self.game_api.send_updates()
user_game_state_call = mock.call("game-state", {"foo": "bar"},
room=self.sid)
user_game_code_changed_call = mock.call("feedback-avatar-updated",
{},
room=self.sid)
mocked_emit.assert_has_calls(
[user_game_state_call, user_game_code_changed_call],
any_order=True)
async def test_can_handle_message_can_nack(self, send_frame_mock):
frame = Frame("MESSAGE", {
"subscription": "123",
"message-id": "321"
}, "blah")
handler = CoroutineMock()
handler.return_value = False
subscription = Subscription("123", 1, "client-individual", {}, handler)
frame_handler = Mock()
frame_handler.get.return_value = subscription
stomp = StompReader(frame_handler, self.loop)
await stomp._handle_message(frame)
handler.assert_called_with(frame, frame.body)
send_frame_mock.assert_called_with("NACK", {
"subscription": "123",
"message-id": "321"
})
async def test_lock_expire_retries(self, lock_manager_redis_patched,
locked_lock):
lock_manager, redis = lock_manager_redis_patched
redis.set_lock = CoroutineMock(side_effect=[
LockError('Can not lock'),
LockError('Can not lock'),
LockError('Can not lock')
])
with pytest.raises(LockError):
await lock_manager.lock('resource')
await real_sleep(0.1) # wait until cleaning is completed
calls = [
call('resource', ANY),
call('resource', ANY),
call('resource', ANY)
]
redis.set_lock.assert_has_calls(calls)
redis.unset_lock.assert_called_once_with('resource', ANY)
async def test_expired_session(http_redirect, ssl_certificate):
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
task = asyncio.create_task(controller.horn(TEST_VIN_3_G2))
await server_js_response(server,
VALIDATE_SESSION_FAIL,
path=sc.API_VALIDATE_SESSION)
await server_js_response(server,
LOGIN_MULTI_REGISTERED,
path=sc.API_LOGIN)
await server_js_response(
server,
SELECT_VEHICLE_3,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_3_G2,
"_": str(int(time.time()))
},
)
await server_js_response(
server,
REMOTE_SERVICE_EXECUTE,
path=sc.API_HORN_LIGHTS,
)
await server_js_response(
server,
REMOTE_SERVICE_STATUS_STARTED,
path=sc.API_REMOTE_SVC_STATUS,
)
await server_js_response(
server,
REMOTE_SERVICE_STATUS_FINISHED_SUCCESS,
path=sc.API_REMOTE_SVC_STATUS,
)
assert await task
async def test_initalizes_creating_min_connection(self, mocker,
not_closed_connection,
min_connections):
ev = asyncio.Event()
connections_created = 0
def f(*args, **kwargs):
nonlocal connections_created
connections_created += 1
if connections_created == min_connections:
ev.set()
return not_closed_connection
create_protocol = mocker.patch(
"emcache.connection_pool.create_protocol",
CoroutineMock(side_effect=f))
max_connections = min_connections
connection_pool = ConnectionPool("localhost", 11211, max_connections,
min_connections, None, None,
lambda _: _, False, False, None)
# wait till the min_connections have been created.
await ev.wait()
create_protocol.assert_called_with("localhost",
11211,
ssl=False,
ssl_verify=False,
ssl_extra_ca=None,
timeout=None)
assert connection_pool.total_connections == min_connections
# test specific atributes of the metrics
assert connection_pool.metrics().cur_connections == min_connections
assert connection_pool.metrics().connections_created == min_connections
assert connection_pool.metrics().create_connection_avg is not None
assert connection_pool.metrics().create_connection_p50 is not None
assert connection_pool.metrics().create_connection_p99 is not None
assert connection_pool.metrics().create_connection_upper is not None
async def test_setup_no_config(hass):
"""Tests component setup with no config."""
with patch.object(
Hole,
"get_data",
new=CoroutineMock(side_effect=mock_pihole_data_call(Hole))):
assert await async_setup_component(hass, pi_hole.DOMAIN,
{pi_hole.DOMAIN: {}})
await hass.async_block_till_done()
assert (hass.states.get("sensor.pi_hole_ads_blocked_today").name ==
"Pi-Hole Ads Blocked Today")
assert (hass.states.get("sensor.pi_hole_ads_percentage_blocked_today").name
== "Pi-Hole Ads Percentage Blocked Today")
assert (hass.states.get("sensor.pi_hole_dns_queries_cached").name ==
"Pi-Hole DNS Queries Cached")
assert (hass.states.get("sensor.pi_hole_dns_queries_forwarded").name ==
"Pi-Hole DNS Queries Forwarded")
assert (hass.states.get("sensor.pi_hole_dns_queries_today").name ==
"Pi-Hole DNS Queries Today")
assert (hass.states.get("sensor.pi_hole_dns_unique_clients").name ==
"Pi-Hole DNS Unique Clients")
assert (hass.states.get("sensor.pi_hole_dns_unique_domains").name ==
"Pi-Hole DNS Unique Domains")
assert (hass.states.get("sensor.pi_hole_domains_blocked").name ==
"Pi-Hole Domains Blocked")
assert hass.states.get(
"sensor.pi_hole_seen_clients").name == "Pi-Hole Seen Clients"
assert hass.states.get("sensor.pi_hole_ads_blocked_today").state == "0"
assert hass.states.get(
"sensor.pi_hole_ads_percentage_blocked_today").state == "0"
assert hass.states.get("sensor.pi_hole_dns_queries_cached").state == "0"
assert hass.states.get("sensor.pi_hole_dns_queries_forwarded").state == "0"
assert hass.states.get("sensor.pi_hole_dns_queries_today").state == "0"
assert hass.states.get("sensor.pi_hole_dns_unique_clients").state == "0"
assert hass.states.get("sensor.pi_hole_dns_unique_domains").state == "0"
assert hass.states.get("sensor.pi_hole_domains_blocked").state == "0"
assert hass.states.get("sensor.pi_hole_seen_clients").state == "0"
async def test_bookmark(
self,
subject,
session,
tap,
tap_process,
target_process,
plugin_invoker_factory,
full_refresh,
select_filter,
payload_flag,
):
lines = (b'{"line": 1}\n', b'{"line": 2}\n', b'{"line": 3}\n')
# testing with a real subprocess proved to be pretty
# complicated.
target_process.stdout = mock.MagicMock()
target_process.stdout.at_eof.side_effect = (False, False, False, True)
target_process.stdout.readline = CoroutineMock(side_effect=lines)
subject.context.full_refresh = full_refresh
subject.context.select_filter = select_filter
async with subject.context.job.run(session):
with mock.patch.object(
session, "add",
side_effect=session.add) as add_mock, mock.patch.object(
session, "commit",
side_effect=session.commit) as commit_mock:
bookmark_writer = subject.bookmark_writer()
await capture_subprocess_output(target_process.stdout,
bookmark_writer)
assert add_mock.call_count == 3
assert commit_mock.call_count == 3
# assert the STATE's `value` was saved
job = subject.context.job
assert job.payload["singer_state"] == {"line": 3}
assert job.payload_flags == payload_flag
