From 582171d1f9c6959cb130b24dcea84594980b2201 Mon Sep 17 00:00:00 2001
From: Vic <anis.benziane@gmail.com>
Date: Tue, 24 May 2022 19:44:13 +0200
Subject: [PATCH] linter + prettier

---
 src/database.ts                     |  22 +--
 src/handlers/orders.ts              | 123 ++++++++-------
 src/handlers/products.ts            | 126 ++++++++--------
 src/handlers/users.ts               | 187 +++++++++++------------
 src/handlers/utils.ts               |  46 +++---
 src/models/order.ts                 | 216 +++++++++++++-------------
 src/models/product.ts               | 134 ++++++++---------
 src/models/user.ts                  | 225 ++++++++++++++--------------
 src/server.ts                       |  34 ++---
 src/tests/handlers/orders_spec.ts   | 122 ++++++++-------
 src/tests/handlers/products_spec.ts |  89 +++++------
 src/tests/handlers/users_spec.ts    | 115 +++++++-------
 src/tests/models/order_spec.ts      | 166 ++++++++++----------
 src/tests/models/product_spec.ts    | 119 +++++++--------
 src/tests/models/user_spec.ts       | 205 ++++++++++++-------------
 15 files changed, 938 insertions(+), 991 deletions(-)

diff --git a/src/database.ts b/src/database.ts
index 75c5147..f4845fc 100644
--- a/src/database.ts
+++ b/src/database.ts
@@ -1,7 +1,7 @@
-import dotenv from 'dotenv'
-import { Pool } from 'pg'
+import dotenv from "dotenv";
+import { Pool } from "pg";
 
-dotenv.config()
+dotenv.config();
 
 const {
   ENV,
@@ -9,28 +9,28 @@ const {
   POSTGRES_DB,
   POSTGRES_TEST_DB,
   POSTGRES_USER,
-  POSTGRES_PASSWORD
-} = process.env
+  POSTGRES_PASSWORD,
+} = process.env;
 
 let client = new Pool();
-console.log(ENV)
+console.log(ENV);
 
-if(ENV === 'dev') {
+if (ENV === "dev") {
   client = new Pool({
     host: POSTGRES_HOST,
     database: POSTGRES_DB,
     user: POSTGRES_USER,
     password: POSTGRES_PASSWORD,
-  })
+  });
 }
 
-if(ENV === 'test') {
+if (ENV === "test") {
   client = new Pool({
     host: POSTGRES_HOST,
     database: POSTGRES_TEST_DB,
     user: POSTGRES_USER,
     password: POSTGRES_PASSWORD,
-  })
+  });
 }
 
-export default client;
\ No newline at end of file
+export default client;
diff --git a/src/handlers/orders.ts b/src/handlers/orders.ts
index 6be44d7..44ef7a5 100644
--- a/src/handlers/orders.ts
+++ b/src/handlers/orders.ts
@@ -1,78 +1,75 @@
-import express, { Request, Response } from 'express'
-import { Order, OrderProduct, OrderStore } from '../models/order'
-import { verifyAuthToken } from './utils'
+import express, { Request, Response } from "express";
+import { Order, OrderProduct, OrderStore } from "../models/order";
+import { verifyAuthToken } from "./utils";
 
 const orderRoutes = (app: express.Application) => {
-    app.get('/orders', index)
-    app.get('/orders/:id', read)
-    app.post('/orders', verifyAuthToken, create)
-    app.post('/orders/:id/products', verifyAuthToken, addProduct)
-    app.delete('/orders/:id/products', verifyAuthToken, deleteProduct)
-}
+  app.get("/orders", index);
+  app.get("/orders/:id", read);
+  app.post("/orders", verifyAuthToken, create);
+  app.post("/orders/:id/products", verifyAuthToken, addProduct);
+  app.delete("/orders/:id/products", verifyAuthToken, deleteProduct);
+};
 
-const store = new OrderStore()
+const store = new OrderStore();
 
 const index = async (req: Request, res: Response) => {
-    try {
-        const orders = await store.index()
-        res.json(orders)
-    } catch (err) {
-        res.status(400)
-        res.json(err)
-    }
-}
+  try {
+    const orders = await store.index();
+    res.json(orders);
+  } catch (err) {
+    res.status(400);
+    res.json(err);
+  }
+};
 
 const read = async (req: Request, res: Response) => {
-    try {
-        const order = await store.read(parseInt(req.params.id))
-        res.json(order)
-    } catch (err) {
-        res.status(400)
-        res.json(err) 
-    }
-    
-}
+  try {
+    const order = await store.read(parseInt(req.params.id));
+    res.json(order);
+  } catch (err) {
+    res.status(400);
+    res.json(err);
+  }
+};
 
 const create = async (req: Request, res: Response) => {
-    try {
-        const orderInfo: Order = {
-            status: req.body.status,
-            user_id: parseInt(req.body.user_id)
-        }
+  try {
+    const orderInfo: Order = {
+      status: req.body.status,
+      user_id: parseInt(req.body.user_id),
+    };
 
-    
-        const newOrder = await store.create(orderInfo)
-        res.json(newOrder)
-    } catch (err) {
-        res.status(400)
-        res.json(err)
-    }
-}
+    const newOrder = await store.create(orderInfo);
+    res.json(newOrder);
+  } catch (err) {
+    res.status(400);
+    res.json(err);
+  }
+};
 
 const addProduct = async (req: Request, res: Response) => {
-    try {
-        const orderProductInfo: OrderProduct = {
-            order_id: parseInt(req.params.id),
-            quantity: parseInt(req.body.quantity),
-            product_id: parseInt(req.body.product_id)
-        }
-        const addedProduct = await store.addProduct(orderProductInfo)
-        res.json(addedProduct)
-    } catch (err) {
-        res.status(400)
-        res.json(err)   
-    }
-}
+  try {
+    const orderProductInfo: OrderProduct = {
+      order_id: parseInt(req.params.id),
+      quantity: parseInt(req.body.quantity),
+      product_id: parseInt(req.body.product_id),
+    };
+    const addedProduct = await store.addProduct(orderProductInfo);
+    res.json(addedProduct);
+  } catch (err) {
+    res.status(400);
+    res.json(err);
+  }
+};
 
 const deleteProduct = async (req: Request, res: Response) => {
-    try {
-        const deletedProduct = await store.deleteProduct(parseInt(req.params.id))
-        res.json(deletedProduct)
-    } catch (err) {
-        res.status(400)
-        res.json(err)   
-    }
-}
+  try {
+    const deletedProduct = await store.deleteProduct(parseInt(req.params.id));
+    res.json(deletedProduct);
+  } catch (err) {
+    res.status(400);
+    res.json(err);
+  }
+};
 
-
-export default orderRoutes
\ No newline at end of file
+export default orderRoutes;
diff --git a/src/handlers/products.ts b/src/handlers/products.ts
index 0ecc45f..4152509 100644
--- a/src/handlers/products.ts
+++ b/src/handlers/products.ts
@@ -1,80 +1,74 @@
-import express, { Request, Response } from 'express'
-import { Product, ProductStore } from '../models/product'
-import { verifyAuthToken } from './utils'
+import express, { Request, Response } from "express";
+import { Product, ProductStore } from "../models/product";
+import { verifyAuthToken } from "./utils";
 
 const productRoutes = (app: express.Application) => {
-    app.get('/products', index)
-    app.get('/products/:id', read)
-    app.post('/products', verifyAuthToken, create)
-    app.put('/products/:id', verifyAuthToken, update)
-    app.delete('/products/:id', verifyAuthToken, destroy)
-}
+  app.get("/products", index);
+  app.get("/products/:id", read);
+  app.post("/products", verifyAuthToken, create);
+  app.put("/products/:id", verifyAuthToken, update);
+  app.delete("/products/:id", verifyAuthToken, destroy);
+};
 
-const store = new ProductStore()
+const store = new ProductStore();
 
 const index = async (req: Request, res: Response) => {
-    try {
-        const products = await store.index()
-        res.json(products)   
-    } catch (err) {
-        res.status(400)
-        res.json(err)
-    }
-        
-}
+  try {
+    const products = await store.index();
+    res.json(products);
+  } catch (err) {
+    res.status(400);
+    res.json(err);
+  }
+};
 
 const read = async (req: Request, res: Response) => {
-    try {
-        const product = await store.read(parseInt(req.params.id))
-        res.json(product)
-    } catch (err) {
-        res.status(400)
-        res.json(err)
-    }
-        
-}
+  try {
+    const product = await store.read(parseInt(req.params.id));
+    res.json(product);
+  } catch (err) {
+    res.status(400);
+    res.json(err);
+  }
+};
 
 const create = async (req: Request, res: Response) => {
-
-    try {
-        const productInfo: Product = {
-            name: req.body.name,
-            price: req.body.price,
-        }
-        const newProduct = await store.create(productInfo)
-        res.json(newProduct)
-    } catch (err) {
-        res.status(400)
-        res.json(err)
-    }
-   
-}
+  try {
+    const productInfo: Product = {
+      name: req.body.name,
+      price: req.body.price,
+    };
+    const newProduct = await store.create(productInfo);
+    res.json(newProduct);
+  } catch (err) {
+    res.status(400);
+    res.json(err);
+  }
+};
 
 const update = async (req: Request, res: Response) => {
-    try {
-        const productInfo: Product = {
-            id: parseInt(req.params.id),
-            name: req.body.name,
-            price: req.body.price,
-        }
-        const updatedProduct = await store.update(productInfo)
-        res.json(updatedProduct)
-    } catch (err) {
-        res.status(400)
-        res.json(err)
-    }
-}
+  try {
+    const productInfo: Product = {
+      id: parseInt(req.params.id),
+      name: req.body.name,
+      price: req.body.price,
+    };
+    const updatedProduct = await store.update(productInfo);
+    res.json(updatedProduct);
+  } catch (err) {
+    res.status(400);
+    res.json(err);
+  }
+};
 
 const destroy = async (req: Request, res: Response) => {
-    try {
-        const deleted = await store.delete(parseInt(req.params.id))
-        res.json(deleted)
-    } catch (err) {
-        res.status(400)
-        res.json(err)
-    }
-    
-}
-
+  try {
+    const deleted = await store.delete(parseInt(req.params.id));
+    res.json(deleted);
+  } catch (err) {
+    res.status(400);
+    res.json(err);
+  }
+};
 
-export default productRoutes
\ No newline at end of file
+export default productRoutes;
diff --git a/src/handlers/users.ts b/src/handlers/users.ts
index a2c0c42..dc03660 100644
--- a/src/handlers/users.ts
+++ b/src/handlers/users.ts
@@ -1,113 +1,108 @@
-import express, { Request, Response } from 'express'
-import { User, UserStore } from '../models/user'
-import { verifyAuthToken, verifyUserToken} from './utils'
-
+import express, { Request, Response } from "express";
+import { User, UserStore } from "../models/user";
+import { verifyAuthToken, verifyUserToken } from "./utils";
 
 const userRoutes = (app: express.Application) => {
-    app.get('/users', verifyAuthToken, index)
-    app.get('/users/:id', verifyAuthToken, read)
-    app.post('/users', create)
-    app.put('/users/:id', verifyAuthToken, update)
-    app.delete('/users/:id', verifyAuthToken, destroy)
-    app.post("/users/auth", authenticate)
-}
-
-const store = new UserStore()
+  app.get("/users", verifyAuthToken, index);
+  app.get("/users/:id", verifyAuthToken, read);
+  app.post("/users", create);
+  app.put("/users/:id", verifyAuthToken, update);
+  app.delete("/users/:id", verifyAuthToken, destroy);
+  app.post("/users/auth", authenticate);
+};
 
+const store = new UserStore();
 
 const index = async (req: Request, res: Response) => {
-    try {
-        const users = await store.index()
-        res.json(users);
-    } catch (err) {
-        res.status(400)
-        res.json(err)
-    }
-}
+  try {
+    const users = await store.index();
+    res.json(users);
+  } catch (err) {
+    res.status(400);
+    res.json(err);
+  }
+};
 
 const read = async (req: Request, res: Response) => {
-    try {
-        const user = await store.read(parseInt(req.params.id))
-        res.json(user)
-    } catch (err) {
-        res.status(400)
-        res.json(err)
-    }
-}
-
-
-
-const create = async (req: Request, res: Response) => { 
-
-    const userInfo: User = {
-        firstname: req.body.firstname,
-        lastname: req.body.lastname,
-        username: req.body.username,
-        password: req.body.password
-    }
-
-    try {
-        const newUser = await store.create(userInfo)
-        res.json(verifyUserToken(newUser))
-    } catch(err) {
-        res.status(400)
-        res.json(err)
-    }
-}
+  try {
+    const user = await store.read(parseInt(req.params.id));
+    res.json(user);
+  } catch (err) {
+    res.status(400);
+    res.json(err);
+  }
+};
+
+const create = async (req: Request, res: Response) => {
+  const userInfo: User = {
+    firstname: req.body.firstname,
+    lastname: req.body.lastname,
+    username: req.body.username,
+    password: req.body.password,
+  };
+
+  try {
+    const newUser = await store.create(userInfo);
+    res.json(verifyUserToken(newUser));
+  } catch (err) {
+    res.status(400);
+    res.json(err);
+  }
+};
 
 const update = async (req: Request, res: Response) => {
-    try {
-        const userInfo: User = {
-            id: parseInt(req.params.id),
-            firstname: req.body.firstname,
-            lastname: req.body.lastname,
-            username: req.body.username,
-            password: req.body.password
-        }
-        const updatedUser = await store.update(userInfo)
-        res.json(updatedUser)
-    } catch (err) {
-        res.status(400)
-        res.json(err)
-    }
-}
-
+  try {
+    const userInfo: User = {
+      id: parseInt(req.params.id),
+      firstname: req.body.firstname,
+      lastname: req.body.lastname,
+      username: req.body.username,
+      password: req.body.password,
+    };
+    const updatedUser = await store.update(userInfo);
+    res.json(updatedUser);
+  } catch (err) {
+    res.status(400);
+    res.json(err);
+  }
+};
 
 const destroy = async (req: Request, res: Response) => {
-    try {
-        const deleted = await store.delete(parseInt(req.params.id))
-        res.json(deleted)
-    } catch (err) {
-        res.status(400)
-        res.json(err)
-    }
-}
+  try {
+    const deleted = await store.delete(parseInt(req.params.id));
+    res.json(deleted);
+  } catch (err) {
+    res.status(400);
+    res.json(err);
+  }
+};
 
 const authenticate = async (req: Request, res: Response) => {
-    try {
-        const userInfo: User = {
-            username: req.body.username,
-            password: req.body.password
-        }
-    
-        if (userInfo.username === undefined || userInfo.password === undefined) {
-            res.status(400)
-            res.send("Missing credentials username or password")
-
-        }
-
-        const authUser: User | null = await store.authenticate(userInfo.username, userInfo.password)
+  try {
+    const userInfo: User = {
+      username: req.body.username,
+      password: req.body.password,
+    };
 
-        if (authUser === null) {
-            res.status(401)
-            res.send("Password is incorrect")
-        }
-        res.json(verifyUserToken(authUser))
-    } catch(err) {
-        res.status(401)
-        res.json(err)
+    if (userInfo.username === undefined || userInfo.password === undefined) {
+      res.status(400);
+      res.send("Missing credentials username or password");
     }
-}
 
+    const authUser: User | null = await store.authenticate(
+      userInfo.username,
+      userInfo.password
+    );
 
-export default userRoutes
\ No newline at end of file
+    if (authUser === null) {
+      res.status(401);
+      res.send("Password is incorrect");
+    }
+    res.json(verifyUserToken(authUser));
+  } catch (err) {
+    res.status(401);
+    res.json(err);
+  }
+};
+
+export default userRoutes;
diff --git a/src/handlers/utils.ts b/src/handlers/utils.ts
index 66319b2..91c460d 100644
--- a/src/handlers/utils.ts
+++ b/src/handlers/utils.ts
@@ -1,27 +1,31 @@
-import jwt, { Secret } from "jsonwebtoken"
-import { User } from "../models/user"
-import { NextFunction, Request, Response } from "express"
+import jwt, { Secret } from "jsonwebtoken";
+import { User } from "../models/user";
+import { NextFunction, Request, Response } from "express";
 
-const SECRET = process.env.TOKEN_SECRET as Secret
+const SECRET = process.env.TOKEN_SECRET as Secret;
 
-export const verifyAuthToken = (req: Request, res: Response, next: NextFunction) => {
-    if (!req.headers.authorization) {
-        res.status(401)
-        res.json("Missing authorization header")
+export const verifyAuthToken = (
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  if (!req.headers.authorization) {
+    res.status(401);
+    res.json("Missing authorization header");
 
-        return false
-    }
+    return false;
+  }
 
-    try {
-        const token = req.headers.authorization.split(' ')[1]
-        jwt.verify(token, SECRET)
-        next()
-    } catch (err) {
-        res.status(401)
-        res.json("Access denied, invalid token")
-    }
-}
+  try {
+    const token = req.headers.authorization.split(" ")[1];
+    jwt.verify(token, SECRET);
+    next();
+  } catch (err) {
+    res.status(401);
+    res.json("Access denied, invalid token");
+  }
+};
 
 export const verifyUserToken = (user: User | null) => {
-    return jwt.sign({ user }, SECRET)
-}
+  return jwt.sign({ user }, SECRET);
+};
diff --git a/src/models/order.ts b/src/models/order.ts
index b72c438..10d3ad4 100644
--- a/src/models/order.ts
+++ b/src/models/order.ts
@@ -1,135 +1,129 @@
-import client from '../database'
+import client from "../database";
 
 export type Order = {
-    id?: number
-    status: string
-    user_id: number
-}
+  id?: number;
+  status: string;
+  user_id: number;
+};
 
 export type OrderProduct = {
-    id?: number
-    quantity: number
-    order_id: number
-    product_id: number
-}
-
+  id?: number;
+  quantity: number;
+  order_id: number;
+  product_id: number;
+};
 
 export class OrderStore {
-    async index(): Promise<Order[]> {
-        try {
-
-            const conn = await client.connect()
-            const sql = 'SELECT * FROM orders'
+  async index(): Promise<Order[]> {
+    try {
+      const conn = await client.connect();
+      const sql = "SELECT * FROM orders";
 
-            const result = await conn.query(sql)
-            const orders = result.rows
-            
-            conn.release()
+      const result = await conn.query(sql);
+      const orders = result.rows;
 
-            return orders
+      conn.release();
 
-        } catch (err) {
-            throw new Error(`Cannot get any order ${err}`)
-        }
+      return orders;
+    } catch (err) {
+      throw new Error(`Cannot get any order ${err}`);
     }
+  }
 
-    async read(user_id: number): Promise<Order> {
-        try {
+  async read(user_id: number): Promise<Order> {
+    try {
+      const conn = await client.connect();
+      const sql = "SELECT * FROM orders WHERE user_id=($1)";
 
-            const conn = await client.connect()
-            const sql = 'SELECT * FROM orders WHERE user_id=($1)'
+      const result = await conn.query(sql, [user_id]);
+      const order = result.rows[0];
 
-            const result = await conn.query(sql, [user_id])
-            const order = result.rows[0]
-            
-            conn.release()
+      conn.release();
 
-            return order
-
-        } catch (err) {
-            throw new Error(`Could not find order ${user_id}. Error: ${err}`)
-        }
+      return order;
+    } catch (err) {
+      throw new Error(`Could not find order ${user_id}. Error: ${err}`);
     }
+  }
 
-    async create(o: Order): Promise<Order> {
-        try {
-
-            const conn = await client.connect()
-            const sql = 'INSERT INTO orders (status, user_id) VALUES ($1, $2) RETURNING *'
+  async create(o: Order): Promise<Order> {
+    try {
+      const conn = await client.connect();
+      const sql =
+        "INSERT INTO orders (status, user_id) VALUES ($1, $2) RETURNING *";
 
-            const result = await conn.query(sql, [o.status, o.user_id])
-            const order = result.rows[0]
+      const result = await conn.query(sql, [o.status, o.user_id]);
+      const order = result.rows[0];
 
-            conn.release()
+      conn.release();
 
-            return order
+      return order;
+    } catch (err) {
+      throw new Error(`Could not add a new order ${o.user_id}. Error: ${err}`);
+    }
+  }
+
+  async addProduct(o: OrderProduct): Promise<OrderProduct> {
+    try {
+      const ordersql = "SELECT * FROM orders WHERE id=($1)";
+      const conn = await client.connect();
+      const result = await conn.query(ordersql, [o.order_id]);
+      const order = result.rows[0];
+
+      if (order.status !== "active") {
+        throw new Error(
+          `Could not add product ${o.product_id} to order ${o.order_id} because order status is ${order.status}`
+        );
+      }
+
+      conn.release();
+    } catch (err) {
+      throw new Error(`${err}`);
+    }
 
-        } catch (err) {
-            throw new Error(`Could not add a new order ${o.user_id}. Error: ${err}`)
-        }
+    try {
+      const sql =
+        "INSERT INTO order_products (quantity, order_id, product_id) VALUES ($1, $2, $3) RETURNING *";
+      const conn = await client.connect();
+      const result = await conn.query(sql, [
+        o.quantity,
+        o.order_id,
+        o.product_id,
+      ]);
+      const order = result.rows[0];
+
+      conn.release();
+
+      return order;
+    } catch (err) {
+      throw new Error(
+        `Could not add product ${o.product_id} to order ${o.order_id}: Error: ${err}`
+      );
     }
-    
-    async addProduct(o: OrderProduct): Promise<OrderProduct> {
-        try {
-            
-            const ordersql = 'SELECT * FROM orders WHERE id=($1)'
-            const conn = await client.connect()
-            const result = await conn.query(ordersql, [o.order_id])
-            const order = result.rows[0]
-
-            if(order.status !== "active") {
-                throw new Error(`Could not add product ${o.product_id} to order ${o.order_id} because order status is ${order.status}`)
-            }
-
-            conn.release()
-        } catch (err) {
-            throw new Error(`${err}`)
-        }
-
-        try {
-            
-            const sql = 'INSERT INTO order_products (quantity, order_id, product_id) VALUES ($1, $2, $3) RETURNING *'
-            const conn = await client.connect()
-            const result = await conn.query(sql, [o.quantity, o.order_id, o.product_id])
-            const order = result.rows[0]
-
-            conn.release()
-
-            return order
-        } catch (err) {
-            throw new Error(`Could not add product ${o.product_id} to order ${o.order_id}: Error: ${err}`)
-        }
-            
+  }
+
+  async deleteProduct(id: number): Promise<Order> {
+    try {
+      const sql = "DELETE FROM order_products WHERE order_id=($1)";
+      const conn = await client.connect();
+      const result = await conn.query(sql, [id]);
+
+      conn.release();
+    } catch (err) {
+      throw new Error(`Could not delete order ${id}: Error: ${err}`);
     }
 
-    async deleteProduct(id: number): Promise<Order> {
-        try {
-            
-            const sql = 'DELETE FROM order_products WHERE order_id=($1)'
-            const conn = await client.connect()
-            const result = await conn.query(sql, [id])
-
-            conn.release()
-
-            
-        } catch (err) {
-            throw new Error(`Could not delete order ${id}: Error: ${err}`)
-        }
-            
-        
-        try {
-            
-            const ordersql = 'DELETE FROM orders WHERE id=($1)'
-            const conn = await client.connect()
-            const ordersResult = await conn.query(ordersql, [id])
-            const order = ordersResult.rows[0]
-
-            conn.release()
-
-            return order
-
-        } catch (err) {
-            throw new Error(`${err}`)
-        }
+    try {
+      const ordersql = "DELETE FROM orders WHERE id=($1)";
+      const conn = await client.connect();
+      const ordersResult = await conn.query(ordersql, [id]);
+      const order = ordersResult.rows[0];
+
+      conn.release();
+
+      return order;
+    } catch (err) {
+      throw new Error(`${err}`);
     }
-}
\ No newline at end of file
+  }
+}
diff --git a/src/models/product.ts b/src/models/product.ts
index 4eb9938..9255fd1 100644
--- a/src/models/product.ts
+++ b/src/models/product.ts
@@ -1,101 +1,91 @@
-import client from '../database';
+import client from "../database";
 
 export type Product = {
-    id?: number;
-    name: string;
-    price: number;
-}
+  id?: number;
+  name: string;
+  price: number;
+};
 
 export class ProductStore {
-    async index(): Promise<Product[]> {
-        try {
-
-            const conn = await client.connect()
-            const sql = 'SELECT * FROM products'
-
-            const result = await conn.query(sql)
-            const products = result.rows
+  async index(): Promise<Product[]> {
+    try {
+      const conn = await client.connect();
+      const sql = "SELECT * FROM products";
 
-            conn.release()
+      const result = await conn.query(sql);
+      const products = result.rows;
 
-            return products
+      conn.release();
 
-        } catch (err) {
-            throw new Error(`Cannot get any products ${err}`)
-        }
+      return products;
+    } catch (err) {
+      throw new Error(`Cannot get any products ${err}`);
     }
+  }
 
-    async read(id: number): Promise<Product> {
-        try {
+  async read(id: number): Promise<Product> {
+    try {
+      const conn = await client.connect();
+      const sql = "SELECT * FROM products WHERE id=($1)";
 
-            const conn = await client.connect()
-            const sql = 'SELECT * FROM products WHERE id=($1)'
-            
-            const result = await conn.query(sql, [id])
-            const product = result.rows[0]
+      const result = await conn.query(sql, [id]);
+      const product = result.rows[0];
 
-            conn.release()
-
-            return product
-
-        } catch (err) {
-            throw new Error(`Could not find product ${id}. Error: ${err}`)
-        }
+      conn.release();
 
+      return product;
+    } catch (err) {
+      throw new Error(`Could not find product ${id}. Error: ${err}`);
     }
-    
-    async create(p: Product): Promise<Product> {
-        try {
-
-            const conn = await client.connect()
-            const sql = 'INSERT INTO products (name, price) VALUES ($1, $2) RETURNING *'
+  }
 
-            const result = await conn.query(sql, [p.name, p.price])
-            const product = result.rows[0]
+  async create(p: Product): Promise<Product> {
+    try {
+      const conn = await client.connect();
+      const sql =
+        "INSERT INTO products (name, price) VALUES ($1, $2) RETURNING *";
 
-            conn.release()
+      const result = await conn.query(sql, [p.name, p.price]);
+      const product = result.rows[0];
 
-            return product 
-
-            } catch (err) {
-                throw new Error(`Could not add a new product ${p.name}. Error: ${err}`)
-            }
+      conn.release();
 
+      return product;
+    } catch (err) {
+      throw new Error(`Could not add a new product ${p.name}. Error: ${err}`);
     }
+  }
 
-    async update(p: Product): Promise<Product> {
-        try {
-
-            const conn = await client.connect();
-            const sql = 'UPDATE products SET name=$1, price=$2 WHERE id=$3 RETURNING *'
-
-            const result = await conn.query(sql, [p.name, p.price, p.id])
-            const product = result.rows[0]
+  async update(p: Product): Promise<Product> {
+    try {
+      const conn = await client.connect();
+      const sql =
+        "UPDATE products SET name=$1, price=$2 WHERE id=$3 RETURNING *";
 
-            conn.release()
+      const result = await conn.query(sql, [p.name, p.price, p.id]);
+      const product = result.rows[0];
 
-            return product
+      conn.release();
 
-        } catch (err) {
-            throw new Error(`Could not update product ${p.id}. Error: ${err}`)
-        }
+      return product;
+    } catch (err) {
+      throw new Error(`Could not update product ${p.id}. Error: ${err}`);
     }
+  }
 
-    async delete(id: number): Promise<Product> {
-        try {
-
-            const conn = await client.connect()
-            const sql = 'DELETE FROM products WHERE id=($1)'
-
-            const result = await conn.query(sql, [id])
-            const product = result.rows[0]
+  async delete(id: number): Promise<Product> {
+    try {
+      const conn = await client.connect();
+      const sql = "DELETE FROM products WHERE id=($1)";
 
-            conn.release()
+      const result = await conn.query(sql, [id]);
+      const product = result.rows[0];
 
-            return product
+      conn.release();
 
-        } catch (err) {
-            throw new Error(`Could not delete product ${id}. Error: ${err}`)
-        }
+      return product;
+    } catch (err) {
+      throw new Error(`Could not delete product ${id}. Error: ${err}`);
     }
+  }
 }
diff --git a/src/models/user.ts b/src/models/user.ts
index 16fc05d..28cb62c 100644
--- a/src/models/user.ts
+++ b/src/models/user.ts
@@ -1,142 +1,141 @@
-import client from '../database';
-import bcrypt from 'bcrypt';
+import client from "../database";
+import bcrypt from "bcrypt";
 
-const { BCRYPT_PASSWORD, SALT_ROUNDS} = process.env
-const pepper = BCRYPT_PASSWORD
-const saltRounds = SALT_ROUNDS
+const { BCRYPT_PASSWORD, SALT_ROUNDS } = process.env;
+const pepper = BCRYPT_PASSWORD;
+const saltRounds = SALT_ROUNDS;
 
 export type User = {
-    id?: number;
-    firstname?: string;
-    lastname?: string;
-    username: string;
-    password:  string;
-}
+  id?: number;
+  firstname?: string;
+  lastname?: string;
+  username: string;
+  password: string;
+};
 
 export class UserStore {
-    async index(): Promise<User[]> {
-        try {
-
-            const conn = await client.connect()
-            const sql = 'SELECT * FROM users'
+  async index(): Promise<User[]> {
+    try {
+      const conn = await client.connect();
+      const sql = "SELECT * FROM users";
 
-            const result = await conn.query(sql)
-            const users = result.rows
+      const result = await conn.query(sql);
+      const users = result.rows;
 
-            conn.release()
+      conn.release();
 
-            return users
-
-        } catch (err) {
-            throw new Error(`Cannot get any users ${err}`)
-        }
+      return users;
+    } catch (err) {
+      throw new Error(`Cannot get any users ${err}`);
     }
+  }
 
-    async read(id: number): Promise<User> {
-        try {
-            const conn = await client.connect()
-            const sql = 'SELECT * FROM users WHERE id=($1)'
+  async read(id: number): Promise<User> {
+    try {
+      const conn = await client.connect();
+      const sql = "SELECT * FROM users WHERE id=($1)";
 
-            const result = await conn.query(sql, [id])
-            const user = result.rows[0]
+      const result = await conn.query(sql, [id]);
+      const user = result.rows[0];
 
-            conn.release()
+      conn.release();
 
-            return user
-
-        } catch (err) {
-            throw new Error(`Could not find user ${id}. Error: ${err}`)
-        }
+      return user;
+    } catch (err) {
+      throw new Error(`Could not find user ${id}. Error: ${err}`);
     }
-
-    async create(u: User): Promise<User> {
-        try {
-
-            const conn = await client.connect()
-            const sql = 'INSERT INTO users (firstname, lastname, username, password) VALUES ($1, $2, $3, $4) RETURNING *'
-            const hash = bcrypt.hashSync(
-                u.password + pepper,
-                parseInt(saltRounds as string, 10)
-            )
-
-            const result = await conn.query(sql, [u.firstname, u.lastname, u.username, hash])
-            const user = result.rows[0]
-
-            conn.release()
-
-            return user
-
-        } catch(err) {
-            throw new Error(`Could not add a new user ${u.firstname}. Error: ${err}`)
-        }
+  }
+
+  async create(u: User): Promise<User> {
+    try {
+      const conn = await client.connect();
+      const sql =
+        "INSERT INTO users (firstname, lastname, username, password) VALUES ($1, $2, $3, $4) RETURNING *";
+      const hash = bcrypt.hashSync(
+        u.password + pepper,
+        parseInt(saltRounds as string, 10)
+      );
+
+      const result = await conn.query(sql, [
+        u.firstname,
+        u.lastname,
+        u.username,
+        hash,
+      ]);
+      const user = result.rows[0];
+
+      conn.release();
+
+      return user;
+    } catch (err) {
+      throw new Error(`Could not add a new user ${u.firstname}. Error: ${err}`);
     }
-
-    async update(u: User): Promise<User> {
-        try {
-
-            const conn = await client.connect()
-            const sql = 'UPDATE users SET firstname=$1, lastName=$2, username=$3, password=$4 WHERE id=$5 RETURNING *'
-            const hash = bcrypt.hashSync(
-                u.password + pepper,
-                parseInt(saltRounds as string, 10)
-            )
-
-            const result = await conn.query(sql, [u.firstname, u.lastname, u.username, hash, u.id])
-            const user = result.rows[0]
-
-            conn.release()
-
-            return user
-
-        } catch (err) {
-            throw new Error(`Could not update user ${u.firstname}. Error: ${err}`)
-        }
+  }
+
+  async update(u: User): Promise<User> {
+    try {
+      const conn = await client.connect();
+      const sql =
+        "UPDATE users SET firstname=$1, lastName=$2, username=$3, password=$4 WHERE id=$5 RETURNING *";
+      const hash = bcrypt.hashSync(
+        u.password + pepper,
+        parseInt(saltRounds as string, 10)
+      );
+
+      const result = await conn.query(sql, [
+        u.firstname,
+        u.lastname,
+        u.username,
+        hash,
+        u.id,
+      ]);
+      const user = result.rows[0];
+
+      conn.release();
+
+      return user;
+    } catch (err) {
+      throw new Error(`Could not update user ${u.firstname}. Error: ${err}`);
     }
+  }
 
-    async delete(id: Number): Promise<User> {
-        try {
-
-            const conn = await client.connect()
-            const sql = 'DELETE FROM users WHERE id=($1)'
-            
-            const result = await conn.query(sql, [id])
-            const user = result.rows[0]
+  async delete(id: Number): Promise<User> {
+    try {
+      const conn = await client.connect();
+      const sql = "DELETE FROM users WHERE id=($1)";
 
-            conn.release()
+      const result = await conn.query(sql, [id]);
+      const user = result.rows[0];
 
-            return user
-
-        } catch (err) {
-            throw new Error(`Could not delete user ${id}. Error: ${err}`)
-        }
+      conn.release();
 
+      return user;
+    } catch (err) {
+      throw new Error(`Could not delete user ${id}. Error: ${err}`);
     }
+  }
 
-    async authenticate(username: string, password: string): Promise<User | null> {
-        try {
-
-            const conn = await client.connect()
-            //const sql = 'SELECT password FROM users WHERE username=($1)'
-            const sql = 'SELECT * FROM users WHERE username=($1)'
-
-            const result = await conn.query(sql, [username])
+  async authenticate(username: string, password: string): Promise<User | null> {
+    try {
+      const conn = await client.connect();
+      //const sql = 'SELECT password FROM users WHERE username=($1)'
+      const sql = "SELECT * FROM users WHERE username=($1)";
 
-            if(result.rows.length) {
-                const user = result.rows[0]
-               
+      const result = await conn.query(sql, [username]);
 
-                if (bcrypt.compareSync(password + pepper, user.password)) {
-                    return user
-                }
-            }
+      if (result.rows.length) {
+        const user = result.rows[0];
 
-            conn.release()
+        if (bcrypt.compareSync(password + pepper, user.password)) {
+          return user;
+        }
+      }
 
-            return null
+      conn.release();
 
-        } catch (err) {
-            throw new Error(`Could not find user ${username}. Error: ${err}`)
-        }
+      return null;
+    } catch (err) {
+      throw new Error(`Could not find user ${username}. Error: ${err}`);
     }
+  }
 }
-
diff --git a/src/server.ts b/src/server.ts
index 3fc7d34..906f703 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -1,29 +1,27 @@
-import express, { Request, Response } from 'express'
-import bodyParser from 'body-parser'
+import express, { Request, Response } from "express";
+import bodyParser from "body-parser";
 
-import productRoutes from './handlers/products'
-import userRoutes from './handlers/users'
-import orderRoutes from './handlers/orders'
+import productRoutes from "./handlers/products";
+import userRoutes from "./handlers/users";
+import orderRoutes from "./handlers/orders";
 
-const app: express.Application = express()
-const address: string = "0.0.0.0:3000"
+const app: express.Application = express();
+const address: string = "0.0.0.0:3000";
 const port = 3000;
 
-app.use(bodyParser.json())
+app.use(bodyParser.json());
 
-app.get('/', function (req: Request, res: Response) {
-    res.send('Main API')
-})
+app.get("/", function (req: Request, res: Response) {
+  res.send("Main API");
+});
 
-productRoutes(app)
-userRoutes(app)
-orderRoutes(app)
+productRoutes(app);
+userRoutes(app);
+orderRoutes(app);
 
 // Start express server
 app.listen(port, function () {
-    console.log(`starting app on: ${address}`)
-})
-
-
+  console.log(`starting app on: ${address}`);
+});
 
 export default app;
diff --git a/src/tests/handlers/orders_spec.ts b/src/tests/handlers/orders_spec.ts
index cd557f3..30f6e4c 100644
--- a/src/tests/handlers/orders_spec.ts
+++ b/src/tests/handlers/orders_spec.ts
@@ -1,89 +1,85 @@
-import supertest from "supertest"
-import app from "../../server"
-import { Product } from '../../models/product'
-import { User } from '../../models/user'
-import { Order, OrderProduct } from '../../models/order'
+import supertest from "supertest";
+import app from "../../server";
+import { Product } from "../../models/product";
+import { User } from "../../models/user";
+import { Order, OrderProduct } from "../../models/order";
 
-const token  = process.env.TOKEN_SECRET_TEST as string
+const token = process.env.TOKEN_SECRET_TEST as string;
 const request = supertest(app);
 
 const testProduct: Product = {
-    id: 3,
-    name: "metro",
-    price: 10
-}
+  id: 3,
+  name: "metro",
+  price: 10,
+};
 
 const testUser: User = {
-    id: 3,
-    firstname: 'John',
-    lastname: 'Doe',
-    username: 'Jd',
-    password:  'password'
-}
+  id: 3,
+  firstname: "John",
+  lastname: "Doe",
+  username: "Jd",
+  password: "password",
+};
 
 const testOrder: Order = {
-    status: "active",
-    user_id: 3
-}
+  status: "active",
+  user_id: 3,
+};
 
 const testOrderProduct: OrderProduct = {
-    id: 2,
-    quantity: 5,
-    order_id: 2,
-    product_id: 3
-}
+  id: 2,
+  quantity: 5,
+  order_id: 2,
+  product_id: 3,
+};
 
 describe("Order handler", () => {
-
-  beforeAll( async () => {
+  beforeAll(async () => {
     const product = await request
-    .post('/products')
-    .auth(token, {type: "bearer"})
-    .send(testProduct)
+      .post("/products")
+      .auth(token, { type: "bearer" })
+      .send(testProduct);
 
     const user = await request
-    .post('/users')
-    .auth(token, {type: "bearer"})
-    .send(testUser)
-  })
+      .post("/users")
+      .auth(token, { type: "bearer" })
+      .send(testUser);
+  });
 
-  it('Should create a new order', async () => {
+  it("Should create a new order", async () => {
     const response = await request
-    .post("/orders")
-    .auth(token, {type: "bearer"})
-    .send(testOrder)
+      .post("/orders")
+      .auth(token, { type: "bearer" })
+      .send(testOrder);
 
-    expect(response.status).toBe(200)
-  })
+    expect(response.status).toBe(200);
+  });
 
-  it('Should index orders', async () => {
-      const response = await request
-      .get("/orders")
+  it("Should index orders", async () => {
+    const response = await request.get("/orders");
 
-      expect(response.status).toBe(200)
-  })
+    expect(response.status).toBe(200);
+  });
 
-  it('Should get order by id', async () => {
-    const response = await request
-    .get("/orders/2")
+  it("Should get order by id", async () => {
+    const response = await request.get("/orders/2");
 
-    expect(response.status).toBe(200)
-  })
-  it('Should add a new product to order', async () => {
-      const response = await request
-      .post('/orders/2/products')
-      .auth(token, {type: 'bearer'})
-      .send(testOrderProduct)
+    expect(response.status).toBe(200);
+  });
+  it("Should add a new product to order", async () => {
+    const response = await request
+      .post("/orders/2/products")
+      .auth(token, { type: "bearer" })
+      .send(testOrderProduct);
 
-      expect(response.status).toBe(200)
-  })
+    expect(response.status).toBe(200);
+  });
 
-  it('Should delete order', async () => {
+  it("Should delete order", async () => {
     const response = await request
-    .delete('/orders/2/products')
-    .auth(token, {type: 'bearer'})
-
-    expect(response.status).toBe(200)
-})
+      .delete("/orders/2/products")
+      .auth(token, { type: "bearer" });
 
-})
\ No newline at end of file
+    expect(response.status).toBe(200);
+  });
+});
diff --git a/src/tests/handlers/products_spec.ts b/src/tests/handlers/products_spec.ts
index b4e469c..06632ff 100644
--- a/src/tests/handlers/products_spec.ts
+++ b/src/tests/handlers/products_spec.ts
@@ -1,64 +1,57 @@
-import supertest from "supertest"
-import app from "../../server"
-import { Product } from '../../models/product'
+import supertest from "supertest";
+import app from "../../server";
+import { Product } from "../../models/product";
 
-
-
-const token  = process.env.TOKEN_SECRET_TEST as string
+const token = process.env.TOKEN_SECRET_TEST as string;
 const request = supertest(app);
 
 const testProduct: Product = {
-    name: "metro",
-    price: 10
-}
+  name: "metro",
+  price: 10,
+};
 
 const updatedProduct: Product = {
-    name: "1984",
-    price: 5
-}
-
-
+  name: "1984",
+  price: 5,
+};
 
 describe("Product handler", () => {
-
-    console.log("PRODUCT")
-    it('Should create a new product', async () => {
-       const response = await request
+  console.log("PRODUCT");
+  it("Should create a new product", async () => {
+    const response = await request
       .post("/products")
       .auth(token, { type: "bearer" })
       .send(testProduct);
 
-       expect(response.status).toBe(200);
-    })
+    expect(response.status).toBe(200);
+  });
 
-    it('Should index products', async () => {
-        const response = await request
-       .get("/products")
- 
-        expect(response.status).toBe(200);
-    })
+  it("Should index products", async () => {
+    const response = await request.get("/products");
+
+    expect(response.status).toBe(200);
+  });
+
+  it("Should get product by id", async () => {
+    const response = await request.get("/products/1");
+
+    expect(response.status).toBe(200);
+  });
+
+  it("Should update product with id", async () => {
+    const response = await request
+      .put("/products/1")
+      .auth(token, { type: "bearer" })
+      .send(updatedProduct);
 
-    it('Should get product by id', async () => {
-        const response = await request
-       .get("/products/1")
- 
-        expect(response.status).toBe(200);
-    })
+    expect(response.status).toBe(200);
+  });
 
-    it('Should update product with id', async () => {
-        const response = await request
-       .put("/products/1")
-       .auth(token, { type: 'bearer'})
-       .send(updatedProduct)
- 
-        expect(response.status).toBe(200);
-    })
+  it("Should delete product with id", async () => {
+    const response = await request
+      .delete("/products/1")
+      .auth(token, { type: "bearer" });
 
-    it('Should delete product with id', async () => {
-        const response = await request
-       .delete("/products/1")
-       .auth(token, { type: 'bearer'})
- 
-        expect(response.status).toBe(200);
-    })
-})
\ No newline at end of file
+    expect(response.status).toBe(200);
+  });
+});
diff --git a/src/tests/handlers/users_spec.ts b/src/tests/handlers/users_spec.ts
index fc22ac3..6aaf876 100644
--- a/src/tests/handlers/users_spec.ts
+++ b/src/tests/handlers/users_spec.ts
@@ -1,75 +1,74 @@
-import supertest from "supertest"
-import app from "../../server"
-import { User } from '../../models/user'
+import supertest from "supertest";
+import app from "../../server";
+import { User } from "../../models/user";
 
-const token  = process.env.TOKEN_SECRET_TEST as string
+const token = process.env.TOKEN_SECRET_TEST as string;
 const request = supertest(app);
 
 const testUser: User = {
-    id: 1,
-    firstname: 'John',
-    lastname: 'Doe',
-    username: 'Jd',
-    password:  'password'
-}
+  id: 1,
+  firstname: "John",
+  lastname: "Doe",
+  username: "Jd",
+  password: "password",
+};
 
 describe("Users handler", () => {
-    it('Should create a new user', async () => {
-        const response = await request
-        .post("/users")
-        .auth(token, {type: "bearer"})
-        .send(testUser);
+  it("Should create a new user", async () => {
+    const response = await request
+      .post("/users")
+      .auth(token, { type: "bearer" })
+      .send(testUser);
 
-        expect(response.status).toBe(200)
-    })
+    expect(response.status).toBe(200);
+  });
 
-    it('Should authenticate a user', async () => {
-        const response = await request
-        .post("/users/auth")
-        .auth(token, {type: "bearer"})
-        .send(testUser);
+  it("Should authenticate a user", async () => {
+    const response = await request
+      .post("/users/auth")
+      .auth(token, { type: "bearer" })
+      .send(testUser);
 
-        expect(response.status).toBe(200)
-    })
+    expect(response.status).toBe(200);
+  });
 
-    it('Should index users', async () => {
-        const response = await request
-        .get("/users")
-        .auth(token, {type: "bearer"})
-        
-        expect(response.status).toBe(200)
-    })
+  it("Should index users", async () => {
+    const response = await request
+      .get("/users")
+      .auth(token, { type: "bearer" });
 
-    it('Should get user by id', async () => {
-        const response = await request
-        .get("/users/1")
-        .auth(token, {type: "bearer"})
+    expect(response.status).toBe(200);
+  });
 
-        expect(response.status).toBe(200)
-    })
+  it("Should get user by id", async () => {
+    const response = await request
+      .get("/users/1")
+      .auth(token, { type: "bearer" });
 
-    it('Should update a user', async () => {
-        const updatedUser = {
-            id: 1,
-            firstname: 'Sara',
-            lastname: 'Doe',
-            username: 'Sd',
-            password:  'password123'
-        }
-        const response = await request
-        .put("/users/1")
-        .auth(token, {type: 'bearer'})
-        .send(updatedUser)
+    expect(response.status).toBe(200);
+  });
 
-        expect(response.status).toBe(200)
-    })
+  it("Should update a user", async () => {
+    const updatedUser = {
+      id: 1,
+      firstname: "Sara",
+      lastname: "Doe",
+      username: "Sd",
+      password: "password123",
+    };
+    const response = await request
+      .put("/users/1")
+      .auth(token, { type: "bearer" })
+      .send(updatedUser);
 
-    it('Should delete a user by id', async () => {
+    expect(response.status).toBe(200);
+  });
 
-        const response = await request
-        .delete("/users/1")
-        .auth(token, {type: 'bearer'})
+  it("Should delete a user by id", async () => {
+    const response = await request
+      .delete("/users/1")
+      .auth(token, { type: "bearer" });
 
-        expect(response.status).toBe(200)
-    })
-})
\ No newline at end of file
+    expect(response.status).toBe(200);
+  });
+});
diff --git a/src/tests/models/order_spec.ts b/src/tests/models/order_spec.ts
index bc52af3..c21c6be 100644
--- a/src/tests/models/order_spec.ts
+++ b/src/tests/models/order_spec.ts
@@ -1,98 +1,90 @@
-import { User, UserStore } from '../../models/user'
-import { Product, ProductStore } from '../../models/product';
-import { Order, OrderProduct, OrderStore } from '../../models/order'
+import { User, UserStore } from "../../models/user";
+import { Product, ProductStore } from "../../models/product";
+import { Order, OrderProduct, OrderStore } from "../../models/order";
 
-const orderStore = new OrderStore()
-const userStore = new UserStore()
-const productStore = new ProductStore()
+const orderStore = new OrderStore();
+const userStore = new UserStore();
+const productStore = new ProductStore();
 
 const testProduct: Product = {
-    id: 2,
-    name: '1984',
-    price: 5
-}
+  id: 2,
+  name: "1984",
+  price: 5,
+};
 
 const testUser: User = {
-    id: 2,
-    firstname: 'John',
-    lastname: 'Doe',
-    username: 'Jd',
-    password:  'password'
-}
+  id: 2,
+  firstname: "John",
+  lastname: "Doe",
+  username: "Jd",
+  password: "password",
+};
 
 const testOrder: Order = {
-    id: 1,
-    status: "active",
-    user_id: 2
-}
+  id: 1,
+  status: "active",
+  user_id: 2,
+};
 
 const testOrderProduct: OrderProduct = {
-    id: 1,
-    quantity: 5,
-    order_id: 1,
-    product_id: 2
-}
+  id: 1,
+  quantity: 5,
+  order_id: 1,
+  product_id: 2,
+};
 
 describe("Order model", () => {
-    
-    beforeAll(async () => {
-        await productStore.create(testProduct)
-        await userStore.create(testUser)
-    })
-    
-    console.log('ORDER')
-    it('Should have an index method', () => {
-        expect(orderStore.index).toBeDefined();
-    });
-
-    it('Should have a read method', () => {
-        expect(orderStore.read).toBeDefined;
-    });
-
-    it('Should have a create method', () => {
-        expect(orderStore.create).toBeDefined;
-    });
-
-    it('Should have a update method', () => {
-        expect(orderStore.addProduct).toBeDefined;
-    });
-
-    it('Create method should add a new order', async () => {
-        const result = await orderStore.create(testOrder)
-        expect(result).toEqual(testOrder)
-    });
-
-    it('Index method should return a list of orders', async () => {
-        const result = await orderStore.index();
-        expect(result[0]).toEqual(testOrder)
-    })
-
-    
-    it('Read method should return a order', async () => {
-        const result = await orderStore.read(2);
-        expect(result).toEqual(testOrder)
-    })
-
-    
-    it('addProduct should add a new product to order', async () => {
-        const result = await orderStore.addProduct(testOrderProduct)
-        expect(result).toEqual(testOrderProduct)
-    })
-
-    it('deleteProduct should delete product from order', async () => {
-        const result = await orderStore.deleteProduct(1)
-        
-        const checkorder = await orderStore.index()
-        expect(checkorder).toEqual([])
-
-    })
-
-
-
-    afterAll(async () => {
-        await productStore.delete(1)
-        await userStore.delete(1)
-    })
-
-
-});
\ No newline at end of file
+  beforeAll(async () => {
+    await productStore.create(testProduct);
+    await userStore.create(testUser);
+  });
+
+  console.log("ORDER");
+  it("Should have an index method", () => {
+    expect(orderStore.index).toBeDefined();
+  });
+
+  it("Should have a read method", () => {
+    expect(orderStore.read).toBeDefined;
+  });
+
+  it("Should have a create method", () => {
+    expect(orderStore.create).toBeDefined;
+  });
+
+  it("Should have a update method", () => {
+    expect(orderStore.addProduct).toBeDefined;
+  });
+
+  it("Create method should add a new order", async () => {
+    const result = await orderStore.create(testOrder);
+    expect(result).toEqual(testOrder);
+  });
+
+  it("Index method should return a list of orders", async () => {
+    const result = await orderStore.index();
+    expect(result[0]).toEqual(testOrder);
+  });
+
+  it("Read method should return a order", async () => {
+    const result = await orderStore.read(2);
+    expect(result).toEqual(testOrder);
+  });
+
+  it("addProduct should add a new product to order", async () => {
+    const result = await orderStore.addProduct(testOrderProduct);
+    expect(result).toEqual(testOrderProduct);
+  });
+
+  it("deleteProduct should delete product from order", async () => {
+    const result = await orderStore.deleteProduct(1);
+
+    const checkorder = await orderStore.index();
+    expect(checkorder).toEqual([]);
+  });
+
+  afterAll(async () => {
+    await productStore.delete(1);
+    await userStore.delete(1);
+  });
+});
diff --git a/src/tests/models/product_spec.ts b/src/tests/models/product_spec.ts
index 3c9eff1..15e6d8e 100644
--- a/src/tests/models/product_spec.ts
+++ b/src/tests/models/product_spec.ts
@@ -1,73 +1,68 @@
-import { Product, ProductStore } from '../../models/product'
+import { Product, ProductStore } from "../../models/product";
 
-const store = new ProductStore()
+const store = new ProductStore();
 
 const testProduct: Product = {
-    id: 1,
-    name: '1984',
-    price: 5,
-}
+  id: 1,
+  name: "1984",
+  price: 5,
+};
 
 const updatedProduct: Product = {
-    id: 1,
-    name: 'The Dark Tower',
-    price: 7
-}
+  id: 1,
+  name: "The Dark Tower",
+  price: 7,
+};
 
 describe("Product model", () => {
-    it('Should have an index method', () => {
-        expect(store.index).toBeDefined();
+  it("Should have an index method", () => {
+    expect(store.index).toBeDefined();
+  });
+
+  it("Should have a read method", () => {
+    expect(store.read).toBeDefined;
+  });
+
+  it("Should have a create method", () => {
+    expect(store.create).toBeDefined;
+  });
+
+  it("Should have a update method", () => {
+    expect(store.update).toBeDefined;
+  });
+
+  it("Should have a delete method", () => {
+    expect(store.delete).toBeDefined;
+  });
+
+  it("Create method should add a product", async () => {
+    const result = await store.create(testProduct);
+    expect(result).toEqual(testProduct);
+  });
+
+  it("Index method should return a list of products", async () => {
+    const result = await store.index();
+    expect(result).toEqual([testProduct]);
+  });
+
+  it("Read method should return a product", async () => {
+    const result = await store.read(1);
+    expect(result).toEqual(testProduct);
+  });
+
+  it("Update method should update a product", async () => {
+    const result = await store.update(updatedProduct);
+    expect(result).toEqual({
+      id: 1,
+      name: "The Dark Tower",
+      price: 7,
     });
+  });
 
-    it('Should have a read method', () => {
-        expect(store.read).toBeDefined;
-    });
-
-    it('Should have a create method', () => {
-        expect(store.create).toBeDefined;
-    });
-
-    it('Should have a update method', () => {
-        expect(store.update).toBeDefined;
-    });
-
-    it('Should have a delete method', () => {
-        expect(store.delete).toBeDefined;
-    });
-
-
-    it('Create method should add a product', async () => {
-        const result = await store.create(testProduct);
-        expect(result).toEqual(testProduct);
-    });
+  it("Delete method should remove the product", async () => {
+    store.delete(1);
+    const result = await store.index();
 
-    it('Index method should return a list of products', async () => {
-        const result = await store.index();
-        expect(result).toEqual([testProduct]);
-        
-    });
-
-    it('Read method should return a product', async () => {
-        const result = await store.read(1);
-        expect(result).toEqual(testProduct);
-        
-    });
-
-    it('Update method should update a product', async () => {
-        const result = await store.update(updatedProduct);
-        expect(result).toEqual({
-            id: 1,
-            name: 'The Dark Tower',
-            price: 7,
-        });
-        
-    });
-
-    it('Delete method should remove the product', async () => {
-        store.delete(1);
-        const result = await store.index()
-
-        expect(result).toEqual([]);
-    });
+    expect(result).toEqual([]);
+  });
 });
-
diff --git a/src/tests/models/user_spec.ts b/src/tests/models/user_spec.ts
index c0d5bdc..7525ed4 100644
--- a/src/tests/models/user_spec.ts
+++ b/src/tests/models/user_spec.ts
@@ -1,110 +1,111 @@
-import { User, UserStore } from '../../models/user'
-import bcrypt from 'bcrypt'
+import { User, UserStore } from "../../models/user";
+import bcrypt from "bcrypt";
 
+const { BCRYPT_PASSWORD } = process.env;
+const pepper = BCRYPT_PASSWORD;
 
-const { BCRYPT_PASSWORD } = process.env
-const pepper = BCRYPT_PASSWORD
-
-
-const store = new UserStore()
+const store = new UserStore();
 
 const testUser: User = {
-    id: 1,
-    firstname: 'John',
-    lastname: 'Doe',
-    username: 'Jd',
-    password:  'password'
-}
+  id: 1,
+  firstname: "John",
+  lastname: "Doe",
+  username: "Jd",
+  password: "password",
+};
 
 const updatedUser: User = {
-    id: 1,
-    firstname: 'Sara',
-    lastname: 'Doe',
-    username: 'Sd',
-    password:  'password123'
-}
+  id: 1,
+  firstname: "Sara",
+  lastname: "Doe",
+  username: "Sd",
+  password: "password123",
+};
 
 describe("User model", () => {
-    console.log("USER")
-    it('Should have an index method', () => {
-        expect(store.index).toBeDefined();
-    });
-
-    it('Should have a read method', () => {
-        expect(store.read).toBeDefined;
-    });
-
-    it('Should have a create method', () => {
-        expect(store.create).toBeDefined;
-    });
-
-    it('Should have a update method', () => {
-        expect(store.update).toBeDefined;
-    });
-
-    it('Should have a delete method', () => {
-        expect(store.delete).toBeDefined;
-    });
-
-    it('Create method should create a new user', async () => {
-        const result = await store.create(testUser);
-
-        expect(result.firstname).toEqual(testUser.firstname)
-        expect(result.lastname).toEqual(testUser.lastname)
-        expect(result.username).toEqual(testUser.username)
-        expect(bcrypt.compareSync(testUser.password + pepper, result.password)).toBeTrue
-    })
-
-
-
-    it('Index method should should return a list of users', async () => {
-
-        
-        const result = await store.index();
-        expect(result[0].firstname).toEqual(testUser.firstname)
-        expect(result[0].lastname).toEqual(testUser.lastname)
-        expect(result[0].username).toEqual(testUser.username)
-        expect(bcrypt.compareSync(testUser.password + pepper, result[0].password)).toBeTrue
-    })
-
-    it('Read method should return user', async () => {
-        const result = await store.read(1);
-
-        expect(result.firstname).toEqual(testUser.firstname)
-        expect(result.lastname).toEqual(testUser.lastname)
-        expect(result.username).toEqual(testUser.username)
-        expect(bcrypt.compareSync(testUser.password + pepper, result.password)).toBeTrue
-    })
-
-    it('Authenticate method', async () => {
-        const authUser = {
-            username: 'Jd',
-            password: 'password'
-        }
-        const result = await store.authenticate(authUser.username, authUser.password);
-
-        if (result) {
-            expect(result.firstname).toEqual(testUser.firstname)
-            expect(result.lastname).toEqual(testUser.lastname)
-            expect(result.username).toEqual(testUser.username)
-            expect(bcrypt.compareSync(testUser.password + pepper, result.password)).toBeTrue
-        }
-        
-    })
-
-    it('Update method should create a new user', async () => {
-        const result = await store.update(updatedUser);
-
-        expect(result.firstname).toEqual(updatedUser.firstname)
-        expect(result.lastname).toEqual(updatedUser.lastname)
-        expect(result.username).toEqual(updatedUser.username)
-        expect(bcrypt.compareSync(updatedUser.password + pepper, result.password)).toBeTrue
-    })
-
-    it('Delete method should delete a user by Id', async () => {
-        const result = await store.delete(1);
-        const checkUsers = await store.index()
-
-        expect(checkUsers).toEqual([])
-    })
-})
\ No newline at end of file
+  console.log("USER");
+  it("Should have an index method", () => {
+    expect(store.index).toBeDefined();
+  });
+
+  it("Should have a read method", () => {
+    expect(store.read).toBeDefined;
+  });
+
+  it("Should have a create method", () => {
+    expect(store.create).toBeDefined;
+  });
+
+  it("Should have a update method", () => {
+    expect(store.update).toBeDefined;
+  });
+
+  it("Should have a delete method", () => {
+    expect(store.delete).toBeDefined;
+  });
+
+  it("Create method should create a new user", async () => {
+    const result = await store.create(testUser);
+
+    expect(result.firstname).toEqual(testUser.firstname);
+    expect(result.lastname).toEqual(testUser.lastname);
+    expect(result.username).toEqual(testUser.username);
+    expect(bcrypt.compareSync(testUser.password + pepper, result.password))
+      .toBeTrue;
+  });
+
+  it("Index method should should return a list of users", async () => {
+    const result = await store.index();
+    expect(result[0].firstname).toEqual(testUser.firstname);
+    expect(result[0].lastname).toEqual(testUser.lastname);
+    expect(result[0].username).toEqual(testUser.username);
+    expect(bcrypt.compareSync(testUser.password + pepper, result[0].password))
+      .toBeTrue;
+  });
+
+  it("Read method should return user", async () => {
+    const result = await store.read(1);
+
+    expect(result.firstname).toEqual(testUser.firstname);
+    expect(result.lastname).toEqual(testUser.lastname);
+    expect(result.username).toEqual(testUser.username);
+    expect(bcrypt.compareSync(testUser.password + pepper, result.password))
+      .toBeTrue;
+  });
+
+  it("Authenticate method", async () => {
+    const authUser = {
+      username: "Jd",
+      password: "password",
+    };
+    const result = await store.authenticate(
+      authUser.username,
+      authUser.password
+    );
+
+    if (result) {
+      expect(result.firstname).toEqual(testUser.firstname);
+      expect(result.lastname).toEqual(testUser.lastname);
+      expect(result.username).toEqual(testUser.username);
+      expect(bcrypt.compareSync(testUser.password + pepper, result.password))
+        .toBeTrue;
+    }
+  });
+
+  it("Update method should create a new user", async () => {
+    const result = await store.update(updatedUser);
+
+    expect(result.firstname).toEqual(updatedUser.firstname);
+    expect(result.lastname).toEqual(updatedUser.lastname);
+    expect(result.username).toEqual(updatedUser.username);
+    expect(bcrypt.compareSync(updatedUser.password + pepper, result.password))
+      .toBeTrue;
+  });
+
+  it("Delete method should delete a user by Id", async () => {
+    const result = await store.delete(1);
+    const checkUsers = await store.index();
+
+    expect(checkUsers).toEqual([]);
+  });
+});