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_get_orders_by_user():
user_id = create_user()["id"]
sell_order = create_sell_order("1", user_id=user_id)
sell_order2 = create_sell_order("2", user_id=user_id)
orders = sell_order_service.get_orders_by_user(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_order_by_id__unauthorized():
sell_order = create_sell_order()
user_id = sell_order["user_id"]
false_user_id = ("1" if user_id[0] == "0" else "0") + user_id[1:]
with pytest.raises(ResourceNotOwnedException):
sell_order_service.get_order_by_id(id=sell_order["id"], user_id=false_user_id)
def test_get_order_by_id():
sell_order = create_sell_order()
order_retrieved = sell_order_service.get_order_by_id(
id=sell_order["id"], user_id=sell_order["user_id"]
)
assert order_retrieved["id"] == sell_order["id"]
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_delete_order():
user_id = create_user()["id"]
sell_order_id = create_sell_order(user_id=user_id)["id"]
sell_order_service.delete_order(id=sell_order_id, subject_id=user_id)
with session_scope() as session:
assert session.query(SellOrder).filter_by(id=sell_order_id).count() == 0
def test_should_round_start__unique_sellers():
create_sell_order("1", number_of_shares=5, round_id=None)
assert not round_service.should_round_start()
create_sell_order("2", number_of_shares=5, round_id=None)
assert round_service.should_round_start()
create_sell_order("3", number_of_shares=5, round_id=None)
assert round_service.should_round_start()
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_edit_order():
user = create_user()
user_id = user["id"]
sell_order = create_sell_order(user_id=user_id)
with patch("src.services.EmailService.send_email") as email_mock:
sell_order_service.edit_order(
id=sell_order["id"], subject_id=user_id, new_number_of_shares=50
)
email_mock.assert_called_with(
emails=[user["email"]], template="edit_sell_order"
)
with session_scope() as session:
new_sell_order = session.query(SellOrder).get(sell_order["id"]).asdict()
test_dict = {**sell_order, "number_of_shares": 50}
del test_dict["updated_at"]
assert_dict_in(test_dict, new_sell_order)
def test_should_round_start__big_shares_amount():
create_sell_order("1", number_of_shares=1000, round_id=None)
assert round_service.should_round_start()