Merge 4af8d90 into fe16abe

src/config/config.js

@@ -23,5 +23,4 @@ const config = {
     DATABASE_URL: process.env.DATABASE_URL
   }
 };
-
 module.exports = config;

src/controllers/AccommodationController.js

@@ -0,0 +1,38 @@
+import models from '../models';
+import { HelperMethods } from '../utils';
+
+const { Room } = models;
+
+/**
+ * Class representing the Accomodation controller
+ * @class AccommodationController
+ * @description accommodation controller
+ */
+class AccommodationController {
+  /**
+  * Book An  Accommodation.
+  * Route: POST: /accommodation
+  * @param {object} req - HTTP Request object
+  * @param {object} res - HTTP Response object
+  * @return {res} res - HTTP Response object
+  * @memberof AccommodationController
+ */
+  static async bookAnAccommodation(req, res) {
+    try {
+      const { body } = req;
+      const { dataValues } = await Room.create({ ...body });
+      if (dataValues.id) {
+        HelperMethods.requestSuccessful(res, {
+          success: true,
+          message: 'Accommodation booked successfully',
+          accommodationCreated: dataValues,
+        }, 201);
+      }
+    } catch (error) {
+      if (error.errors) return HelperMethods.sequelizeValidationError(res, error);
+      return HelperMethods.serverError(res);
+    }
+  }
+}
+
+export default AccommodationController;

src/controllers/RequestController.js

@@ -335,7 +335,7 @@ class RequestController {
   * @return {res} res - HTTP Response object
   * @memberof RequestController
   */
-  static async confirmRequestApproval(req, res) {
+  static async confirmRequestApproval(req, res, next) {
     try {
       const approvedRequest = await Request.findOne({
         where: { id: req.body.id },
@@ -361,8 +361,9 @@ class RequestController {
       return HelperMethods.clientError(res,
         'The request you are trying to confirm cannot be found', 404);
     } catch (error) {
-      if (error.errors) return HelperMethods.sequelizeValidationError(res, error);
-      return HelperMethods.serverError(res);
+      // if (error.errors) return HelperMethods.sequelizeValidationError(res, error);
+      // return HelperMethods.serverError(res);
+      return next(error)
     }
   }
 }

src/controllers/index.js

@@ -1,4 +1,5 @@
 import UserController from './UserController';
 import RequestController from './RequestController';
+import AccommodationController from './AccommodationController';
 
-export { UserController, RequestController };
+export { UserController, RequestController, AccommodationController };

src/migrations/02-create-accommodations.js

@@ -1,5 +1,5 @@
 module.exports = {
-  up: (queryInterface, Sequelize) => queryInterface.createTable('Accommodations', {
+  up: (queryInterface, Sequelize) => queryInterface.createTable('Rooms', {
     id: {
       primaryKey: true,
       type: Sequelize.UUID,
@@ -37,5 +37,5 @@ module.exports = {
     }
   }),
 
-  down: queryInterface => queryInterface.dropTable('Accommodations')
+  down: queryInterface => queryInterface.dropTable('Rooms')
 };

src/migrations/03-create-requests.js

@@ -39,7 +39,7 @@ module.exports = {
     accommodationId: {
       type: Sequelize.UUID,
       references: {
-        model: 'Accommodations',
+        model: 'Rooms',
         key: 'id'
       }
     },

src/models/Accommodation.js

@@ -1,5 +1,5 @@
 export default (sequelize, DataTypes) => {
-  const Accommodation = sequelize.define('Accommodation', {
+  const Room = sequelize.define('Room', {
     id: {
       type: DataTypes.UUID,
       primaryKey: true,
@@ -36,12 +36,12 @@ export default (sequelize, DataTypes) => {
     },
   });
 
-  Accommodation.associate = models => {
-    Accommodation.hasMany(models.Request, {
+  Room.associate = models => {
+    Room.hasMany(models.Request, {
       foreignKey: 'accommodationId',
       as: 'accommodation',
     });
   };
 
-  return Accommodation;
+  return Room;
 };

src/models/Request.js

@@ -55,7 +55,7 @@ export default (sequelize, DataTypes) => {
       foreignKey: 'userId',
       onDelete: 'CASCADE',
     });
-    Request.belongsTo(models.Accommodation, {
+    Request.belongsTo(models.Room, {
       foreignKey: 'accommodationId',
       onDelete: 'CASCADE',
     });

src/routes/accommodationRoute.js

@@ -0,0 +1,14 @@
+import { AccommodationController } from '../controllers';
+import { Authorization } from '../middlewares';
+import Validate from '../validation';
+
+const accommodationRoute = app => {
+  app.post(
+    '/api/v1/accommodation',
+    Validate.validateUserInput,
+    Authorization.checkToken,
+    AccommodationController.bookAnAccommodation
+  );
+};
+
+export default accommodationRoute;

src/routes/index.js

@@ -1,5 +1,6 @@
 import authRoute from './authRoute';
 import requestRoute from './requestRoute';
+import accommodationRoute from './accommodationRoute';
 import userRoute from './userRoute';
 import socialAuthRoute from './socialAuthRoute';
 /**
@@ -19,6 +20,7 @@ const routes = app => {
   requestRoute(app);
   userRoute(app);
   socialAuthRoute(app);
+  accommodationRoute(app);
 };
 
 export default routes;

src/seeders/02-demo-accommodation.js

@@ -1,5 +1,5 @@
 module.exports = {
-  up: queryInterface => queryInterface.bulkInsert('Accommodations', [
+  up: queryInterface => queryInterface.bulkInsert('Rooms', [
     {
       id: '2125be7b-f1f1-4f0a-af86-49c657870b5c',
       name: 'Southern Sun Ikoyi Hotel',
@@ -32,5 +32,5 @@ module.exports = {
     }
   ], {}),
 
-  down: queryInterface => queryInterface.bulkDelete('Accommodations', null, {})
+  down: queryInterface => queryInterface.bulkDelete('Rooms', null, {})
 };

src/test/integrationTests/accommodationController.test.js

@@ -0,0 +1,57 @@
+import chai from 'chai';
+import chaiHttp from 'chai-http';
+import app from '../../index';
+
+chai.use(chaiHttp);
+const { expect } = chai;
+
+describe('Integration Tests For Accommodation Controller', () => {
+  describe('Test book accommodation controller', () => {
+    const accommodationDetails = {
+      name: 'Southern Sun Ikoyi Hotel',
+      address: '174, Owolabi street, Yaba',
+      roomName: 'C3',
+      roomType: '2 bedroom',
+      vacantNumber: '1',
+    };
+    let token;
+    before('Get Token', async () => {
+      const loginResponse = await chai.request(app).post('/api/v1/auth/login')
+        .send({
+          email: 'demo2@demo.com',
+          password: 'password',
+        });
+      token = loginResponse.body.data.userDetails.token;
+    });
+    it('should book an accommodation for a user', async () => {
+      const response = await chai.request(app).post('/api/v1/accommodation')
+        .send(accommodationDetails).set('x-access-token', token);
+      expect(response.status).to.deep.equal(201);
+      expect(response.body.data).to.have.property('success');
+      expect(response.body.data.success).to.equal(true);
+      expect(response.body.data).to.have.property('message');
+      expect(response.body.data.message)
+        .to.equal('Accommodation booked successfully');
+    });
+    it('should return client error when some details are missing', async () => {
+      const response = await chai.request(app).post('/api/v1/accommodation')
+        .send().set({ 'x-access-token': token });
+      expect(response.status).to.deep.equal(400);
+      expect(response.body).to.have.property('success');
+      expect(response.body.success).to.equal(false);
+      expect(response.body).to.have.property('message');
+      expect(response.body.message)
+        .to.equal('The "name" field is required');
+    });
+    it('should return error for missing token', async () => {
+      const response = await chai.request(app).post('/api/v1/accommodation')
+        .send(accommodationDetails);
+      expect(response.status).to.deep.equal(401);
+      expect(response.body).to.have.property('success');
+      expect(response.body.success).to.equal(false);
+      expect(response.body).to.have.property('message');
+      expect(response.body.message)
+        .to.equal('User not authorized');
+    });
+  });
+});

src/test/integrationTests/index.js

@@ -1,3 +1,4 @@
 import './requestController.test';
 import './userController.test';
 import './socialController.test';
+import './accommodationController.test';

src/test/unitTests/accomodationController.test.js

@@ -0,0 +1,35 @@
+import sinon from 'sinon';
+import chai from 'chai';
+import { AccommodationController } from '../../controllers';
+import models from '../../models';
+
+const { expect } = chai;
+const { Room } = models;
+
+const req = { decoded: { id: 'some id' } };
+
+const res = {
+  status() {
+    return this;
+  },
+  json(obj) {
+    return obj;
+  }
+};
+
+describe('unit test for the Accomodation Controller', () => {
+  let stubbedMethod;
+  afterEach(() => {
+    if (stubbedMethod.restore) stubbedMethod.restore();
+  });
+  it('should return a server error when an unexpected error happens', async () => {
+    stubbedMethod = sinon.stub(Room, 'create').throws({
+      dataValues: 'some thing'
+    });
+    const response = await AccommodationController.bookAnAccommodation(req, res);
+    expect(response).to.have.property('message');
+    expect(response.message).to.equal('Internal server error');
+    expect(response).to.have.property('success');
+    expect(response.success).to.equal(false);
+  });
+});

src/test/unitTests/index.js

@@ -2,5 +2,7 @@ import './authentication.test';
 import './sendEmail.test';
 import './helperMethods.test';
 import './requestController.test';
+import './accomodationController.test';
+import './userController.test';
 import './middleware.test';
 import './searchRequestsMiddleware.test';

src/test/unitTests/userController.test.js

@@ -0,0 +1,73 @@
+import sinon from 'sinon';
+import chai from 'chai';
+import { UserController } from '../../controllers';
+import models from '../../models';
+
+const { expect } = chai;
+const { User } = models;
+
+const req = { decoded: { id: 'some id' } };
+
+const res = {
+  status() {
+    return this;
+  },
+  json(obj) {
+    return obj;
+  }
+};
+
+describe('unit test for the User Controller', () => {
+  let stubbedMethod;
+  afterEach(() => {
+    if (stubbedMethod.restore) stubbedMethod.restore();
+  });
+  it('should return a server error when an unexpected error happens', async () => {
+    stubbedMethod = sinon.stub(User, 'findByPk').throws({
+      dataValues: 'some thing'
+    });
+    const response = await UserController.updateProfile(req, res);
+    expect(response).to.have.property('message');
+    expect(response.message).to.equal('Internal server error');
+    expect(response).to.have.property('success');
+    expect(response.success).to.equal(false);
+  });
+  it('should return a server error when an unexpected error happens', async () => {
+    stubbedMethod = sinon.stub(User, 'findByPk').throws({
+      dataValues: 'some thing'
+    });
+    const response = await UserController.getProfile(req, res);
+    expect(response).to.have.property('message');
+    expect(response.message).to.equal('Internal server error');
+    expect(response).to.have.property('success');
+    expect(response.success).to.equal(false);
+  });
+  it('should return a server error when an unexpected error happens', async () => {
+    stubbedMethod = sinon.stub(User, 'findByPk').throws({
+      dataValues: 'some thing'
+    });
+    const response = await UserController.verifyEmail(req, res);
+    expect(response).to.have.property('message');
+    expect(response.message).to.equal('Internal server error');
+    expect(response).to.have.property('success');
+    expect(response.success).to.equal(false);
+  });
+  it('should return a server error when an unexpected error happens', async () => {
+    stubbedMethod = sinon.stub(User, 'findOne').throws({
+      dataValues: 'some thing'
+    });
+    const response = await UserController.resetPassword(req, res);
+    expect(response).to.have.property('message');
+    expect(response.message).to.equal('Internal server error');
+    expect(response).to.have.property('success');
+    expect(response.success).to.equal(false);
+  });
+  it('should only allow managers reject a User', async () => {
+    stubbedMethod = sinon.stub(User, 'update').throws({ dataValues: 'some thing' });
+    const response = await UserController.rememberUserDetails(req, res);
+    expect(response).to.have.property('message');
+    expect(response.message).to.equal('Internal server error');
+    expect(response).to.have.property('success');
+    expect(response.success).to.equal(false);
+  });
+});