fix hooks and write tests

Author: muhammaddadu

hookslib/CloutApiRoute.js

@@ -3,6 +3,7 @@
  * Copyright(c) 2018 Muhammad Dadu
  * MIT Licensed
  */
+const debug = require('debug')('clout-js:api')
 const { safePromisifyCallFn } = require('../lib/utils');
 const types = require('./apiType');
 
@@ -64,13 +65,17 @@ class CloutApiRoute {
  * handles router method in a promise
  * @param {*} fn RouterCallback
  */
- handlePromisePostTriggers(fn) {
- const { isPublicFacing } = this;
+ handlePromisePostTriggers(fn, _isPublicFacing) {
+ const { isPublicFacing } = typeof _isPublicFacing !== 'undefined' ? _isPublicFacing : this;
  return function postPromiseHandle(req, resp, next, ...args) {
  safePromisifyCallFn(fn, this, [req, resp, null, ...args])
  .then((data) => {
+ const headerSent = !!resp._header;
+ debug(req.url, 'isPublicFacing', isPublicFacing)
+ debug(req.url, 'headerSent', headerSent)
+ debug('data', data);
  if (isPublicFacing) {
- if (!resp.headerSent) {
+ if (!headerSent) {
  return resp.ok(data);
  }
  } else {

hookslib/apiType/api.js

@@ -1,11 +1,13 @@
+const debug = require('debug')('clout-js:api');
+
 module.exports = {
  name: 'api',
  fn(fn) {
  const apiPath = this.path && `${this.path}.:acceptType?`;
 
  const attachHook = (method, hookFn) => this.router[method](
  apiPath,
- this.handlePromisePostTriggers(hookFn),
+ this.handlePromisePostTriggers(hookFn, false),
  );
 
  this.methods.forEach((method) => {
@@ -16,7 +18,19 @@ module.exports = {
  });
 
  // attach hooks
- this.hooks.map(hookFn => attachHook(method, hookFn));
+ this.hooks
+ .filter(hookFn => {
+ const isFunction = typeof hookFn === 'function';
+ if (!isFunction) {
+ console.error({apiPath, isFunction}, 'hook is not a function');;
+ }
+
+ return isFunction;
+ })
+ .map(hookFn => {
+ debug({method, hookFn}, 'attaching hookFn for method');
+ return attachHook(method, hookFn);
+ });
 
  this.router[method](apiPath, this.handlePromisePostTriggers(fn));
  });

test/e2e_user_auth_test.js

@@ -0,0 +1,103 @@
+const should = require('should');
+const testLib = require('./lib');
+const request = testLib.request;
+const {merge} = require('lodash');
+
+const USER_1 = {
+ name: 'Dadu',
+ email: 'dadu@test.com',
+};
+
+const USER_2 = {
+ name: 'Marcos',
+ email: 'marcos@test.com',
+};
+
+describe('e2e User Auth Tests', function () {
+ let clout;
+
+ before(() => {
+ process.env.PORT = 8420;
+ process.env.NODE_ENV = 'test';
+ clout = testLib.createInstance();
+ });
+
+ it('start server', (done) => {
+ clout.start();
+ clout.on('started', () => {
+ let server = clout.server['http'];
+ if (server) {
+ let port = server.address().port;
+ serverAddress = `http://localhost:${port}`;
+ }
+ done();
+ });
+ });
+
+ describe('/user - non authenticated', () => {
+ it('should give 403 /user', async () => {
+ const response = await request({ uri: `/api/user`, json: true });
+ should(response.statusCode).be.equal(401);
+ });
+
+ it('should add 1 user to /user', async () => {
+ const response = await request({
+ method: 'put',
+ uri: `/api/user`,
+ body: USER_1,
+ json: true
+ });
+
+ should(response.body).be.deepEqual(merge({ id: 1 }, USER_1));
+ });
+ });
+
+
+
+ describe('/user - example api', () => {
+ const headers = {
+ 'X-Auth-Token': 'test-auth-token',
+ }
+
+ it('should return 1 item from /user', async () => {
+ const response = await request({ uri: `/api/user`, json: true , headers});
+ 
+ should(response.statusCode).be.equal(200);
+ should(response.body.length).be.equal(1);
+ });
+
+ it('should add 1 more item to /user', async () => {
+ const response = await request({
+ method: 'put',
+ uri: `/api/user`,
+ body: USER_2,
+ json: true,
+ headers,
+ });
+
+ should(response.body).be.deepEqual(merge({ id: 2 }, USER_2));
+ });
+
+ it('should return 2 items from /user', async () => {
+ const response = await request({ uri: `/api/user`, json: true, headers });
+ 
+ should(response.statusCode).be.equal(200);
+ should(response.body.length).be.equal(2);
+ });
+
+ it('should delete an item from /user/2 & /user/3', async () => {
+ await request({ uri: `/api/user/1`, method: 'delete', json: true, headers });
+ await request({ uri: `/api/user/2`, method: 'delete', json: true, headers });
+ 
+ const response = await request({ uri: `/api/user`, json: true, headers });
+
+ should(response.statusCode).be.equal(200);
+ should(response.body.length).be.equal(0);
+ });
+ });
+
+ after('stop server', (done) => {
+ clout.on('stopped', () => done());
+ clout.stop();
+ });
+});

test/fixed/kitchensink/apis/account_example/index.js

@@ -0,0 +1,20 @@
+/**
+ * User API Example
+ * Define API settings and helpers
+ */
+
+module.exports = {
+ userId: {
+ type: 'param',
+ param: 'userId',
+ result: 'user',
+ description: 'define userId',
+ fn: (req, resp, next, userId) => {
+ return req.models.user.getById(userId)
+ .catch((err) => {
+ req.logger.error(err);
+ throw err;
+ });
+ }
+ }
+};

test/fixed/kitchensink/apis/account_example/user.js

@@ -0,0 +1,60 @@
+/**
+ * Simple API Example
+ */
+const {isAuthenticated} = require('../../middleware/authentication');
+
+module.exports = {
+ list: {
+ path: '/user',
+ method: 'get',
+ description: `
+ API Example to demonstrate simple key value storage using a user model
+ `,
+ hooks: [isAuthenticated],
+ fn: (req, resp) => {
+ const UserDB = req.models.user;
+
+ return UserDB.list();
+ }
+ },
+ create: {
+ path: '/user',
+ method: 'put',
+ params: {
+ name: 'string',
+ email: 'string'
+ },
+ description: `
+ API Example to demonstrate simple key value storage using a user model
+ `,
+ fn: (req, resp) => {
+ const UserDB = req.models.user;
+ const params = req.body;
+
+ return UserDB.add(params);
+ }
+ },
+ getById: {
+ path: '/user/:userId',
+ method: 'get',
+ description: `
+ API Example to demonstrate advanced routing
+ `,
+ hooks: [isAuthenticated],
+ fn: (req, resp) => {
+ resp.ok(req.param('user'));
+ }
+ },
+ delete: {
+ path: '/user/:userId',
+ method: 'delete',
+ description: `
+ API Example to demonstrate advanced routing
+ `,
+ hooks: [isAuthenticated],
+ fn: (req, resp) => {
+ req.param('user').delete()
+ .then(() => resp.ok({}));
+ }
+ }
+};

test/fixed/kitchensink/middleware/authentication.js

@@ -0,0 +1,13 @@
+const authToken = 'test-auth-token';
+
+module.exports = {
+ isAuthenticated: (req, resp, next) => {
+ const isValidToken = req.header('X-Auth-Token') === authToken;
+
+ if (!isValidToken) {
+ return resp.unauthorized();
+ }
+
+ return next();
+ }
+};

test/fixed/kitchensink/models/user.js

@@ -0,0 +1,41 @@
+const simpleModel = require('./simple');
+const userDB = {};
+
+class User {
+ constructor(user) {
+ Object.assign(this, user);
+ }
+
+ async save() {
+ const instance = !this.id
+ ? await simpleModel.create(this)
+ : await simpleModel.getById(this.id);
+
+ Object.assign(this, instance);
+ userDB[this.id] = instance;
+
+ return Promise.resolve(instance);
+ }
+
+ delete() {
+ simpleModel.deleteById(this.id);
+ userDB[this.id] = null;
+ delete userDB[this.id];
+ return Promise.resolve();
+ }
+}
+
+module.exports = {
+ list() {
+ let list = Object.keys(userDB).map((id) => Object.assign(userDB[id], { id }));
+
+ return Promise.resolve(list);
+ },
+ getById(userId) {
+ return simpleModel.getById(userId)
+ .then((info) => new User(info));
+ },
+ add(info) {
+ return (new User(info)).save();
+ }
+};