def test_order_mail(self):
with self.app.app_context():
self.basic_setup()
book2 = BooksModel(2, 2, 13.1, "book2")
book2.save_to_db()
isbns = [self.book.isbn, book2.isbn]
prices = [self.book.precio, book2.precio]
quantities = [1, 1]
dataTransaction = {
"isbns": isbns,
'prices': prices,
'quantities': quantities,
"email": self.user.email,
}
res = self.client.post(
"/api/transaction",
data=dataTransaction,
headers={
"Authorization":
'Basic ' + base64.b64encode(
(self.token + ":").encode('ascii')).decode('ascii')
})
self.assertEqual(201, res.status_code)
# hi ha dues transaccions amb id 1
transactions = TransactionsModel.find_by_id(1)
self.assertEqual(len(transactions), 2)
# les dues transaccions equivalen als llibres que acabem de posar
for i, isbn in enumerate(isbns):
self.assertEqual(
TransactionsModel.find_by_id_and_isbn(1, isbn).json(),
json.loads(res.data)['transactions'][i])
def test_get_all_transactions(self):
with self.app.app_context():
self.basic_setup()
book2 = BooksModel(2, 2, 13.1, "book2")
book2.save_to_db()
isbns = [self.book.isbn, book2.isbn]
prices = [self.book.precio, book2.precio]
quantities = [1, 1]
TransactionsModel.save_transaction(self.user.id, isbns, prices,
quantities)
res = self.client.get(
"/api/allTransactions",
headers={
"Authorization":
'Basic ' + base64.b64encode(
(self.token + ":").encode('ascii')).decode('ascii')
})
self.assertEqual(200, res.status_code)
allTransactions = TransactionsModel.query.all()
for i, transaction in enumerate(allTransactions):
self.assertEqual(transaction.json(),
json.loads(res.data)['transactions'][0][i])
def test_get_all_transactions_no_admin(self):
with self.app.app_context():
user = UsersModel("test",
"*****@*****.**",
role=Roles.User)
user.hash_password("test")
user.save_to_db()
res = self.client.post("/api/login",
data={
"email": user.email,
"password": "******"
})
token = json.loads(res.data)["token"]
book = BooksModel(1, 1, 1, "book1")
book.save_to_db()
book2 = BooksModel(2, 2, 13.1, "book2")
book2.save_to_db()
isbns = [book.isbn, book2.isbn]
prices = [book.precio, book2.precio]
quantities = [1, 1]
TransactionsModel.save_transaction(user.id, isbns, prices,
quantities)
res = self.client.get(
"/api/allTransactions",
headers={
"Authorization":
'Basic ' + base64.b64encode(
(token + ":").encode('ascii')).decode('ascii')
})
self.assertEqual(403, res.status_code)
def test_model_add_no_stock(self):
with self.app.app_context():
self.basic_setup()
book2 = BooksModel(2, 1, 1, "book2")
book2.save_to_db()
with self.assertRaises(Exception):
TransactionsModel.save_transaction(self.user.id,
[self.book.isbn],
[self.book.precio], [100])
def test_model_delete(self):
with self.app.app_context():
self.basic_setup()
TransactionsModel.save_transaction(self.user.id, [self.book.isbn],
[self.book.precio], [1])
self.assertEqual(1, len(TransactionsModel.query.all()))
TransactionsModel.query.filter_by(
id_transaction=1).first().delete_from_db()
self.assertEqual(0, len(TransactionsModel.query.all()))
def test_model_invalid_update(self):
with self.app.app_context():
self.basic_setup()
TransactionsModel.save_transaction(self.user.id, [self.book.isbn],
[self.book.precio], [1])
self.assertEqual(1, len(TransactionsModel.query.all()))
data = {"id_transaction": 'string'} # must be an integer
with self.assertRaises(Exception):
TransactionsModel.query.filter_by(
id_transaction=1).first().update_from_db(data)
def test_model_add_some(self):
with self.app.app_context():
self.basic_setup()
book2 = BooksModel(2, 1, 1, "book2")
book2.save_to_db()
expected = TransactionsModel.save_transaction(
self.user.id, [self.book.isbn, book2.isbn],
[self.book.precio, book2.precio], [1, 1])
self.assertEqual(
expected[0],
TransactionsModel.find_by_id_and_isbn(1,
self.book.isbn).json())
self.assertEqual(expected[1],
TransactionsModel.find_by_id_and_isbn(
1, book2.isbn).json()) # same id
def test_filter_transactions_by_user_id_and_date_desc(self):
with self.app.app_context():
self.basic_setup()
self.add_transactions_user1()
self.add_transactions_user2()
res = self.client.get(
"/api/allTransactions",
data={
'user_id': self.user2.id,
'date': 'desc'
},
headers={
"Authorization":
'Basic ' + base64.b64encode(
(self.token + ":").encode('ascii')).decode('ascii')
})
self.assertEqual(200, res.status_code)
transactions = TransactionsModel.query.filter_by(
user_id=self.user2.id).order_by(desc('date')).all()
expected_transactions = TransactionsModel.group_transactions_by_id(
transactions)
for i, transactions in enumerate(expected_transactions):
for j, transaction in enumerate(transactions):
self.assertEqual(
transaction,
json.loads(res.data)['transactions'][i][j])
def test_filter_transactions_by_isbn(self):
with self.app.app_context():
self.basic_setup()
self.add_transactions_user1() # has book with isbn = 1
self.add_transactions_user2() # has book with isbn = 1
res = self.client.get(
"/api/allTransactions",
data={'isbn': self.book.isbn},
headers={
"Authorization":
'Basic ' + base64.b64encode(
(self.token + ":").encode('ascii')).decode('ascii')
})
self.assertEqual(200, res.status_code)
# the transactions with the books with isbn 1 are transactions 1 and 2
ids_transactions = [1, 2]
transactions = TransactionsModel.query.filter(
TransactionsModel.id_transaction.in_(ids_transactions))
expected_transactions = TransactionsModel.group_transactions_by_id(
transactions)
for i, transactions in enumerate(expected_transactions):
for j, transaction in enumerate(transactions):
self.assertEqual(
transaction,
json.loads(res.data)['transactions'][i][j])
def get(self, id_transaction):
with lock:
transaction = TransactionsModel.find_by_id(id_transaction)
if not transaction:
return {"message": f"Transaction with ['id_transaction':{id_transaction}] not found"}, 404
if UsersModel.find_by_id(transaction.user_id) != g.user:
return {"message": "Invalid transaction, can only be yours"}, 401
return {"transaction": transaction.json()}, 200
def get(self, email):
with lock:
user = UsersModel.find_by_email(email)
if user is None:
return {"message": "User with ['email': " + email + "] Not Found"}, 404
if g.user != user:
return {"message": "Invalid user, can only be yourself"}, 401
transactions = TransactionsModel.query.filter_by(user_id=user.id).all()
grouped_transactions = TransactionsModel.group_transactions_by_id(transactions)
return {'transactions': grouped_transactions}, 200
def get(self):
with lock:
parser = reqparse.RequestParser(bundle_errors=True)
parser.add_argument('isbn', type=int, required=False,
help="In this field goes the isbn of the transactions")
# parser.add_argument('titulo', type=str, required=False,
# help="In this field goes the tittle of the book")
parser.add_argument('user_id', type=int, required=False,
help="In this field goes the user_id of the transactions")
parser.add_argument('date', type=str, required=False,
help="In this field goes the date order (asc, desc) of the transactions")
data = parser.parse_args()
transactions = TransactionsModel.query
if not any(v is not None for k, v in data.items()): # no filter asked
grouped_transactions = TransactionsModel.group_transactions_by_id(transactions)
return {'transactions': grouped_transactions}, 200
else:
if data['isbn'] is not None:
# Get transactions with isbn = isbn
transactions_containing_isbn = transactions.filter_by(isbn=data['isbn'])
# Ids of the transactions that have the isbn
ids_transactions = [t.id_transaction for t in transactions_containing_isbn]
# All transactions with the ids
transactions = TransactionsModel.query.filter(
TransactionsModel.id_transaction.in_(ids_transactions))
if data['user_id'] is not None:
transactions = transactions.filter_by(user_id=data['user_id'])
if data['date'] == str('asc'):
transactions = transactions.order_by(asc('date'))
elif data['date'] == str('desc'):
transactions = transactions.order_by(desc('date'))
grouped_transactions = TransactionsModel.group_transactions_by_id(transactions)
return {'transactions': grouped_transactions}, 200
def test_model_update(self):
with self.app.app_context():
self.basic_setup()
TransactionsModel.save_transaction(self.user.id, [self.book.isbn],
[self.book.precio], [1])
self.assertEqual(1, len(TransactionsModel.query.all()))
data = {"id_transaction": 10} # id = 10
TransactionsModel.query.filter_by(
id_transaction=1).first().update_from_db(data)
expected_output = {
'date': dt.datetime.today().strftime("%d-%m-%Y"),
'id_transaction': 10,
'user_id': 1,
'isbn': self.book.isbn,
'price': self.book.precio,
'book': self.book.json(),
'quantity': 1
}
self.assertEqual(
expected_output,
TransactionsModel.find_by_id(data["id_transaction"])[0].json())
def test_get_transactions_user(self):
with self.app.app_context():
self.basic_setup()
book2 = BooksModel(2, 2, 13.1, "book2")
book2.save_to_db()
isbns = [self.book.isbn, book2.isbn]
prices = [self.book.precio, book2.precio]
quantities = [1, 1]
dataTransaction = {
"isbns": isbns,
'prices': prices,
'quantities': quantities,
"email": self.user.email,
}
res = self.client.post(
"/api/transaction",
data=dataTransaction,
headers={
"Authorization":
'Basic ' + base64.b64encode(
(self.token + ":").encode('ascii')).decode('ascii')
})
self.assertEqual(201, res.status_code)
res = self.client.get(
f"/api/transactions/{self.user.email}",
headers={
"Authorization":
'Basic ' + base64.b64encode(
(self.token + ":").encode('ascii')).decode('ascii')
})
self.assertEqual(200, res.status_code)
# l'usuari te dues transactions
self.assertEqual(2, len(self.user.transactions))
# comprovem que son les que hem acabat d'afegir
expected = [
transaction.json()
for transaction in TransactionsModel.find_by_id(1)
]
real_output = [
transaction.json() for transaction in self.user.transactions
]
self.assertEqual(expected, real_output)
def get(self):
parser = reqparse.RequestParser(bundle_errors=True)
parser.add_argument(
'numBooks',
type=int,
required=False,
help="In this field goes the number of the books to show")
data = parser.parse_args()
isbns = TransactionsModel.best_sellers()
return {
'books':
list(
islice(
filter(
lambda book: book['vendible'],
map(
lambda x: BooksModel.find_by_isbn(x).json(
score=True), isbns)), data['numBooks']))
}, 200
def post(self):
data = parse_transaction()
with lock:
user = UsersModel.find_by_email(data['email'])
if user is None:
return {"message": f"User with ['email': {data['email']}] Not Found"}, 404
if user != g.user:
return {"message": "Invalid transaction, can only post yours"}, 401
for isbn, quantity in zip(data['isbns'], data['quantities']):
book = BooksModel.find_by_isbn(isbn)
if book is None:
return {"message": "Book with ['isbn': " + str(isbn) + "] Not Found"}, 404
if quantity > book.stock:
return {"message": "Not enough stock for book with 'isbn': " + str(isbn) + "only "
+ str(book.stock) + " available"}, 404
try:
transactions = TransactionsModel.save_transaction(user.id, data['isbns'], data['prices'],
data['quantities'])
except Exception as ex:
return {'message': str(ex)}, 500
return {'transactions': transactions}, 201
def test_get_best_sellers(self):
with self.app.app_context():
self.basic_setup()
isbns = [self.book.isbn, self.book2.isbn]
prices = [self.book.precio, self.book2.precio]
quantities = [1, 50]
dataTransaction = {
"isbns": isbns,
'prices': prices,
'quantities': quantities,
"email": self.user.email,
}
res = self.client.post(
"/api/transaction",
data=dataTransaction,
headers={
"Authorization":
'Basic ' + base64.b64encode(
(self.token + ":").encode('ascii')).decode('ascii')
})
self.assertEqual(201, res.status_code)
# hi ha dues transaccions amb id 1
transactions = TransactionsModel.find_by_id(1)
self.assertEqual(len(transactions), 2)
args = {
"numBooks": 2,
}
res = self.client.get('/api/trending', data=args)
self.assertEqual(200, res.status_code)
self.assertEqual(
2, len(json.loads(res.data)
['books'])) # veiem que n'hi ha dos com li hem demanat
self.assertEqual(self.book2.isbn,
json.loads(res.data)['books'][0]
['isbn']) # el més venut és el llibre amb isbn 2
def test_get_all_transactions_no_filter(self):
with self.app.app_context():
self.basic_setup()
self.add_transactions_user1()
self.add_transactions_user2()
res = self.client.get(
"/api/allTransactions",
headers={
"Authorization":
'Basic ' + base64.b64encode(
(self.token + ":").encode('ascii')).decode('ascii')
})
self.assertEqual(200, res.status_code)
transactions = TransactionsModel.query.all()
expected_transactions = TransactionsModel.group_transactions_by_id(
transactions)
for i, transactions in enumerate(expected_transactions):
for j, transaction in enumerate(transactions):
self.assertEqual(
transaction,
json.loads(res.data)['transactions'][i][j])
def add_transactions_user2(self):
isbns = [self.book.isbn, self.book2.isbn]
prices = [self.book.precio, self.book2.precio]
quantities = [3, 1]
TransactionsModel.save_transaction(self.user2.id, isbns, prices,
quantities)