async def test_record_transaction_cache_hit_container(
self, dummy_guillotina, metrics_registry):
storage = AsyncMock()
mng = TransactionManager(storage)
cache = AsyncMock()
cache.get.return_value = {
"state": pickle.dumps(create_content(Container)),
"zoid": ROOT_ID,
"tid": 1,
"id": "foobar",
}
strategy = AsyncMock()
txn = Transaction(mng, cache=cache, strategy=strategy)
await txn.get("foobar")
assert (metrics_registry.get_sample_value("guillotina_cache_ops_total",
{
"type": "_get",
"result": "hit"
}) is None)
assert (metrics_registry.get_sample_value("guillotina_cache_ops_total",
{
"type": "_get",
"result": "hit_roots"
}) == 1.0)
def testsolver():
mock_ws = AsyncMock(spec=Workspace)
mock_ws.storage = "mock_storage"
mock_ws.get_container_uri = AsyncMock(
return_value="mock_container_uri/foo/bar")
testsolver = Solver(mock_ws, "Microsoft", "SimulatedAnnealing", "json",
"json")
return testsolver
async def test_get(self):
get_mock = AsyncMock(return_value=Article(id="1", body='test'))
repo = RepositoryMock()
repo.get_list = get_mock
usecase = ArticleInteractor(article_repository=repo)
self.assertEqual(await usecase.get_list(1), Article(id="1", body="test"))
get_mock.assert_called_with(1)
async def test_no_publish_if_exc_during_register(self, request_dict):
channel_stub = StubCollection().channel_stubs[CHANNEL_STUB_NAME]
channel_stub.register_citizen = AsyncMock(return_value=False)
WSDispatcher.publish_heartbeat = AsyncMock()
WSDispatcher.publish_new_block = AsyncMock()
WSDispatcher.publish_unregister = AsyncMock()
await WSDispatcher.node_ws_Subscribe(**request_dict)
assert not WSDispatcher.publish_heartbeat.called
assert not WSDispatcher.publish_new_block.called
assert WSDispatcher.publish_unregister.called
async def test_register_citizen_and_channel_returns_false(self):
channel_stub: MockChannelInnerStub = StubCollection(
).channel_stubs[CHANNEL_STUB_NAME]
channel_stub.register_citizen = AsyncMock(return_value=False)
channel_stub.unregister_citizen = AsyncMock()
async with Reception(channel_name=CHANNEL_STUB_NAME,
peer_id="",
remote_target="") as registered:
assert channel_stub.register_citizen.called
assert not registered
assert channel_stub.unregister_citizen.called
async def test_register_citizen_and_raised_exc_during_communicate(self):
channel_stub: MockChannelInnerStub = StubCollection(
).channel_stubs[CHANNEL_STUB_NAME]
channel_stub.register_citizen = AsyncMock(side_effect=RuntimeError(
"SUBSCRIBE_LIMIT or Already registered!!"))
channel_stub.unregister_citizen = AsyncMock()
async with Reception(channel_name=CHANNEL_STUB_NAME,
peer_id="",
remote_target="") as registered:
assert channel_stub.register_citizen.called
assert not registered
assert channel_stub.unregister_citizen.called
async def test_get(self):
get_main_group_mock = AsyncMock(
return_value={"articles": [{
"id": "1",
"body": "test"
}]})
driver = DriverMock()
driver.get_articles = get_main_group_mock
repository = ArticleRepositoryImpl(article_driver=driver)
self.assertEqual(await repository.get_list(1),
Articles(values=[Article(id="1", body="test")]))
get_main_group_mock.assert_called_with(1)
async def test__normal_service(caplog, method):
caplog.set_level(logging.INFO)
with patch("middlewared.main.multiprocessing"):
middleware = Middleware()
middleware.loop = asyncio.get_event_loop()
middleware.add_service(MockService(middleware))
fut = asyncio.Future()
application = Application(
middleware, asyncio.get_event_loop(), Mock(),
Mock(send_str=AsyncMock(side_effect=fut.set_result)))
application.authenticated = True
application.handshake = True
await application.on_message({
"id": "1",
"msg": "method",
"method": f"mock.{method}",
"params": [{
"password": "******"
}]
})
await fut
assert any(
f"Exception while calling mock.{method}(*[{{'password': '******'}}])"
in record.message for record in caplog.get_records("call"))
async def test_send_exception_check_parameters(self):
ws = MockWebSocket()
ws.send = AsyncMock()
expected_method = "fake_method"
expected_exc = RuntimeError("test")
expected_error_code = message_code.Response.fail_subscribe_limit
expected_request = Request(method=expected_method,
error=str(expected_exc),
code=expected_error_code)
expected_called_params = dict(expected_request)
await WSDispatcher.send_exception(ws,
method=expected_method,
exception=expected_exc,
error_code=expected_error_code)
actual_called_params, _ = ws.send.call_args
actual_called_params: dict = json.loads(actual_called_params[0])
# Remove id because jsonrpc call auto-increments request id.
expected_called_params.pop("id")
actual_called_params.pop("id")
assert actual_called_params == expected_called_params
async def test_sell_all_currencies(self):
_, exchange_manager, trader_inst = await self.init_default()
portfolio_manager = exchange_manager.exchange_personal_data.portfolio_manager
portfolio_manager.portfolio.portfolio["ADA"] = {
PORTFOLIO_AVAILABLE: 1500,
PORTFOLIO_TOTAL: 1500
}
portfolio_manager.portfolio.portfolio["USDT"] = {
PORTFOLIO_AVAILABLE: 1000,
PORTFOLIO_TOTAL: 1000
}
if not os.getenv('CYTHON_TEST_IGNORE'):
with patch(
'octobot_trading.data_manager.prices_manager.PricesManager.get_mark_price',
new=AsyncMock(return_value=1)):
orders = await trader_inst.sell_all()
# 1 order to sell ada, 1 order to buy btc (sell usdt), NO order for usd (not in config pairs)
assert len(orders) == 2
sell_ADA_order = orders[0]
assert sell_ADA_order.symbol == "ADA/BTC"
assert sell_ADA_order.order_type == TraderOrderType.SELL_MARKET
assert sell_ADA_order.origin_quantity == 1500
sell_USDT_order = orders[1]
assert sell_USDT_order.symbol == "BTC/USDT"
assert sell_USDT_order.order_type == TraderOrderType.BUY_MARKET
assert round(sell_USDT_order.origin_quantity,
8) == round(1000 / sell_USDT_order.origin_price, 8)
await self.stop(exchange_manager)
def version_mock(mocker, spec):
import sys
if sys.version_info[1] < 8:
from asyncmock import AsyncMock # type: ignore
return AsyncMock(spec=spec)
else:
return mocker.MagicMock(spec=spec)
async def test__job_service(caplog, method):
caplog.set_level(logging.INFO)
with patch("middlewared.main.multiprocessing"):
middleware = Middleware()
middleware.loop = asyncio.get_event_loop()
middleware.add_service(CoreService(middleware))
middleware.add_service(DatastoreService(middleware))
middleware.add_service(JobService(middleware))
middleware._resolve_methods()
fut = asyncio.Future()
application = Application(middleware, asyncio.get_event_loop(), Mock(), Mock(send_str=AsyncMock(side_effect=fut.set_result)))
application.authenticated = True
application.authenticated_credentials = Mock(authorize=Mock(return_value=True))
application.handshake = True
await application.on_message({"id": "1", "msg": "method", "method": f"job.{method}", "params": [{"password": "******"}]})
await fut
fut = asyncio.Future()
application.response.send_str = AsyncMock(side_effect=fut.set_result)
await application.on_message({"id": "1", "msg": "method", "method": "core.get_jobs", "params": []})
result = json.loads(await fut)
assert result["result"][0]["arguments"] == [{"password": "******"}]
async def test_cli_run(cli):
mock_parse = AsyncMock()
cli.parse = mock_parse
argv: List = []
await cli.run(argv)
assert mock_parse.call_count == 1
async def test_delete_many_memcached_metric(self, metrics_registry):
driver = MemcachedDriver()
driver._client = AsyncMock()
await driver.delete_all(["foo", "bar"])
assert (
metrics_registry.get_sample_value(
"guillotina_cache_memcached_ops_total", {"type": "delete_many", "error": "none"}
)
== 1.0
)
assert (
metrics_registry.get_sample_value(
"guillotina_cache_memcached_ops_processing_time_seconds_sum", {"type": "delete_many"}
)
> 0
)
assert (
metrics_registry.get_sample_value(
"guillotina_cache_memcached_ops_total", {"type": "delete", "error": "none"}
)
== 2.0
)
assert (
metrics_registry.get_sample_value(
"guillotina_cache_memcached_ops_processing_time_seconds_sum", {"type": "delete"}
)
> 0
)
assert metrics_registry.get_sample_value("guillotina_cache_memcached_delete_all_num_keys_sum") > 0
async def test_client_ws_connect(mocker: pytest_mock.MockerFixture):
runner_mock = mocker.Mock()
runner_mock.wait = AsyncMock()
m = mocker.patch("pybotters.client.WebSocketRunner",
return_value=runner_mock)
hdlr_str = mocker.Mock()
hdlr_bytes = mocker.Mock()
hdlr_json = mocker.Mock()
async with pybotters.Client() as client:
ret = await client.ws_connect(
"ws://test.org",
send_str='{"foo":"bar"}',
send_bytes=b'{"foo":"bar"}',
send_json={"foo": "bar"},
hdlr_str=hdlr_str,
hdlr_bytes=hdlr_bytes,
hdlr_json=hdlr_json,
)
assert m.called
assert m.call_args == [
("ws://test.org", client._session),
{
"send_str": '{"foo":"bar"}',
"send_bytes": b'{"foo":"bar"}',
"send_json": {
"foo": "bar"
},
"hdlr_str": hdlr_str,
"hdlr_bytes": hdlr_bytes,
"hdlr_json": hdlr_json,
},
]
assert ret == runner_mock
def setUp(self) -> None:
"""
Set up the tests environment
"""
container.reset()
self.uaa_service = AsyncMock(spec=UaaService)
container.set('uaa_service', self.uaa_service)
def test_small_single_player_game(self):
game = get_game(max_nb_ticks=10)
game.register_player(RandomPlayer())
viewer = AsyncMock()
game.register_viewer(viewer)
asyncio.run(game.game_loop())
self.assertEqual(10, viewer.send_tick.call_count)
self.assertEqual(1, viewer.send_winner.call_count)
async def test_consume_ends_called():
consumer = await init_consumer_test()
with patch.object(consumer, 'consume_ends',
new=AsyncMock()) as mocked_consume_ends:
await get_chan(TEST_CHANNEL).get_internal_producer().send({})
await mock_was_called_once(mocked_consume_ends)
await get_chan(TEST_CHANNEL).stop()
async def test_send_primitive_async(request_adapter, request_info,
mock_no_content_response):
request_adapter.get_http_response_message = AsyncMock(
return_value=mock_no_content_response)
resp = await request_adapter.get_http_response_message(request_info)
assert resp.headers.get("content-type") == 'application/json'
final_result = await request_adapter.send_primitive_async(
request_info, float, None, {})
assert final_result is None
async def test_log_new_url_signal_data(mocker, config, test_input, expected):
mocker.patch('consumer.pg_db_adapter.ssl')
close_mock = AsyncMock()
fetch_mock = AsyncMock(side_effect=[[], [], [{
'url': "test",
'id': "test"
}], expected])
execute_mock = AsyncMock()
async def await_pool():
return SimpleNamespace(close=close_mock,
fetch=fetch_mock,
execute=execute_mock)
mocker.patch('asyncpg.create_pool', return_value=await_pool())
db_writer = DbWebsiteMetricsWriter(config)
async with db_writer:
await db_writer.log_signal_data(*test_input)
async def test_send_collection_of_primitive_async(
request_adapter, request_info, mock_primitive_collection_response):
request_adapter.get_http_response_message = AsyncMock(
return_value=mock_primitive_collection_response)
resp = await request_adapter.get_http_response_message(request_info)
assert resp.headers.get("content-type") == 'application/json'
final_result = await request_adapter.send_collection_of_primitive_async(
request_info, int, None, {})
assert final_result == [12.1, 12.2, 12.3, 12.4, 12.5]
async def test_upload(mock_ws, pubo_problem):
with patch("azure.quantum.aio.optimization.problem.BlobClient") as mock_blob_client, \
patch("azure.quantum.aio.optimization.problem.ContainerClient") as mock_container_client, \
patch("azure.quantum.aio.job.base_job.upload_blob") as mock_upload:
mock_blob_client.from_blob_url.return_value = Mock()
mock_container_client.from_container_url.return_value = Mock()
assert(pubo_problem.uploaded_blob_uri == None)
actual_result = await pubo_problem.upload(mock_ws)
mock_upload.get_blob_uri_with_sas_token = AsyncMock()
azure.quantum.aio.job.base_job.upload_blob.assert_called_once()
def request_next_move(return_value):
server = Mock()
server.game.max_nb_ticks = 500
socket = AsyncMock()
socket.recv.return_value = return_value
gs, player = get_player(server, socket)
player.logger = Mock()
next_move = asyncio.run(player.request_next_move(123, gs))
socket.send.assert_called_once()
return next_move, player
async def test_record_transaction_cache_empty(self, dummy_guillotina,
metrics_registry):
storage = AsyncMock()
mng = TransactionManager(storage)
cache = AsyncMock()
cache.get.return_value = transaction._EMPTY
strategy = AsyncMock()
txn = Transaction(mng, cache=cache, strategy=strategy)
ob = create_content(Container)
with pytest.raises(KeyError):
await txn.get_annotation(ob, "foobar")
assert (metrics_registry.get_sample_value(
"guillotina_cache_ops_total", {
"type": "_get_annotation",
"result": "hit_empty"
}) == 1.0)
def test_socket_closed(self):
server = Mock()
server.game.max_nb_ticks = 500
socket = AsyncMock()
socket.recv.side_effect = websockets.ConnectionClosed(0, "")
gs, player = get_player(server, socket)
player.logger = Mock()
next_move = asyncio.run(player.request_next_move(123, gs))
socket.send.assert_called_once()
self.assertEqual((None, Action.FORWARD), next_move)
player.logger.warning.assert_called_once()
player.server.game.unregister_player.assert_called_once()
async def test_delete_redis_metric(self, metrics_registry):
driver = RedisDriver()
driver._pool = AsyncMock()
await driver.delete("foo")
assert (metrics_registry.get_sample_value(
"guillotina_cache_redis_ops_total", {
"type": "delete",
"error": "none"
}) == 1.0)
assert (metrics_registry.get_sample_value(
"guillotina_cache_redis_ops_processing_time_seconds_sum",
{"type": "delete"}) > 0)
def test_exception(self):
server = Mock()
server.game.max_nb_ticks = 500
socket = AsyncMock()
socket.recv.side_effect = Exception("dummy")
gs, player = get_player(server, socket)
player.logger = Mock()
next_move = asyncio.run(player.request_next_move(123, gs))
socket.send.assert_called_once()
self.assertEqual((None, Action.FORWARD), next_move)
player.logger.warning.assert_called_once()
player.server.game.unregister_player.assert_not_called()
self.assertTrue(len(player.player_state.history) > 0)
async def test_uaa_auth_middleware_from_header(self):
"""
Test calling the uaa auth middleware with a request with the token in headers validates the token
and sets its user field
"""
test_token = 'test_token'
request_mock = Mock(spec=Request)
request_mock.headers = {'X-API-Key': test_token}
handler_mock = AsyncMock()
handled_middleware = await uaa_auth_middleware(None, handler_mock)
await handled_middleware(request_mock)
self.uaa_service.validate_token.assert_called_with(test_token)
self.assertIsNotNone(request_mock.user)
async def test_get_miss_redis_metric(self, metrics_registry):
driver = RedisDriver()
driver._pool = AsyncMock()
driver._pool.execute.return_value = None
await driver.get("foo")
assert (metrics_registry.get_sample_value(
"guillotina_cache_redis_ops_total", {
"type": "get_miss",
"error": "none"
}) == 1.0)
assert (metrics_registry.get_sample_value(
"guillotina_cache_redis_ops_processing_time_seconds_sum",
{"type": "get_miss"}) > 0)
async def test_uaa_auth_middleware_no_token(self):
"""
Test calling the uaa auth middleware with a request without do not call to validate the token
and its user field is None
"""
request_mock = Mock(spec=Request)
request_mock.headers = {}
request_mock.cookies = {}
handler_mock = AsyncMock()
handled_middleware = await uaa_auth_middleware(None, handler_mock)
await handled_middleware(request_mock)
self.uaa_service.validate_token.assert_not_called()
self.assertIsNone(request_mock.user)
