From 83d9b14e10a6188e08da9c0a3e4feddc928558e1 Mon Sep 17 00:00:00 2001
From: Benny Ogidan <bennyogidan@Andelas-MacBook-Pro.local>
Date: Wed, 3 Jan 2018 12:54:19 +0100
Subject: [PATCH] fix(tests): Implement test in a more streamlined manner

- describe block for implemented for all tests
- extra tests implemented for new authenticated routes
- Coverage for client side back up to 95 %
- Naming conventions changed to correct case
- Test cases refactored to improve test

- TestHook introduced to implement better seeding of token
---
 .eslintrc                                     |   4 +
 server/src/app.js                             |   9 +-
 server/src/controllers/user.js                |  10 +-
 server/src/routes/.hound.yml                  |   4 -
 .../seeders/{seedbooks.js => seedBooks.js}    |   0
 .../{seedcategories.js => seedCategories.js}  |   0
 .../seeders/{seedlevels.js => seedLevels.js}  |   0
 .../seeders/{seedusers.js => seedUsers.js}    |   4 +-
 server/src/test/authenticate.spec.js          | 463 +++++++++++-
 server/src/test/books.spec.js                 | 323 +++++----
 server/src/test/categories.spec.js            | 400 ++++++-----
 server/src/test/helpers/testHooks.js          |  40 ++
 server/src/test/index.spec.js                 |   2 +-
 server/src/test/notifications.spec.js         |  31 +-
 server/src/test/user.spec.js                  | 662 ++++++------------
 server/src/test/userBooks.spec.js             | 351 +++++-----
 16 files changed, 1303 insertions(+), 1000 deletions(-)
 delete mode 100644 server/src/routes/.hound.yml
 rename server/src/seeders/{seedbooks.js => seedBooks.js} (100%)
 rename server/src/seeders/{seedcategories.js => seedCategories.js} (100%)
 rename server/src/seeders/{seedlevels.js => seedLevels.js} (100%)
 rename server/src/seeders/{seedusers.js => seedUsers.js} (89%)
 create mode 100644 server/src/test/helpers/testHooks.js

diff --git a/.eslintrc b/.eslintrc
index 690dfca..0c335cf 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -44,6 +44,10 @@
 			80,
 			2
 		],
+		"max-nested-callbacks": [2, 7],
+    "max-depth": [2, {
+      "max": 2
+    }],
 		"import/no-unresolved": [
 			2,
 			{
diff --git a/server/src/app.js b/server/src/app.js
index 3ec635e..d27e278 100644
--- a/server/src/app.js
+++ b/server/src/app.js
@@ -19,21 +19,22 @@ app.use(logger('dev'));
 app.use(bodyParser.json());
 app.use(bodyParser.urlencoded({ extended: false }));
 
-app.use('/api-docs', express.static(path.join(__dirname, '../../apiDocs/')));
+app.use('/apiDocs', express.static(path.join(__dirname, '../../apiDocs/')));
 app.use(express.static(path.join(__dirname, '../../client/dist/app')));
 
 app.use((req, res, next) => {
   res.header(
     'Access-Control-Allow-Headers',
     'Authorization, X-PINGOTHER, Origin, X-Requested-With,' +
-     'Content-Type, Accept, x-ac' +
-      'cess-token'
+     'Content-Type, Accept, x-access-token'
   );
   next();
 });
 
 app.use('/api/v1', authenticateRoutes, routes);
 
-app.get('*', (req, res) => res.sendFile(path.join(__dirname, '../../client/dist/app/index.html')));
+app
+  .get('*', (req, res) =>
+    res.sendFile(path.join(__dirname, '../../client/dist/app/index.html')));
 
 export default(app);
diff --git a/server/src/controllers/user.js b/server/src/controllers/user.js
index 2f905b4..440d25d 100644
--- a/server/src/controllers/user.js
+++ b/server/src/controllers/user.js
@@ -52,9 +52,9 @@ const userController = {
                 }).then((user) => {
                   if (user) {
                     res.status(201).send({
-                      message: `${user.username} has
-                       been added to the library, ` +
-                       'Please Login, you will be only required to do this once'
+                      message: `${user.username} has been added to 
+                      the library, 'Please Login, you will be only ` +
+                      'required to do this once'
                     });
                   }
                 });
@@ -179,8 +179,8 @@ const userController = {
           return res.status(409)
             .send({
               message:
-              'Your current password does not match our records,'
-              + 'Please Re-enter'
+              'Your current password does not match our records, ' +
+              'Please Re-enter'
             });
         }
         const compareNewPasswords =
diff --git a/server/src/routes/.hound.yml b/server/src/routes/.hound.yml
deleted file mode 100644
index 9ad3511..0000000
--- a/server/src/routes/.hound.yml
+++ /dev/null
@@ -1,4 +0,0 @@
-eslint:
-  enabled: true
-  config_file: .eslintrc
-  ignore_file: .eslintignore
\ No newline at end of file
diff --git a/server/src/seeders/seedbooks.js b/server/src/seeders/seedBooks.js
similarity index 100%
rename from server/src/seeders/seedbooks.js
rename to server/src/seeders/seedBooks.js
diff --git a/server/src/seeders/seedcategories.js b/server/src/seeders/seedCategories.js
similarity index 100%
rename from server/src/seeders/seedcategories.js
rename to server/src/seeders/seedCategories.js
diff --git a/server/src/seeders/seedlevels.js b/server/src/seeders/seedLevels.js
similarity index 100%
rename from server/src/seeders/seedlevels.js
rename to server/src/seeders/seedLevels.js
diff --git a/server/src/seeders/seedusers.js b/server/src/seeders/seedUsers.js
similarity index 89%
rename from server/src/seeders/seedusers.js
rename to server/src/seeders/seedUsers.js
index fc0f9a6..e33e404 100644
--- a/server/src/seeders/seedusers.js
+++ b/server/src/seeders/seedUsers.js
@@ -1,5 +1,7 @@
 import faker from 'faker';
 
+require('dotenv').config();
+
 
 const bcrypt = require('bcrypt');
 
@@ -18,7 +20,7 @@ module.exports = {
       },
       {
         username: 'bennyogidan',
-        password: bcrypt.hashSync('bennyogidan', bcrypt.genSaltSync(10)),
+        password: bcrypt.hashSync(process.env.ADMIN_PASSWORD, bcrypt.genSaltSync(10)),
         email: 'benfluleck@gmail.com',
         firstname: 'Administrator',
         isAdmin: true,
diff --git a/server/src/test/authenticate.spec.js b/server/src/test/authenticate.spec.js
index ebf05a6..a9ae0ca 100644
--- a/server/src/test/authenticate.spec.js
+++ b/server/src/test/authenticate.spec.js
@@ -8,11 +8,11 @@ const { expect } = chai;
 
 chai.use(chaiHttp);
 
-let token = '';
+let userToken = '';
 const errorToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9';
 
 describe('Authentication', () => {
-  it('should return 401 if token is not a token', (done) => {
+  it('should return a 401 status code if token is not a token', (done) => {
     chai
       .request(app)
       .put('/api/v1/users/changepassword')
@@ -22,70 +22,493 @@ describe('Authentication', () => {
         expect(res.status)
           .to
           .equal(401);
+        expect(res.body.token)
+          .to.equal(null);
+        expect(res.body.message)
+          .to.equal("Unauthorised access");
         done();
       });
   });
-  it('should return 201 when a regular user is created', (done) => {
+  it(
+    'should return a 201 status code when a regular user is created',
+    (done) => {
+      chai
+        .request(app)
+        .post('/api/v1/auth/users/signup')
+        .set('Accept', 'application/x-www-form-urlencoded')
+        .send({
+          username: 'benogidan',
+          password: 'boooboo',
+          passwordConfirmation: 'boooboo',
+          firstname: 'Benny',
+          email: faker
+            .internet
+            .email(),
+          lastname: faker
+            .name
+            .lastName()
+        })
+        .end((err, res) => {
+          expect(res.status)
+            .to
+            .equal(201);
+          expect(res.body).to.be.a('object');
+          done();
+        });
+    }
+  );
+  it('should return 200 when a regular user signs in', (done) => {
+    chai
+      .request(app)
+      .post('/api/v1/auth/users/signin')
+      .set('Accept', 'application/x-www-form-urlencoded')
+      .send({ username: 'benogidan', password: 'boooboo' })
+      .end((err, res) => {
+        expect(res.status)
+          .to
+          .equal(200);
+        expect(res.body.username).to.equal('benogidan');
+        expect(res.body).to.be.a('object');
+        userToken = res.body.token;
+        done();
+      });
+  });
+  it('should return a 401 stus code if token is not an admin token', (done) => {
     chai
       .request(app)
+      .post('/api/v1/admin/category')
+      .set('x-access-token', userToken)
+      .send({ categoryName: 'EDUCATIONAL' })
+      .end((err, res) => {
+        expect(res.status)
+          .to
+          .equal(403);
+        expect(res.body.token)
+          .to.equal(undefined);
+        done();
+      });
+  });
+  it('should return 401 if there is an error with token', (done) => {
+    chai
+      .request(app)
+      .post('/api/v1/admin/category')
+      .set('x-access-token', errorToken)
+      .send({ categoryName: 'EDUCATIONAL' })
+      .end((err, res) => {
+        expect(res.status)
+          .to
+          .equal(401);
+        expect(res.body.token)
+          .to.equal(null);
+        expect(res.body.message)
+          .to.equal("Unauthorised access");
+        done();
+      });
+  });
+  it('should return 201 when a regular administrator is created', (done) => {
+    chai.request(app)
       .post('/api/v1/auth/users/signup')
       .set('Accept', 'application/x-www-form-urlencoded')
       .send({
-        username: 'benogidan',
+        username: 'testadmin',
         password: 'boooboo',
         passwordConfirmation: 'boooboo',
         firstname: 'Benny',
+        isAdmin: true,
+        email: faker.internet.email(),
+        lastname: faker.name.lastName()
+      })
+      .end((err, res) => {
+        expect(res.status).to.equal(201);
+        done();
+      });
+  });
+  it('should return 200 when a administrator signs in', (done) => {
+    chai.request(app)
+      .post('/api/v1/auth/users/signin')
+      .set('Accept', 'application/x-www-form-urlencoded')
+      .send({
+        username: 'testadmin',
+        password: 'boooboo'
+      })
+      .end((err, res) => {
+        expect(res.status).to.equal(200);
+        done();
+      });
+  });
+
+  it(
+    'should not log a user in with a wrong googleID',
+    (done) => {
+      const newUser = {
+        googleId: '345678976543'
+      };
+      chai.request(app)
+        .post('/api/v1/auth/users/signin')
+        .send(newUser)
+        .end((err, res) => {
+          expect(res.status).to.equal(500);
+          done();
+        });
+    }
+  );
+
+  it(
+    'should not log a user in with a wrong googleID with user details',
+    (done) => {
+      const newUser = {
+        googleId: '345678976543',
+        username: faker
+          .internet
+          .userName(),
         email: faker
           .internet
           .email(),
+        password: 'testpassword',
+        passwordConfirmation: 'testpassword'
+      };
+      chai.request(app)
+        .post('/api/v1/auth/users/signin')
+        .send(newUser)
+        .end((err, res) => {
+          expect(res.status).to.equal(400);
+          done();
+        });
+    }
+  );
+  it(
+    'should sign up users who fill the correct ' +
+    'parameters for the signup form',
+    (done) => {
+      const email = 'bo345@kent.ac.uk';
+      chai
+        .request(app)
+        .post('/api/v1/auth/users/signup')
+        .set('Accept', 'application/x-www-form-urlencoded')
+        .send({
+          firstname: faker
+            .name
+            .firstName(),
+          lastname: faker
+            .name
+            .lastName(),
+          username: 'samplename',
+          password: 'password',
+          passwordConfirmation: 'password',
+          email
+        })
+        .end((err, res) => {
+          expect(res.status)
+            .to
+            .equal(201);
+          done();
+        });
+    }
+  );
+  it('should throw a validation error for invalid user data', (done) => {
+    const email = faker
+      .internet
+      .email();
+    chai
+      .request(app)
+      .post('/api/v1/auth/users/signup')
+      .set('Accept', 'application/x-www-form-urlencoded')
+      .send({
+        firstname: faker
+          .name
+          .firstName(),
         lastname: faker
           .name
-          .lastName()
+          .lastName(),
+        password: 'password',
+        passwordConfirmation: 'password',
+        email
       })
       .end((err, res) => {
         expect(res.status)
           .to
-          .equal(201);
+          .equal(400);
         done();
       });
   });
-  it('should return 200 when a regular user signs in', (done) => {
+  it('should throw a validation error for invalid user data', (done) => {
+    const email = 'nenemail.com';
+    chai
+      .request(app)
+      .post('/api/v1/auth/users/signup')
+      .set('Accept', 'application/x-www-form-urlencoded')
+      .send({
+        firstname: faker
+          .name
+          .firstName(),
+        lastname: faker
+          .name
+          .lastName(),
+        username: faker
+          .internet
+          .userName(),
+        password: 'password',
+        passwordConfirmation: 'password',
+        email
+      })
+      .end((err, res) => {
+        expect(res.status)
+          .to
+          .equal(422);
+        done();
+      });
+  });
+  it(
+    'should reject authorization for users due to no token being defined',
+    (done) => {
+      chai
+        .request(app)
+        .post('/api/v1/users/books')
+        .end((err, res) => {
+          expect(res.status)
+            .to
+            .be
+            .equal(401);
+          done();
+        });
+    }
+  );
+  it(
+    'should respond with 404 status code if bad username or password',
+    (done) => {
+      chai
+        .request(app)
+        .post('/api/v1/auth/users/signin')
+        .set('Accept', 'application/x-www-form-urlencoded')
+        .send({
+          username: faker
+            .internet
+            .userName(),
+          password: faker
+            .internet
+            .password()
+        })
+        .end((err, res) => {
+          expect(res.status)
+            .to
+            .equal(404);
+          done();
+        });
+    }
+  );
+  it('should ensure all signup fields are required on sign up', (done) => {
+    chai
+      .request(app)
+      .post('/api/v1/auth/users/signup')
+      .set('Accept', 'application/x-www-form-urlencoded')
+      .send({
+        username: faker
+          .internet
+          .userName(),
+        email: faker
+          .internet
+          .email(),
+        password: 'testpassword',
+        passwordConfirmation: 'testpassword'
+      })
+      .end((err, res) => {
+        expect(res.body.message)
+          .to
+          .equal('Firstname is invalid');
+        expect(res.status)
+          .to
+          .equal(400);
+        done();
+      });
+  });
+  it('should throw a 404 error for Users that do not exist', (done) => {
     chai
       .request(app)
       .post('/api/v1/auth/users/signin')
       .set('Accept', 'application/x-www-form-urlencoded')
-      .send({ username: 'benogidan', password: 'boooboo' })
+      .send({ username: 'UnknownUser', password: 'error' })
       .end((err, res) => {
+        expect(res.body.message)
+          .to
+          .equal('UnknownUser does not exist, Make sure you are signed up');
         expect(res.status)
           .to
-          .equal(200);
-        token = res.body.token;
+          .equal(404);
         done();
       });
   });
-  it('should return 403 if token is not an admin token', (done) => {
+  it('should return a 400 error for an invalid password ', (done) => {
     chai
       .request(app)
-      .post('/api/v1/admin/category')
-      .set('x-access-token', token)
-      .send({ categoryName: 'EDUCATIONAL' })
+      .post('/api/v1/auth/users/signin')
+      .set('Accept', 'application/x-www-form-urlencoded')
+      .send({ username: 'Benny', password: '' })
       .end((err, res) => {
+        expect(res.body.message)
+          .to
+          .equal('Password is too short');
         expect(res.status)
           .to
-          .equal(403);
+          .equal(400);
         done();
       });
   });
-  it('should return 401 if error with token', (done) => {
+  it(
+    'should return a 404 error for an Invalid user',
+    (done) => {
+      chai
+        .request(app)
+        .post('/api/v1/auth/users/signin')
+        .set('Accept', 'application/x-www-form-urlencoded')
+        .send({ username: 'Benny', password: 'nnnnnnn' })
+        .end((err, res) => {
+          expect(res.body.message)
+            .to
+            .equal('Benny does not exist, Make sure you are signed up');
+          expect(res.status)
+            .to
+            .equal(404);
+          done();
+        });
+    }
+  );
+  it('should validate that a newly signed up user is unique', (done) => {
     chai
       .request(app)
-      .post('/api/v1/admin/category')
-      .set('x-access-token', errorToken)
-      .send({ categoryName: 'EDUCATIONAL' })
+      .post('/api/v1/auth/users/signup')
+      .set('Accept', 'application/x-www-form-urlencoded')
+      .send({
+        username: 'testuser',
+        firstname: 'Benn',
+        lastname: 'Nyotu',
+        email: 'ben@gmail.com',
+        password: 'benny',
+        passwordConfirmation: 'benny'
+      })
       .end((err, res) => {
         expect(res.status)
           .to
-          .equal(401);
+          .be
+          .equal(409);
+        expect(res.body.message).to.equal('This username is already in use');
+        done();
+      });
+  });
+  it('should validate that the new user\'s email as unique', (done) => {
+    chai
+      .request(app)
+      .post('/api/v1/auth/users/signup')
+      .set('Accept', 'application/x-www-form-urlencoded')
+      .send({
+        username: 'Homer',
+        firstname: 'Homer',
+        lastname: 'Simpson',
+        email: 'sample@email.com',
+        password: 'benny',
+        passwordConfirmation: 'benny'
+      })
+      .end((err, res) => {
+        expect(res.status)
+          .to
+          .be
+          .equal(409);
+        expect(res.body.message).to.equal('This email is already in use');
+        done();
+      });
+  });
+  it('should not create a user if the password does not match', (done) => {
+    chai
+      .request(app)
+      .post('/api/v1/auth/users/signup')
+      .set('Accept', 'application/x-www-form-urlencoded')
+      .send({
+        username: 'Homer',
+        firstname: 'Homer',
+        lastname: 'Simpson',
+        email: 'ben@gmail.com',
+        password: 'benny',
+        passwordConfirmation: 'benny23'
+      })
+      .end((err, res) => {
+        expect(res.status)
+          .to
+          .be
+          .equal(422);
+        done();
+      });
+  });
+  it(
+    'should return a successful login message ' +
+    'if user name and password are valid',
+    (done) => {
+      chai
+        .request(app)
+        .post('/api/v1/auth/users/signin')
+        .set('Accept', 'application/x-www-form-urlencoded')
+        .send({ username: 'testuser', password: 'testuser' })
+        .end((err, res) => {
+          expect('Content-Type', /json/);
+          expect(res.body)
+            .have
+            .property('message');
+          expect(res.body.message)
+            .to
+            .equal(' You are now logged in as testuser');
+          done();
+        });
+    }
+  );
+  it('should require the username field when signing up', (done) => {
+    chai
+      .request(app)
+      .post('/api/v1/auth/users/signin')
+      .set('Accept', 'application/x-www-form-urlencoded')
+      .send({ username: '', password: 'benny' })
+      .end((err, res) => {
+        expect('Content-Type', /json/);
+        expect(res.status)
+          .to
+          .be
+          .equal(400);
+        expect(res.body.message)
+          .to
+          .equal('Username is invalid');
+        done();
+      });
+  });
+  it(
+    'should require the password field when a new user\'s signs up',
+    (done) => {
+      chai
+        .request(app)
+        .post('/api/v1/auth/users/signin')
+        .set('Accept', 'application/x-www-form-urlencoded')
+        .send({ username: 'Benny', password: '' })
+        .end((err, res) => {
+          expect('Content-Type', /json/);
+          expect(res.status)
+            .to
+            .be
+            .equal(400);
+          expect(res.body.message)
+            .to
+            .equal('Password is too short');
+          done();
+        });
+    }
+  );
+  it('should ensure all signup fields are defined when signing up', (done) => {
+    chai
+      .request(app)
+      .post('/api/v1/auth/users/signup')
+      .set('Accept', 'application/x-www-form-urlencoded')
+      .send({
+        usename: '', email: '', password: '', passwordConfirmation: ''
+      })
+      .end((err, res) => {
+        expect(res.body.message)
+          .to
+          .equal('This email address you have provided is invalid');
         done();
       });
   });
diff --git a/server/src/test/books.spec.js b/server/src/test/books.spec.js
index a3f111a..867d553 100644
--- a/server/src/test/books.spec.js
+++ b/server/src/test/books.spec.js
@@ -1,16 +1,9 @@
-/*
-eslint-disable no-console
-*/
-
-import faker from 'faker';
 import chai from 'chai';
 import chaiHttp from 'chai-http';
-import dotenv from 'dotenv';
 
 import app from '../app';
 import db from '../models';
-
-dotenv.config();
+import usrToken from './helpers/testHooks';
 
 const { Books } = db;
 const { expect } = chai;
@@ -18,12 +11,18 @@ const { expect } = chai;
 chai.use(chaiHttp);
 
 let bookId;
-let token = '';
+let userToken = '';
+let adminToken = '';
 const testdate = new Date('2018-01-04');
 let limit;
 
-describe('HelloBooks', () => {
+describe('Books', () => {
   before((done) => {
+    usrToken().then((response) => {
+      userToken = response.userToken;
+      adminToken = response.adminToken;
+      done();
+    });
     Books
       .create({
         title: 'Shola comes home',
@@ -35,63 +34,24 @@ describe('HelloBooks', () => {
       })
       .then((book) => {
         bookId = book.id;
-        done();
       })
       .catch(() => {});
   });
-
-  describe('Authentication', () => {
-    it('should return 201 when a regular administrator is created', (done) => {
-      chai
-        .request(app)
-        .post('/api/v1/auth/users/signup')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .send({
-          username: 'ogidan',
-          password: 'boooboo',
-          passwordConfirmation: 'boooboo',
-          firstname: 'Benny',
-          isAdmin: true,
-          email: faker
-            .internet
-            .email(),
-          lastname: faker
-            .name
-            .lastName()
-        })
-        .end((err, res) => {
-          expect(res.status)
-            .to
-            .equal(201);
-          done();
-        });
-    });
-    it('should return 200 when a administrator signs in', (done) => {
-      chai
-        .request(app)
-        .post('/api/v1/auth/users/signin')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .send({ username: 'ogidan', password: 'boooboo' })
-        .end((err, res) => {
-          expect(res.status)
-            .to
-            .equal(200);
-          token = res.body.token;
-          done();
-        });
-    });
-  });
-  describe('Books', () => {
+  describe('<Get Booklist', () => {
     it('should display all books from the data', (done) => {
       chai
         .request(app)
         .get('/api/v1/books')
         .set('Accept', 'application/x-www-form-urlencoded')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .end((err, res) => {
           expect(res.status)
             .to
             .equal(200);
+          expect(res.body)
+            .to
+            .be
+            .a('object');
           done();
         });
     });
@@ -99,7 +59,7 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .get('/api/v1/books')
-        .set({ 'x-access-token': token })
+        .set({ 'x-access-token': userToken })
         .query({ limit: 2 })
         .end((err, res) => {
           expect(res.status)
@@ -111,6 +71,10 @@ describe('HelloBooks', () => {
             .to
             .be
             .equal(2);
+          expect(res.body)
+            .to
+            .be
+            .a('object');
           done();
         });
     });
@@ -118,7 +82,7 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .get('/api/v1/books')
-        .set({ 'x-access-token': token })
+        .set({ 'x-access-token': userToken })
         .query({ limit: 1 })
         .end((err, res) => {
           expect(res.status)
@@ -137,7 +101,7 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .get('/api/v1/books')
-        .set({ 'x-access-token': token })
+        .set({ 'x-access-token': userToken })
         .query({ limit: 1, offset: 1 })
         .end((err, res) => {
           expect(res.status)
@@ -156,7 +120,7 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .get('/api/v1/books')
-        .set({ 'x-access-token': token })
+        .set({ 'x-access-token': userToken })
         .query({ limit, offset: 1 })
         .end((err, res) => {
           expect(res.status)
@@ -172,13 +136,13 @@ describe('HelloBooks', () => {
         });
     });
   });
-  describe('Edit books', () => {
+  describe('<Edit books', () => {
     it('should edit a selected book from the database', (done) => {
       chai
         .request(app)
         .put(`/api/v1/admin/books/${bookId}`)
         .set('Accept', 'application/x-www-form-urlencoded')
-        .set('x-access-token', token)
+        .set('x-access-token', adminToken)
         .send({
           title: 'The Chronicles of Andela',
           author: 'C.S. Lewis',
@@ -191,6 +155,10 @@ describe('HelloBooks', () => {
           expect(res.status)
             .to
             .equal(200);
+          expect('Content-Type', /json/);
+          expect(res.body.message)
+            .to
+            .equal('The Chronicles of Andela has been updated');
           done();
         });
     });
@@ -199,7 +167,7 @@ describe('HelloBooks', () => {
         .request(app)
         .put(`/api/v1/admin/books/${bookId}`)
         .set('Accept', 'application/x-www-form-urlencoded')
-        .set('x-access-token', token)
+        .set('x-access-token', adminToken)
         .send({
           title: 'The Chronicles of Andela',
           author: '',
@@ -212,31 +180,44 @@ describe('HelloBooks', () => {
           expect(res.status)
             .to
             .equal(400);
-          done();
-        });
-    });
-    it('should throw an error if category Id is not defined', (done) => {
-      chai
-        .request(app)
-        .put('/api/v1/admin/books')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .set('x-access-token', token)
-        .send({
-          title: 'The Chronicles of Andela', author: 'C.S. Lewis', quantity: '23', description: 'This is a test', bookImage: 'Image'
-        })
-        .end((err, res) => {
-          expect(res.status)
+          expect(res.body.message)
             .to
-            .equal(404);
+            .equal('This author\'s name is invalid');
           done();
         });
     });
+    it(
+      'should throw a 404 errror if book to be edited is not defined',
+      (done) => {
+        chai
+          .request(app)
+          .put('/api/v1/admin/books/')
+          .set('Accept', 'application/x-www-form-urlencoded')
+          .set('x-access-token', adminToken)
+          .send({
+            title: 'The Chronicles of Andela',
+            author: 'C.S. Lewis',
+            quantity: '23',
+            categoryId: '2',
+            description: 'This is a test',
+            bookImage: 'Image'
+          })
+          .end((err, res) => {
+            expect(res.status)
+              .to
+              .equal(404);
+            done();
+          });
+      }
+    );
+  });
+  describe('<Create books', () => {
     it('should allow administrators to create books', (done) => {
       chai
         .request(app)
         .post('/api/v1/admin/books')
         .set('Accept', 'application/x-www-form-urlencoded')
-        .set('x-access-token', token)
+        .set('x-access-token', adminToken)
         .send({
           title: 'Learn Java',
           author: 'Sleeping Master',
@@ -251,7 +232,8 @@ describe('HelloBooks', () => {
             .equal(201);
           expect(res.body.message)
             .to
-            .equal('Learn Java has been added to the library, Category: Drama');
+            .equal('Learn Java has been added to the library,' +
+              ' Category: Drama');
           done();
         });
     });
@@ -260,7 +242,7 @@ describe('HelloBooks', () => {
         .request(app)
         .post('/api/v1/admin/books')
         .set('Accept', 'application/x-www-form-urlencoded')
-        .set('x-access-token', token)
+        .set('x-access-token', adminToken)
         .send({
           title: 'Learn Java',
           author: 'Sleeping Master',
@@ -275,35 +257,35 @@ describe('HelloBooks', () => {
             .equal(409);
           expect(res.body.message)
             .to
-            .equal('A book with the same title and author already exists in the library');
+            .equal('A book with the same title and ' +
+              'author already exists in the library');
           done();
         });
     });
-    it(
-      'should return a 400 response for a book with an incomplete description',
-      (done) => {
-        chai
-          .request(app)
-          .post('/api/v1/admin/books')
-          .set('Accept', 'application/x-www-form-urlencoded')
-          .set('x-access-token', token)
-          .send({
-            title: 'Benedict goes to school',
-            author: 'Benny O',
-            categoryId: '3',
-            quantity: '20',
-            description: 'This ',
-            bookimage: 'Test Image'
-          })
-          .end((err, res) => {
-            expect(res.status)
-              .to
-              .equal(400);
-            done();
-          });
-      }
-    );
-    it('should allow only authenticated users allowed to create books', (done) => {
+    it('should return a 400 response for ' +
+      'a book with an incomplete description', (done) => {
+      chai
+        .request(app)
+        .post('/api/v1/admin/books')
+        .set('Accept', 'application/x-www-form-urlencoded')
+        .set('x-access-token', adminToken)
+        .send({
+          title: 'Benedict goes to school',
+          author: 'Benny O',
+          categoryId: '3',
+          quantity: '20',
+          description: 'This ',
+          bookimage: 'Test Image'
+        })
+        .end((err, res) => {
+          expect(res.status)
+            .to
+            .equal(400);
+          done();
+        });
+    });
+    it('should allow only authenticated ' +
+      'users allowed to create books', (done) => {
       chai
         .request(app)
         .post('/api/v1/admin/books/')
@@ -312,18 +294,26 @@ describe('HelloBooks', () => {
           expect(res.status)
             .to
             .equal(401);
+          expect(res.body.token)
+            .to.equal(null);
+          expect(res.body.message)
+            .to.equal("Unauthorised access");
           done();
         });
     });
+  });
+  describe('<Search books', () => {
     it('should return 200 when searching all books', (done) => {
       chai
         .request(app)
         .get('/api/v1/books/search?searchTerm=Sta')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .end((err, res) => {
           expect(res.status)
             .to
             .equal(200);
+          expect(res.body.success)
+            .to.equal(true);
           done();
         });
     });
@@ -331,11 +321,13 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .get('/api/v1/books/search?searchTerm=Sta&categoryId=1')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .end((err, res) => {
           expect(res.status)
             .to
             .equal(200);
+          expect(res.body.success)
+            .to.equal(true);
           done();
         });
     });
@@ -343,11 +335,14 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .get('/api/v1/books/search?searchTerm=')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .end((err, res) => {
           expect(res.status)
             .to
             .equal(400);
+          expect(res.body.message)
+            .to
+            .equal('Please enter your search criteria');
           done();
         });
     });
@@ -355,73 +350,64 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .get('/api/v1/books/search?searchTerm=999999')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .end((err, res) => {
           expect(res.status)
             .to
             .equal(404);
-          done();
-        });
-    });
-    it('should return 200 when getting a single book', (done) => {
-      chai
-        .request(app)
-        .get('/api/v1/auth/books/1')
-        .set('x-access-token', token)
-        .end((err, res) => {
-          expect(res.status)
+          expect(res.body.message)
             .to
-            .equal(200);
+            .equal('Sorry no books match your search criteria');
           done();
         });
     });
+  });
+  it('should return 200 when getting a single book', (done) => {
+    chai
+      .request(app)
+      .get('/api/v1/auth/books/1')
+      .set('x-access-token', userToken)
+      .end((err, res) => {
+        expect(res.status)
+          .to
+          .equal(200);
+        done();
+      });
+  });
+  describe('<Select Book', () => {
     it('should return 400 if the bookId is not valid', (done) => {
       chai
         .request(app)
         .get('/api/v1/auth/books/sfgh')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .end((err, res) => {
           expect(res.status)
             .to
             .equal(400);
+          expect(res.body.message)
+            .to
+            .equal('Please enter a valid bookId');
           done();
         });
     });
-    it('should return 404 when getting a single book if it does not exist', (done) => {
+    it('should return 404 when getting a' +
+     'single book if it does not exist', (done) => {
       chai
         .request(app)
         .get('/api/v1/auth/books/100')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .end((err, res) => {
           expect(res.status)
             .to
             .equal(404);
-          done();
-        });
-    });
-    it('should throw an error if the selected book undefined', (done) => {
-      chai
-        .request(app)
-        .put('/api/v1/admin/books/')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .set('x-access-token', token)
-        .send({
-          title: 'The Chronicles of Andela',
-          author: 'C.S. Lewis',
-          category: 4,
-          quantity: '23',
-          description: 'This is a test',
-          bookimage: 'Image'
-        })
-        .end((err, res) => {
-          expect(res.status)
+          expect(res.body.message)
             .to
-            .equal(404);
+            .equal('This book does not exist in the library');
           done();
         });
     });
   });
-  describe('/LOAN', () => {
+  describe('/Loan a book', () => {
     it('should allow an authenticated user to loan a book', (done) => {
       const userbook = {
         bookId: bookId.toString(),
@@ -430,36 +416,42 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .post('/api/v1/users/loanbook')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .send(userbook)
         .end((err, res) => {
           expect(res.status)
             .to
             .equal(200);
+          expect(res.body.message)
+            .to
+            .equal('The Chronicles of Andela successfully loaned');
           done();
         });
     });
   });
 
   describe('Delete books', () => {
-    it('should allow only administrators are allowed to delete books', (done) => {
-      chai
-        .request(app)
-        .delete('/api/v1/admin/books/2')
-        .set('x-access-token', token)
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .end((err, res) => {
-          expect(res.status)
-            .to
-            .equal(200);
-          done();
-        });
-    });
+    it(
+      'should allow only administrators to delete books',
+      (done) => {
+        chai
+          .request(app)
+          .delete('/api/v1/admin/books/2')
+          .set('x-access-token', userToken)
+          .set('Accept', 'application/x-www-form-urlencoded')
+          .end((err, res) => {
+            expect(res.status)
+              .to
+              .equal(403);
+            done();
+          });
+      }
+    );
     it('should allow only all books in the database to be deleted', (done) => {
       chai
         .request(app)
         .delete('/api/v1/admin/books/344')
-        .set('x-access-token', token)
+        .set('x-access-token', adminToken)
         .set('Accept', 'application/x-www-form-urlencoded')
         .end((err, res) => {
           expect(res.status)
@@ -472,12 +464,16 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .delete(`/api/v1/admin/books/${bookId}`)
-        .set('x-access-token', token)
+        .set('x-access-token', adminToken)
         .set('Accept', 'application/x-www-form-urlencoded')
         .end((err, res) => {
           expect(res.status)
             .to
             .equal(409);
+          expect(res.body.message)
+            .to
+            .equal('You can\'t delete this book ' +
+            'while there is a copy still out on loan');
           done();
         });
     });
@@ -485,12 +481,15 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .delete('/api/v1/admin/books/thisbook')
-        .set('x-access-token', token)
+        .set('x-access-token', adminToken)
         .set('Accept', 'application/x-www-form-urlencoded')
         .end((err, res) => {
           expect(res.status)
             .to
             .equal(400);
+          expect(res.body.message)
+            .to
+            .equal('Please enter a valid bookId');
           done();
         });
     });
diff --git a/server/src/test/categories.spec.js b/server/src/test/categories.spec.js
index cd9c8c3..ac8fb52 100644
--- a/server/src/test/categories.spec.js
+++ b/server/src/test/categories.spec.js
@@ -1,5 +1,6 @@
 import chai from 'chai';
 import chaiHttp from 'chai-http';
+import usrToken from './helpers/testHooks';
 
 import app from '../app';
 
@@ -7,220 +8,283 @@ const expect = chai.expect;
 
 chai.use(chaiHttp);
 
-
 let adminToken = '';
 
-
-describe('User', () => {
-  it('should return 200 when an admin user login is successful', (done) => {
-    chai.request(app).post('/api/v1/auth/users/signin')
+describe('Categories', () => {
+  before((done) => {
+    usrToken().then((response) => {
+      adminToken = response.adminToken;
+      done();
+    });
+  });
+  it('should return 200 when displaying all categories', (done) => {
+    chai
+      .request(app)
+      .get('/api/v1/books/listcategories')
       .set('Accept', 'application/x-www-form-urlencoded')
-      .send({
-        username: 'bennyogidan',
-        password: 'bennyogidan',
-      })
+      .set('x-access-token', adminToken)
       .end((err, res) => {
-        expect(res.status).to.equal(200);
-        adminToken = res.body.token;
+        expect(res.status)
+          .to
+          .equal(200);
+        expect(res.body.categories)
+          .to
+          .have
+          .length(7);
+        expect(res.body.categories)
+          .to
+          .be
+          .an('array');
+        done();
+      });
+  });
+  it('should return 200 when displaying all book categories', (done) => {
+    chai
+      .request(app)
+      .get('/api/v1/books/category/1')
+      .set('Accept', 'application/x-www-form-urlencoded')
+      .set('x-access-token', adminToken)
+      .end((err, res) => {
+        expect(res.status)
+          .to
+          .equal(200);
+        expect(res.body.books)
+          .to
+          .be
+          .an('array');
+        expect(res.body.books)
+          .to
+          .have
+          .length(6);
         done();
       });
   });
-});
-
-describe('Categories', () => {
-  it(
-    'should return 200 when displaying all categories',
-    (done) => {
-      chai.request(app).get('/api/v1/books/listcategories')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .set('x-access-token', adminToken)
-        .end((err, res) => {
-          expect(res.status).to.equal(200);
-          done();
-        });
-    }
-  );
-  it(
-    'should return 200 when displaying all book categories',
-    (done) => {
-      chai.request(app).get('/api/v1/books/category/1')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .set('x-access-token', adminToken)
-        .end((err, res) => {
-          expect(res.status).to.equal(200);
-          done();
-        });
-    }
-  );
   it(
-    'should return 409 when dtrying to delete a category with books in it',
+    'should return 409 when trying to delete a category with books in it',
     (done) => {
-      chai.request(app).delete('/api/v1/admin/category/1')
+      chai
+        .request(app)
+        .delete('/api/v1/admin/category/1')
         .set('Accept', 'application/x-www-form-urlencoded')
         .set('x-access-token', adminToken)
         .end((err, res) => {
-          expect(res.status).to.equal(409);
+          expect(res.body.message)
+            .to
+            .equal('You cannot delete this category ' +
+            'as there are still books in it');
+          expect(res.status)
+            .to
+            .equal(409);
           done();
         });
     }
   );
   it('should return 201 when a category is added', (done) => {
-    chai.request(app).post('/api/v1/admin/category')
+    chai
+      .request(app)
+      .post('/api/v1/admin/category')
       .set('Accept', 'application/x-www-form-urlencoded')
       .set('x-access-token', adminToken)
-      .send({
-        categoryName: 'EDUCATIONAL'
-      })
+      .send({ categoryName: 'EDUCATIONAL' })
       .end((err, res) => {
-        expect(res.status).to.equal(201);
+        expect(res.body.message)
+          .to
+          .equal('Category added!, EDUCATIONAL');
+        expect(res.status)
+          .to
+          .equal(201);
         done();
       });
   });
 
-  it('should return 400 when an empty form is submitted', (done) => {
-    chai.request(app).post('/api/v1/admin/category')
+  it('should return 400 when an no category name is submitted', (done) => {
+    chai
+      .request(app)
+      .post('/api/v1/admin/category')
       .set('Accept', 'application/x-www-form-urlencoded')
       .set('x-access-token', adminToken)
-      .send({ })
+      .send({})
       .end((err, res) => {
-        expect(res.status).to.equal(400);
+        expect(res.body.message)
+          .to
+          .equal('The category name is Invalid');
+        expect(res.status)
+          .to
+          .equal(400);
         done();
       });
   });
   it('should return 409 when a category to be added already exists', (done) => {
-    chai.request(app).post('/api/v1/admin/category')
+    chai
+      .request(app)
+      .post('/api/v1/admin/category')
       .set('Accept', 'application/x-www-form-urlencoded')
       .set('x-access-token', adminToken)
-      .send({
-        categoryName: 'EDUCATIONAL'
-      })
+      .send({ categoryName: 'EDUCATIONAL' })
       .end((err, res) => {
-        expect(res.status).to.equal(409);
+        expect(res.body.message)
+          .to
+          .equal('Category already exists');
+        expect(res.status)
+          .to
+          .equal(409);
+        done();
+      });
+  });
+  it('should return 400 when categoryId to display is not valid', (done) => {
+    chai
+      .request(app)
+      .get('/api/v1/books/category/bbnbnnb')
+      .set('x-access-token', adminToken)
+      .end((err, res) => {
+        expect(res.body.message)
+          .to
+          .equal('Please enter a valid category');
+        expect(res.status)
+          .to
+          .equal(400);
+        done();
+      });
+  });
+  it('should return 404 when categoryId to display is not found', (done) => {
+    chai
+      .request(app)
+      .get('/api/v1/books/category/404')
+      .set('x-access-token', adminToken)
+      .end((err, res) => {
+        expect(res.body.message)
+          .to
+          .equal('Category does not exist in this Library');
+        expect(res.status)
+          .to
+          .equal(404);
         done();
       });
   });
-
-  it(
-    'should return 200 when displaying books by categories in the library',
-    (done) => {
-      chai.request(app).get('/api/v1/books/category/1')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .set('x-access-token', adminToken)
-        .end((err, res) => {
-          expect(res.status).to.equal(200);
-          done();
-        });
-    }
-  );
-  it(
-    'should return 400 when categoryId to display is not valid',
-    (done) => {
-      chai.request(app).get('/api/v1/books/category/bbnbnnb').set('x-access-token', adminToken)
-        .end((err, res) => {
-          expect(res.status).to.equal(400);
-          done();
-        });
-    }
-  );
-  it(
-    'should return 404 when categoryId to display is not found',
-    (done) => {
-      chai.request(app).get('/api/v1/books/category/404').set('x-access-token', adminToken)
-        .end((err, res) => {
-          expect(res.status).to.equal(404);
-          done();
-        });
-    }
-  );
   it('should return 200 when a category is modified', (done) => {
-    chai.request(app).put('/api/v1/admin/category/7').set('x-access-token', adminToken)
-      .send({
-        categoryName: 'TestCategory'
-      })
+    chai
+      .request(app)
+      .put('/api/v1/admin/category/7')
+      .set('x-access-token', adminToken)
+      .send({ categoryName: 'TestCategory' })
       .end((err, res) => {
-        expect(res.status).to.equal(200);
+        expect(res.body.message)
+          .to
+          .equal('Category Modified!');
+        expect(res.status)
+          .to
+          .equal(200);
         done();
       });
   });
   it('should return 400 when a category name field is null', (done) => {
-    chai.request(app).put('/api/v1/admin/category/2').set('x-access-token', adminToken)
+    chai
+      .request(app)
+      .put('/api/v1/admin/category/2')
+      .set('x-access-token', adminToken)
       .send({ categoryName: null })
       .end((err, res) => {
-        expect(res.status).to.equal(400);
+        expect(res.body.message)
+          .to
+          .equal('The category name is Invalid');
+        expect(res.status)
+          .to
+          .equal(400);
+        done();
+      });
+  });
+  it('should return 400 when categoryId to modify is not valid', (done) => {
+    chai
+      .request(app)
+      .put('/api/v1/admin/category/nkkkj')
+      .set('x-access-token', adminToken)
+      .send({ name: 'Test Category' })
+      .end((err, res) => {
+        expect(res.body.message)
+          .to
+          .equal('The category name is Invalid');
+        expect(res.status)
+          .to
+          .equal(400);
+        done();
+      });
+  });
+  it('should return 404 when category to modify is not found', (done) => {
+    chai
+      .request(app)
+      .put('/api/v1/admin/category/404')
+      .set('x-access-token', adminToken)
+      .send({ categoryName: 'TestCategory' })
+      .end((err, res) => {
+        expect(res.body.message)
+          .to
+          .equal('Category does not exist in this Library');
+        expect(res.status)
+          .to
+          .equal(404);
+        done();
+      });
+  });
+  it('should return 409 when category to modify to already exists', (done) => {
+    chai
+      .request(app)
+      .put('/api/v1/admin/category/2')
+      .set('x-access-token', adminToken)
+      .send({ categoryName: 'TestCategory' })
+      .end((err, res) => {
+        expect(res.body.message)
+          .to
+          .equal('This Category already exists');
+        expect(res.status)
+          .to
+          .equal(409);
+        done();
+      });
+  });
+  it('should return 200 when category is deleted', (done) => {
+    chai
+      .request(app)
+      .delete('/api/v1/admin/category/7')
+      .set('x-access-token', adminToken)
+      .end((err, res) => {
+        expect(res.body.message)
+          .to
+          .equal('This category has been deleted');
+        expect(res.status)
+          .to
+          .equal(200);
+        done();
+      });
+  });
+  it('should return 404 when category to delete is not found', (done) => {
+    chai
+      .request(app)
+      .put('/api/v1/admin/category/7')
+      .set('x-access-token', adminToken)
+      .send({ categoryName: 'TestCategory' })
+      .end((err, res) => {
+        expect(res.body.message)
+          .to
+          .equal('Category does not exist in this Library');
+        expect(res.status)
+          .to
+          .equal(404);
+        done();
+      });
+  });
+  it('should return 400 when categoryId to delete is not valid', (done) => {
+    chai
+      .request(app)
+      .delete('/api/v1/admin/category/nkkkj')
+      .set('x-access-token', adminToken)
+      .end((err, res) => {
+        expect(res.body.message)
+          .to
+          .equal('Please enter a valid CategoryId');
+        expect(res.status)
+          .to
+          .equal(400);
         done();
       });
   });
-  it(
-    'should return 400 when categoryId to modify is not valid',
-    (done) => {
-      chai.request(app).put('/api/v1/admin/category/nkkkj').set('x-access-token', adminToken)
-        .send({
-          name: 'Test Category'
-        })
-        .end((err, res) => {
-          expect(res.status).to.equal(400);
-          done();
-        });
-    }
-  );
-  it(
-    'should return 404 when category to modify is not found',
-    (done) => {
-      chai.request(app).put('/api/v1/admin/category/404').set('x-access-token', adminToken)
-        .send({
-          categoryName: 'TestCategory'
-        })
-        .end((err, res) => {
-          expect(res.status).to.equal(404);
-          done();
-        });
-    }
-  );
-  it(
-    'should return 409 when category to modify to already exists',
-    (done) => {
-      chai.request(app).put('/api/v1/admin/category/2').set('x-access-token', adminToken)
-        .send({
-          categoryName: 'TestCategory'
-        })
-        .end((err, res) => {
-          expect(res.status).to.equal(409);
-          done();
-        });
-    }
-  );
-  it(
-    'should return 200 when category is deleted',
-    (done) => {
-      chai.request(app).delete('/api/v1/admin/category/7').set('x-access-token', adminToken)
-        .end((err, res) => {
-          expect(res.status).to.equal(200);
-          done();
-        });
-    }
-  );
-  it(
-    'should return 404 when category to delete is not found',
-    (done) => {
-      chai.request(app).put('/api/v1/admin/category/7').set('x-access-token', adminToken)
-        .send({
-          categoryName: 'TestCategory'
-        })
-        .end((err, res) => {
-          expect(res.status).to.equal(404);
-          done();
-        });
-    }
-  );
-  it(
-    'should return 400 when categoryId to delete is not valid',
-    (done) => {
-      chai.request(app).delete('/api/v1/admin/category/nkkkj').set('x-access-token', adminToken)
-        .end((err, res) => {
-          expect(res.status).to.equal(400);
-          done();
-        });
-    }
-  );
 });
-
diff --git a/server/src/test/helpers/testHooks.js b/server/src/test/helpers/testHooks.js
new file mode 100644
index 0000000..493f561
--- /dev/null
+++ b/server/src/test/helpers/testHooks.js
@@ -0,0 +1,40 @@
+
+import chai from 'chai';
+import chaiHttp from 'chai-http';
+
+import app from '../../app';
+
+require('dotenv').config();
+
+chai.use(chaiHttp);
+
+const usrToken = () => new Promise((resolve) => {
+  let userToken = '';
+  let adminToken = '';
+  chai
+    .request(app)
+    .post('/api/v1/auth/users/signin')
+    .send({
+      username: 'testuser',
+      password: 'testuser',
+    })
+    .end((err, res) => {
+      userToken = res.body.token;
+      chai
+        .request(app)
+        .post('/api/v1/auth/users/signin')
+        .send({
+          username: 'bennyogidan',
+          password: process.env.ADMIN_PASSWORD,
+        })
+        .end((err, res) => {
+          adminToken = res.body.token;
+          resolve({
+            userToken,
+            adminToken
+          });
+        });
+    });
+});
+
+export default usrToken;
diff --git a/server/src/test/index.spec.js b/server/src/test/index.spec.js
index 214790e..92dca5d 100644
--- a/server/src/test/index.spec.js
+++ b/server/src/test/index.spec.js
@@ -1,7 +1,7 @@
-require('./user.spec');
 require('./books.spec');
 require('./userBooks.spec');
 require('./model.spec');
 require('./categories.spec');
 require('./authenticate.spec');
 require('./notifications.spec');
+require('./user.spec');
diff --git a/server/src/test/notifications.spec.js b/server/src/test/notifications.spec.js
index c010529..293df49 100644
--- a/server/src/test/notifications.spec.js
+++ b/server/src/test/notifications.spec.js
@@ -1,35 +1,28 @@
 import chai from 'chai';
 import chaiHttp from 'chai-http';
 
-
+import usrToken from './helpers/testHooks';
 import app from '../app';
 
-
 const expect = chai.expect;
 
 chai.use(chaiHttp);
 
-
 let adminToken = '';
 
-describe('User', () => {
-  it('should return 200 when an admin user login is successful', (done) => {
-    chai.request(app).post('/api/v1/auth/users/signin')
-      .set('Accept', 'application/x-www-form-urlencoded')
-      .send({
-        username: 'bennyogidan',
-        password: 'bennyogidan',
-      })
-      .end((err, res) => {
-        expect(res.status).to.equal(200);
-        adminToken = res.body.token;
-        done();
-      });
+describe('<Notifications', () => {
+  before((done) => {
+    usrToken().then((response) => {
+      adminToken = response.adminToken;
+      done();
+    });
   });
-});
-describe('Notifications', () => {
+
   it('should return 200 when admin displays notification', (done) => {
-    chai.request(app).get('/api/v1/admin/notifications').set('x-access-token', adminToken)
+    chai
+      .request(app)
+      .get('/api/v1/admin/notifications')
+      .set('x-access-token', adminToken)
       .end((err, res) => {
         expect(res.status)
           .to
diff --git a/server/src/test/user.spec.js b/server/src/test/user.spec.js
index 0aaee78..7ec92b6 100644
--- a/server/src/test/user.spec.js
+++ b/server/src/test/user.spec.js
@@ -1,29 +1,28 @@
 import * as log from 'loglevel';
-
-import faker from 'faker';
 import chai from 'chai';
 import chaiHttp from 'chai-http';
-import jwt from 'jsonwebtoken';
-import dotenv from 'dotenv';
+import usrToken from './helpers/testHooks';
 
 import app from '../app';
 import db from '../models';
 
-const { User } = db;
 const { Books } = db;
 const { expect } = chai;
 
-dotenv.config();
 chai.use(chaiHttp);
 
-let userId;
 let bookId;
-let token;
-let userToken;
-
+const userId = '1';
+let userToken = '';
+let adminToken = '';
 
-describe('HelloBooks', () => {
+describe('Users', () => {
   before((done) => {
+    usrToken().then((response) => {
+      userToken = response.userToken;
+      adminToken = response.adminToken;
+      done();
+    });
     Books
       .create({
         title: 'Shola comes home',
@@ -35,569 +34,334 @@ describe('HelloBooks', () => {
       })
       .then((book) => {
         bookId = book.id;
-      });
-    User.create({
-      firstname: faker
-        .name
-        .firstName(),
-      lastname: faker
-        .name
-        .lastName(),
-      username: 'Benny',
-      password: 'benny',
-      isAdmin: false,
-      passwordConfirmation: 'benny',
-      email: faker
-        .internet
-        .email()
-    })
-      .then((user) => {
-        userId = user.id;
-        userToken = jwt.sign({
-          id: user.id,
-          email: user.email,
-          isAdmin: true
-        }, process.env.JWT_SECRET);
-        done();
       })
       .catch((error) => {
         log.debug('Error in seeding the db', error);
-        done();
       });
   });
-
-  /*
-  * Unauthenticated user tests
-  */
-  describe('/GET', () => {
-    it('should allow only authenticated users to view books', (done) => {
-      chai
-        .request(app)
-        .get('/api/v1/books/')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .end((err, res) => {
-          expect(res.status)
-            .to
-            .equal(401);
-          done();
-        });
-    });
-    it('should allow only authenticated users see the book list', (done) => {
-      chai
-        .request(app)
-        .get('/api/v1/users/1/books')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .end((err, res) => {
-          expect(res.status)
-            .to
-            .equal(401);
-          done();
-        });
-    });
+  it('should allow only authenticated users to view books', (done) => {
+    chai
+      .request(app)
+      .get('/api/v1/books/')
+      .set('Accept', 'application/x-www-form-urlencoded')
+      .end((err, res) => {
+        expect(res.status)
+          .to
+          .equal(401);
+        expect(res.body.token)
+          .to.equal(null);
+        expect(res.body.message)
+          .to.equal("Unauthorised access");
+        done();
+      });
   });
-
-  describe('Authentication', () => {
-    it('should return 201 when a regular administrator is created', (done) => {
-      chai.request(app)
-        .post('/api/v1/auth/users/signup')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .send({
-          username: 'testadmin',
-          password: 'boooboo',
-          passwordConfirmation: 'boooboo',
-          firstname: 'Benny',
-          isAdmin: true,
-          email: faker.internet.email(),
-          lastname: faker.name.lastName()
-        })
-        .end((err, res) => {
-          expect(res.status).to.equal(201);
-          done();
-        });
-    });
-    it('should return 200 when a administrator signs in', (done) => {
-      chai.request(app)
-        .post('/api/v1/auth/users/signin')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .send({
-          username: 'testadmin',
-          password: 'boooboo'
-        })
-        .end((err, res) => {
-          expect(res.status).to.equal(200);
-          token = res.body.token;
-          done();
-        });
-    });
+  it('should allow only authenticated users see the book list', (done) => {
+    chai
+      .request(app)
+      .get('/api/v1/users/1/books')
+      .set('Accept', 'application/x-www-form-urlencoded')
+      .end((err, res) => {
+        expect(res.status)
+          .to
+          .equal(401);
+        expect(res.body.token)
+          .to.equal(null);
+        expect(res.body.message)
+          .to.equal("Unauthorised access");
+        done();
+      });
   });
 
-  describe('User level', () => {
-    it('should return 409 when level is the same as user level', (done) => {
-      chai.request(app).put('/api/v1/admin/changeuserlevel').set('x-access-token', token)
-        .send({
-          newLevelId: '1',
-          userId: 1
-        })
-        .end((err, res) => {
-          expect(res.status).to.equal(409);
-          done();
-        });
-    });
-    it('should return 200 when level change is successful', (done) => {
-      chai.request(app).put('/api/v1/admin/changeuserlevel').set('x-access-token', token)
-        .send({
-          newLevelId: '2',
-          userId: 1
-        })
-        .end((err, res) => {
-          expect(res.status).to.equal(200);
-          done();
-        });
-    });
-    it('should return 400 when newLevelId is null', (done) => {
-      chai.request(app).put('/api/v1/admin/changeuserlevel').set('x-access-token', token)
-        .send({
-          userId: 1
-        })
-        .end((err, res) => {
-          expect(res.status).to.equal(400);
-          done();
-        });
-    });
-    it('should return 404 when new level does not exist', (done) => {
-      chai.request(app).put('/api/v1/admin/changeuserlevel').set('x-access-token', token)
-        .send({
-          newLevelId: '20',
-          userId: 1
-        })
-        .end((err, res) => {
-          expect(res.status).to.equal(404);
-          done();
-        });
-    });
-    it('should return 404 when the user is not found ', (done) => {
-      chai.request(app).put('/api/v1/admin/changeuserlevel').set('x-access-token', token)
-        .send({
-          newLevelId: '2',
-          userId: 445454
-        })
-        .end((err, res) => {
-          expect(res.status).to.equal(404);
-          done();
-        });
-    });
-  });
-  describe('Signing up a user', () => {
-    it('should sign up users who fill the correct parameters for the signup form', (done) => {
-      const email = faker
-        .internet
-        .email();
+  describe('<Change User level Route', () => {
+    it('should return 409 when the level is ' +
+    'changed to the existing level', (done) => {
       chai
         .request(app)
-        .post('/api/v1/auth/users/signup')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .send({
-          firstname: faker
-            .name
-            .firstName(),
-          lastname: faker
-            .name
-            .lastName(),
-          username: 'samplename',
-          password: 'password',
-          passwordConfirmation: 'password',
-          email
-        })
+        .put('/api/v1/admin/changeuserlevel')
+        .set('x-access-token', adminToken)
+        .send({ newLevelId: '1', userId: 1 })
         .end((err, res) => {
           expect(res.status)
             .to
-            .equal(201);
+            .equal(409);
+          expect(res.body.message)
+            .to
+            .equal('This user is already on this level');
           done();
         });
     });
-    it('should throw a validation error for invalid user data', (done) => {
-      const email = faker
-        .internet
-        .email();
+    it('should return 400 when the new level is not a number ', (done) => {
       chai
         .request(app)
-        .post('/api/v1/auth/users/signup')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .send({
-          firstname: faker
-            .name
-            .firstName(),
-          lastname: faker
-            .name
-            .lastName(),
-          password: 'password',
-          passwordConfirmation: 'password',
-          email
-        })
+        .put('/api/v1/admin/changeuserlevel')
+        .set('x-access-token', adminToken)
+        .send({ newLevelId: 'aas', userId: 1 })
         .end((err, res) => {
           expect(res.status)
             .to
             .equal(400);
-          done();
-        });
-    });
-    it('should throw a validation error for invalid user data', (done) => {
-      const email = 'nenemail.com';
-      chai
-        .request(app)
-        .post('/api/v1/auth/users/signup')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .send({
-          firstname: faker
-            .name
-            .firstName(),
-          lastname: faker
-            .name
-            .lastName(),
-          username: faker
-            .internet
-            .userName(),
-          password: 'password',
-          passwordConfirmation: 'password',
-          email
-        })
-        .end((err, res) => {
-          expect(res.status)
+          expect(res.body.message)
             .to
-            .equal(422);
+            .equal('Please select a valid level');
           done();
         });
     });
-    it('should allow only authenticated users allowed to loan', (done) => {
+    it('should return 200 when level change is successful', (done) => {
       chai
         .request(app)
-        .post(`/api/v1/users/${userId}/books`)
-        .set('Accept', 'application/x-www-form-urlencoded')
+        .put('/api/v1/admin/changeuserlevel')
+        .set('x-access-token', adminToken)
+        .send({ newLevelId: '2', userId: 1 })
         .end((err, res) => {
           expect(res.status)
             .to
-            .equal(401);
-          done();
-        });
-    });
-  });
-  describe('/PUT', () => {
-    it('should allow only authenticated users to edit books', (done) => {
-      chai
-        .request(app)
-        .put(`/api/v1/books/${bookId}`)
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .end((err, res) => {
-          expect(res.status)
+            .equal(200);
+          expect(res.body).to.be.a('object');
+          expect(res.body.message)
             .to
-            .equal(401);
+            .equal('Level changed Successfully,New Level "Silver"');
           done();
         });
     });
-    it('should allow only authenticated users to return books', (done) => {
+    it('should return 400 when newLevelId is null', (done) => {
       chai
         .request(app)
-        .put(`/api/v1/users/${userId}/books`)
-        .set('Accept', 'application/x-www-form-urlencoded')
+        .put('/api/v1/admin/changeuserlevel')
+        .set('x-access-token', adminToken)
+        .send({ userId: 1 })
         .end((err, res) => {
           expect(res.status)
             .to
-            .equal(401);
-          done();
-        });
-    });
-  });
-  describe('Authentication processes', () => {
-    it('should reject invalid user', (done) => {
-      chai
-        .request(app)
-        .post('/api/v1/users/books')
-        .set({ 'x-access-token': '12345' })
-        .end((err, res) => {
-          expect(res.status)
+            .equal(400);
+          expect(res.body.message)
             .to
-            .be
-            .equal(401);
+            .equal('Please select a valid level');
           done();
         });
     });
-    it('should reject authorization for users due to no token', (done) => {
+    it('should return 404 when new level does not exist', (done) => {
       chai
         .request(app)
-        .post('/api/v1/users/books')
+        .put('/api/v1/admin/changeuserlevel')
+        .set('x-access-token', adminToken)
+        .send({ newLevelId: '20', userId: 1 })
         .end((err, res) => {
           expect(res.status)
             .to
-            .be
-            .equal(401);
+            .equal(404);
+          expect(res.body.message)
+            .to
+            .equal('Level does not exist');
+
           done();
         });
     });
-    it('should respond with 404 status code if bad username or password', (done) => {
+    it('should return 404 when the user is not found ', (done) => {
       chai
         .request(app)
-        .post('/api/v1/auth/users/signin')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .send({
-          username: faker
-            .internet
-            .userName(),
-          password: faker
-            .internet
-            .password()
-        })
+        .put('/api/v1/admin/changeuserlevel')
+        .set('x-access-token', adminToken)
+        .send({ newLevelId: '2', userId: 445454 })
         .end((err, res) => {
           expect(res.status)
             .to
             .equal(404);
-          done();
-        });
-    });
-    it('should ensure all signup fields are required', (done) => {
-      chai
-        .request(app)
-        .post('/api/v1/auth/users/signup')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .send({
-          username: faker.internet.userName(),
-          email: faker.internet.email(),
-          password: 'testpassword',
-          passwordConfirmation: 'testpassword',
-        })
-        .end((err, res) => {
-          expect(res.body.message).to.equal('Firstname is invalid');
-          expect(res.status).to.equal(400);
-          done();
-        });
-    });
+          expect(res.body.message)
+            .to
+            .equal('User not found');
 
-    it('should ensure all signup fields are defined', (done) => {
-      chai
-        .request(app)
-        .post('/api/v1/auth/users/signup')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .send({
-          usename: '',
-          email: '',
-          password: '',
-          passwordConfirmation: '',
-        })
-        .end((err, res) => {
-          expect(res.body.message).to.equal('This email address you have provided is invalid');
           done();
         });
     });
   });
-  /*
-   Authenticated users Tests
-   */
-  describe('POST /books', () => {
-    it('should throw a 404 error for Users that do not exist', (done) => {
+  describe('<Loan Books', () => {
+    it('should not allow only unauthenticated users to loan books', (done) => {
       chai
         .request(app)
-        .post('/api/v1/auth/users/signin')
+        .post(`/api/v1/users/loanbook`)
         .set('Accept', 'application/x-www-form-urlencoded')
-        .send({ username: 'UnknownUser', password: 'error' })
         .end((err, res) => {
-          token = res.body.token;
-          const response = res.body;
-          expect(response.message).to.equal('UnknownUser does not exist, Make sure you are signed up');
           expect(res.status)
             .to
-            .equal(404);
+            .equal(401);
+          expect(res.body.token)
+            .to.equal(null);
+          expect(res.body.message)
+            .to.equal("Unauthorised access");
           done();
         });
     });
-    it('should validate username', (done) => {
+  });
+  describe('<Edit Books', () => {
+    it('should not allow unauthenticated users to edit books', (done) => {
       chai
         .request(app)
-        .post('/api/v1/auth/users/signin')
+        .put(`/api/v1/books/${bookId}`)
         .set('Accept', 'application/x-www-form-urlencoded')
-        .send({ username: 'Benny', password: '' })
         .end((err, res) => {
-          token = res.body.token;
-          const response = res.body;
-          expect(response.message).to.equal('Password is too short');
           expect(res.status)
             .to
-            .equal(400);
+            .equal(401);
+          expect(res.body.token)
+            .to.equal(null);
+          expect(res.body.message)
+            .to.equal("Unauthorised access");
           done();
         });
     });
-    it('should validate a password for a user', (done) => {
+    it('should not allow only authenticated users to return books', (done) => {
       chai
         .request(app)
-        .post('/api/v1/auth/users/signin')
+        .put(`/api/v1/users/returnbook`)
         .set('Accept', 'application/x-www-form-urlencoded')
-        .send({ username: 'Benny', password: 'nnnnnnn' })
         .end((err, res) => {
-          token = res.body.token;
-          const response = res.body;
-          expect(response.message).to.equal('Wrong Credentials');
           expect(res.status)
             .to
-            .equal(403);
+            .equal(401);
+          expect(res.body.token)
+            .to.equal(null);
+          expect(res.body.message)
+            .to.equal("Unauthorised access");
+
           done();
         });
     });
-    it('should respond with 200 status code if good username or password', (done) => {
+  });
+  describe('<ChangePassword route', () => {
+    it(
+      'should produce a 409 error message if the there is an' +
+      ' error with previous password is supplied',
+      (done) => {
+        chai
+          .request(app)
+          .put('/api/v1/users/changepassword')
+          .set('Accept', 'application/x-www-form-urlencoded')
+          .set({ 'x-access-token': userToken })
+          .send({ newPassword: 'benny', oldPassword: 'bebrb' })
+          .end((err, res) => {
+            expect(res.status)
+              .to
+              .equal(409);
+            expect(res.body.message)
+              .to
+              .equal('Your current password does not ' +
+              'match our records, Please Re-enter');
+            done();
+          });
+      }
+    );
+    it(
+      'should be able to change a user\'s password ' +
+     'provided a new password is specified',
+      (done) => {
+        chai
+          .request(app)
+          .put('/api/v1/users/changepassword')
+          .set('Accept', 'application/x-www-form-urlencoded')
+          .set({ 'x-access-token': userToken })
+          .send({ newPassword: 'newtestuser', oldPassword: 'testuser' })
+          .end((err, res) => {
+            expect(res.status)
+              .to
+              .equal(200);
+            expect(res.body.message)
+              .to
+              .equal('testuser, your password has been updated');
+            done();
+          });
+      }
+    );
+    it(
+      'should return a 409 error if new password is set ' +
+     'to the old password value',
+      (done) => {
+        chai
+          .request(app)
+          .put('/api/v1/users/changepassword')
+          .set('Accept', 'application/x-www-form-urlencoded')
+          .set({ 'x-access-token': userToken })
+          .send({ newPassword: 'newtestuser', oldPassword: 'newtestuser' })
+          .end((err, res) => {
+            expect(res.status)
+              .to
+              .equal(409);
+            expect(res.body.message)
+              .to
+              .equal('You cannot use a previous password');
+            done();
+          });
+      }
+    );
+  });
+  describe('<Userlist route', () => {
+    it('should return 200 when displaying all users', (done) => {
       chai
         .request(app)
-        .post('/api/v1/auth/users/signin')
+        .get('/api/v1//admin/getuserlist')
         .set('Accept', 'application/x-www-form-urlencoded')
-        .send({ username: 'Benny', password: 'benny' })
+        .set('x-access-token', adminToken)
         .end((err, res) => {
-          userToken = res.body.token;
           expect(res.status)
             .to
             .equal(200);
-          done();
-        });
-    });
-    it('should validate that the new user is unique', (done) => {
-      chai
-        .request(app)
-        .post('/api/v1/auth/users/signup')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .set({ 'x-access-token': userToken })
-        .send({
-          username: 'Benny',
-          firstname: 'Benn',
-          lastname: 'Nyotu',
-          email: 'ben@gmail.com',
-          password: 'benny',
-          passwordConfirmation: 'benny'
-        })
-        .end((err, res) => {
-          expect(res.status)
+          expect(res.body.users)
             .to
-            .be
-            .equal(409);
-          done();
-        });
-    });
-    it('should validate that the new user\'s email as unique', (done) => {
-      chai
-        .request(app)
-        .post('/api/v1/auth/users/signup')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .set({ 'x-access-token': userToken })
-        .send({
-          username: 'Homer',
-          firstname: 'Homer',
-          lastname: 'Simpson',
-          email: 'sample@email.com',
-          password: 'benny',
-          passwordConfirmation: 'benny'
-        })
-        .end((err, res) => {
-          expect(res.status)
+            .have
+            .length(3);
+          expect(res.body.users)
             .to
             .be
-            .equal(409);
+            .an('array');
           done();
         });
     });
-
-    it('should not create a user if the password does not match', (done) => {
+  });
+  describe('<Userlevellist route', () => {
+    it('should return 200 when displaying all user levels', (done) => {
       chai
         .request(app)
-        .post('/api/v1/auth/users/signup')
+        .get('/api/v1/auth/getuserlevellist')
         .set('Accept', 'application/x-www-form-urlencoded')
-        .set({ 'x-access-token': userToken })
-        .send({
-          username: 'Homer',
-          firstname: 'Homer',
-          lastname: 'Simpson',
-          email: 'ben@gmail.com',
-          password: 'benny',
-          passwordConfirmation: 'benny23'
-        })
+        .set('x-access-token', adminToken)
         .end((err, res) => {
           expect(res.status)
             .to
-            .be
-            .equal(422);
-          done();
-        });
-    });
-    it('should return successful login if user name and password', (done) => {
-      chai
-        .request(app)
-        .post('/api/v1/auth/users/signin')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .send({ username: 'Benny', password: 'benny' })
-        .end((err, res) => {
-          expect('Content-Type', /json/);
-          expect(res.body)
-            .have
-            .property('token');
-          done();
-        });
-    });
-    it('should require the username field', (done) => {
-      chai
-        .request(app)
-        .post('/api/v1/auth/users/signin')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .send({ username: '', password: 'benny' })
-        .end((err, res) => {
-          expect('Content-Type', /json/);
-          expect(res.status)
+            .equal(200);
+          expect(res.body.userLevels)
             .to
-            .be
-            .equal(400);
-          done();
-        });
-    });
-    it('should require the password field', (done) => {
-      chai
-        .request(app)
-        .post('/api/v1/auth/users/signin')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .send({ username: 'Benny', password: '' })
-        .end((err, res) => {
-          expect('Content-Type', /json/);
-          expect(res.status)
+            .have
+            .length(4);
+          expect(res.body.userLevels)
             .to
             .be
-            .equal(400);
+            .an('array');
           done();
         });
     });
   });
-  describe('Change password', () => {
-    it('should produce a 409 error message if the there is an error with previous password is supplied', (done) => {
-      chai
-        .request(app)
-        .put('/api/v1/users/changepassword')
-        .set('Accept', 'application/x-www-form-urlencoded')
-        .set({ 'x-access-token': userToken })
-        .send({ newPassword: 'benny', oldPassword: 'bebrb' })
-        .end((err, res) => {
-          expect(res.status)
-            .to
-            .equal(409);
-          done();
-        });
-    });
-    it('should be able to change a user\'s password provided a new password is specified', (done) => {
+  describe('<Get User route', () => {
+    it('should return 200 when get a seleted user', (done) => {
       chai
         .request(app)
-        .put('/api/v1/users/changepassword')
+        .get(`/api/v1/admin/users/${userId}`)
         .set('Accept', 'application/x-www-form-urlencoded')
-        .set({ 'x-access-token': userToken })
-        .send({ newPassword: 'bbbbvvvvvvvv', oldPassword: 'benny' })
+        .set('x-access-token', adminToken)
         .end((err, res) => {
           expect(res.status)
             .to
             .equal(200);
+          expect(res.body.user.username)
+            .to
+            .equal('testuser');
+          expect(res.body.user.userLevel)
+            .to
+            .equal(2);
+          expect(res.body.user)
+            .to
+            .be
+            .an('object');
           done();
         });
     });
   });
 });
-
-/*
-Authenticated users
-*/
diff --git a/server/src/test/userBooks.spec.js b/server/src/test/userBooks.spec.js
index ded5c07..74956d3 100644
--- a/server/src/test/userBooks.spec.js
+++ b/server/src/test/userBooks.spec.js
@@ -1,34 +1,31 @@
-import * as log from 'loglevel';
-
-import faker from 'faker';
 import chai from 'chai';
 import chaiHttp from 'chai-http';
-import jwt from 'jsonwebtoken';
-import dotenv from 'dotenv';
 
 import app from '../app';
 import db from '../models';
+import usrToken from './helpers/testHooks';
 
-
-const { User, Books } = db;
+const { Books } = db;
 const { expect } = chai;
 
-dotenv.config();
-
 chai.use(chaiHttp);
 
-
 let userId;
 let bookId;
 let zerobookId;
 let testbookId;
-let token;
+let userToken = '';
+let adminToken = '';
 const testdate = new Date('2018-01-04');
 const nulluserId = '';
 
-
-describe('HelloBooks', () => {
+describe('UserBooks', () => {
   before((done) => {
+    usrToken().then((response) => {
+      userToken = response.userToken;
+      adminToken = response.adminToken;
+      done();
+    });
     Books
       .create({
         title: 'Eze goes to school',
@@ -66,32 +63,9 @@ describe('HelloBooks', () => {
       .then((book) => {
         testbookId = book.id;
       });
-    User.create({
-      firstname: faker
-        .name
-        .firstName(),
-      lastname: faker
-        .name
-        .lastName(),
-      username: 'Fidelis',
-      password: 'bennyogidan',
-      passwordConfirmation: 'bennyogidan',
-      userLevel: '3',
-      email: faker.internet.email()
-    })
-      .then((user) => {
-        userId = user.id;
-        token = jwt.sign({
-          id: user.id
-        }, process.env.JWT_SECRET);
-        done();
-      })
-      .catch(() => {
-        log.debug('Error in the seeding of the db');
-      });
   });
 
-  describe('Loan', () => {
+  describe('<Loan Books', () => {
     it('should allow an authenticated user to loan a book', (done) => {
       const userbook = {
         bookId: bookId.toString(),
@@ -100,7 +74,7 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .post('/api/v1/users/loanbook')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .send(userbook)
         .end((err, res) => {
           expect(res.status)
@@ -111,16 +85,17 @@ describe('HelloBooks', () => {
     });
     it('should not allow loans without a specified return date', (done) => {
       const userbook = {
-        bookId: bookId.toString(),
+        bookId: bookId.toString()
       };
       chai
         .request(app)
         .post('/api/v1/users/loanbook')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .send(userbook)
         .end((err, res) => {
           const response = res.body;
-          expect(response.message).to
+          expect(response.message)
+            .to
             .equal('Please specify a valid return date');
           expect(res.status)
             .to
@@ -136,16 +111,20 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .post('/api/v1/users/loanbook')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .send(userbook)
         .end((err, res) => {
           const response = res.body;
-          expect(response.message).to
+          expect(response.message)
+            .to
             .equal('Amarachi continues to go to school successfully loaned');
           expect(res.status)
             .to
             .equal(200);
-          expect(res.body).to.be.an('object');
+          expect(res.body)
+            .to
+            .be
+            .an('object');
           done();
         });
     });
@@ -158,117 +137,148 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .post('/api/v1/users/loanbook')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .send(userbook)
         .end((err, res) => {
           const response = res.body;
-          expect(response.message).to
+          expect(response.message)
+            .to
             .equal('You have already borrowed this book');
           expect(res.status)
             .to
             .equal(409);
-          expect(res.body).to.be.an('object');
-          done();
-        });
-    });
-    it('should not be able to borrow book if the user id is invalid', (done) => {
-      const userbook = {
-        bookId: bookId.toString(),
-        returnDate: testdate
-      };
-      chai
-        .request(app)
-        .post(`/api/v1/users/${nulluserId}/books`)
-        .set('x-access-token', token)
-        .send(userbook)
-        .end((err, res) => {
-          expect(res.status)
-            .to
-            .equal(404);
-          done();
-        });
-    });
-    it('should not be able to borrow book with previous functioning route', (done) => {
-      const userbook = {
-        bookId: bookId.toString(),
-        returnDate: testdate
-      };
-      chai
-        .request(app)
-        .post('/api/v1/users/2/books')
-        .set('x-access-token', token)
-        .send(userbook)
-        .end((err, res) => {
-          const response = res.body;
-          expect(response.message).to
-            .equal(undefined);
-          expect(res.status)
-            .to
-            .equal(404);
-          expect(res.body).to.be.an('object');
-          done();
-        });
-    });
-    it('should not be able to borrow a book if bookId cannot be found', (done) => {
-      const userbook = {
-        bookId: 500,
-        returnDate: testdate
-      };
-      chai
-        .request(app)
-        .post('/api/v1/users/loanbook')
-        .set('x-access-token', token)
-        .send(userbook)
-        .end((err, res) => {
-          const response = res.body;
-          expect(response.message).to
-            .equal('Sorry we can\'t find this book or all copies of this book are on loan');
-          expect(res.status)
-            .to
-            .equal(404);
-          done();
-        });
-    });
-    it('should not be able to borrow a book if a valid return date is not inputted', (done) => {
-      const userbook = {
-        userId,
-        bookId: bookId.toString(),
-        returnDate: 'Invalid date'
-      };
-      chai
-        .request(app)
-        .post('/api/v1/users/loanbook')
-        .set('x-access-token', token)
-        .send(userbook)
-        .end((err, res) => {
-          const response = res.body;
-          expect(response.message).to
-            .equal('Please provide a valid return date');
-          expect(res.status)
+          expect(res.body)
             .to
-            .equal(422);
-          expect(res.body).to.be.an('object');
-          done();
-        });
-    });
-    it('should not be able to borrow a book if a valid return date is not inputted', (done) => {
-      const userbook = {
-        userId,
-        bookId: bookId.toString(),
-        returnDate: 2108
-      };
-      chai
-        .request(app)
-        .post('/api/v1/users/loanbook')
-        .set('x-access-token', token)
-        .send(userbook)
-        .end((err, res) => {
-          expect(res.status)
-            .to
-            .equal(500);
+            .be
+            .an('object');
           done();
         });
     });
+    it(
+      'should not be able to borrow book if the user id is invalid'
+      , (done) => {
+        const userbook = {
+          bookId: bookId.toString(),
+          returnDate: testdate
+        };
+        chai
+          .request(app)
+          .post(`/api/v1/users/${nulluserId}/books`)
+          .set('x-access-token', userToken)
+          .send(userbook)
+          .end((err, res) => {
+            expect(res.status)
+              .to
+              .equal(404);
+            done();
+          });
+      }
+    );
+    it(
+      'should not be able to borrow book with previous functioning route'
+      , (done) => {
+        const userbook = {
+          bookId: bookId.toString(),
+          returnDate: testdate
+        };
+        chai
+          .request(app)
+          .post('/api/v1/users/2/books')
+          .set('x-access-token', userToken)
+          .send(userbook)
+          .end((err, res) => {
+            const response = res.body;
+            expect(response.message)
+              .to
+              .equal(undefined);
+            expect(res.status)
+              .to
+              .equal(404);
+            expect(res.body)
+              .to
+              .be
+              .an('object');
+            done();
+          });
+      }
+    );
+    it(
+      'should not be able to borrow a book if bookId cannot be found'
+      , (done) => {
+        const userbook = {
+          bookId: 500,
+          returnDate: testdate
+        };
+        chai
+          .request(app)
+          .post('/api/v1/users/loanbook')
+          .set('x-access-token', userToken)
+          .send(userbook)
+          .end((err, res) => {
+            const response = res.body;
+            expect(response.message)
+              .to
+              .equal('Sorry we can\'t find this book or ' +
+                 'all copies of this book are on loan');
+            expect(res.status)
+              .to
+              .equal(404);
+            done();
+          });
+      }
+    );
+    it(
+      'should not be able to borrow a book if a valid ' +
+       'return date is not inputted',
+      (done) => {
+        const userbook = {
+          userId,
+          bookId: bookId.toString(),
+          returnDate: 'Invalid date'
+        };
+        chai
+          .request(app)
+          .post('/api/v1/users/loanbook')
+          .set('x-access-token', userToken)
+          .send(userbook)
+          .end((err, res) => {
+            const response = res.body;
+            expect(response.message)
+              .to
+              .equal('Please provide a valid return date');
+            expect(res.status)
+              .to
+              .equal(422);
+            expect(res.body)
+              .to
+              .be
+              .an('object');
+            done();
+          });
+      }
+    );
+    it(
+      'should not be able to borrow a book ' +
+      'if a valid return date is not inputted',
+      (done) => {
+        const userbook = {
+          userId,
+          bookId: bookId.toString(),
+          returnDate: 2108
+        };
+        chai
+          .request(app)
+          .post('/api/v1/users/loanbook')
+          .set('x-access-token', userToken)
+          .send(userbook)
+          .end((err, res) => {
+            expect(res.status)
+              .to
+              .equal(500);
+            done();
+          });
+      }
+    );
     it('should not be able to borrow a book if book quantity = 0', (done) => {
       const userbook = {
         userId,
@@ -278,29 +288,34 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .post('/api/v1/users/loanbook')
-        .set('x-access-token', token)
+        .set('x-access-token', adminToken)
         .send(userbook)
         .end((err, res) => {
           const response = res.body;
-          expect(response.message).to
-            .equal('Sorry we can\'t find this book or all copies of this book are on loan');
+          expect(response.message)
+            .to
+            .equal('Sorry we can\'t ' +
+            'find this book or all copies of this book are on loan');
           expect(res.status)
             .to
             .equal(404);
-          expect(res.body).to.be.an('object');
+          expect(res.body)
+            .to
+            .be
+            .an('object');
           done();
         });
     });
   });
 
-  describe('/GET should return a borrow history ', () => {
+  describe('<Get Borrow History', () => {
     it('should return a list of books loaned by the user', (done) => {
       chai
         .request(app)
         .get('/api/v1/users/borrowedbooks')
         .set('Accept', 'application/x-www-form-urlencoded')
         .query({ returned: false })
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .end((err, res) => {
           expect(res.status)
             .to
@@ -308,13 +323,12 @@ describe('HelloBooks', () => {
           done();
         });
     });
-    // /users/getloanhistory
     it('should not return a borrow list if return query is not set', (done) => {
       chai
         .request(app)
         .get('/api/v1/users/borrowedbooks')
         .set('Accept', 'application/x-www-form-urlencoded')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .end((err, res) => {
           expect(res.status)
             .to
@@ -327,7 +341,7 @@ describe('HelloBooks', () => {
         .request(app)
         .get('/api/v1/users/getloanhistory')
         .set('Accept', 'application/x-www-form-urlencoded')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .end((err, res) => {
           expect(res.status)
             .to
@@ -340,7 +354,7 @@ describe('HelloBooks', () => {
         .request(app)
         .get('/api/v1/users/getoverduebooks')
         .set('Accept', 'application/x-www-form-urlencoded')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .end((err, res) => {
           expect(res.status)
             .to
@@ -350,12 +364,12 @@ describe('HelloBooks', () => {
     });
   });
 
-  describe('/PUT Return book', () => {
+  describe('<Return book', () => {
     it('should be able to return a book with a book id', (done) => {
       chai
         .request(app)
         .put('/api/v1/users/returnbook')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .send({ bookId })
         .end((err, res) => {
           expect(res.status)
@@ -368,25 +382,30 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .put('/api/v1/users/returnbook')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .send({ bookId: 7 })
         .end((err, res) => {
           const response = res.body;
-          expect(response.message).to.equal('You did not borrow this book');
+          expect(response.message)
+            .to
+            .equal('You did not borrow this book');
           expect(res.status)
             .to
             .equal(409);
           done();
         });
     });
-    it('should not be able to return a book with an invalid id they have not borrowed', (done) => {
+    it('should not be able to return a book with an ' +
+      'invalid id they have not borrowed', (done) => {
       chai
         .request(app)
         .put('/api/v1/users/returnbook')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .send({ bookId: 'one' })
         .end((err, res) => {
-          expect(res.error.text).to.equal('invalid input syntax for integer: "one"');
+          expect(res.error.text)
+            .to
+            .equal('invalid input syntax for integer: "one"');
           expect(res.status)
             .to
             .equal(500);
@@ -397,11 +416,13 @@ describe('HelloBooks', () => {
       chai
         .request(app)
         .put('/api/v1/users/returnbook')
-        .set('x-access-token', token)
+        .set('x-access-token', userToken)
         .send({ bookId })
         .end((err, res) => {
           const response = res.body;
-          expect(response.message).to.equal('You did not borrow this book');
+          expect(response.message)
+            .to
+            .equal('You did not borrow this book');
           expect(res.status)
             .to
             .equal(409);
@@ -411,7 +432,3 @@ describe('HelloBooks', () => {
   });
 });
 
-/*
-
-Authenticated users
-*/