def test_get_chats_by_user_id__offer_responses():
user = create_user("00")
other_party = create_user("10")
chat_room = create_chat_room("01")
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"])
offer = create_offer("03",
chat_room_id=chat_room["id"],
author_id=user["id"])
resp = create_offer_response("04", offer_id=offer["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"]]
chat_room.pop("disband_by_user_id")
chat_room.pop("disband_time")
assert_dict_in(chat_room, res_room)
res_chats = res_room["chats"]
assert {**offer, "type": "offer"} in res_chats
assert {
**offer,
**resp,
"author_id": other_party["id"],
"is_deal_closed": False,
"type": "offer_response",
} in res_chats
def test_create_order__authorized():
user = create_user()
user_id = user["id"]
security_id = create_security()["id"]
sell_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=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"]
email_mock.assert_called_with(
emails=[user["email"]], template="create_sell_order"
)
with session_scope() as session:
sell_order = session.query(SellOrder).get(sell_order_id).asdict()
assert_dict_in({**sell_order_params, "round_id": None}, sell_order)
def test_create__is_sell():
user_params = {
"email": "*****@*****.**",
"full_name": "Ben",
"provider_user_id": "testing",
"display_image_url": "http://blah",
"is_buy": False,
"auth_token": None,
}
committee_email = create_user(is_committee=True)["email"]
with patch("src.services.EmailService.send_email") as mock:
user_service.create_if_not_exists(**user_params)
mock.assert_any_call(emails=[user_params["email"]],
template="register_seller")
mock.assert_any_call(emails=[committee_email],
template="new_user_review")
with session_scope() as session:
user = session.query(User).filter_by(email="*****@*****.**").one().asdict()
req = session.query(UserRequest).one().asdict()
user_expected = user_params
user_expected.pop("is_buy")
user_expected.update({"can_buy": "NO", "can_sell": "UNAPPROVED"})
assert_dict_in(user_expected, user)
assert_dict_in({"user_id": user["id"], "is_buy": False}, req)
def test_get_chats_by_user_id__chats():
user = create_user("00")
other_party = create_user("10")
chat_room = create_chat_room("01")
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"])
chat = create_chat("03",
chat_room_id=chat_room["id"],
author_id=user["id"])
other_chat = create_chat("13",
chat_room_id=chat_room["id"],
author_id=other_party["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"]]
chat_room.pop("disband_by_user_id")
chat_room.pop("disband_time")
assert_dict_in(chat_room, res_room)
res_chats = res_room["chats"]
assert {**chat, "type": "chat"} in res_chats
assert {**other_chat, "type": "chat"} in res_chats
def test_create__user_exists():
user_params = {
"email": "*****@*****.**",
"full_name": "Ben",
"provider_user_id": "testing",
"display_image_url": "http://blah",
"is_buy": True,
"auth_token": None,
}
with patch("src.services.EmailService.send_email"):
user_service.create_if_not_exists(
**{
**user_params,
"email": "*****@*****.**",
"full_name": "Boo",
"display_image_url": "old",
})
with patch("src.services.EmailService.send_email") as mock:
user_service.create_if_not_exists(**user_params)
mock.assert_not_called()
with session_scope() as session:
user = session.query(User).one().asdict()
user_expected = user_params
user_expected.pop("is_buy")
user_expected.update({"can_buy": "UNAPPROVED", "can_sell": "NO"})
assert_dict_in(user_expected, user)
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__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_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)
def test_get_chats_by_user_id__archived():
user = create_user("00")
other_party = create_user("10")
chat_room = create_chat_room("01")
create_user_chat_room_association("02",
user_id=user["id"],
chat_room_id=chat_room["id"],
is_archived=True)
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["archived"][chat_room["id"]]
chat_room.pop("disband_by_user_id")
chat_room.pop("disband_time")
assert_dict_in(chat_room, res_room)
def test_create_order__authorized_no_active_rounds():
user = create_user()
user_id = user["id"]
security_id = create_security()["id"]
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=None), 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": None}, buy_order)
def test_asdict():
assert_dict_in({"a": 2}, DummyClass().asdict())