def pre_run_initialization(self):
self.seller_id = "test_auto_comment_seller_id_{}".format(
str(uuid.uuid1()))
self.store_id = "test_auto_comment_store_id_{}".format(
str(uuid.uuid1()))
self.buyer_id = "test_auto_comment_buyer_id_{}".format(
str(uuid.uuid1()))
self.seller_password = self.seller_id
self.buyer_password = self.buyer_id
# 创建商家用户并插入图书数据
gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = gen_book.gen(non_exist_book_id=False,
low_stock_level=False,
max_book_count=20)
self.buy_book_info_list = gen_book.buy_book_info_list
assert ok
# 创建用户
self.buyer = register_new_buyer(self.buyer_id, self.buyer_password)
# 生成订单
code, self.order_id = self.buyer.new_order(self.store_id,
buy_book_id_list)
assert code == 200
def test_ok(self):
order_num = random.randint(10, 20)
for i in range(order_num):
self.seller_id = "test_search_order_seller_id_{}".format(str(uuid.uuid1()))
self.store_id = "test_search_order_store_id_{}".format(str(uuid.uuid1()))
self.gen_book = GenBook(self.seller_id, self.store_id)
self.seller = self.gen_book.seller
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False, low_stock_level=False, max_book_count=5)
self.buy_book_info_list = self.gen_book.buy_book_info_list
assert ok
self.total_price = 0
for item in self.buy_book_info_list:
book: Book = item[0]
num = item[1]
self.total_price = self.total_price + book.price * num
code = self.buyer.add_funds(self.total_price + 99999)
assert code == 200
code, self.order_id = self.buyer.new_order(self.store_id, buy_book_id_list)
assert code == 200
paystatus = random.randint(0, 3)
if (paystatus != 3): # 3：未付款
code = self.buyer.payment(self.order_id)
assert code == 200
if (paystatus != 0): # 0：未发货；1：已发货
code = self.seller.send_books(self.seller_id, self.order_id)
assert code == 200
if (paystatus == 2): # 2：已收货
code = self.buyer.receive_books(self.buyer_id, self.order_id)
assert code == 200
code = self.buyer.search_order()
assert code == 200
def pre_run_initialization(self):
self.seller_id = "test_change_received_seller_id_{}".format(
str(uuid.uuid1()))
self.store_id = "test_change_received_store_id_{}".format(
str(uuid.uuid1()))
self.buyer_id = "test_change_received_buyer_id_{}".format(
str(uuid.uuid1()))
self.seller_password = self.seller_id
self.buyer_password = self.buyer_id
gen_book = GenBook(self.seller_id, self.store_id)
ok, self.buy_book_id_list = gen_book.gen(non_exist_book_id=False,
low_stock_level=False,
max_book_count=20)
self.buy_book_info_list = gen_book.buy_book_info_list
assert ok
# 创建用户
self.buyer = register_new_buyer(self.buyer_id, self.buyer_password)
# 生成订单
code, self.order_id = self.buyer.new_order(self.store_id,
self.buy_book_id_list)
assert code == 200
self.total_price = 99
for item in self.buy_book_info_list:
book: Book = item[0]
num = item[1]
self.total_price = self.total_price + book.price * num
code = self.buyer.add_funds(self.total_price)
assert code == 200
class TestQueryOrder:
@pytest.fixture(autouse=True)
def pre_run_initialization(self):
self.seller_id = "test_new_order_seller_id_{}".format(str(
uuid.uuid1()))
self.store_id = "test_new_order_store_id_{}".format(str(uuid.uuid1()))
self.buyer_id = "test_new_order_buyer_id_{}".format(str(uuid.uuid1()))
self.password = self.seller_id
self.buyer = register_new_buyer(self.buyer_id, self.password)
self.gen_book = GenBook(self.seller_id, self.store_id)
yield
def test_non_exist_user_id(self):
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False,
low_stock_level=False)
assert ok
code, _ = self.buyer.new_order(self.store_id, buy_book_id_list)
assert code == 200
self.buyer.user_id = self.buyer.user_id + "_x"
code, _ = self.buyer.query_order(self.buyer.user_id)
assert code != 200
def test_query_order(self):
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False,
low_stock_level=False)
assert ok
code, _ = self.buyer.new_order(self.store_id, buy_book_id_list)
assert code == 200
code, _ = self.buyer.query_order(self.buyer.user_id)
assert code == 200
def pre_run_initialization(self):
self.seller_id = "test_confirm_receipt_seller_id_{}".format(
str(uuid.uuid1()))
self.store_id = "test_confirm_receipt_store_id_{}".format(
str(uuid.uuid1()))
self.buyer_id = "test_confirm_receipt_buyer_id_{}".format(
str(uuid.uuid1()))
self.password = self.seller_id
gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = gen_book.gen(non_exist_book_id=False,
low_stock_level=False,
max_book_count=5)
self.buy_book_info_list = gen_book.buy_book_info_list
assert ok
b = register_new_buyer(self.buyer_id, self.password)
self.buyer = b
code, self.order_id = b.new_order(self.store_id, buy_book_id_list)
assert code == 200
self.total_price = 0
for item in self.buy_book_info_list:
book: Book = item[0]
num = item[1]
if book.price is None:
continue
else:
self.total_price = self.total_price + book.price * num
code = self.buyer.add_funds(self.total_price)
assert code == 200
s = Seller(conf.URL, self.seller_id, self.password)
self.seller = s
code = self.buyer.payment(self.order_id)
assert code == 200
yield
def pre_run_initialization(self):
self.seller_id = "test_deliver_book_seller_id_{}".format(
str(uuid.uuid1()))
self.store_id = "test_deliver_book_store_id_{}".format(
str(uuid.uuid1()))
self.buyer_id = "test_deliver_book_buyer_id_{}".format(
str(uuid.uuid1()))
self.password = self.seller_id
#会注册该seller和店铺
gen_book = GenBook(self.seller_id, self.store_id)
s = gen_book.seller
self.seller = s
#书籍信息
ok, buy_book_id_list = gen_book.gen(non_exist_book_id=False,
low_stock_level=False,
max_book_count=1)
self.buy_book_info_list = gen_book.buy_book_info_list
assert ok
#添加新的买家
b = register_new_buyer(self.buyer_id, self.password)
self.buyer = b
#添加新的订单
code, self.order_id = b.new_order(self.store_id, buy_book_id_list)
assert code == 200
#计算书的总价格
self.total_price = 0
for item in self.buy_book_info_list:
book: Book = item[0]
num = item[1]
if book.price is None:
continue
else:
self.total_price = self.total_price + book.price * num
yield
def pre_run_initialization(self):
self.seller_id = "test_close_order_seller_id_{}".format(
str(uuid.uuid1()))
self.store_id = "test_close_order_store_id_{}".format(str(
uuid.uuid1()))
self.buyer_id = "test_close_order_buyer_id_{}".format(str(
uuid.uuid1()))
self.password = self.buyer_id
gen_book = GenBook(self.seller_id, self.store_id)
self.seller = gen_book.seller
ok, buy_book_id_list = gen_book.gen(non_exist_book_id=False,
low_stock_level=False,
max_book_count=5)
self.buy_book_info_list = gen_book.buy_book_info_list
assert ok
b = register_new_buyer(self.buyer_id, self.password)
self.buyer = b
code, self.order_id = b.new_order(self.store_id, buy_book_id_list)
assert code == 200
self.total_price = 0
for item in self.buy_book_info_list:
book: Book = item[0]
num = item[1]
self.total_price = self.total_price + book.price * num
self.buyer2_id = "test_close_order_buyer2_id_{}".format(
str(uuid.uuid1())) # 2号无订单买家
self.password2 = self.buyer2_id
b2 = register_new_buyer(self.buyer2_id, self.password2)
self.buyer2 = b2
yield
def pre_run_initialization(self):
self.store_id = "test_cancel_store_{}".format(str(uuid.uuid1()))
self.seller_id = "test_cancel_seller_{}".format(str(uuid.uuid1()))
self.store_id = "test_cancel_store_id_{}".format(str(uuid.uuid1()))
self.buyer_id = "test_cancel__buyer_{}".format(str(uuid.uuid1()))
gen_book = GenBook(self.seller_id, self.store_id)
self.seller = gen_book.seller
ok, buy_book_id_list = gen_book.gen(non_exist_book_id=False,
low_stock_level=False,
max_book_count=5)
self.buy_book_info_list = gen_book.buy_book_info_list
assert ok
self.password = self.buyer_id
b = register_new_buyer(self.buyer_id, self.password)
self.buyer = b
self.total_price = 0
for item in self.buy_book_info_list:
book: Book = item[0]
num = item[1]
self.total_price = self.total_price + book.price * num
code = self.buyer.add_funds(self.total_price + 100000)
assert code == 200
code, self.order_id = b.new_order(self.store_id, buy_book_id_list)
assert code == 200
yield
def pre_run_initialization(self):
# 创建一个用户，开一家店
self.seller_id = "test_deliver_seller_id_{}".format(str(uuid.uuid1()))
self.store_id = "test_deliver_store_id_{}".format(str(uuid.uuid1()))
self.password = self.seller_id
gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = gen_book.gen(non_exist_book_id=False, low_stock_level=False, max_book_count=5)
self.buy_book_info_list = gen_book.buy_book_info_list
assert ok
self.seller = gen_book.get_seller()
self.buyer_id = "test_deliver_buyer_id_{}".format(str(uuid.uuid1()))
b = register_new_buyer(self.buyer_id, self.password)
self.buyer = b
code, self.order_id = b.new_order(self.store_id, buy_book_id_list)
assert code == 200
self.total_price = 0
for item in self.buy_book_info_list:
book: Book = item[0]
num = item[1]
self.total_price = self.total_price + book.price * num
self.another_seller_id = self.seller_id + "_another"
self.another_seller = register_new_seller(self.another_seller_id, self.password)
yield
def pre_run_initialization(self):
# do before test
self.seller_id = "test_delivery_books_seller_id_{}".format(
str(uuid.uuid1()))
self.buyer_id = "test_delivery_books_buyer_id_{}".format(
str(uuid.uuid1()))
self.store_id = "test_delivery_books_store_id_{}".format(
str(uuid.uuid1()))
self.password = self.buyer_id
self.total_price = 0
self.buyer = register_new_buyer(self.buyer_id, self.password)
self.gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False,
low_stock_level=False)
assert ok
self.buy_book_info_list = self.gen_book.buy_book_info_list
for item in self.buy_book_info_list:
price = item[2]
num = item[1]
if price is None:
continue
else:
self.total_price = self.total_price + price * num
code, self.order_id = self.buyer.new_order(self.store_id,
buy_book_id_list)
assert code == 200
yield
def test_comment_while_order_is_not_done(self):
gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = gen_book.gen(non_exist_book_id=False,
low_stock_level=False,
max_book_count=5)
self.buy_book_info_list = gen_book.buy_book_info_list
assert ok
b = register_new_buyer(self.buyer_id, self.password)
self.buyer = b
code, self.order_id = b.new_order(self.store_id, buy_book_id_list)
assert code == 200
self.total_price = 0
for item in self.buy_book_info_list:
book: Book = item[0]
num = item[1]
if book.price is None:
continue
else:
self.total_price = self.total_price + book.price * num
code = self.buyer.add_funds(self.total_price)
assert code == 200
s = Seller(conf.URL, self.seller_id, self.password)
self.seller = s
code = self.buyer.payment(self.order_id)
assert code == 200
code = self.seller.deliver_books(self.store_id, self.order_id)
assert code == 200
code = self.buyer.add_comment(self.store_id,
self.buy_book_info_list[0][0].id,
self.comment, self.rate)
assert code != 200
def pre_run_initialization(self):
self.seller_id = "test_new_order_seller_id_{}".format(str(uuid.uuid1()))
self.store_id = "test_new_order_store_id_{}".format(str(uuid.uuid1()))
self.buyer_id = "test_new_order_buyer_id_{}".format(str(uuid.uuid1()))
self.password = self.seller_id # self.password = self.buyer_id
self.buyer = register_new_buyer(self.buyer_id, self.password)
self.gen_book = GenBook(self.seller_id, self.store_id)
yield
def pre_run_initialization(self):
self.buyer_id = "test_track_order_buyer_id_{}".format(str(
uuid.uuid1()))
# 创建用户
self.buyer_password = self.buyer_id
self.buyer = register_new_buyer(self.buyer_id, self.buyer_password)
# 生成十家不同店铺的订单
for i in range(10):
self.seller_id = "test_change_status_to_unreceived_seller_id_{}".format(
str(uuid.uuid1()))
self.store_id = "test_change_status_to_unreceived_store_id_{}".format(
str(uuid.uuid1()))
self.seller_password = self.seller_id
# 创建商家用户并插入图书数据
gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = gen_book.gen(non_exist_book_id=False,
low_stock_level=False,
max_book_count=20)
self.buy_book_info_list = gen_book.buy_book_info_list
assert ok
# 生成订单
code, self.order_id = self.buyer.new_order(self.store_id,
buy_book_id_list)
assert code == 200
self.total_price = 0
for item in self.buy_book_info_list:
book: Book = item[0]
num = item[1]
self.total_price = self.total_price + book.price * num
code = self.buyer.add_funds(100 + self.total_price)
assert code == 200
if i % 5 == 0:
code = cancel_order(self.buyer_id, self.buyer_password,
self.order_id)
assert code == 200
else:
if i % 5 >= 2:
code = self.buyer.payment(self.order_id)
assert code == 200
if i % 5 >= 3:
code = change_unreceived(self.seller_id,
self.seller_password,
self.store_id, self.order_id)
assert code == 200
if i % 5 >= 4:
code = change_received(self.buyer_id, self.buyer_password,
self.order_id)
assert code == 200
def pre_run_initialization(self):
self.seller_id = "test_new_order_seller_id_{}".format(str(uuid.uuid1()))
self.store_id = "test_new_order_store_id_{}".format(str(uuid.uuid1()))
self.buyer_id = "test_new_order_buyer_id_{}".format(str(uuid.uuid1()))
self.password = self.seller_id
self.buyer = register_new_buyer(self.buyer_id, self.password)
self.gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False, low_stock_level=False)
assert ok
code, _ = self.buyer.new_order(self.store_id, buy_book_id_list)
assert code == 200
yield
class TestNewOrder:
@pytest.fixture(autouse=True)
def pre_run_initialization(self):
self.seller_id = "test_new_order_seller_id_{}".format(str(
uuid.uuid1()))
self.store_id = "test_new_order_store_id_{}".format(str(uuid.uuid1()))
self.buyer_id = "test_new_order_buyer_id_{}".format(str(uuid.uuid1()))
self.password = self.seller_id
self.buyer = register_new_buyer(self.buyer_id, self.password)
self.gen_book = GenBook(self.seller_id, self.store_id)
yield
@pytest.mark.run(order=21)
def test_non_exist_book_id(self):
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=True,
low_stock_level=False)
assert ok
code, _ = self.buyer.new_order(self.store_id, buy_book_id_list)
assert code != 200
@pytest.mark.run(order=22)
def test_low_stock_level(self):
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False,
low_stock_level=True)
assert ok
code, _ = self.buyer.new_order(self.store_id, buy_book_id_list)
assert code != 200
@pytest.mark.run(order=23)
def test_ok(self):
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False,
low_stock_level=False)
assert ok
code, _ = self.buyer.new_order(self.store_id, buy_book_id_list)
assert code == 200
@pytest.mark.run(order=24)
def test_non_exist_user_id(self):
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False,
low_stock_level=False)
assert ok
self.buyer.user_id = self.buyer.user_id + "_x"
code, _ = self.buyer.new_order(self.store_id, buy_book_id_list)
assert code != 200
@pytest.mark.run(order=25)
def test_non_exist_store_id(self):
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False,
low_stock_level=False)
assert ok
code, _ = self.buyer.new_order(self.store_id + "_x", buy_book_id_list)
assert code != 200
def test_non_exist_store(self):
gen_book_1 = GenBook(self.seller1_id, self.store1_id)
ok, buy_book_id_list_1 = gen_book_1.gen(non_exist_book_id=False,
low_stock_level=False,
max_book_count=5)
self.buy_book_info_list_1 = gen_book_1.buy_book_info_list
assert ok
b = register_new_buyer(self.buyer_id, self.password)
self.buyer = b
for i in self.buy_book_info_list_1:
code = self.buyer.add_into_cart(self.store1_id + "_x", i[0].id,
i[1])
assert code != 200
def test_non_exist_order(self):
gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = gen_book.gen(non_exist_book_id=False,
low_stock_level=False,
max_book_count=5)
self.buy_book_info_list = gen_book.buy_book_info_list
assert ok
b = register_new_buyer(self.buyer_id, self.password)
self.buyer = b
code = self.buyer.add_comment(self.store_id,
self.buy_book_info_list[0][0].id,
self.comment, self.rate)
assert code != 200
def pre_run_initialization(self):
self.seller_id = "test_view_historical_seller_id_{}".format(str(uuid.uuid1()))
self.store_id = "test_view_historical_store_id_{}".format(str(uuid.uuid1()))
self.buyer_id = "test_view_historical_buyer_id_{}".format(str(uuid.uuid1()))
self.password = self.seller_id
gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = gen_book.gen(non_exist_book_id=False, low_stock_level=False, max_book_count=5)
self.buy_book_info_list = gen_book.buy_book_info_list
assert ok
b = register_new_buyer(self.buyer_id, self.password)
self.buyer = b
code, self.order_id = b.new_order(self.store_id, buy_book_id_list)
self.time = time.strftime('%a, %d %b %Y %H:%M:%S GMT', time.localtime(time.time()))
yield
def pre_run_initialization(self):
self.seller_id = "test_payment_seller_id_{}".format(str(uuid.uuid1()))
self.store_id = "test_payment_store_id_{}".format(str(uuid.uuid1()))
self.buyer_id = "test_payment_buyer_id_{}".format(str(uuid.uuid1()))
self.password = self.seller_id
gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = gen_book.gen(non_exist_book_id=False,
low_stock_level=False,
max_book_count=5)
self.buy_book_info_list = gen_book.buy_book_info_list
assert ok
b = register_new_buyer(self.buyer_id, self.password)
self.buyer = b
code, self.order_id = b.new_order(self.store_id, buy_book_id_list)
assert code == 200
def test_ok(self):
buy_time = random.randint(4, 10) #买buy_time次书，产生buytime个记录
for i in range(buy_time):
self.seller_id = "test_search_history_status_seller_{}".format(
str(uuid.uuid1()))
self.store_id = "test_search_history_status_id_{}".format(
str(uuid.uuid1()))
self.gen_book = GenBook(self.seller_id, self.store_id)
self.seller = self.gen_book.seller
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False,
low_stock_level=False,
max_book_count=5)
self.buy_book_info_list = self.gen_book.buy_book_info_list
assert ok
self.total_price = 0
for item in self.buy_book_info_list:
book: Book = item[0]
num = item[1]
self.total_price = self.total_price + book.price * num
code = self.buyer.add_funds(self.total_price + 100000)
assert code == 200
code, self.order_id = self.buyer.new_order(self.store_id,
buy_book_id_list)
assert code == 200
flag = random.randint(0, 2)
if flag != 0:
code = self.buyer.payment(self.order_id)
assert code == 200
if flag == 1:
code = self.seller.deliver_book(self.seller_id,
self.order_id)
assert code == 200
code = self.buyer.receive_book(self.buyer_id,
self.order_id)
assert code == 200
code = self.buyer.search_history_status(self.buyer_id, 0)
assert code == 200
code = self.buyer.search_history_status(self.buyer_id, 1)
assert code == 200
code = self.buyer.search_history_status(self.buyer_id, 2)
assert code == 200
code = self.buyer.search_history_status(self.buyer_id, 3)
assert code == 200
code = self.buyer.search_history_status(self.buyer_id, 4)
assert code == 200
code = self.buyer.search_history_status(self.buyer_id, 5)
assert code == 200
class TestCancel:
@pytest.fixture(autouse=True)
def pre_run_initialization(self):
engine = create_engine(
'postgresql://*****:*****@localhost:5432/bookstore')
DBSession = sessionmaker(bind=engine)
self.session = DBSession()
self.seller_id = "test_autocancel_seller_{}".format(str(uuid.uuid1()))
self.store_id = "test_autocancel_store_{}".format(str(uuid.uuid1()))
self.buyer_id = "test_autocancel_buyer_{}".format(str(uuid.uuid1()))
self.password = self.seller_id
self.buyer = register_new_buyer(self.buyer_id, self.password)
self.gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False,
low_stock_level=False)
assert ok
code, self.order_id = self.buyer.new_order(self.store_id,
buy_book_id_list)
assert code == 200
yield
def test_autocancel(self):
time.sleep(7)
cursor = self.session.query(Order).filter_by(id=self.order_id).first()
assert cursor.status == Order_status.cancelled
class TestCancelOrder:
@pytest.fixture(autouse=True)
def pre_run_initialization(self):
self.seller_id = "test_cancel_order_seller_id_{}".format(str(uuid.uuid1()))
self.buyer_id = "test_cancel_order_buyer_id_{}".format(str(uuid.uuid1()))
self.store_id = "test_cancel_order_store_id_{}".format(str(uuid.uuid1()))
self.password = self.buyer_id
self.total_price = 0
self.buyer = register_new_buyer(self.buyer_id, self.password)
self.gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False, low_stock_level=False)
assert ok
self.buy_book_info_list = self.gen_book.buy_book_info_list
for item in self.buy_book_info_list:
price = item[2]
num = item[1]
if price is None:
continue
else:
self.total_price = self.total_price + price * num
code, self.order_id = self.buyer.new_order(self.store_id, buy_book_id_list)
assert code == 200
yield
def test_non_exist_user_id(self):
self.buyer_id = self.buyer_id + "_x"
code = self.buyer.cancel_order(self.buyer_id, self.order_id)
assert code != 200
def test_non_exist_order_id(self):
self.order_id = self.order_id + "_x"
code = self.buyer.cancel_order(self.buyer_id, self.order_id)
assert code != 200
def test_ok(self):
# print(self.order_id)
code = self.buyer.add_funds(self.total_price)
assert code == 200
code = self.buyer.payment(self.order_id)
assert code == 200
code = self.buyer.cancel_order(self.buyer_id, self.order_id)
assert code == 200
def test_already_delivered(self):
code = self.buyer.add_funds(self.total_price)
assert code == 200
code = self.buyer.payment(self.order_id)
assert code == 200
self.gen_book.seller.delivery_book(self.seller_id, self.order_id)
code = self.buyer.cancel_order(self.buyer_id, self.order_id)
assert code != 200
self.buyer.receive_book(self.buyer_id, self.order_id)
code = self.buyer.cancel_order(self.buyer_id, self.order_id)
assert code != 200
def test_have_not_pay(self):
code = self.buyer.add_funds(self.total_price)
assert code == 200
code = self.buyer.cancel_order(self.buyer_id, self.order_id)
assert code == 200
class TestAutoCancle:
@pytest.fixture(autouse=True)
def pre_run_initialization(self):
self.seller_id = "test_new_order_seller_id_{}".format(str(
uuid.uuid1()))
self.store_id = "test_new_order_store_id_{}".format(str(uuid.uuid1()))
self.buyer_id = "test_new_order_buyer_id_{}".format(str(uuid.uuid1()))
self.password = self.seller_id
self.buyer = register_new_buyer(self.buyer_id, self.password)
self.gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False,
low_stock_level=False)
assert ok
code, _ = self.buyer.new_order(self.store_id, buy_book_id_list)
assert code == 200
yield
def test_non_exist_user_id(self):
self.buyer_id = self.buyer_id + "_x"
code, _ = self.buyer.query_order(self.buyer_id)
# print(code)
assert code != 200
def test_auto_cancle(self):
# 暂时设置超时60s未付款就取消订单
time.sleep(70)
# 然后去查询订单
code, order_list = self.buyer.query_order(self.buyer_id)
assert len(order_list) == 0
class TestSearchOrder:
@pytest.fixture(autouse=True)
def pre_run_initialization(self):
self.buyer_id = "test_search_order_buyer_id_{}".format(str(uuid.uuid1()))
self.password = self.buyer_id
b = register_new_buyer(self.buyer_id, self.password)
self.buyer = b
self.buyer2_id = "test_close_order_buyer2_id_{}".format(str(uuid.uuid1())) # 2号无订单买家
self.password2 = self.buyer2_id
b2 = register_new_buyer(self.buyer2_id, self.password2)
self.buyer2 = b2
yield
def test_ok(self):
order_num = random.randint(10, 20)
for i in range(order_num):
self.seller_id = "test_search_order_seller_id_{}".format(str(uuid.uuid1()))
self.store_id = "test_search_order_store_id_{}".format(str(uuid.uuid1()))
self.gen_book = GenBook(self.seller_id, self.store_id)
self.seller = self.gen_book.seller
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False, low_stock_level=False, max_book_count=5)
self.buy_book_info_list = self.gen_book.buy_book_info_list
assert ok
self.total_price = 0
for item in self.buy_book_info_list:
book: Book = item[0]
num = item[1]
self.total_price = self.total_price + book.price * num
code = self.buyer.add_funds(self.total_price + 99999)
assert code == 200
code, self.order_id = self.buyer.new_order(self.store_id, buy_book_id_list)
assert code == 200
paystatus = random.randint(0, 3)
if (paystatus != 3): # 3：未付款
code = self.buyer.payment(self.order_id)
assert code == 200
if (paystatus != 0): # 0：未发货；1：已发货
code = self.seller.send_books(self.seller_id, self.order_id)
assert code == 200
if (paystatus == 2): # 2：已收货
code = self.buyer.receive_books(self.buyer_id, self.order_id)
assert code == 200
code = self.buyer.search_order()
assert code == 200
def test_authorization_error(self):
self.buyer.password = self.buyer.password + "_x"
code = self.buyer.search_order()
assert code != 200
self.buyer_id = self.buyer_id + "_x"
code = self.buyer.search_order()
assert code != 200
def test_no_history(self):
code = self.buyer2.search_order()
assert code == 200
def pre_run_initialization(self):
self.seller_id = "test_search_book_in_site_seller_id_{}".format(str(uuid.uuid1()))
self.store_id = "test_search_book_in_site_store_id_{}".format(str(uuid.uuid1()))
self.buyer_id = "test_search_book_in_site_buyer_id_{}".format(str(uuid.uuid1()))
self.seller_password = self.seller_id
self.buyer_password = self.buyer_id
self.key_word = "科学"
# 创建商家用户并插入图书数据
gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = gen_book.gen(non_exist_book_id=False, low_stock_level=False, max_book_count=20)
self.buy_book_info_list = gen_book.buy_book_info_list
assert ok
# 创建用户
self.buyer = register_new_buyer(self.buyer_id, self.buyer_password)
class TestCancel:
@pytest.fixture(autouse=True)
def pre_run_initialization(self):
self.seller_id = "test_cancel_seller_{}".format(str(uuid.uuid1()))
self.store_id = "test_cancel_store_{}".format(str(uuid.uuid1()))
self.buyer_id = "test_cancel_buyer_{}".format(str(uuid.uuid1()))
self.password = self.seller_id
self.buyer = register_new_buyer(self.buyer_id, self.password)
self.gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False, low_stock_level=False)
assert ok
code, self.order_id = self.buyer.new_order(self.store_id, buy_book_id_list)
assert code == 200
yield
def test_non_exist_buyer(self):
code = self.buyer.cancel(self.buyer_id + 's', self.password, self.order_id)
assert code != 200
def test_wrong_password_buyer(self):
code = self.buyer.cancel(self.buyer_id, self.password + 's', self.order_id)
assert code != 200
def test_ok(self):
code = self.buyer.cancel(self.buyer_id, self.password, self.order_id)
assert code == 200
def pre_run_initialization(self):
engine = create_engine(
'postgresql://*****:*****@localhost:5432/bookstore')
DBSession = sessionmaker(bind=engine)
self.session = DBSession()
self.seller_id = "test_autocancel_seller_{}".format(str(uuid.uuid1()))
self.store_id = "test_autocancel_store_{}".format(str(uuid.uuid1()))
self.buyer_id = "test_autocancel_buyer_{}".format(str(uuid.uuid1()))
self.password = self.seller_id
self.buyer = register_new_buyer(self.buyer_id, self.password)
self.gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False,
low_stock_level=False)
assert ok
code, self.order_id = self.buyer.new_order(self.store_id,
buy_book_id_list)
assert code == 200
yield
def test_ok(self):
gen_book_1 = GenBook(self.seller1_id, self.store1_id)
gen_book_2 = GenBook(self.seller2_id, self.store2_id)
ok, buy_book_id_list_1 = gen_book_1.gen(non_exist_book_id=False,
low_stock_level=False,
max_book_count=5)
ok, buy_book_id_list_2 = gen_book_2.gen(non_exist_book_id=False,
low_stock_level=False,
max_book_count=5)
self.buy_book_info_list_1 = gen_book_1.buy_book_info_list
self.buy_book_info_list_2 = gen_book_2.buy_book_info_list
assert ok
b = register_new_buyer(self.buyer_id, self.password)
self.buyer = b
buy_book_id_list_1 = list(
list(items) for items in list(buy_book_id_list_1))
buy_book_id_list_2 = list(
list(items) for items in list(buy_book_id_list_2))
cart_test = {
self.store1_id: buy_book_id_list_1,
self.store2_id: buy_book_id_list_2
}
for i in self.buy_book_info_list_1:
code = self.buyer.add_into_cart(self.store1_id, i[0].id, i[1])
assert code == 200
for i in self.buy_book_info_list_2:
code = self.buyer.add_into_cart(self.store2_id, i[0].id, i[1])
assert code == 200
code, cart = self.buyer.view_cart()
assert code == 200
assert cart == cart_test
code = self.buyer.checkout_cart()
assert code == 200
class TestAutoReceive:
@pytest.fixture(autouse=True)
def pre_run_initialization(self):
self.seller_id = "test_new_order_seller_id_{}".format(str(
uuid.uuid1()))
self.store_id = "test_new_order_store_id_{}".format(str(uuid.uuid1()))
self.buyer_id = "test_new_order_buyer_id_{}".format(str(uuid.uuid1()))
self.password = self.seller_id
self.total_price = 0
self.buyer = register_new_buyer(self.buyer_id, self.password)
self.gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False,
low_stock_level=False)
assert ok
self.buy_book_info_list = self.gen_book.buy_book_info_list
for item in self.buy_book_info_list:
book: Book = item[0]
num = item[1]
if book.price is None:
continue
else:
self.total_price = self.total_price + book.price * num
code, self.order_id = self.buyer.new_order(self.store_id,
buy_book_id_list)
assert code == 200
yield
def test_auto_receive(self):
# 暂时设置超时60s未付款就取消订单
code = self.buyer.add_funds(self.total_price)
assert code == 200
code = self.buyer.payment(self.order_id)
assert code == 200
self.gen_book.seller.delivery_book(self.seller_id, self.order_id)
assert code == 200
# self.buyer.receive_book(self.buyer_id, self.order_id)
# assert code == 200
time.sleep(70)
# 然后去查询订单,订单状态为已收货
code, order_state = self.buyer.query_order_state(self.order_id)
assert order_state == 3
class TestHistory:
@pytest.fixture(autouse=True)
def pre_run_initialization(self):
self.seller_id = "test_history_seller_{}".format(str(uuid.uuid1()))
self.store_id = "test_history_store_{}".format(str(uuid.uuid1()))
self.buyer_id = "test_history_buyer_{}".format(str(uuid.uuid1()))
self.password = self.seller_id
self.buyer = register_new_buyer(self.buyer_id, self.password)
self.gen_book = GenBook(self.seller_id, self.store_id)
ok, buy_book_id_list = self.gen_book.gen(non_exist_book_id=False,
low_stock_level=False)
assert ok
code, self.order_id = self.buyer.new_order(self.store_id,
buy_book_id_list)
assert code == 200
yield
def test_history(self):
code, response = self.buyer.history()
assert code == 200
