def test_run_matches():
round = create_round()
buy_user = create_user("1")
buy_user2 = create_user("2")
sell_user = create_user("3")
sell_user2 = create_user("4")
buy_order = create_buy_order("1", round_id=round["id"], user_id=buy_user["id"])
buy_order_id = buy_order["id"]
create_buy_order("2", round_id=round["id"], user_id=buy_user2["id"])
sell_order = create_sell_order("3", round_id=round["id"], user_id=sell_user["id"])
sell_order_id = sell_order["id"]
create_sell_order("4", round_id=round["id"], user_id=sell_user2["id"])
with patch(
"src.services.match_buyers_and_sellers",
return_value=[(buy_order_id, sell_order_id)],
) as mock_match, patch(
"src.services.RoundService.get_active", return_value=round
), patch(
"src.services.EmailService.send_email"
) as mock_email:
match_service.run_matches()
mock_email.assert_has_calls(
[
call([buy_user["email"]], template="match_done_has_match_buyer"),
call([sell_user["email"]], template="match_done_has_match_seller"),
call(
[buy_user2["email"], sell_user2["email"]],
template="match_done_no_match",
),
]
)
assert set(u["user_id"] for u in mock_match.call_args[0][0]) == set(
[buy_user["id"], buy_user2["id"]]
)
assert set(u["user_id"] for u in mock_match.call_args[0][1]) == set(
[sell_user["id"], sell_user2["id"]]
)
assert mock_match.call_args[0][2] == []
with session_scope() as session:
match = session.query(Match).one()
assert match.buy_order_id == buy_order_id
assert match.sell_order_id == sell_order_id
assert (
session.query(UserChatRoomAssociation)
.filter_by(user_id=buy_order["user_id"])
.one()
.chat_room_id
== session.query(UserChatRoomAssociation)
.filter_by(user_id=sell_order["user_id"])
.one()
.chat_room_id
)
assert session.query(Round).get(round["id"]).is_concluded
def test_run_matches__cannot_buy_or_sell():
round = create_round()
buy_user = create_user("1", can_buy=True)
buy_user2 = create_user("2", can_buy=False)
sell_user = create_user("3", can_sell=True)
sell_user2 = create_user("4", can_sell=False)
create_buy_order("1", round_id=round["id"], user_id=buy_user["id"])
create_buy_order("2", round_id=round["id"], user_id=buy_user2["id"])
create_sell_order("3", round_id=round["id"], user_id=sell_user["id"])
create_sell_order("4", round_id=round["id"], user_id=sell_user2["id"])
with patch("src.services.match_buyers_and_sellers") as mock_match, patch(
"src.services.RoundService.get_active", return_value=round
), patch("src.services.EmailService.send_email"):
match_service.run_matches()
assert set(u["user_id"] for u in mock_match.call_args[0][0]) == set(
[buy_user["id"]]
)
assert set(u["user_id"] for u in mock_match.call_args[0][1]) == set(
[sell_user["id"]]
)
assert mock_match.call_args[0][2] == []
def test_run_matches__banned_pairs():
round = create_round()
buy_user = create_user("1")
buy_user2 = create_user("2")
sell_user = create_user("3")
sell_user2 = create_user("4")
buy_user_id = buy_user["id"]
sell_user_id = sell_user["id"]
create_buy_order("1", round_id=round["id"], user_id=buy_user["id"])
create_buy_order("2", round_id=round["id"], user_id=buy_user2["id"])
create_sell_order("3", round_id=round["id"], user_id=sell_user["id"])
create_sell_order("4", round_id=round["id"], user_id=sell_user2["id"])
create_banned_pair(buyer_id=buy_user_id, seller_id=sell_user_id)
with patch("src.services.match_buyers_and_sellers") as mock_match, patch(
"src.services.RoundService.get_active", return_value=round
), patch("src.services.EmailService.send_email"):
match_service.run_matches()
assert set(u["user_id"] for u in mock_match.call_args[0][0]) == set(
[buy_user_id, buy_user2["id"]]
)
assert set(u["user_id"] for u in mock_match.call_args[0][1]) == set(
[sell_user_id, sell_user2["id"]]
)
assert mock_match.call_args[0][2] == [(buy_user_id, sell_user_id)]
def test_create_order__add_new_round():
user = create_user()
security_id = create_security()["id"]
user_id = user["id"]
sell_order_params = {
"user_id": user_id,
"number_of_shares": 20,
"price": 30,
"security_id": security_id,
}
create_buy_order(round_id=None, user_id=user_id)
with patch("src.services.RoundService.get_active",
return_value=None), patch(
"src.services.RoundService.should_round_start",
return_value=False), patch(
"src.services.EmailService.send_email") as email_mock:
sell_order_id = sell_order_service.create_order(**sell_order_params,
scheduler=None)["id"]
with patch("src.services.RoundService.get_active",
return_value=None), patch(
"src.services.RoundService.should_round_start",
return_value=True), patch(
"src.services.EmailService.send_email") as email_mock:
scheduler_mock = MagicMock()
class SchedulerMock(BaseScheduler):
shutdown = MagicMock()
wakeup = MagicMock()
add_job = scheduler_mock
sell_order_id2 = sell_order_service.create_order(
**sell_order_params, scheduler=SchedulerMock())["id"]
email_mock.assert_any_call([user["email"]], template="round_opened")
email_mock.assert_any_call(emails=[user["email"]],
template="create_sell_order")
scheduler_args = scheduler_mock.call_args
assert scheduler_args[0][1] == "date"
with session_scope() as session:
assert scheduler_args[1]["run_date"] == session.query(
Round).one().end_time
sell_order = session.query(SellOrder).get(sell_order_id).asdict()
sell_order2 = session.query(SellOrder).get(sell_order_id2).asdict()
buy_order = session.query(BuyOrder).one().asdict()
assert_dict_in(sell_order_params, sell_order)
assert sell_order["round_id"] is not None
assert_dict_in(sell_order_params, sell_order2)
assert sell_order2["round_id"] is not None
assert buy_order["round_id"] is not None
def test_get_chats_by_user_id__buy_sell_order():
user = create_user("00")
other_party = create_user("10")
buy_order = create_buy_order("02", user_id=user["id"])
sell_order = create_sell_order("03", user_id=user["id"])
match = create_match("04",
buy_order_id=buy_order["id"],
sell_order_id=sell_order["id"])
chat_room = create_chat_room("01", match_id=match["id"])
create_user_chat_room_association("02",
user_id=user["id"],
chat_room_id=chat_room["id"],
is_archived=False)
create_user_chat_room_association("12",
user_id=other_party["id"],
chat_room_id=chat_room["id"])
res = chat_service.get_chats_by_user_id(user_id=user["id"],
as_buyer=True,
as_seller=True)
res_room = res["unarchived"][chat_room["id"]]
assert buy_order == res_room["buy_order"]
assert sell_order == res_room["sell_order"]
def test_get_order_by_id__unauthorized():
buy_order = create_buy_order()
user_id = buy_order["user_id"]
false_user_id = ("1" if user_id[0] == "0" else "0") + user_id[1:]
with pytest.raises(ResourceNotOwnedException):
buy_order_service.get_order_by_id(id=buy_order["id"], user_id=false_user_id)
def test_get_order_by_id():
buy_order = create_buy_order()
order_retrieved = buy_order_service.get_order_by_id(
id=buy_order["id"], user_id=buy_order["user_id"]
)
assert order_retrieved["id"] == buy_order["id"]
def test_delete_order():
user_id = create_user()["id"]
buy_order_id = create_buy_order(user_id=user_id)["id"]
buy_order_service.delete_order(id=buy_order_id, subject_id=user_id)
with session_scope() as session:
assert session.query(BuyOrder).filter_by(id=buy_order_id).count() == 0
def test_get_orders_by_user():
user_id = create_user()["id"]
buy_order = create_buy_order("1", user_id=user_id)
buy_order2 = create_buy_order("2", user_id=user_id)
orders = buy_order_service.get_orders_by_user(user_id=user_id)
assert len(orders) == 2
assert (
buy_order == orders[0]
if orders[0]["number_of_shares"] == buy_order["number_of_shares"]
else orders[1]
)
assert (
buy_order2 == orders[1]
if orders[0]["number_of_shares"] == buy_order["number_of_shares"]
else orders[0]
)
def test_edit_order():
user = create_user()
user_id = user["id"]
buy_order = create_buy_order(user_id=user_id)
with patch("src.services.EmailService.send_email") as email_mock:
buy_order_service.edit_order(
id=buy_order["id"], subject_id=user_id, new_number_of_shares=50
)
email_mock.assert_called_with(emails=[user["email"]], template="edit_buy_order")
with session_scope() as session:
new_buy_order = session.query(BuyOrder).get(buy_order["id"]).asdict()
test_dict = {**buy_order, "number_of_shares": 50}
del test_dict["updated_at"]
assert_dict_in(test_dict, new_buy_order)
