def test_get_all():
round_id = create_round("1")["id"]
round_id2 = create_round("2")["id"]
rounds = round_service.get_all()
assert len(rounds) == 2
assert frozenset([r["id"]
for r in rounds]) == frozenset([round_id, round_id2])
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():
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__double_sell_orders():
round = create_round()
sell_user = create_user("3")
sell_user2 = create_user("4")
sell_order1 = create_sell_order("3", round_id=round["id"], user_id=sell_user["id"])
sell_order21 = create_sell_order(
"4", round_id=round["id"], user_id=sell_user2["id"]
)
sell_order22 = create_sell_order(
"5", 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 (
len([o for o in mock_match.call_args[0][1] if o["id"] == sell_order1["id"]])
== 2
)
assert (
len(
[o for o in mock_match.call_args[0][1] if o["id"] == sell_order21["id"]]
)
== 1
)
assert (
len(
[o for o in mock_match.call_args[0][1] if o["id"] == sell_order22["id"]]
)
== 1
)
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__pending():
user = create_user(can_buy=False)
user_id = user["id"]
security_id = create_security()["id"]
create_user_request(user_id=user_id, is_buy=True)
round = create_round()
buy_order_params = {
"user_id": user_id,
"number_of_shares": 20,
"price": 30,
"security_id": security_id,
}
with patch("src.services.RoundService.get_active", return_value=round), patch(
"src.services.RoundService.should_round_start", return_value=False
), patch("src.services.EmailService.send_email") as email_mock:
buy_order_id = buy_order_service.create_order(**buy_order_params)["id"]
email_mock.assert_called_with(
emails=[user["email"]], template="create_buy_order"
)
with session_scope() as session:
buy_order = session.query(BuyOrder).get(buy_order_id).asdict()
assert_dict_in({**buy_order_params, "round_id": round["id"]}, buy_order)
def test_create_order__limit_reached():
user_id = create_user()["id"]
security_id = create_security()["id"]
create_round()
buy_order_params = {
"user_id": user_id,
"number_of_shares": 20,
"price": 30,
"security_id": security_id,
}
with patch("src.services.EmailService.send_email"):
for _ in range(APP_CONFIG["ACQUITY_BUY_ORDER_PER_ROUND_LIMIT"]):
buy_order_service.create_order(**buy_order_params)
with pytest.raises(UnauthorizedException), patch(
"src.services.EmailService.send_email"
) as email_mock:
buy_order_service.create_order(**buy_order_params)
email_mock.assert_not_called()
def test_get_orders_by_user_in_current_round():
user_id = create_user()["id"]
current_round = create_round()
past_round = create_round(is_concluded=True)
sell_order = create_sell_order("1", user_id=user_id, round_id=None)
sell_order2 = create_sell_order("2", user_id=user_id, round_id=current_round["id"])
create_sell_order("3", user_id=user_id, round_id=past_round["id"])
orders = sell_order_service.get_orders_by_user_in_current_round(user_id=user_id)
assert len(orders) == 2
assert (
sell_order == orders[0]
if orders[0]["number_of_shares"] == sell_order["number_of_shares"]
else orders[1]
)
assert (
sell_order2 == orders[1]
if orders[0]["number_of_shares"] == sell_order["number_of_shares"]
else orders[0]
)
def test_get_active__all_concluded():
create_round(end_time=datetime.now() + timedelta(weeks=1),
is_concluded=True)
create_round(end_time=datetime.now() + timedelta(weeks=2),
is_concluded=True)
assert round_service.get_active() is None
def test_get_active():
active_id = create_round(end_time=datetime.now() + timedelta(weeks=1),
is_concluded=False)["id"]
active_round = round_service.get_active()
assert active_round["id"] == active_id
