def setUp(self):
My_app.config.from_object(app_config["testing"])
self.app = My_app.test_client()
self.db_obj = DbConn()
self.con = self.db_obj.create_connection()
self.db_obj.create_users_table()
self.db_obj.create_menu_table()
self.db_obj.create_orders_table()
self.querry = UserQueries()
self.hostname = "http://*****:*****@gmail.com",
"password": "******"
}
self.resgistered_user = {"user_name": "mos", "password": "******"}
from app.models.db_connection import DbConn
from config.config import app_config
from app.views.routes import My_app
My_app.config.from_object(app_config["development"])
if __name__ == "__main__":
db_obj = DbConn()
con = db_obj.create_connection()
db_obj.create_users_table()
db_obj.create_menu_table()
db_obj.create_orders_table()
My_app.run()
class BaseTestCase(unittest.TestCase):
def setUp(self):
My_app.config.from_object(app_config["testing"])
self.app = My_app.test_client()
self.db_obj = DbConn()
self.con = self.db_obj.create_connection()
self.db_obj.create_users_table()
self.db_obj.create_menu_table()
self.db_obj.create_orders_table()
self.querry = UserQueries()
self.hostname = "http://*****:*****@gmail.com",
"password": "******"
}
self.resgistered_user = {"user_name": "mos", "password": "******"}
def tearDown(self):
cursor = self.con.cursor()
cursor.execute("DROP TABLE IF EXISTS users CASCADE")
cursor.execute("DROP TABLE IF EXISTS menu CASCADE")
cursor.execute("DROP TABLE IF EXISTS orders CASCADE")
self.con.commit()
self.con.close()
def register_user(self, new_user):
return self.app.post(self.hostname + "auth/signup",
data=json.dumps(new_user),
content_type='application/json')
def login_user(self, user):
return self.app.post(self.hostname + "auth/login",
data=json.dumps(user),
content_type='application/json')
def make_admin(self, user):
self.querry.authorise_user(user, True)
def post_food(self, food, token):
return self.app.post(self.hostname + "menu",
data=json.dumps(food),
content_type='application/json',
headers=({
"acces-token": token
}))
def get_all_orders(self, token):
return self.app.get(self.hostname + "orders",
headers=({
"acces-token": token
}))
def post_order(self, order, token):
return self.app.post(self.hostname + "users/orders",
data=json.dumps(order),
content_type='application/json',
headers=({
"acces-token": token
}))
def fetch_specific_order(self, uuid, token):
return self.app.get(self.hostname + "orders/" + str(uuid),
headers=({
"acces-token": token
}))
def update_status(self, status, uuid, token):
return self.app.put(self.hostname + "orders/" + str(uuid),
data=json.dumps(status),
content_type='application/json',
headers=({
"acces-token": token
}))
def get_user_order_history(self, token):
return self.app.get(self.hostname + "users/orders",
headers=({
"acces-token": token
}))
def get_menu(self, token):
return self.app.get(self.hostname + "menu",
headers=({
"acces-token": token
}))
def get_all_users(self, token):
return self.app.get(self.hostname + "users",
headers=({
"acces-token": token
}))
def promote_user(self, user, token):
return self.app.put(self.hostname + "promote",
data=json.dumps(user),
content_type='application/json',
headers=({
"acces-token": token
}))
def __init__(self):
self.conn = DbConn().create_connection()
self.cur = self.conn.cursor()
class UserQueries:
def __init__(self):
self.conn = DbConn().create_connection()
self.cur = self.conn.cursor()
def insert_user(self, first_name, last_name, user_name, email, password,
created_at, admin):
"a method to insert user into users table"
sql = """INSERT INTO users ( first_name, last_name, user_name, email, password, created_at, admin )
VALUES ('{f_name}', '{l_name}', '{u_name}', '{email}', '{password}',
'{created_at}', '{admin}' )"""
sql_command = sql.format(f_name=first_name,
l_name=last_name,
u_name=user_name,
email=email,
password=password,
created_at=created_at,
admin=admin)
self.cur.execute(sql_command)
self.conn.commit()
# self.conn.close()
def get_all_users(self, users_list=[]):
"a method to get al users"
users_list.clear()
sql = """SELECT * FROM users ;"""
self.cur.execute(sql)
orders = self.cur.fetchall()
user = {}
for row in orders:
user = {
"user_id": row[0],
"first_name": row[1],
"last_name": row[2],
"user_name": row[3],
"email": row[4],
"password": row[5],
"created_a": row[6],
"admin": row[7]
}
users_list.append(user)
self.conn.commit()
# self.conn.close()
return users_list
def get_user(self, user_name):
" a methos to get user"
sql = """SELECT * FROM users WHERE user_name ='{u_name}' ;"""
sql_command = sql.format(u_name=user_name)
self.cur.execute(sql_command)
orders = self.cur.fetchall()
user = {}
for row in orders:
user = {
"user_id": row[0],
"first_name": row[1],
"last_name": row[2],
"user_name": row[3],
"email": row[4],
"password": row[5],
"created_a": row[6],
"admin": row[7]
}
self.conn.commit()
# self.conn.close()
return user
def authorise_user(self, u_name, admin):
" a method to promote user"
sql = """UPDATE users SET admin = '{admin}' WHERE user_name = '{u_name}';"""
sql_command = sql.format(admin=admin, u_name=u_name)
self.cur.execute(sql_command)
self.conn.commit()
# self.conn.close()
def get_user_Order_history(self, user_id):
"a metod to get user order history"
order_list = []
sql = """SELECT * FROM orders WHERE user_id = '{user_id}' ;"""
sql_command = sql.format(user_id=user_id)
self.cur.execute(sql_command)
orders = self.cur.fetchall()
order = {}
for row in orders:
order = {
"order_id": row[0],
"order_client": row[1],
"order_food_id": row[2],
"order_uuid": row[3],
"order_created_at": row[4],
"order_status": row[5],
"order_quantity": row[6]
}
order_list.append(order)
self.conn.commit()
# self.conn.close()
return order_list
def check_admin(self, user_id):
" a method to chek whether user is admin"
sql = """SELECT admin FROM users WHERE user_id = '{user_id}' ;"""
sql_command = sql.format(user_id=user_id)
self.cur.execute(sql_command)
values = self.cur.fetchall()
admin = None
for row in values:
admin = row[0]
self.conn.commit()
# self.conn.close()
return admin
def close_conn(self):
" a method to close the datase connection"
DbConn().close_DB()
def close_conn(self):
" a method to close the datase connection"
DbConn().close_DB()
class DbQueries():
def __init__(self):
self.conn = DbConn().create_connection()
self.cur = self.conn.cursor()
def insert_orders(self, user_id, food_id, order_uuid, created_at, status,
quantity):
"a method to insert orders into the orders table"
sql = """INSERT INTO orders ( user_id ,food_id, order_uuid,created_at, status, quantity )
VALUES ('{user_id}', '{food_id}', '{order_uuid}', '{created_at}',
'{status}', '{quantity}' )"""
sql_command = sql.format(user_id=user_id,
food_id=food_id,
order_uuid=order_uuid,
created_at=created_at,
status=status,
quantity=quantity)
self.cur.execute(sql_command)
self.conn.commit()
# self.conn.close()
def get_orders(self, order_list=[]):
"a methos to fetch orders froorders table"
order_list.clear()
sql = """SELECT * FROM orders ;"""
self.cur.execute(sql)
orders = self.cur.fetchall()
order = {}
for row in orders:
order = {
"order_id": row[0],
"order_client": row[1],
"order_food_id": row[2],
"order_uuid": row[3],
"order_created_at": row[4],
"order_status": row[5],
"order_quantity": row[6]
}
order_list.append(order)
self.conn.commit()
# self.conn.close()
return order_list
def fetch_order(self, uuid):
"a methos to fetch specific order"
sql = """SELECT * FROM orders WHERE order_uuid = '{uuid}' ;"""
sql_command = sql.format(uuid=uuid)
self.cur.execute(sql_command)
orders = self.cur.fetchall()
order = {}
for row in orders:
order = {
"order_id": row[0],
"order_client": row[1],
"order_food_id": row[2],
"order_uuid": row[3],
"order_created_at": row[4],
"order_status": row[5],
"order_quantity": row[6]
}
self.conn.commit()
# self.conn.close()
return order
def update_order_status(self, status, uuid):
"a methos to update order status"
sql = """UPDATE orders SET status = '{status}' WHERE order_uuid = '{uuid}';"""
sql_command = sql.format(status=status, uuid=uuid)
self.cur.execute(sql_command)
self.conn.commit()
# self.conn.close()
def insert_food(self, food_name, food_price):
"a methos to insert food object into menu tale"
sql = """INSERT INTO menu ( food_name, food_price ) VALUES ('{food}', '{price}');"""
sql_command = sql.format(food=food_name, price=food_price)
self.cur.execute(sql_command)
self.conn.commit()
# self.conn.close()
def get_food(self, food_name):
"a methos to get food "
sql = """SELECT * FROM menu WHERE food_name = '{name}' ;"""
sql_command = sql.format(name=food_name)
self.cur.execute(sql_command)
foods = self.cur.fetchall()
food = {}
for row in foods:
food = {
"food_id": row[0],
"food_name": row[1],
"food_price": row[2]
}
self.conn.commit()
# self.conn.close()
return food
def get_all_foods(self, food_list=[]):
"a method to get all foods"
food_list.clear()
sql = """SELECT * FROM menu ;"""
self.cur.execute(sql)
foods = self.cur.fetchall()
food = {}
for row in foods:
food = {
"food_id": row[0],
"food_name": row[1],
"food_price": row[2]
}
food_list.append(food)
self.conn.commit()
# self.conn.close()
return food_list
def close_conn(self):
DbConn().close_DB()
def close_conn(self):
DbConn().close_DB()