added user_spec

migrations/sqls/20220520025053-shelf-up.sql

@@ -10,7 +10,7 @@ CREATE TABLE users (
   firstName         VARCHAR(250) NOT NULL,
   lastName          VARCHAR(250) NOT NULL,
   username          VARCHAR(250) NOT NULL,
-  password_digest   VARCHAR(250) NOT NULL
+  password   VARCHAR(250) NOT NULL
 );
 
 CREATE TABLE orders (

src/models/user.ts

@@ -53,7 +53,7 @@ export class UserStore {
         try {
 
             const conn = await client.connect()
-            const sql = 'INSERT INTO users (firstname, lastname, username, password_digest) VALUES ($1, $2, $3, $4) RETURNING *'
+            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)
@@ -75,7 +75,7 @@ export class UserStore {
         try {
 
             const conn = await client.connect()
-            const sql = 'UPDATE users SET firstname=$1, lastName=$2, username=$3, password_digest=$4 WHERE id=$5 RETURNING *'
+            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)
@@ -116,16 +116,16 @@ export class UserStore {
         try {
 
             const conn = await client.connect()
-            const sql = 'SELECT password_digest FROM users WHERE username=($1)'
+            //const sql = 'SELECT password FROM users WHERE username=($1)'
+            const sql = 'SELECT * FROM users WHERE username=($1)'
 
             const result = await conn.query(sql, [username])
-            console.log("password + pepper :", password + pepper )
 
             if(result.rows.length) {
                 const user = result.rows[0]
-                console.log(user)
+               
 
-                if (bcrypt.compareSync(password + pepper, user.password_digest)) {
+                if (bcrypt.compareSync(password + pepper, user.password)) {
                     return user
                 }
             }

src/tests/models/product_spec.ts

@@ -7,14 +7,23 @@ describe("Product model", () => {
         expect(store.index).toBeDefined();
     });
 
+    it('Should have a read method', () => {
+        expect(store.read).toBeDefined;
+    });
+
     it('Should have a create method', () => {
-        expect(store.index).toBeDefined;
+        expect(store.create).toBeDefined;
     });
 
     it('Should have a update method', () => {
-        expect(store.index).toBeDefined;
+        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({
             name: '1984',

src/tests/models/user_spec.ts

@@ -0,0 +1,109 @@
+import { UserStore } from '../../models/user'
+import bcrypt from 'bcrypt'
+
+
+const { BCRYPT_PASSWORD } = process.env
+const pepper = BCRYPT_PASSWORD
+
+
+const store = new UserStore()
+
+const newUser = {
+    id: 1,
+    firstname: 'John',
+    lastname: 'Doe',
+    username: 'Jd',
+    password:  'password'
+}
+
+describe("User model", () => {
+    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(newUser);
+
+        expect(result.firstname).toEqual(newUser.firstname)
+        expect(result.lastname).toEqual(newUser.lastname)
+        expect(result.username).toEqual(newUser.username)
+        expect(bcrypt.compareSync(newUser.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(newUser.firstname)
+        expect(result[0].lastname).toEqual(newUser.lastname)
+        expect(result[0].username).toEqual(newUser.username)
+        expect(bcrypt.compareSync(newUser.password + pepper, result[0].password)).toBeTrue
+    })
+
+    it('Read method should return user', async () => {
+        const result = await store.read(1);
+
+        expect(result.firstname).toEqual(newUser.firstname)
+        expect(result.lastname).toEqual(newUser.lastname)
+        expect(result.username).toEqual(newUser.username)
+        expect(bcrypt.compareSync(newUser.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(newUser.firstname)
+            expect(result.lastname).toEqual(newUser.lastname)
+            expect(result.username).toEqual(newUser.username)
+            expect(bcrypt.compareSync(newUser.password + pepper, result.password)).toBeTrue
+        }
+        
+    })
+
+    it('Update method should create a new user', async () => {
+        const updatedUser = {
+            id: 1,
+            firstname: 'Sara',
+            lastname: 'Doe',
+            username: 'Sd',
+            password:  'password123'
+        }
+
+        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(newUser.id);
+        const checkUsers = await store.index()
+
+        expect(checkUsers).toEqual([])
+    })
+})