def test_post_finish_mainOrder_with_id(res_query_result, res, monkeypatch):
def mock_orders_query_get(id):
if res_query_result is not None:
fake = Faker()
order = Orders(name=fake.name(),
summary="None",
createdate=fake.date_time(),
deadline=fake.date_time(),
address=fake.city(),
quantity=1,
price=1.0,
totalprice=1.0,
createuser=0,
comments="None",
phone=fake.phone_number(),
status=0,
progress=0)
order.ID = res_query_result["ID"]
return order
else:
return None
def mock_db_commit():
return
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.mainorder_api.Orders.query",
Mocker(get=mock_orders_query_get))
monkeypatch.setattr("src.api.mainorder_api.db.session",
Mocker(commit=mock_db_commit))
result = post_finish_mainOrder_with_id(
res_query_result["ID"] if res_query_result is not None else 0)
assert isinstance(result, dict) and result["code"] == res["code"] \
and isinstance(result["data"], dict) and result["data"]["msg"] == res["msg"]
def test_post_cancel_sub_order_with_id(res_query_result, res, monkeypatch):
def mock_suborders_query_get(id):
if res_query_result is not None:
fake = Faker()
order = subOrders(mainorder=0,
createdate=fake.date_time(),
createuser=0,
quantity=1,
comments="None",
phone=fake.phone_number(),
status=0)
order.ID = res_query_result["ID"]
return order
else:
return None
def mock_db_commit():
return
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.suborder_api.subOrders.query",
Mocker(get=mock_suborders_query_get))
monkeypatch.setattr("src.api.suborder_api.db.session",
Mocker(commit=mock_db_commit))
result = post_cancel_subOrder_with_id(
res_query_result["ID"] if res_query_result is not None else 0)
assert isinstance(result, dict) and result["code"] == res["code"] \
and isinstance(result["data"], dict) and result["data"]["msg"] == res["msg"]
def test_add_new_main_order(json_body, session, targets_user, res,
monkeypatch):
def mock_db_add(order):
order.ID = 0
def mock_db_commit():
return
def mock_users_query_filter_by(username):
def mock_first():
if targets_user is not None:
user = Users(username=username,
password="******",
email="*****@*****.**",
phone="13588888888",
usertype=0,
userstatus=0)
user.ID = targets_user["ID"]
return user
else:
return None
return Mocker(first=mock_first)
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.mainorder_api.session", session)
monkeypatch.setattr("src.api.mainorder_api.Users.query",
Mocker(filter_by=mock_users_query_filter_by))
monkeypatch.setattr("src.api.mainorder_api.db.session",
Mocker(add=mock_db_add, commit=mock_db_commit))
result = add_new_main_order(json_body)
assert isinstance(result, dict) and result["code"] == res["code"] \
and isinstance(result["data"], dict) and result["data"]["msg"] == res["msg"] \
and result["data"]["id"] == res["id"]
def test_deposit_wallet_balancee(user_id, target_user, deposit, res, monkeypatch):
user = None
def mock_users_query_filter_by(ID):
def mock_first():
nonlocal user
fake = Faker()
if target_user is not None:
user = Users(username="******",
password=fake.password(),
email=fake.email(),
phone=fake.phone_number(),
usertype=0,
userstatus=0)
user.balance = target_user["balance"]
user.ID = target_user["ID"]
return user
else:
return None
return Mocker(first=mock_first)
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.user_api.Users.query", Mocker(filter_by=mock_users_query_filter_by))
result = deposit_wallet_balance(user_id, deposit)
assert isinstance(result, dict)
assert result == res
assert user.balance == target_user["balance"] + deposit if target_user is not None else True
def test_get_main_orders(skip, limit, db_orders, res, monkeypatch):
def mock_orders_query_all():
orders = []
fake = Faker()
for i in range(0, db_orders["orders_num"]):
o = Orders(name=fake.name(),
summary="None",
createdate=fake.date_time(),
deadline=fake.date_time(),
address=fake.city(),
quantity=1,
price=1.0,
totalprice=1.0,
createuser=i,
comments="None",
phone=fake.phone_number(),
status=0,
progress=0)
o.ID = i
orders.append(o)
return orders
def mock_get_main_order_supply(id):
fake = Faker()
return fake.random_int()
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.mainorder_api.Orders.query",
Mocker(all=mock_orders_query_all))
monkeypatch.setattr("src.api.mainorder_api.get_main_order_supply",
mock_get_main_order_supply)
result = get_main_orders(skip, limit)
assert isinstance(result, dict) and result["code"] == res["code"] \
and isinstance(result["data"], dict) and len(result["data"]["orders"]) == res["orders_num"]
def test_get_sub_orders(skip, limit, role, db_suborders, res, monkeypatch):
def mock_suborders_query_all():
suborders = []
fake = Faker()
for i in range(0, db_suborders["suborders_num"]):
o = subOrders(mainorder=0,
createdate=fake.date_time(),
createuser=0,
quantity=1,
comments="None",
phone=fake.phone_number(),
status=0)
o.ID = 1
suborders.append(o)
return suborders
def mock_get_main_order_supply(id):
fake = Faker()
return fake.random_int()
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.suborder_api.subOrders.query",
Mocker(all=mock_suborders_query_all))
monkeypatch.setattr("src.api.suborder_api.session", {"role": role})
result = get_sub_orders(skip, limit)
assert isinstance(result, dict) and result["code"] == res["code"] \
and isinstance(result["data"], dict) and len(result["data"]["orders"]) == res["suborders_num"]
def test_login_status(session, targets_user, res, monkeypatch):
def mock_users_query_filter_by(username):
def mock_first():
if targets_user is not None:
user = Users(username=username,
password="******",
email="*****@*****.**",
phone="None",
usertype=0,
userstatus=0)
user.ID = targets_user["ID"]
return user
else:
return None
return Mocker(first=mock_first)
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.user_api.session", session)
monkeypatch.setattr("src.api.user_api.Users.query",
Mocker(filter_by=mock_users_query_filter_by))
result = login_status()
assert (isinstance(result, dict) and result["code"] == res["code"]
and result["data"]["msg"] == res["msg"]
and result["data"]["userid"] == targets_user["ID"]
if targets_user is not None else True)
def test_get_sub_order_with_id(res_query_result, res, monkeypatch):
def mock_suborders_query_get(id):
if res_query_result is not None:
fake = Faker()
order = subOrders(mainorder=0,
createdate=fake.date_time(),
createuser=0,
quantity=1,
comments="None",
phone=fake.phone_number(),
status=0)
order.ID = res_query_result[
"ID"] if res_query_result is not None else 0
return order
else:
return None
def mock_get_main_order_supply(id):
return 10
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.suborder_api.subOrders.query",
Mocker(get=mock_suborders_query_get))
result = get_sub_order_with_id(0)
assert isinstance(result, dict) and result["code"] == res["code"] \
and isinstance(result["data"], dict) and result["data"]["msg"] == res["msg"] \
and (result["data"]["order"]["id"] == res_query_result["ID"]
if "order" in result["data"] else True)
def test_get_main_order_supply(db_suborders, res, monkeypatch):
def mock_suborders_query(p1, p2):
return db_suborders
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.mainorder_api.subOrders.query",
Mocker(filter=mock_suborders_query))
result = get_main_order_supply(0)
assert result == res and isinstance(result, int)
def mock_users_query_filter_by(username):
def mock_first():
for u in fake_users_db:
if u.username == username:
return u
else:
return None
return Mocker(first=mock_first)
def test_get_orders_by_userid(user_id, res, monkeypatch):
def mock_orders_query_filter_by(createuser):
fake = Faker()
order = Orders(name=fake.name(),
summary="None",
createdate=fake.date_time(),
deadline=fake.date_time(),
address=fake.city(),
quantity=1,
price=1.0,
totalprice=1.0,
createuser=user_id,
comments="None",
phone=fake.phone_number(),
status=0,
progress=0)
order.ID = 1
return [order]
def mock_suborders_query_filter_by(createuser):
fake = Faker()
order = subOrders(mainorder=0,
createdate=fake.date_time(),
createuser=0,
quantity=1,
comments="None",
phone=fake.phone_number(),
status=0)
order.ID = 1
return [order]
def mock_get_main_order_supply(mainOrderId):
return 0
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.user_api.Orders.query",
Mocker(filter_by=mock_orders_query_filter_by))
monkeypatch.setattr("src.api.user_api.subOrders.query",
Mocker(filter_by=mock_suborders_query_filter_by))
monkeypatch.setattr("src.api.user_api.get_main_order_supply",
mock_get_main_order_supply)
result = get_orders_by_userid(user_id)
assert (isinstance(result, dict) and result["code"] == res["code"])
def test_add_new_sub_order(json_body, res, monkeypatch):
def mock_db_add(order):
order.ID = 0
def mock_db_commit():
return
def mock_users_query_filter_by(username):
def mock_first():
fake = Faker()
user = Users(username=username,
password=fake.password(),
email=fake.email(),
phone=fake.phone_number(),
usertype=0,
userstatus=0)
user.ID = 1
return user
return Mocker(first=mock_first)
def mock_get_main_order_with_id(mainOrderId):
return {'data': {'order': {'remain_quantity': 100}}}
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.suborder_api.db.session",
Mocker(add=mock_db_add, commit=mock_db_commit))
monkeypatch.setattr(
"src.api.suborder_api.Users",
Mocker(query=Mocker(filter_by=mock_users_query_filter_by)))
monkeypatch.setattr("src.api.suborder_api.session",
{"username": "******"})
monkeypatch.setattr("src.api.suborder_api.get_main_order_with_id",
mock_get_main_order_with_id)
result = add_new_sub_order(json_body)
assert isinstance(result, dict) and result["code"] == res["code"]
if result['code'] == 0:
assert (result["data"]["msg"] == res["msg"]
and result["data"]["id"] == res["id"])
elif result['code'] == 2:
assert (result["data"]["msg"] == res["msg"]
and result["data"]["remain_quantity"]
== res["remain_quantity"])
def mock_users_query_filter_by(username):
def mock_first():
fake = Faker()
user = Users(username=username,
password=fake.password(),
email=fake.email(),
phone=fake.phone_number(),
usertype=0,
userstatus=0)
user.ID = 1
return user
return Mocker(first=mock_first)
def test_cancel_all_subOrder_with_mainOrder(monkeypatch):
def mock_suborders_query_filter_by(mainorder):
fake = Faker()
return [
subOrders(mainorder=0,
createdate=fake.date_time(),
createuser=0,
quantity=1,
comments="None",
phone=fake.phone_number(),
status=0)
]
def mock_db_commit():
return
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.mainorder_api.subOrders.query",
Mocker(filter_by=mock_suborders_query_filter_by))
monkeypatch.setattr("src.api.mainorder_api.db.session",
Mocker(commit=mock_db_commit))
cancel_all_subOrder_with_mainOrder(1)
def mock_users_query_filter_by(username):
def mock_first():
if targets_user is not None:
user = Users(username=username,
password="******",
email="*****@*****.**",
phone="None",
usertype=0,
userstatus=0)
user.ID = targets_user["ID"]
return user
else:
return None
return Mocker(first=mock_first)
def mock_users_query_filter_by(ID):
def mock_first():
if find_user is not None:
user = Users(username=json_body["username"],
password="******",
email="*****@*****.**",
phone="None",
usertype=0,
userstatus=0)
user.ID = ID
return user
else:
return None
return Mocker(first=mock_first)
def mock_users_query_filter_by(username):
def mock_first():
fake = Faker()
if target_user is not None:
user = Users(username=username,
password=fake.password(),
email=fake.email(),
phone=fake.phone_number(),
usertype=0,
userstatus=0)
user.ID = target_user["ID"]
return [user]
else:
return None
return Mocker(first=mock_first)
def test_add_user(username, password, email, phone, usertype, userstatus, role,
res, monkeypatch):
def mock_db_add(user):
return
def mock_db_commit():
return
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.user_api.session",
{"role": role} if role is not None else {})
monkeypatch.setattr("src.api.user_api.db.session",
Mocker(add=mock_db_add, commit=mock_db_commit))
result = add_user(username, password, email, phone, usertype,
userstatus)
assert result == res
def mock_users_query_filter_by(ID):
def mock_first():
nonlocal user
fake = Faker()
if target_user is not None:
user = Users(username="******",
password=fake.password(),
email=fake.email(),
phone=fake.phone_number(),
usertype=0,
userstatus=0)
user.balance = target_user["balance"]
user.ID = target_user["ID"]
return user
else:
return None
return Mocker(first=mock_first)
def test_get_user_infos(target_user, res, monkeypatch):
def mock_users_query_all():
if target_user is not None:
user = Users(username="******",
password="******",
email="*****@*****.**",
phone="None",
usertype=0,
userstatus=0)
user.ID = 0
return [user]
else:
return None
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.user_api.Users.query",
Mocker(all=mock_users_query_all))
result = get_user_infos()
assert isinstance(result, dict) and result["code"] == res["code"]
def test_do_register(json_body, find_user, finished, res, monkeypatch):
fake_users_db = []
if find_user is not None:
user = Users(username=json_body["username"],
password=json_body["password"],
email=json_body["email"],
phone=json_body["phone"],
usertype=0,
userstatus=0)
user.ID = find_user["ID"]
fake_users_db.append(user)
def mock_users_query_filter_by(username):
def mock_first():
for u in fake_users_db:
if u.username == username:
return u
else:
return None
return Mocker(first=mock_first)
def mock_add_user(username, password, email, phone, role, userstatus):
if finished:
user = Users(username=username,
password=password,
email=email,
phone=phone,
usertype=0,
userstatus=userstatus)
user.ID = 1
fake_users_db.append(user)
return finished
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.user_api.Users.query",
Mocker(filter_by=mock_users_query_filter_by))
monkeypatch.setattr("src.api.user_api.add_user", mock_add_user)
monkeypatch.setattr("src.api.user_api.session", {})
result = do_register(json_body)
assert (isinstance(result, dict) and result["code"] == res["code"]
and result["data"]["msg"] == res["msg"])
def test_get_user_info(target_user, res, monkeypatch):
def mock_users_query_filter_by(ID):
def mock_first():
if target_user is not None:
user = Users(username="******",
password="******",
email="*****@*****.**",
phone="None",
usertype=0,
userstatus=0)
user.ID = ID
return user
else:
return None
return Mocker(first=mock_first)
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.user_api.Users.query",
Mocker(filter_by=mock_users_query_filter_by))
result = get_user_info(1)
assert isinstance(result, dict) and result["code"] == res["code"]
def test_get_main_order_with_id(res_query_result, res, monkeypatch):
def mock_orders_query_get(id):
if res_query_result is not None:
fake = Faker()
order = Orders(name=fake.name(),
summary="None",
createdate=fake.date_time(),
deadline=fake.date_time(),
address=fake.city(),
quantity=1,
price=1.0,
totalprice=1.0,
createuser=0,
comments="None",
phone=fake.phone_number(),
status=0,
progress=0)
order.ID = res_query_result[
"ID"] if res_query_result is not None else 0
return order
else:
return None
def mock_get_main_order_supply(id):
return 10
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.mainorder_api.Orders.query",
Mocker(get=mock_orders_query_get))
monkeypatch.setattr("src.api.mainorder_api.get_main_order_supply",
mock_get_main_order_supply)
result = get_main_order_with_id(0)
assert isinstance(result, dict) and result["code"] == res["code"] \
and isinstance(result["data"], dict) and result["data"]["msg"] == res["msg"] \
and (result["data"]["order"]["id"] == res_query_result["ID"]
and result["data"]["order"]["current_supply"] == 10) \
if "order" in result["data"] else True
def test_get_sub_order_by_main_order(res_query_result, res, monkeypatch):
def mock_suborders_query_filter_by(mainorder):
if res_query_result is not None:
fake = Faker()
order = subOrders(mainorder=0,
createdate=fake.date_time(),
createuser=0,
quantity=1,
comments="None",
phone=fake.phone_number(),
status=0)
order.ID = res_query_result["ID"]
return [order]
else:
return None
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.suborder_api.subOrders.query",
Mocker(filter_by=mock_suborders_query_filter_by))
result = get_sub_order_by_main_order(
res_query_result["ID"] if res_query_result is not None else 0)
assert isinstance(result, dict) and result["code"] == res["code"] \
and (isinstance(result["data"], dict) and result["data"]["msg"] == res["msg"]) \
if "msg" in res else True
def test_check_username(username, target_user, res, monkeypatch):
def mock_users_query_filter_by(username):
def mock_first():
fake = Faker()
if target_user is not None:
user = Users(username=username,
password=fake.password(),
email=fake.email(),
phone=fake.phone_number(),
usertype=0,
userstatus=0)
user.ID = target_user["ID"]
return [user]
else:
return None
return Mocker(first=mock_first)
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.user_api.Users.query",
Mocker(filter_by=mock_users_query_filter_by))
result = check_username(username)
assert (isinstance(result, dict) and result["code"] == res["code"]
and result["data"]["msg"] == res["msg"])
def test_edit_user_info(json_body, find_user, session, res, monkeypatch):
def mock_users_query_filter_by(ID):
def mock_first():
if find_user is not None:
user = Users(username=json_body["username"],
password="******",
email="*****@*****.**",
phone="None",
usertype=0,
userstatus=0)
user.ID = ID
return user
else:
return None
return Mocker(first=mock_first)
with monkeypatch.context() as m:
monkeypatch.setattr("src.api.user_api.Users.query",
Mocker(filter_by=mock_users_query_filter_by))
monkeypatch.setattr("src.api.user_api.session", session)
result = edit_user_info(0, json_body)
assert (isinstance(result, dict) and result["code"] == res["code"]
and result["data"]["msg"] == res["msg"])
