stefanie hansen

stefanie-hansen/.gitignore

@@ -0,0 +1,2 @@
+/node_modules
+.eslintrc.js

stefanie-hansen/gulpfile.js

@@ -0,0 +1,63 @@
+const gulp = require('gulp');
+const mocha = require('gulp-mocha');
+const lint = require('gulp-eslint');
+const opts = {
+  'extends': 'eslint:recommended',
+  'ecmaFeatures': {
+    'modules': true
+  },
+  'rules': {
+    'no-alert': 0,
+    'no-bitwise': 0,
+    'camelcase': 1,
+    'no-console': 1,
+    'curly': 1,
+    'eqeqeq': 0,
+    'no-eq-null': 0,
+    'guard-for-in': 1,
+    'no-empty': 1,
+    'no-use-before-define': 0,
+    'no-obj-calls': 2,
+    'no-unused-vars': 0,
+    'new-cap': 1,
+    'no-shadow': 0,
+    'strict': 1,
+    'no-invalid-regexp': 2,
+    'comma-dangle': 2,
+    'no-undef': 1,
+    'no-new': 1,
+    'no-extra-semi': 1,
+    'no-debugger': 2,
+    'no-caller': 1,
+    'semi': 1,
+    'quotes': 0,
+    'no-unreachable': 2
+  },
+  'globals': {
+    '$': false
+  },
+  'env': {
+    'node': true,
+    'es6': true
+  }
+};
+
+
+gulp.task('linter' , () => {
+  return gulp.src(['./*.js', './test/*.js', './lib/*.js'])
+    .pipe(lint(opts))
+    .pipe(lint.format());
+});
+
+gulp.task('tests', () => {
+  return gulp.src(['./*.js', './test/*.js', './lib/*.js'], {read: false})
+    .pipe(mocha({reporter: 'nyan'}));
+});
+
+gulp.task('watch', () => {
+  gulp.watch(['./*.js', './test/*.js', './lib/*.js'], ['linter', 'tests']);
+});
+
+gulp.task('default', ['linter', 'tests', 'watch'], () => {
+
+});

stefanie-hansen/index.js

@@ -0,0 +1 @@
+require('./lib/server');

stefanie-hansen/lib/middleware.js

@@ -0,0 +1,23 @@
+'use strict';
+
+// for testing
+let requestObj = exports.requestObj = {};
+
+exports.parse = function jsonParser(req, res, next) {
+  let dataBody = '';
+  req.on('data', (data) => {
+    dataBody += data.toString();
+  });
+  req.on('end', () => {
+    try {
+      req.body = requestObj.body = JSON.parse(dataBody);
+      req.status = requestObj.status = 200;
+      if (next) next();
+    } catch(err) {
+      console.log('Error', err);
+      req.body = requestObj.err = {"Message":"invalid json"};
+      req.status = requestObj.statusErr = 400;
+      if (next) next();
+    }
+  });
+};

stefanie-hansen/lib/router.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const express = require('express');
+const app = express();
+const bodyParser = require('body-parser');
+const middleware = require('./middleware');
+const router = express.Router();
+module.exports = router;
+
+router.use(middleware.parse);
+
+router.post('*', (req, res) => {
+  res.status(req.status).send(req.body);
+}).put('*', (req, res) => {
+  res.status(req.status).send(req.body);
+});

stefanie-hansen/lib/server.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const express = require('express');
+const app = express();
+const router = require('./router');
+
+app.use(router);
+
+app.all('*', (req, res) => {
+  res.sendStatus(404);
+});
+
+app.listen(3000, () => {
+  console.log('Listening on Port 3000');
+});

stefanie-hansen/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "stefanie-hansen",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "body-parser": "^1.15.1",
+    "express": "^4.13.4"
+  },
+  "devDependencies": {
+    "chai": "^3.5.0",
+    "chai-http": "^2.0.1",
+    "gulp": "^3.9.1",
+    "gulp-eslint": "^2.0.0",
+    "gulp-mocha": "^2.2.0",
+    "mocha": "^2.5.2"
+  }
+}

stefanie-hansen/test/middleware-test.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const chai = require('chai');
+const expect = chai.expect;
+const chaiHTTP = require('chai-http');
+chai.use(chaiHTTP);
+const request = chai.request;
+const middleware = require('../lib/middleware');
+require('../lib/server');
+const Readable = require('stream').Readable;
+let requestObj;
+
+describe('Middleware tests', () => {
+
+  describe('Unit tests', () => {
+
+    before('obtain request object from middleware after valid JSON sent', (done) => {
+      // test input for middleware
+      let reqStream = new Readable;
+      reqStream.push('{"message":"test"}');
+      reqStream.push(null);
+
+      let res = {};
+      middleware.parse(reqStream, res);
+      requestObj = middleware.requestObj;
+      done();
+    });
+
+    it('should parse JSON and attach it to the request body', () => {
+      expect(requestObj.body).to.eql({message: 'test'});
+      expect(requestObj.status).to.eql(200);
+    });
+
+    before('obtain request object from middleware after invalid JSON sent', (done) => {
+      // test input for middleware
+      let reqStream2 = new Readable;
+      reqStream2.push('test message');
+      reqStream2.push(null);
+
+      let res = {};
+      middleware.parse(reqStream2, res);
+      requestObj = middleware.requestObj;
+      done();
+    });
+
+    it('should return an error message attached to the request body if valid JSON is not sent', () => {
+      expect(requestObj.err).to.eql({Message: 'invalid json'});
+      expect(requestObj.statusErr).to.eql(400);
+    });
+  });
+
+
+  describe('Integration tests', () => {
+
+    it('should respond without errors', (done) => {
+      request('localhost:3000')
+          .post('/')
+          .send({"test":"test"})
+          .end((err, res) => {
+            expect(err).to.eql(null);
+            expect(res).to.have.status(200);
+            done();
+          });
+    });
+
+    it('should respond with parsed JSON attached to the response body after an actual request', (done) => {
+      request('localhost:3000')
+          .post('/')
+          .send({"test":"test"})
+          .end((err, res) => {
+            expect(res.body).to.eql({test:'test'});
+            expect(res).to.have.status(200);
+            done();
+          });
+    });
+
+    it('should respond with an error attached to the response body after invalid JSON is sent with an actual request', (done) => {
+      request('localhost:3000')
+          .post('/')
+          .send('not json')
+          .end((err, res) => {
+            expect(res.body).to.eql({Message:'invalid json'});
+            expect(res).to.have.status(400);
+            done();
+          });
+    });
+
+    it('should respond to any request other than a POST or PUT with an error', (done) => {
+      request('localhost:3000')
+          .get('/')
+          .end((err, res) => {
+            expect(res.text).to.eql('Not Found');
+            expect(res).to.have.status(404);
+            done();
+          });
+    });
+  });
+});