Moved tests -> test because mocha likes that

test/routes/api/assets/index.js

@@ -0,0 +1,147 @@
+const passport = require('../../../passport');
+
+const app = require('../../../../app');
+const chai = require('chai');
+const expect = chai.expect;
+
+// Setup chai.
+chai.should();
+chai.use(require('chai-http'));
+
+const Asset = require('../../../../models/asset');
+
+describe('/api/v1/assets', () => {
+
+  beforeEach(() => {
+    return Asset.create([
+      {
+        url: 'https://coralproject.net/news/asset1',
+        title: 'Asset 1',
+        description: 'term1',
+        closedAt: Date.now()
+      },
+      {
+        url: 'https://coralproject.net/news/asset2',
+        title: 'Asset 2',
+        description: 'term2',
+        closedAt: null
+      }
+    ]);
+  });
+
+  describe('#get', () => {
+
+    it('should return all assets without a search query', () => {
+      return chai.request(app)
+        .get('/api/v1/assets')
+        .set(passport.inject({roles: ['admin']}))
+        .then((res) => {
+          const body = res.body;
+
+          expect(body).to.have.property('count', 2);
+          expect(body).to.have.property('result');
+
+          const assets = body.result;
+
+          expect(assets).to.have.length(2);
+        });
+    });
+
+    it('should return assets that we search for', () => {
+      return chai.request(app)
+        .get('/api/v1/assets?search=term2')
+        .set(passport.inject({roles: ['admin']}))
+        .then((res) => {
+          const body = res.body;
+
+          expect(body).to.have.property('count', 1);
+          expect(body).to.have.property('result');
+
+          const assets = body.result;
+
+          expect(assets).to.have.length(1);
+
+          const asset = assets[0];
+
+          expect(asset).to.have.property('url', 'https://coralproject.net/news/asset2');
+          expect(asset).to.have.property('title', 'Asset 2');
+        });
+    });
+
+    it('should not return assets that we do not search for', () => {
+      return chai.request(app)
+        .get('/api/v1/assets?search=term3')
+        .set(passport.inject({roles: ['admin']}))
+        .then((res) => {
+          const body = res.body;
+
+          expect(body).to.have.property('count', 0);
+          expect(body).to.have.property('result');
+
+          expect(body.result).to.be.empty;
+        });
+    });
+
+    it('should return only closed assets', () => {
+      return chai.request(app)
+        .get('/api/v1/assets?filter=closed')
+        .set(passport.inject({roles: ['admin']}))
+        .then((res) => {
+          const body = res.body;
+
+          expect(body).to.have.property('count', 1);
+          expect(body).to.have.property('result');
+
+          const assets = body.result;
+
+          expect(assets[0]).to.have.property('title', 'Asset 1');
+        });
+    });
+
+    it('should return only opened assets', () => {
+      return chai.request(app)
+        .get('/api/v1/assets?filter=open')
+        .set(passport.inject({roles: ['admin']}))
+        .then((res) => {
+          const body = res.body;
+
+          expect(body).to.have.property('count', 1);
+          expect(body).to.have.property('result');
+
+          const assets = body.result;
+
+          expect(assets[0]).to.have.property('title', 'Asset 2');
+        });
+    });
+
+  });
+
+  describe('#put', () => {
+    it('should close the asset', function() {
+
+      const today = Date.now();
+
+      return Asset.findOrCreateByUrl('http://test.com')
+        .then((asset) => {
+          expect(asset).to.have.property('isClosed', null);
+          expect(asset).to.have.property('closedAt', null);
+
+          return chai.request(app)
+            .put(`/api/v1/assets/${asset.id}/status`)
+            .set(passport.inject({roles: ['admin']}))
+            .send({closedAt: today});
+        })
+        .then((res) => {
+
+          expect(res).to.have.status(204);
+
+          return Asset.findByUrl('http://test.com');
+        })
+        .then((asset) => {
+          expect(asset).to.have.property('isClosed', true);
+          expect(asset).to.have.property('closedAt').and.to.not.equal(null);
+        });
+    });
+  });
+
+});

test/routes/api/auth/index.js

@@ -0,0 +1,96 @@
+const app = require('../../../../app');
+const chai = require('chai');
+const expect = chai.expect;
+
+chai.use(require('chai-http'));
+
+const User = require('../../../../models/user');
+
+describe('/api/v1/auth', () => {
+  describe('#get', () => {
+    it('should return nothing when no user is logged in', () => {
+      return chai.request(app)
+        .get('/api/v1/auth')
+        .then((res) => {
+          expect(res.status).to.be.equal(204);
+          expect(res).to.not.have.a.body;
+        });
+    });
+  });
+});
+
+const Setting = require('../../../../models/setting');
+
+describe('/api/v1/auth/local', () => {
+
+  let mockUser;
+  beforeEach(() => {
+    const settings = {requireEmailConfirmation: false, wordlist: {banned: ['bad'], suspect: ['naughty']}};
+    return Setting.init(settings).then(() => {
+      return User.createLocalUser('maria@gmail.com', 'password!', 'Maria')
+        .then((user) => {
+          mockUser = user;
+        });
+    });
+  });
+
+  describe('email confirmation disabled', () => {
+
+    describe('#post', () => {
+      it('should send back the user on a successful login', () => {
+        return chai.request(app)
+          .post('/api/v1/auth/local')
+          .send({email: 'maria@gmail.com', password: 'password!'})
+          .then((res2) => {
+            expect(res2).to.have.status(200);
+            expect(res2).to.be.json;
+            expect(res2.body).to.have.property('user');
+            expect(res2.body.user).to.have.property('displayName', 'maria');
+          });
+      });
+
+      it('should not send back the user on a unsuccessful login', () => {
+        return chai.request(app)
+          .post('/api/v1/auth/local')
+            .send({email: 'maria@gmail.com', password: 'password!3'})
+            .catch((err) => {
+              expect(err).to.not.be.null;
+              expect(err.response).to.have.status(401);
+              expect(err.response.body).to.have.property('message', 'not authorized');
+            });
+      });
+
+    });
+
+  });
+
+  describe('email confirmation enabled', () => {
+
+    beforeEach(() => Setting.init({requireEmailConfirmation: true}));
+
+    describe('#post', () => {
+      it('should not allow a login from a user that is not confirmed', () => {
+        return chai.request(app)
+          .post('/api/v1/auth/local')
+          .send({email: 'maria@gmail.com', password: 'password!'})
+          .catch((err) => {
+            err.response.should.have.status(401);
+
+            return User.createEmailConfirmToken(mockUser.id, mockUser.profiles[0].id);
+          })
+          .then(User.verifyEmailConfirmation)
+          .then(() => {
+            return chai.request(app)
+              .post('/api/v1/auth/local')
+              .send({email: 'maria@gmail.com', password: 'password!'});
+          })
+          .then((res) => {
+            expect(res).to.have.status(200);
+            expect(res).to.be.json;
+            expect(res.body).to.have.property('user');
+            expect(res.body.user).to.have.property('displayName', 'maria');
+          });
+      });
+    });
+  });
+});

test/routes/api/comments/index.js

@@ -0,0 +1,508 @@
+const passport = require('../../../passport');
+
+const app = require('../../../../app');
+const chai = require('chai');
+const expect = chai.expect;
+
+// Setup chai.
+chai.should();
+chai.use(require('chai-http'));
+
+const Comment = require('../../../../models/comment');
+const Asset = require('../../../../models/asset');
+const Action = require('../../../../models/action');
+const User = require('../../../../models/user');
+
+const Setting = require('../../../../models/setting');
+const settings = {id: '1', moderation: 'pre', wordlist: {banned: ['bad words'], suspect: ['suspect words']}};
+
+describe('/api/v1/comments', () => {
+
+  // Ensure that the settings are always available.
+  beforeEach(() => Setting.init(settings));
+
+  describe('#get', () => {
+    const comments = [{
+      body: 'comment 10',
+      asset_id: 'asset',
+      author_id: '123'
+    }, {
+      body: 'comment 20',
+      asset_id: 'asset',
+      author_id: '456'
+    }, {
+      body: 'comment 20',
+      asset_id: 'asset',
+      author_id: '456',
+      status: 'rejected',
+      status_history: [{
+        type: 'rejected'
+      }]
+    }, {
+      body: 'comment 30',
+      asset_id: '456',
+      status: 'accepted',
+      status_history: [{
+        type: 'accepted'
+      }]
+    }];
+
+    const users = [{
+      displayName: 'Ana',
+      email: 'ana@gmail.com',
+      password: '123456789'
+    }, {
+      displayName: 'Maria',
+      email: 'maria@gmail.com',
+      password: '123456789'
+    }];
+
+    const actions = [{
+      action_type: 'flag',
+      item_id: 'abc',
+      item_type: 'comments'
+    }, {
+      action_type: 'like',
+      item_id: 'hij',
+      item_type: 'comments'
+    }];
+
+    beforeEach(() => {
+      return Promise.all([
+        Comment.create(comments).then((newComments) => {
+          newComments.forEach((comment, i) => {
+            comments[i].id = comment.id;
+          });
+
+          actions[0].item_id = comments[0].id;
+          actions[1].item_id = comments[1].id;
+
+          return Action.create(actions);
+        }),
+        User.createLocalUsers(users)
+      ]);
+    });
+
+    it('should return only the owner’s published comments if the user is not an admin', () => {
+      return chai.request(app)
+        .get('/api/v1/comments?user_id=456')
+        .set(passport.inject({id: '456', roles: []}))
+        .then(res => {
+          expect(res).to.have.status(200);
+          expect(res.body.comments).to.have.length(1);
+          expect(res.body.comments[0]).to.have.property('author_id', '456');
+        });
+    });
+
+    it('should fail if a non-admin requests comments not owned by them', () => {
+      return chai.request(app)
+        .get('/api/v1/comments?user_id=456')
+        .set(passport.inject({id: '123', roles: []}))
+        .then((res) => {
+          expect(res).to.be.empty;
+        })
+        .catch((err) => {
+          expect(err).to.have.status(401);
+        });
+    });
+
+    it('should return all the comments', () => {
+      return chai.request(app)
+        .get('/api/v1/comments')
+        .set(passport.inject({roles: ['admin']}))
+        .then((res) => {
+
+          expect(res).to.have.status(200);
+
+        });
+    });
+
+    it('should return all the rejected comments', () => {
+      return chai.request(app)
+        .get('/api/v1/comments?status=rejected')
+        .set(passport.inject({roles: ['admin']}))
+        .then((res) => {
+          expect(res).to.have.status(200);
+          expect(res.body).to.have.property('comments');
+          expect(res.body.comments).to.have.length(1);
+          expect(res.body.comments[0]).to.have.property('id', comments[2].id);
+        });
+    });
+
+    it('should return all the approved comments', () => {
+      return chai.request(app)
+        .get('/api/v1/comments?status=accepted')
+        .set(passport.inject({roles: ['admin']}))
+        .then((res) => {
+          expect(res).to.have.status(200);
+          expect(res.body.comments).to.have.length(1);
+          expect(res.body.comments[0]).to.have.property('id', comments[3].id);
+        });
+    });
+
+    it('should return all the new comments', () => {
+      return chai.request(app)
+        .get('/api/v1/comments?status=new')
+        .set(passport.inject({roles: ['admin']}))
+        .then((res) => {
+          expect(res).to.have.status(200);
+          expect(res.body.comments).to.have.length(2);
+        });
+    });
+
+    it('should return all the flagged comments', () => {
+      return chai.request(app)
+        .get('/api/v1/comments?action_type=flag')
+        .set(passport.inject({roles: ['admin']}))
+        .then((res) => {
+          expect(res).to.have.status(200);
+
+          expect(res.body.comments).to.have.length(1);
+          expect(res.body.comments[0]).to.have.property('id', comments[0].id);
+        });
+    });
+  });
+
+  describe('#post', () => {
+
+    let asset_id;
+    let postmod_asset_id;
+
+    beforeEach(() => Promise.all([
+      Asset.findOrCreateByUrl('https://coralproject.net/section/article-is-the-best').then((asset) => {
+
+        // Update the asset id.
+        asset_id = asset.id;
+      }),
+      Asset.findOrCreateByUrl('https://coralproject.net/section/postmod-article-is-the-best').then((asset) => {
+
+        // Update the asset id.
+        postmod_asset_id = asset.id;
+
+        return Asset.overrideSettings(postmod_asset_id, {moderation: 'post'});
+      }),
+    ]));
+
+    it('should create a comment', () => {
+      return chai.request(app)
+        .post('/api/v1/comments')
+        .set(passport.inject({roles: []}))
+        .send({'body': 'Something body.', 'author_id': '123', 'asset_id': asset_id, 'parent_id': ''})
+        .then((res) => {
+          expect(res).to.have.status(201);
+          expect(res.body).to.have.property('id');
+          expect(res.body).to.have.property('status', 'premod');
+        });
+    });
+
+    it('should create a comment with a rejected status if it contains a bad word', () => {
+      return chai.request(app).post('/api/v1/comments')
+        .set(passport.inject({roles: []}))
+        .send({'body': 'bad words are the baddest', 'author_id': '123', 'asset_id': asset_id, 'parent_id': ''})
+        .then((res) => {
+          expect(res).to.have.status(201);
+          expect(res.body).to.have.property('id');
+          expect(res.body).to.have.property('status', 'rejected');
+        });
+    });
+
+    it('should create a comment with no status and a flag if it contains a suspected word', () => {
+      return chai.request(app).post('/api/v1/comments')
+        .set(passport.inject({roles: []}))
+        .send({'body': 'suspect words are the most suspicious', 'author_id': '123', 'asset_id': postmod_asset_id, 'parent_id': ''})
+        .then((res) => {
+          expect(res).to.have.status(201);
+          expect(res.body).to.have.property('id');
+          expect(res.body).to.have.property('status', null);
+
+          return Promise.all([
+            res.body,
+            Action.findByType('flag', 'comments')
+          ]);
+        })
+        .then(([comment, actions]) => {
+          expect(actions).to.have.length(1);
+
+          let action = actions[0];
+
+          expect(action).to.have.property('item_id', comment.id);
+          expect(action).to.have.property('metadata');
+          expect(action.metadata).to.have.property('field', 'body');
+          expect(action.metadata).to.have.property('details', 'Matched suspect word filters.');
+        });
+    });
+
+    it('should create a comment with a premod status if it\'s asset is has pre-moderation enabled', () => {
+      return Asset
+        .findOrCreateByUrl('https://coralproject.net/article1')
+        .then((asset) => {
+          return Asset
+            .overrideSettings(asset.id, {moderation: 'pre'})
+            .then(() => asset);
+        })
+        .then((asset) => {
+          return chai.request(app).post('/api/v1/comments')
+            .set(passport.inject({roles: []}))
+            .send({'body': 'Something body.', 'author_id': '123', 'asset_id': asset.id, 'parent_id': ''});
+        })
+        .then((res) => {
+          expect(res).to.have.status(201);
+          expect(res.body).to.have.property('id');
+          expect(res.body).to.have.property('asset_id');
+          expect(res.body).to.have.property('status', 'premod');
+        });
+    });
+
+    it('should create a comment with null status if it\'s asset is has post-moderation enabled', () => {
+      return Asset
+        .findOrCreateByUrl('https://coralproject.net/article1')
+        .then((asset) => {
+          return Asset
+            .overrideSettings(asset.id, {moderation: 'post'})
+            .then(() => asset);
+        })
+        .then((asset) => {
+          return chai.request(app).post('/api/v1/comments')
+            .set(passport.inject({roles: []}))
+            .send({'body': 'Something body.', 'author_id': '123', 'asset_id': asset.id, 'parent_id': ''});
+        })
+        .then((res) => {
+          expect(res).to.have.status(201);
+          expect(res.body).to.have.property('id');
+          expect(res.body).to.have.property('asset_id');
+          expect(res.body).to.have.property('status', null);
+        });
+    });
+
+    it('should create a rejected comment if the body is above the character count', () => {
+      return Asset
+        .findOrCreateByUrl('https://coralproject.net/article1')
+        .then((asset) => {
+          return Asset
+            .overrideSettings(asset.id, {charCountEnable: true, charCount: 10})
+            .then(() => asset);
+        })
+        .then((asset) => {
+          return chai.request(app).post('/api/v1/comments')
+            .set(passport.inject({roles: []}))
+            .send({'body': 'This is way way way way way too long.', 'author_id': '123', 'asset_id': asset.id, 'parent_id': ''});
+        })
+        .then((res) => {
+          expect(res).to.have.status(201);
+          expect(res.body).to.have.property('id');
+          expect(res.body).to.have.property('asset_id');
+          expect(res.body).to.have.property('status', 'rejected');
+        });
+    });
+
+    it('shouldn\'t create a comment when the asset has expired commenting', () => {
+      return Asset.create({
+        closedAt: new Date().setDate(0),
+        closedMessage: 'tests said expired!'
+      })
+      .then((asset) => {
+        return chai.request(app).post('/api/v1/comments')
+          .set(passport.inject({roles: []}))
+          .send({'body': 'Something body.', 'author_id': '123', 'asset_id': asset.id, 'parent_id': ''});
+      })
+      .then((res) => {
+        expect(res).to.have.status(500);
+      })
+      .catch((err) => {
+        expect(err.response.body).to.not.be.null;
+        expect(err.response.body).to.have.property('message');
+        expect(err.response.body.error.metadata.closedMessage).to.be.equal('tests said expired!');
+      });
+    });
+
+    it('should create a comment when the asset has not expired yet', () => {
+      return Asset.create({
+        closedAt: new Date().setDate(32),
+        closedMessage: 'tests said expired!'
+      })
+      .then((asset) => {
+        return chai.request(app).post('/api/v1/comments')
+          .set(passport.inject({roles: []}))
+          .send({'body': 'Something body.', 'author_id': '123', 'asset_id': asset.id, 'parent_id': ''});
+      })
+      .then((res) => {
+        expect(res).to.have.status(201);
+      });
+    });
+  });
+});
+
+describe('/api/v1/comments/:comment_id', () => {
+  const comments = [{
+    id: 'abc',
+    body: 'comment 10',
+    asset_id: 'asset',
+    author_id: '123'
+  }, {
+    id: 'def',
+    body: 'comment 20',
+    asset_id: 'asset',
+    author_id: '456'
+  }, {
+    id: 'hij',
+    body: 'comment 30',
+    asset_id: '456'
+  }];
+
+  const users = [{
+    displayName: 'Ana',
+    email: 'ana@gmail.com',
+    password: '123456789'
+  }, {
+    displayName: 'Maria',
+    email: 'maria@gmail.com',
+    password: '123456789'
+  }];
+
+  const actions = [{
+    action_type: 'flag',
+    item_id: 'abc',
+    item_type: 'comment'
+  }, {
+    action_type: 'like',
+    item_id: 'hij',
+    item_type: 'comment'
+  }];
+
+  beforeEach(() => {
+    return Setting.init(settings).then(() => {
+      return Promise.all([
+        Comment.create(comments),
+        User.createLocalUsers(users),
+        Action.create(actions)
+      ]);
+    });
+  });
+
+  describe('#get', () => {
+
+    it('should return the right comment for the comment_id', () => {
+      return chai.request(app)
+        .get('/api/v1/comments/abc')
+        .set(passport.inject({roles: ['admin']}))
+        .then((res) => {
+          expect(res).to.have.status(200);
+          expect(res).to.have.property('body');
+          expect(res.body).to.have.property('body', 'comment 10');
+        });
+    });
+  });
+
+  describe('#delete', () => {
+    it('it should remove comment', () => {
+      return chai.request(app)
+        .delete('/api/v1/comments/abc')
+        .set(passport.inject({roles: ['admin']}))
+        .then((res) => {
+          expect(res).to.have.status(204);
+          return Comment.findById('abc');
+        })
+        .then((comment) => {
+          expect(comment).to.be.null;
+        });
+    });
+  });
+
+  describe('#put', () => {
+    it('it should update status', function() {
+      return chai.request(app)
+        .put('/api/v1/comments/abc/status')
+        .set(passport.inject({roles: ['admin']}))
+        .send({status: 'accepted'})
+        .then((res) => {
+          expect(res).to.have.status(204);
+          expect(res.body).to.be.empty;
+        });
+    });
+
+    it('it should not allow a non-admin to update status', () => {
+      return chai.request(app)
+        .put('/api/v1/comments/abc/status')
+        .set(passport.inject({roles: []}))
+        .send({status: 'accepted'})
+        .then((res) => {
+          expect(res).to.be.empty;
+        })
+        .catch((err) => {
+          expect(err).to.have.property('status', 401);
+        });
+    });
+  });
+});
+
+describe('/api/v1/comments/:comment_id/actions', () => {
+
+  const comments = [{
+    id: 'abc',
+    body: 'comment 10',
+    asset_id: 'asset',
+    author_id: '123',
+    status_history: []
+  }, {
+    id: 'def',
+    body: 'comment 20',
+    asset_id: 'asset',
+    author_id: '456',
+    status_history: [{
+      type: 'rejected'
+    }]
+  }, {
+    id: 'hij',
+    body: 'comment 30',
+    asset_id: '456',
+    status_history: [{
+      type: 'accepted'
+    }]
+  }];
+
+  const users = [{
+    displayName: 'Ana',
+    email: 'ana@gmail.com',
+    password: '123456789'
+  }, {
+    displayName: 'Maria',
+    email: 'maria@gmail.com',
+    password: '123456789'
+  }];
+
+  const actions = [{
+    action_type: 'flag',
+    item_id: 'abc'
+  }, {
+    action_type: 'like',
+    item_id: 'hij'
+  }];
+
+  beforeEach(() => {
+    return Setting.init(settings).then(() => {
+      return Promise.all([
+        Comment.create(comments),
+        User.createLocalUsers(users),
+        Action.create(actions)
+      ]);
+    });
+  });
+
+  describe('#post', () => {
+    it('it should create an action', () => {
+      return chai.request(app)
+        .post('/api/v1/comments/abc/actions')
+        .set(passport.inject({id: '456', roles: ['admin']}))
+        .send({'action_type': 'flag', 'metadata': {'reason': 'Comment is too awesome.'}})
+        .then((res) => {
+          expect(res).to.have.status(201);
+          expect(res).to.have.body;
+
+          expect(res.body).to.have.property('action_type', 'flag');
+          expect(res.body).to.have.property('metadata');
+          expect(res.body.metadata).to.deep.equal({'reason': 'Comment is too awesome.'});
+          expect(res.body).to.have.property('item_id', 'abc');
+        });
+    });
+  });
+});

test/routes/api/queue/index.js

@@ -0,0 +1,101 @@
+const passport = require('../../../passport');
+
+const app = require('../../../../app');
+const chai = require('chai');
+const expect = chai.expect;
+
+// Setup chai.
+chai.should();
+chai.use(require('chai-http'));
+
+const Comment = require('../../../../models/comment');
+const Action = require('../../../../models/action');
+const User = require('../../../../models/user');
+
+const Setting = require('../../../../models/setting');
+const settings = {id: '1', moderation: 'pre', wordlist: {banned: ['banned'], suspect: ['suspect']}};
+
+describe('/api/v1/queue', () => {
+  const comments = [{
+    id: 'abc',
+    body: 'comment 10',
+    asset_id: 'asset',
+    author_id: '123',
+    status: 'rejected',
+    status_history: [{
+      type: 'rejected'
+    }]
+  }, {
+    id: 'def',
+    body: 'comment 20',
+    asset_id: 'asset',
+    author_id: '456',
+    status: 'premod',
+    status_history: [{
+      type: 'premod'
+    }]
+  }, {
+    id: 'hij',
+    body: 'comment 30',
+    asset_id: '456',
+    status: 'accepted',
+    status_history: [{
+      type: 'accepted'
+    }]
+  }];
+
+  const users = [{
+    displayName: 'Ana',
+    email: 'ana@gmail.com',
+    password: '123456789'
+  }, {
+    displayName: 'Maria',
+    email: 'maria@gmail.com',
+    password: '123456789'
+  }];
+
+  const actions = [{
+    action_type: 'flag',
+    item_id: 'abc',
+    item_type: 'comment'
+  }, {
+    action_type: 'like',
+    item_id: 'hij',
+    item_type: 'comment'
+  }];
+
+  beforeEach(() => {
+    return Setting.init(settings).then(() => {
+      return User.createLocalUsers(users)
+        .then((u) => {
+          comments[0].author_id = u[0].id;
+          comments[1].author_id = u[1].id;
+          comments[2].author_id = u[1].id;
+
+          return Comment.create(comments);
+        })
+        .then((c) => {
+          actions[0].item_id = c[0].id;
+          actions[1].item_id = c[1].id;
+
+          return Promise.all([
+            Action.create(actions),
+            Setting.init(settings)
+          ]);
+        });
+    });
+  });
+
+  it('should return all the pending comments, users and actions', () => {
+    return chai.request(app)
+      .get('/api/v1/queue/comments/pending')
+      .set(passport.inject({roles: ['admin']}))
+      .then((res) => {
+        expect(res).to.have.status(200);
+        expect(res.body.comments).to.have.length(1);
+        expect(res.body.comments[0]).to.have.property('body');
+        expect(res.body.users[0]).to.have.property('displayName');
+        expect(res.body.actions[0]).to.have.property('action_type');
+      });
+  });
+});

test/routes/api/settings/index.js

@@ -0,0 +1,51 @@
+const passport = require('../../../passport');
+
+const app = require('../../../../app');
+const chai = require('chai');
+const expect = chai.expect;
+
+chai.should();
+chai.use(require('chai-http'));
+
+const Setting = require('../../../../models/setting');
+const defaults = {id: '1', moderation: 'pre'};
+
+describe('/api/v1/settings', () => {
+
+  beforeEach(() => Setting.init(defaults));
+
+  describe('#get', () => {
+
+    it('should return a settings object', () => {
+      return chai.request(app)
+        .get('/api/v1/settings')
+        .set(passport.inject({
+          roles: ['admin']
+        }))
+        .then((res) => {
+          expect(res).to.have.status(200);
+          expect(res).to.be.json;
+          expect(res.body).to.have.property('moderation', 'pre');
+        });
+    });
+  });
+
+  describe('#put', () => {
+
+    it('should update the settings', () => {
+      return chai.request(app)
+        .put('/api/v1/settings')
+        .set(passport.inject({roles: ['admin']}))
+        .send({moderation: 'post'})
+        .then((res) => {
+          expect(res).to.have.status(204);
+
+          return Setting.retrieve();
+        })
+        .then((settings) => {
+          expect(settings).to.have.property('moderation', 'post');
+        });
+    });
+  });
+
+});

test/routes/api/stream/index.js

@@ -0,0 +1,225 @@
+const app = require('../../../../app');
+const chai = require('chai');
+const expect = chai.expect;
+
+// Setup chai.
+chai.should();
+chai.use(require('chai-http'));
+
+const Action = require('../../../../models/action');
+const User = require('../../../../models/user');
+const Comment = require('../../../../models/comment');
+const Asset = require('../../../../models/asset');
+
+const Setting = require('../../../../models/setting');
+
+describe('/api/v1/stream', () => {
+  describe('#get', () => {
+    const settings = {
+      id: '1',
+      moderation: 'post',
+      wordlist: {
+        banned: ['banned'],
+        suspect: ['suspect']
+      }
+    };
+
+    const assets = [
+      {
+        url: 'https://example.com/article/1'
+      },
+      {
+        url: 'https://example.com/article/2',
+        settings: {
+          moderation: 'pre'
+        }
+      },
+      {
+        url: 'https://example.com/article/3'
+      }
+    ];
+
+    const comments = [{
+      id: 'abc',
+      body: 'comment 10',
+      author_id: '',
+      parent_id: '',
+      status: 'accepted',
+      status_history: [{
+        type: 'accepted'
+      }]
+    }, {
+      id: 'def',
+      body: 'comment 20',
+      author_id: '',
+      parent_id: '',
+      status: null,
+      status_history: []
+    }, {
+      id: 'uio',
+      body: 'comment 30',
+      asset_id: 'asset',
+      author_id: '456',
+      parent_id: '',
+      status: 'accepted',
+      status_history: [{
+        type: 'accepted'
+      }]
+    }, {
+      id: 'hij',
+      body: 'comment 40',
+      asset_id: '456',
+      status: 'rejected',
+      status_history: [{
+        type: 'rejected'
+      }]
+    }, {
+      body: 'comment 50',
+      status: 'premod',
+      status_history: [{
+        type: 'premod'
+      }]
+    }, {
+      body: 'comment 60',
+      status: 'accepted',
+      status_history: [{
+        type: 'accepted'
+      }]
+    }, {
+      body: 'comment 70',
+      status: 'rejected',
+      status_history: [{
+        type: 'rejected'
+      }]
+    }, {
+      body: 'comment 70',
+      status: null,
+      status_history: []
+    }];
+
+    const users = [{
+      displayName: 'Ana',
+      email: 'ana@gmail.com',
+      password: '123456789'
+    }, {
+      displayName: 'Maria',
+      email: 'maria@gmail.com',
+      password: '123456789'
+    }];
+
+    const actions = [{
+      action_type: 'flag',
+      item_id: 'abc'
+    }, {
+      action_type: 'like',
+      item_id: 'hij'
+    }];
+
+    beforeEach(() => {
+      return Setting.init(settings)
+      .then(() => Promise.all([
+        User.createLocalUsers(users),
+        Promise.all(assets.map((asset) => Asset.create(asset)))
+      ]))
+      .then(([mockUsers, mockAssets]) => {
+
+        // Map the id's over.
+        mockAssets.forEach((asset, i) => {
+          assets[i].id = asset.id;
+        });
+
+        mockUsers.forEach((user, i) => {
+          users[i].id = user.id;
+        });
+
+        comments.forEach((comment, i) => {
+          comments[i].author_id = users[(i % 2) === 0 ? 0 : 1].id;
+        });
+
+        comments[0].asset_id = assets[0].id;
+        comments[1].asset_id = assets[0].id;
+        comments[2].asset_id = assets[1].id;
+        comments[3].asset_id = assets[1].id;
+        comments[4].asset_id = assets[2].id;
+        comments[5].asset_id = assets[2].id;
+        comments[6].asset_id = assets[2].id;
+        comments[7].asset_id = assets[2].id;
+
+        return Promise.all([
+          Comment.create(comments),
+          Action.create(actions)
+        ]);
+      });
+    });
+
+    it('should return a stream with comments, users and actions for an existing asset', () => {
+      return chai.request(app)
+        .get('/api/v1/stream')
+        .query({asset_url: assets[0].url})
+        .then(res => {
+          expect(res).to.have.status(200);
+          expect(res.body.assets.length).to.equal(1);
+          expect(res.body.comments.length).to.equal(2);
+          expect(res.body.users.length).to.equal(2);
+          expect(res.body.actions.length).to.equal(1);
+          expect(res.body.settings).to.have.property('moderation', 'post');
+        });
+    });
+
+    it('should reject requests without a scheme in the asset_url', () => {
+      return chai.request(app)
+        .get('/api/v1/stream')
+        .query({asset_url: 'test.com'})
+        .catch((err) => {
+          expect(err).to.have.status(400);
+          expect(err.response.body.message).to.contain('asset_url is invalid');
+        });
+    });
+
+    it('should merge the settings when the asset contains settings to override it with', () => {
+      return chai.request(app)
+        .get('/api/v1/stream')
+        .query({asset_url: assets[1].url})
+        .then((res) => {
+          expect(res).to.have.status(200);
+          expect(res.body.assets).to.have.length(1);
+          expect(res.body.comments).to.have.length(1);
+          expect(res.body.users).to.have.length(1);
+          expect(res.body.settings).to.have.property('moderation', 'pre');
+          expect(res.body.settings).to.not.have.property('wordlist');
+        });
+    });
+
+    it('should not change the previously displayed comments based on moderation state changes', () => {
+
+      let preComments, postComments;
+
+      return chai.request(app)
+        .get('/api/v1/stream')
+        .query({asset_url: assets[2].url})
+        .then((res) => {
+          expect(res).to.have.status(200);
+          expect(res.body.comments.length).to.equal(2);
+          expect(res.body.settings).to.have.property('moderation', 'post');
+
+          preComments = res.body.comments;
+
+          return Asset.overrideSettings(assets[2].id, {moderation: 'pre'});
+        })
+        .then(() => {
+          return chai.request(app)
+            .get('/api/v1/stream')
+            .query({asset_url: assets[2].url});
+        })
+        .then((res) => {
+          expect(res).to.have.status(200);
+          expect(res.body.comments.length).to.equal(2);
+          expect(res.body.settings).to.have.property('moderation', 'pre');
+
+          postComments = res.body.comments;
+
+          expect(preComments).to.deep.equal(postComments);
+        });
+    });
+  });
+});

test/routes/api/user/index.js

@@ -0,0 +1,87 @@
+const passport = require('../../../passport');
+
+const app = require('../../../../app');
+const mailer = require('../../../../services/mailer');
+const chai = require('chai');
+const expect = chai.expect;
+
+const Setting = require('../../../../models/setting');
+const settings = {id: '1', moderation: 'pre', wordlist: {banned: ['bad words'], suspect: ['suspect words']}};
+
+// Setup chai.
+chai.should();
+chai.use(require('chai-http'));
+
+const User = require('../../../../models/user');
+
+describe('/api/v1/users/:user_id/email/confirm', () => {
+
+  let mockUser;
+
+  beforeEach(() => Setting.init(settings).then(() => {
+    return User.createLocalUser('ana@gmail.com', '123321123', 'Ana');
+  })
+  .then((user) => {
+    mockUser = user;
+  }));
+
+  describe('#post', () => {
+    it('should send an email when we hit the endpoint', () => {
+      expect(mailer.task.tasks).to.have.length(0);
+
+      return chai.request(app)
+        .post(`/api/v1/users/${mockUser.id}/email/confirm`)
+        .set(passport.inject({roles: ['admin']}))
+        .then((res) => {
+          expect(res).to.have.status(204);
+          expect(mailer.task.tasks).to.have.length(1);
+        });
+    });
+
+    it('should send a 404 on not matching a user', () => {
+      return chai.request(app)
+        .post(`/api/v1/users/${mockUser.id}/email/confirm`)
+        .set(passport.inject({roles: ['admin']}))
+        .then((res) => {
+          expect(res).to.have.status(204);
+          expect(mailer.task.tasks).to.have.length(1);
+        });
+    });
+  });
+});
+
+describe('/api/v1/users/:user_id/actions', () => {
+
+  const users = [{
+    displayName: 'Ana',
+    email: 'ana@gmail.com',
+    password: '123456789'
+  }, {
+    displayName: 'Maria',
+    email: 'maria@gmail.com',
+    password: '123456789'
+  }];
+
+  beforeEach(() => {
+    return Setting.init(settings).then(() => {
+      return User.createLocalUsers(users);
+    });
+  });
+
+  describe('#post', () => {
+    it('it should update actions', () => {
+      return chai.request(app)
+        .post('/api/v1/users/abc/actions')
+        .set(passport.inject({id: '456', roles: ['admin']}))
+        .send({'action_type': 'flag', metadata: {reason: 'Bio is too awesome.'}})
+        .then((res) => {
+          expect(res).to.have.status(201);
+          expect(res).to.have.body;
+          expect(res.body).to.have.property('action_type', 'flag');
+          expect(res.body).to.have.property('metadata')
+            .and.to.deep.equal({'reason': 'Bio is too awesome.'});
+          expect(res.body).to.have.property('item_id', 'abc');
+        });
+    });
+  });
+});