Merge pull request #1 from robinjoseph08/add-testing

test(regex): add tests and travis

.travis.yml

@@ -0,0 +1,17 @@
+language: node_js
+sudo: false
+node_js:
+  - '5'
+addons:
+  postgresql: '9.4'
+services:
+  - postgresql
+before_script:
+  - psql -c 'CREATE ROLE "rmj_user" CREATEDB CREATEUSER LOGIN;' -U postgres
+  - createdb -O rmj_user rmj
+  - npm run migrate
+script:
+  - npm test
+  - npm run lint
+after_script:
+  - npm run coveralls

README.md

@@ -2,6 +2,10 @@
 
 The API for [rmj.io](http://rmj.io).
 
+[![Build Status](https://travis-ci.org/robinjoseph08/api.rmj.io.svg)](https://travis-ci.org/robinjoseph08/api.rmj.io)
+[![Coverage Status](https://coveralls.io/repos/robinjoseph08/api.rmj.io/badge.svg?branch=master&service=github)](https://coveralls.io/github/robinjoseph08/api.rmj.io?branch=master)
+[![Dependency Status](https://david-dm.org/robinjoseph08/api.rmj.io.svg)](https://david-dm.org/robinjoseph08/api.rmj.io)
+
 ## Install
 
 This project is meant to be run with Node.js v5, so make sure you have it installed and active when running this application.

config/test.js

@@ -1,11 +1,11 @@
 'use strict';
 
 module.exports = {
-  DB_NAME: 'ubuntu',
+  DB_NAME: 'rmj',
   DB_HOST: 'localhost',
   DB_PORT: 5432,
   DB_PASSWORD: '',
-  DB_USER: 'ubuntu',
+  DB_USER: 'rmj_user',
   DRAIN_TIMEOUT: 5000,
   PORT: 8080
 };

package.json

@@ -4,13 +4,16 @@
   "description": "The API for rmj.io",
   "main": "app/index.js",
   "scripts": {
+    "coveralls": "cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js",
     "lint": "eslint .",
     "migrate": "knex migrate:latest --knexfile db/index.js",
     "migrate:make": "knex migrate:make --knexfile db/index.js",
     "rollback": "knex migrate:rollback --knexfile db/index.js",
     "seed": "knex seed:run --knexfile db/index.js",
     "seed:make": "knex seed:make --knexfile db/index.js",
-    "start": "nodemon --ignore test/"
+    "start": "nodemon --ignore test/",
+    "test": "NODE_ENV=test istanbul cover _mocha -- test --recursive --timeout 30000",
+    "test-no-cover": "NODE_ENV=test mocha test --recursive --timeout 30000"
   },
   "repository": {
     "type": "git",
@@ -23,8 +26,13 @@
   },
   "homepage": "https://github.com/robinjoseph08/api.rmj.io#readme",
   "devDependencies": {
+    "chai": "^3.4.1",
+    "coveralls": "^2.11.6",
     "eslint": "^1.10.3",
     "eslint-config-lob": "^1.0.1",
+    "inject-then": "^2.0.3",
+    "istanbul": "^0.4.1",
+    "mocha": "^2.3.4",
     "nodemon": "^1.8.1"
   },
   "dependencies": {

test/fixtures/regex/levels/default.json

@@ -0,0 +1,3 @@
+{
+  "id": 1
+}

test/fixtures/regex/words/left.json

@@ -0,0 +1,6 @@
+{
+  "id": 1,
+  "value": "left_test",
+  "side": "left",
+  "regex_level_id": 1
+}

test/fixtures/regex/words/right.json

@@ -0,0 +1,6 @@
+{
+  "id": 2,
+  "value": "right_test",
+  "side": "right",
+  "regex_level_id": 1
+}

test/models/regex/level.test.js

@@ -0,0 +1,90 @@
+'use strict';
+
+let expect = require('chai').expect;
+
+let Knex       = require('../../../app/libraries/knex');
+let RegexLevel = require('../../../app/models/regex/level');
+let RegexWord  = require('../../../app/models/regex/word');
+
+let defaultLevel = require('../../fixtures/regex/levels/default');
+let leftWord     = require('../../fixtures/regex/words/left');
+let rightWord    = require('../../fixtures/regex/words/right');
+
+describe('regex level model', () => {
+
+  beforeEach(() => {
+    return Promise.all([
+      Knex.raw('TRUNCATE regex_levels CASCADE'),
+      Knex.raw('TRUNCATE regex_words CASCADE')
+    ])
+    .then(() => {
+      return Knex('regex_levels').insert(defaultLevel);
+    })
+    .then(() => {
+      return Knex('regex_words').insert([leftWord, rightWord]);
+    });
+  });
+
+  describe('left_words', () => {
+
+    it('only lists left words', () => {
+      return new RegexLevel({ id: defaultLevel.id })
+      .fetch({ withRelated: ['left_words'] })
+      .then((level) => {
+        expect(level.related('left_words')).to.have.length(1);
+        expect(level.related('left_words').at(0).get('id')).to.eql(leftWord.id);
+      });
+    });
+
+  });
+
+  describe('right_words', () => {
+
+    it('only lists right words', () => {
+      return new RegexLevel({ id: defaultLevel.id })
+      .fetch({ withRelated: ['right_words'] })
+      .then((level) => {
+        expect(level.related('right_words')).to.have.length(1);
+        expect(level.related('right_words').at(0).get('id')).to.eql(rightWord.id);
+      });
+    });
+
+  });
+
+  describe('serialize', () => {
+
+    let left;
+    let right;
+    let level;
+
+    beforeEach(() => {
+      left = RegexWord.collection([
+        RegexWord.forge({ id: 1, value: 'testing1', side: 'left' }),
+        RegexWord.forge({ id: 2, value: 'testing2', side: 'left' })
+      ]);
+      right = RegexWord.collection([
+        RegexWord.forge({ id: 3, value: 'testing3', side: 'right' }),
+        RegexWord.forge({ id: 4, value: 'testing4', side: 'right' }),
+        RegexWord.forge({ id: 5, value: 'testing5', side: 'right' })
+      ]);
+      level = RegexLevel.forge({ id: 1 });
+      level.relations.left_words = left;
+      level.relations.right_words = right;
+    });
+
+    it('returns the correct properties', () => {
+      let json = level.serialize();
+
+      expect(json).to.have.all.keys('id', 'left_words', 'right_words');
+      expect(json.id).to.eql(level.get('id'));
+      left.each((word, i) => {
+        expect(json.left_words[i]).to.eql(word.serialize());
+      });
+      right.each((word, i) => {
+        expect(json.right_words[i]).to.eql(word.serialize());
+      });
+    });
+
+  });
+
+});

test/models/regex/word.test.js

@@ -0,0 +1,28 @@
+'use strict';
+
+let expect = require('chai').expect;
+
+let RegexWord = require('../../../app/models/regex/word');
+
+describe('regex word model', () => {
+
+  let word;
+
+  beforeEach(() => {
+    word = RegexWord.forge({ id: 1, value: 'testing', side: 'left' });
+  });
+
+  describe('serialize', () => {
+
+    it('returns the correct properties', () => {
+      let json = word.serialize();
+
+      expect(json).to.have.all.keys('id', 'value', 'side');
+      expect(json.id).to.eql(word.get('id'));
+      expect(json.value).to.eql(word.get('value'));
+      expect(json.side).to.eql(word.get('side'));
+    });
+
+  });
+
+});

test/plugins/features/regex/controller.test.js

@@ -0,0 +1,39 @@
+'use strict';
+
+let expect = require('chai').expect;
+
+let Controller = require('../../../../app/plugins/features/regex/controller');
+let Knex       = require('../../../../app/libraries/knex');
+
+let defaultLevel = require('../../../fixtures/regex/levels/default');
+let leftWord     = require('../../../fixtures/regex/words/left');
+let rightWord    = require('../../../fixtures/regex/words/right');
+
+describe('regex controller', () => {
+
+  beforeEach(() => {
+    return Promise.all([
+      Knex.raw('TRUNCATE regex_levels CASCADE'),
+      Knex.raw('TRUNCATE regex_words CASCADE')
+    ])
+    .then(() => {
+      return Knex('regex_levels').insert(defaultLevel);
+    })
+    .then(() => {
+      return Knex('regex_words').insert([leftWord, rightWord]);
+    });
+  });
+
+  describe('list', () => {
+
+    it('gets all regex levels', () => {
+      return Controller.list()
+      .then((levels) => {
+        expect(levels).to.have.length(1);
+        expect(levels.at(0).get('id')).to.eql(defaultLevel.id);
+      });
+    });
+
+  });
+
+});

test/plugins/features/regex/index.test.js

@@ -0,0 +1,43 @@
+'use strict';
+
+let expect = require('chai').expect;
+
+let Knex   = require('../../../../app/libraries/knex');
+let Server = require('../../../../app/server');
+
+let defaultLevel = require('../../../fixtures/regex/levels/default');
+let leftWord     = require('../../../fixtures/regex/words/left');
+let rightWord    = require('../../../fixtures/regex/words/right');
+
+describe('regex integration', () => {
+
+  beforeEach(() => {
+    return Promise.all([
+      Knex.raw('TRUNCATE regex_levels CASCADE'),
+      Knex.raw('TRUNCATE regex_words CASCADE')
+    ])
+    .then(() => {
+      return Knex('regex_levels').insert(defaultLevel);
+    })
+    .then(() => {
+      return Knex('regex_words').insert([leftWord, rightWord]);
+    });
+  });
+
+  describe('list', () => {
+
+    it('correctly retrieves and serializes', () => {
+      return Server.injectThen({
+        url: '/regex',
+        method: 'GET'
+      })
+      .then((res) => {
+        expect(res.statusCode).to.eql(200);
+        expect(res.result).to.have.length(1);
+        expect(res.result[0].id).to.eql(defaultLevel.id);
+      });
+    });
+
+  });
+
+});

test/setup.test.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var Server = require('../app/server');
+
+Server.register([
+  require('inject-then')
+], (err) => {
+  if (err) {
+    throw err;
+  }
+});