def test_delete_controller(token_app, db_perm_session, prod_list):
user_slug = uuid_to_slug(uuid4())
obj = OrderFactory.create(user_slug=user_slug)
db_perm_session.commit()
order_slug = obj.uuid_slug
prod_id_list = [p.meta["id"] for p in prod_list]
for es_id in prod_id_list:
product = ProductFactory.create(es_id=es_id)
OrderProductFactory.create(order=obj, product=product, amount=2)
db_perm_session.commit()
assert len(db_perm_session.query(Order).all()) == 1
assert len(db_perm_session.query(Product).all()) == 5
assert len(db_perm_session.query(OrderProduct).all()) == 5
fake_user_slug = uuid_to_slug(uuid4())
with token_app.test_client() as client:
response = client.delete(
"api/order/delete/%s/%s" % (fake_user_slug, order_slug)
)
data = json.loads(response.data)
assert data == {}
assert response.status_code == 404
assert len(db_perm_session.query(Order).all()) == 1
assert len(db_perm_session.query(Product).all()) == 5
assert len(db_perm_session.query(OrderProduct).all()) == 5
with token_app.test_client() as client:
response = client.delete(
"api/order/delete/%s/%s" % (user_slug, order_slug)
)
data = json.loads(response.data)
assert data == {}
assert response.status_code == 200
assert len(db_perm_session.query(Order).all()) == 0
assert len(db_perm_session.query(Product).all()) == 5
assert len(db_perm_session.query(OrderProduct).all()) == 0
with token_app.test_client() as client:
response = client.delete(
"api/order/delete/%s/%s" % (user_slug, order_slug)
)
data = json.loads(response.data)
assert data == {}
assert response.status_code == 404
assert len(db_perm_session.query(Order).all()) == 0
assert len(db_perm_session.query(Product).all()) == 5
assert len(db_perm_session.query(OrderProduct).all()) == 0
def test_order_insert(db_session):
obj = OrderFactory.create()
db_session.commit()
assert db_session.query(Order).one()
assert db_session.query(Order).filter(Order.id == obj.id).one()
assert db_session.query(Order).filter(Order.uuid == obj.uuid).one()
assert db_session.query(Order).filter(
Order.user_uuid == obj.user_uuid).one()
user_slug = uuid_to_slug(uuid4())
obj = OrderFactory.create(user_slug=user_slug)
db_session.commit()
assert uuid_to_slug(obj.user_uuid) == user_slug
def test_order_service_insert(service, db_perm_session):
user_slug = uuid_to_slug(uuid4())
with pytest.raises(NoContentError):
service.select_by_user_slug(user_slug=user_slug)
item_list = [{"item_id": str(uuid_to_slug(uuid4())), "amount": 2} for i in range(2)]
ins = service.insert(user_slug=user_slug, item_list=item_list)
assert ins is True
assert len(db_perm_session.query(Order).all()) == 1
assert len(db_perm_session.query(Product).all()) == 2
assert len(db_perm_session.query(OrderProduct).all()) == 2
result = service.select_by_user_slug(user_slug=user_slug)
assert len(result["orders"]) == 1
order_info = result["orders"][0].to_dict()
assert order_info["product_types"] == 2
assert order_info["items_amount"] == 4
product_list = ProductFactory.create_batch(5)
db_perm_session.commit()
item_list = [{"item_id": p.es_id, "amount": 3} for p in product_list]
ins = service.insert(user_slug=user_slug, item_list=item_list)
assert ins is True
assert len(db_perm_session.query(Order).all()) == 2
assert len(db_perm_session.query(Product).all()) == 7
assert len(db_perm_session.query(OrderProduct).all()) == 7
result = service.select_by_user_slug(user_slug=user_slug)
assert len(result["orders"]) == 2
order_info = result["orders"][0].to_dict()
assert order_info["product_types"] == 5
assert order_info["items_amount"] == 15
user_slug = uuid_to_slug(uuid4())
ins = service.insert(user_slug=user_slug, item_list=item_list)
assert ins is True
assert len(db_perm_session.query(Order).all()) == 3
assert len(db_perm_session.query(Product).all()) == 7
assert len(db_perm_session.query(OrderProduct).all()) == 12
result = service.select_by_user_slug(user_slug=user_slug)
assert len(result["orders"]) == 1
def test_delete(domain_url, db_perm_session, token_session, prod_list):
user_slug = uuid_to_slug(uuid4())
obj = OrderFactory.create(user_slug=user_slug)
db_perm_session.commit()
order_slug = obj.uuid_slug
prod_id_list = [p.meta["id"] for p in prod_list]
for es_id in prod_id_list:
product = ProductFactory.create(es_id=es_id)
OrderProductFactory.create(order=obj, product=product, amount=2)
db_perm_session.commit()
assert len(db_perm_session.query(Order).all()) == 1
assert len(db_perm_session.query(Product).all()) == 5
assert len(db_perm_session.query(OrderProduct).all()) == 5
fake_user_slug = uuid_to_slug(uuid4())
response = token_session.delete(domain_url + "/api/order/delete/%s/%s" %
(fake_user_slug, order_slug))
data = response.json()
assert data == {}
assert response.status_code == 404
assert len(db_perm_session.query(Order).all()) == 1
assert len(db_perm_session.query(Product).all()) == 5
assert len(db_perm_session.query(OrderProduct).all()) == 5
response = token_session.delete(domain_url + "/api/order/delete/%s/%s" %
(user_slug, order_slug))
data = response.json()
assert data == {}
assert response.status_code == 200
assert len(db_perm_session.query(Order).all()) == 0
assert len(db_perm_session.query(Product).all()) == 5
assert len(db_perm_session.query(OrderProduct).all()) == 0
response = token_session.delete(domain_url + "/api/order/delete/%s/%s" %
(user_slug, order_slug))
data = response.json()
assert data == {}
assert response.status_code == 404
assert len(db_perm_session.query(Order).all()) == 0
assert len(db_perm_session.query(Product).all()) == 5
assert len(db_perm_session.query(OrderProduct).all()) == 0
def test_delete_controller_wrong_user(flask_app, auth_user, es_create, willorders_ws_db_session):
prod_list = es_create("products", 3)
user_slug = uuid_to_slug(uuid4())
obj = OrderFactory.create(user_slug=user_slug)
willorders_ws_db_session.commit()
slug = obj.uuid_slug
prod_id_list = [p.meta["id"] for p in prod_list]
amount = 1
for es_id in prod_id_list:
product = ProductFactory.create(es_id=es_id)
OrderProductFactory.create(order=obj, product=product, amount=amount)
amount += 1
willorders_ws_db_session.commit()
with flask_app.test_client(user=auth_user) as client:
response = client.delete(
"api/order/delete/%s" % slug
)
data = json.loads(response.data)
assert data["error"] == {}
assert response.status_code == 404
def test_insert_controller(token_app, db_perm_session, prod_list):
assert len(db_perm_session.query(Order).all()) == 0
assert len(db_perm_session.query(Product).all()) == 0
assert len(db_perm_session.query(OrderProduct).all()) == 0
user_slug = uuid_to_slug(uuid4())
prod_id_list = [p.meta["id"] for p in prod_list]
item_list = [{"item_id": prod_id, "amount": 2} for prod_id in prod_id_list]
with token_app.test_client() as client:
response = client.put(
"api/order/insert",
json={"user_slug": user_slug, "item_list": item_list}
)
data = json.loads(response.data)
assert data == {}
assert response.status_code == 201
assert len(db_perm_session.query(Order).all()) == 1
assert len(db_perm_session.query(Product).all()) == 5
assert len(db_perm_session.query(OrderProduct).all()) == 5
with token_app.test_client() as client:
response = client.put(
"api/order/insert",
json={"user_slug": user_slug, "item_list": item_list}
)
data = json.loads(response.data)
assert data == {}
assert response.status_code == 201
assert len(db_perm_session.query(Order).all()) == 2
assert len(db_perm_session.query(Product).all()) == 5
assert len(db_perm_session.query(OrderProduct).all()) == 10
def test_order_service_select_by_user_slug_pages(service, db_perm_session):
user_slug = uuid_to_slug(uuid4())
OrderFactory.create_batch(22, user_slug=user_slug)
db_perm_session.commit()
result = service.select_by_user_slug(user_slug=user_slug, page=1, page_size=10)
assert result is not None
assert len(result["orders"]) == 10
assert type(result["orders"][0]) is Order
assert result["total"] == 22
assert result["pages"] == 3
result = service.select_by_user_slug(user_slug=user_slug, page=5, page_size=5)
assert result is not None
assert len(result["orders"]) == 2
assert type(result["orders"][0]) is Order
assert result["total"] == 22
assert result["pages"] == 5
with pytest.raises(NoContentError):
service.select_by_user_slug(user_slug=user_slug, page=6, page_size=5)
with pytest.raises(ZeroDivisionError):
service.select_by_user_slug(user_slug=user_slug, page=1, page_size=0)
with pytest.raises(DataError):
service.select_by_user_slug(user_slug=user_slug, page=0, page_size=5)
def test_insert(domain_url, db_perm_session, token_session, prod_list):
assert len(db_perm_session.query(Order).all()) == 0
assert len(db_perm_session.query(Product).all()) == 0
assert len(db_perm_session.query(OrderProduct).all()) == 0
user_slug = uuid_to_slug(uuid4())
prod_id_list = [p.meta["id"] for p in prod_list]
item_list = [{"item_id": prod_id, "amount": 2} for prod_id in prod_id_list]
response = token_session.put(domain_url + "/api/order/insert",
json={
"user_slug": user_slug,
"item_list": item_list
})
data = response.json()
assert data == {}
assert response.status_code == 201
assert len(db_perm_session.query(Order).all()) == 1
assert len(db_perm_session.query(Product).all()) == 5
assert len(db_perm_session.query(OrderProduct).all()) == 5
response = token_session.put(domain_url + "/api/order/insert",
json={
"user_slug": user_slug,
"item_list": item_list
})
data = response.json()
assert data == {}
assert response.status_code == 201
assert len(db_perm_session.query(Order).all()) == 2
assert len(db_perm_session.query(Product).all()) == 5
assert len(db_perm_session.query(OrderProduct).all()) == 10
def test_order_service_select_by_user_slug(service, db_perm_session):
user_slug = uuid_to_slug(uuid4())
with pytest.raises(NoContentError):
service.select_by_user_slug(user_slug=user_slug)
OrderFactory.create_batch(5, user_slug=user_slug)
db_perm_session.commit()
result = service.select_by_user_slug(user_slug=user_slug)
assert len(result["orders"]) == 5
assert type(result["orders"][0]) is Order
assert result["total"] == 5
assert result["pages"] == 1
datenow = date.today()
spanstart = datenow - timedelta(days=1)
spanend = datenow + timedelta(days=1)
result = service.select_by_user_slug(user_slug=user_slug, datespan={"start": spanstart, "end": spanend})
assert len(result["orders"]) == 5
assert type(result["orders"][0]) is Order
assert result["total"] == 5
assert result["pages"] == 1
with pytest.raises(NoContentError):
result = service.select_by_user_slug(user_slug=user_slug, datespan={"start": spanend, "end": spanstart})
with pytest.raises(NoContentError):
spanstart = datenow - timedelta(days=5)
spanend = datenow - timedelta(days=4)
result = service.select_by_user_slug(user_slug=user_slug, datespan={"start": spanstart, "end": spanend})
def test_uuid_slug_uuid():
uuid_value = uuid4()
slug_value = uuid_to_slug(uuid_value)
assert uuid_value == slug_to_uuid(slug_value)
with pytest.raises(SlugDecodeError):
slug_to_uuid("randomstring")
def test_session(domain_url, es_create):
session_list = es_create("sessions", 3, gender="Women")
session_id = session_list[0].meta["id"]
es_create("products", 5, gender="Women", sessionid=session_id)
response = requests.post(domain_url + "/api/store/session/%s" %
(session_id),
verify=False)
data = response.json()
SessionResultsSchema().load(data)
assert response.status_code == 200
assert data["total"] == 5
response = requests.post(domain_url + "/api/store/session/%s" %
(session_id),
json={"pricerange": {
"min": 1,
"max": 500
}},
verify=False)
data = response.json()
SessionResultsSchema().load(data)
assert response.status_code == 200
assert data["total"] == 5
response = requests.post(domain_url + "/api/store/session/%s" %
(session_id),
json={"pricerange": {
"min": 10000,
"max": 20000
}},
verify=False)
with pytest.raises(JSONDecodeError):
response.json()
assert response.status_code == 204
empty_session_id = session_list[1].meta["id"]
response = requests.post(domain_url + "/api/store/session/%s" %
(empty_session_id),
verify=False)
with pytest.raises(JSONDecodeError):
response.json()
assert response.status_code == 204
response = requests.post(domain_url + "/api/store/session/%s" %
(uuid_to_slug(uuid4())),
verify=False)
assert response.status_code == 404
def test_order_service_select_by_slug(service, db_perm_session):
user_slug = uuid_to_slug(uuid4())
order_slug = uuid_to_slug(uuid4())
with pytest.raises(NotFoundError):
service.select_by_slug(user_slug=user_slug, order_slug=order_slug)
obj = OrderFactory.create()
db_perm_session.commit()
order_slug = obj.uuid_slug
user_slug = obj.user_slug
result = service.select_by_slug(user_slug=user_slug, order_slug=order_slug)
assert type(result) is Order
user_slug = uuid_to_slug(uuid4())
with pytest.raises(NotFoundError):
service.select_by_slug(user_slug=user_slug, order_slug=order_slug)
def test_select_by_slug_controller(token_app, db_perm_session, prod_list):
user_slug = uuid_to_slug(uuid4())
obj = OrderFactory.create(user_slug=user_slug)
db_perm_session.commit()
order_slug = obj.uuid_slug
prod_id_list = [p.meta["id"] for p in prod_list]
amount = 1
for es_id in prod_id_list:
product = ProductFactory.create(es_id=es_id)
OrderProductFactory.create(order=obj, product=product, amount=amount)
amount += 1
db_perm_session.commit()
with token_app.test_client() as client:
response = client.get(
"api/order/%s/%s" % (user_slug, order_slug)
)
data = json.loads(response.data)
OrderSchema().load(data)
assert response.status_code == 200
assert data["slug"] == order_slug
assert data["product_types"] == len(prod_list)
assert data["items_amount"] == ((1 + len(prod_list)) * len(prod_list)) / 2
assert len(data["products"]) == len(prod_list)
for item in [item.to_dict() for item in obj.items]:
product = next(p for p in data["products"] if p["id"] == item["item_id"])
assert product["amount"] == item["amount"]
with token_app.test_client() as client:
response = client.get(
"api/order/WILLrogerPEREIRAslugBR/WILLrogerPEREIRAslugBR"
)
data = json.loads(response.data)
assert data == {}
assert response.status_code == 404
with token_app.test_client() as client:
response = client.get(
"api/order/WILLrogerPEREIRAslugBR/%s" % order_slug
)
data = json.loads(response.data)
assert data == {}
assert response.status_code == 404
def test_insert_unauthorized(domain_url, prod_list):
user_slug = uuid_to_slug(uuid4())
prod_id_list = [p.meta["id"] for p in prod_list]
item_list = [{"item_id": prod_id, "amount": 2} for prod_id in prod_id_list]
response = requests.put(domain_url + "/api/order/insert",
json={
"user_slug": user_slug,
"item_list": item_list
})
data = response.json()
ErrorSchema().load(data)
assert response.status_code == 401
def test_insert_controller_unauthorized(flask_app, prod_list):
user_slug = uuid_to_slug(uuid4())
prod_id_list = [p.meta["id"] for p in prod_list]
item_list = [{"item_id": prod_id, "amount": 2} for prod_id in prod_id_list]
with flask_app.test_client() as client:
response = client.put(
"api/order/insert",
json={"user_slug": user_slug, "item_list": item_list}
)
data = json.loads(response.data)
ErrorSchema().load(data)
assert response.status_code == 401
def test_order_service_delete(service, db_perm_session):
assert len(db_perm_session.query(Order).all()) == 0
with pytest.raises(NotFoundError):
service.delete(user_slug="WILLrogerPEREIRAslugBR", order_slug="WILLrogerPEREIRAslugBR")
user_slug = uuid_to_slug(uuid4())
obj = OrderFactory.create(user_slug=user_slug)
db_perm_session.commit()
prod_list = ProductFactory.create_batch(5)
for p in prod_list:
OrderProduct(order=obj, product=p, amount=2)
db_perm_session.commit()
assert len(db_perm_session.query(Order).all()) == 1
assert len(db_perm_session.query(Product).all()) == 5
assert len(db_perm_session.query(OrderProduct).all()) == 5
fake_user_slug = uuid_to_slug(uuid4())
with pytest.raises(NotFoundError):
service.delete(user_slug=fake_user_slug, order_slug=obj.uuid_slug)
assert len(db_perm_session.query(Order).all()) == 1
assert len(db_perm_session.query(Product).all()) == 5
assert len(db_perm_session.query(OrderProduct).all()) == 5
delete = service.delete(user_slug=user_slug, order_slug=obj.uuid_slug)
assert delete is True
assert len(db_perm_session.query(Order).all()) == 0
assert len(db_perm_session.query(Product).all()) == 5
assert len(db_perm_session.query(OrderProduct).all()) == 0
def test_select_by_user_controller_not_registered(token_app, db_perm_session):
user_slug = uuid_to_slug(uuid4())
bad_obj_list = OrderFactory.create_batch(4, user_slug=user_slug)
bad_product = ProductFactory.create()
for order in bad_obj_list:
OrderProductFactory.create(order=order, product=bad_product, amount=5)
db_perm_session.commit()
with token_app.test_client() as client:
response = client.post("api/order/user/%s" % user_slug)
data = json.loads(response.data)
ErrorSchema().load(data)
assert response.status_code == 400
assert data["error"].find("not registered") != -1
def test_select_by_user_controller_not_registered(domain_url, db_perm_session,
token_session):
user_slug = uuid_to_slug(uuid4())
bad_obj_list = OrderFactory.create_batch(4, user_slug=user_slug)
bad_product = ProductFactory.create()
for order in bad_obj_list:
OrderProductFactory.create(order=order, product=bad_product, amount=5)
db_perm_session.commit()
response = token_session.post(domain_url +
"/api/order/user/%s" % user_slug)
data = response.json()
ErrorSchema().load(data)
assert response.status_code == 400
assert data["error"].find("not registered") != -1
def test_insert_not_registered(domain_url, db_perm_session, token_session):
assert len(db_perm_session.query(Order).all()) == 0
assert len(db_perm_session.query(Product).all()) == 0
assert len(db_perm_session.query(OrderProduct).all()) == 0
user_slug = uuid_to_slug(uuid4())
bad_item_list = [{"item_id": str(uuid4()), "amount": 2} for i in range(3)]
response = token_session.put(domain_url + "/api/order/insert",
json={
"user_slug": user_slug,
"item_list": bad_item_list
})
data = response.json()
ErrorSchema().load(data)
assert response.status_code == 400
assert data["error"].find("not registered") != -1
assert len(db_perm_session.query(Order).all()) == 0
assert len(db_perm_session.query(Product).all()) == 0
assert len(db_perm_session.query(OrderProduct).all()) == 0
def test_insert_controller_not_registered(token_app, db_perm_session):
assert len(db_perm_session.query(Order).all()) == 0
assert len(db_perm_session.query(Product).all()) == 0
assert len(db_perm_session.query(OrderProduct).all()) == 0
user_slug = uuid_to_slug(uuid4())
bad_item_list = [{"item_id": str(uuid4()), "amount": 2} for i in range(3)]
with token_app.test_client() as client:
response = client.put(
"api/order/insert",
json={"user_slug": user_slug, "item_list": bad_item_list}
)
data = json.loads(response.data)
ErrorSchema().load(data)
assert response.status_code == 400
assert data["error"].find("not registered") != -1
assert len(db_perm_session.query(Order).all()) == 0
assert len(db_perm_session.query(Product).all()) == 0
assert len(db_perm_session.query(OrderProduct).all()) == 0
def test_select_by_slug_wrong_user(domain_url, auth_session, es_create,
willorders_ws_db_session):
prod_list = es_create("products", 3)
user_slug = uuid_to_slug(uuid4())
obj = OrderFactory.create(user_slug=user_slug)
willorders_ws_db_session.commit()
slug = obj.uuid_slug
prod_id_list = [p.meta["id"] for p in prod_list]
amount = 1
for es_id in prod_id_list:
product = ProductFactory.create(es_id=es_id)
OrderProductFactory.create(order=obj, product=product, amount=amount)
amount += 1
willorders_ws_db_session.commit()
response = auth_session.get(domain_url + "/api/order/%s" % slug)
data = response.json()
assert data["error"] == {}
assert response.status_code == 404
def test_select_by_user_controller(domain_url, db_perm_session, token_session,
prod_list):
user_slug = uuid_to_slug(uuid4())
prod_id_list = [p.meta["id"] for p in prod_list]
product_list = [
ProductFactory.create(es_id=es_id) for es_id in prod_id_list
]
db_perm_session.commit()
obj_list = OrderFactory.create_batch(2, user_slug=user_slug)
for product in product_list:
OrderProductFactory.create(order=obj_list[0],
product=product,
amount=2)
for product in product_list[0:3]:
OrderProductFactory.create(order=obj_list[1],
product=product,
amount=5)
db_perm_session.commit()
response = token_session.post(domain_url +
"/api/order/user/%s" % user_slug)
data = response.json()
UserOrdersSchema().load(data)
assert response.status_code == 200
assert len(data["orders"]) == 2
assert data["total"] == 2
assert data["pages"] == 1
order_slug_list = [order["slug"] for order in data["orders"]]
for slug in order_slug_list:
assert slug in [obj.uuid_slug for obj in obj_list]
for order in data["orders"]:
if order["slug"] == obj_list[0].uuid_slug:
assert order["product_types"] == 5
assert order["items_amount"] == 10
else:
assert order["product_types"] == 3
assert order["items_amount"] == 15
response = token_session.post(domain_url +
"/api/order/user/%s" % user_slug,
json={
"page": "1",
"page_size": "1"
})
data = response.json()
UserOrdersSchema().load(data)
assert response.status_code == 200
assert len(data["orders"]) == 1
assert data["total"] == 2
assert data["pages"] == 2
response = token_session.post(
domain_url + "/api/order/user/%s" % user_slug,
json={
"datespan": {
"start": str(date.today() - timedelta(days=1)),
"end": str(date.today() + timedelta(days=1))
}
})
data = response.json()
UserOrdersSchema().load(data)
assert response.status_code == 200
assert len(data["orders"]) == 2
assert data["total"] == 2
assert data["pages"] == 1
response = token_session.post(domain_url +
"/api/order/user/WILLrogerPEREIRAslugBR")
with pytest.raises(JSONDecodeError):
response.json()
assert response.status_code == 204
def test_session_controller(flask_app, es_create):
session_list = es_create("sessions", 3, gender="Women")
session_id = session_list[0].meta["id"]
es_create("products", 5, gender="Women", sessionid=session_id)
with flask_app.test_client() as client:
response = client.post(
"api/store/session/%s" % (session_id)
)
data = json.loads(response.data)
SessionResultsSchema().load(data)
assert response.status_code == 200
assert data["total"] == 5
with flask_app.test_client() as client:
response = client.post(
"api/store/session/%s" % (session_id),
json={
"pricerange": {
"min": 1,
"max": 500
}
}
)
data = json.loads(response.data)
SessionResultsSchema().load(data)
assert response.status_code == 200
assert data["total"] == 5
with flask_app.test_client() as client:
response = client.post(
"api/store/session/%s" % (session_id),
json={
"pricerange": {
"min": 10000,
"max": 20000
}
}
)
with pytest.raises(JSONDecodeError):
json.loads(response.data)
assert response.status_code == 204
empty_session_id = session_list[1].meta["id"]
with flask_app.test_client() as client:
response = client.post(
"api/store/session/%s" % (empty_session_id)
)
with pytest.raises(JSONDecodeError):
json.loads(response.data)
assert response.status_code == 204
with flask_app.test_client() as client:
response = client.post(
"api/store/session/%s" % (uuid_to_slug(uuid4()))
)
assert response.status_code == 404
