Merge pull request #6343 from HabitRPG/api-v3-tasks2

[API v3] Tasks 2

test/api/v3/integration/tags/DELETE-tags_id.test.js

@@ -0,0 +1,35 @@
+import {
+  generateUser,
+  requester,
+} from '../../../../helpers/api-integration.helper';
+
+describe('DELETE /tags/:tagId', () => {
+  let user, api;
+
+  before(() => {
+    return generateUser().then((generatedUser) => {
+      user = generatedUser;
+      api = requester(user);
+    });
+  });
+
+  it('deletes a tag given it\'s id', () => {
+    let length;
+    let tag;
+
+    return api.post('/tags', {name: 'Tag 1'})
+    .then((createdTag) => {
+      tag = createdTag;
+      return api.get(`/tags`);
+    })
+    .then((tags) => {
+      length = tags.length;
+      return api.del(`/tags/${tag._id}`);
+    })
+    .then(() => api.get(`/tags`))
+    .then((tags) => {
+      expect(tags.length).to.equal(length - 1);
+      expect(tags[tags.length - 1].name).to.not.equal('Tag 1');
+    });
+  });
+});

test/api/v3/integration/tags/GET-tags.test.js

@@ -0,0 +1,26 @@
+import {
+  generateUser,
+  requester,
+} from '../../../../helpers/api-integration.helper';
+
+describe('GET /tags', () => {
+  let user, api;
+
+  before(() => {
+    return generateUser().then((generatedUser) => {
+      user = generatedUser;
+      api = requester(user);
+    });
+  });
+
+  it('returns all user\'s tags', () => {
+    return api.post('/tags', {name: 'Tag 1'})
+    .then(() => api.post('/tags', {name: 'Tag 2'}))
+    .then(() => api.get('/tags'))
+    .then((tags) => {
+      expect(tags.length).to.equal(2 + 3); // + 3 because 1 is a default task
+      expect(tags[tags.length - 2].name).to.equal('Tag 1');
+      expect(tags[tags.length - 1].name).to.equal('Tag 2');
+    });
+  });
+});

test/api/v3/integration/tags/GET-tags_id.test.js

@@ -0,0 +1,28 @@
+import {
+  generateUser,
+  requester,
+} from '../../../../helpers/api-integration.helper';
+
+describe('GET /tags/:tagId', () => {
+  let user, api;
+
+  before(() => {
+    return generateUser().then((generatedUser) => {
+      user = generatedUser;
+      api = requester(user);
+    });
+  });
+
+  it('returns a tag given it\'s id', () => {
+    let createdTag;
+
+    return api.post('/tags', {name: 'Tag 1'})
+    .then((tag) => {
+      createdTag = tag;
+      return api.get(`/tags/${createdTag._id}`)
+    })
+    .then((tag) => {
+      expect(tag).to.deep.equal(createdTag);
+    });
+  });
+});

test/api/v3/integration/tags/POST-tags.test.js

@@ -0,0 +1,32 @@
+import {
+  generateUser,
+  requester,
+} from '../../../../helpers/api-integration.helper';
+
+describe('POST /tags', () => {
+  let user, api;
+
+  before(() => {
+    return generateUser().then((generatedUser) => {
+      user = generatedUser;
+      api = requester(user);
+    });
+  });
+
+  it('creates a tag correctly', () => {
+    let createdTag;
+
+    return api.post('/tags', {
+      name: 'Tag 1',
+      ignored: false,
+    }).then((tag) => {
+      createdTag = tag;
+      expect(tag.name).to.equal('Tag 1');
+      expect(tag.ignored).to.be.a('undefined');
+      return api.get(`/tags/${createdTag._id}`)
+    })
+    .then((tag) => {
+      expect(tag).to.deep.equal(createdTag);
+    });
+  });
+});

test/api/v3/integration/tags/PUT-tags_id.test.js

@@ -0,0 +1,36 @@
+import {
+  generateUser,
+  requester,
+} from '../../../../helpers/api-integration.helper';
+
+describe('PUT /tags/:tagId', () => {
+  let user, api;
+
+  before(() => {
+    return generateUser().then((generatedUser) => {
+      user = generatedUser;
+      api = requester(user);
+    });
+  });
+
+  it('updates a tag given it\'s id', () => {
+    let length;
+
+    return api.post('/tags', {name: 'Tag 1'})
+    .then((createdTag) => {
+      return api.put(`/tags/${createdTag._id}`, {
+        name: 'Tag updated',
+        ignored: true
+      });
+    })
+    .then((updatedTag) => {
+      expect(updatedTag.name).to.equal('Tag updated');
+      expect(updatedTag.ignored).to.be.a('undefined');
+      return api.get(`/tags/${updatedTag._id}`);
+    })
+    .then((tag) => {
+      expect(tag.name).to.equal('Tag updated');
+      expect(tag.ignored).to.be.a('undefined');
+    });
+  });
+});

test/api/v3/integration/tasks/GET-tasks_id.test.js

@@ -3,6 +3,7 @@ import {
   requester,
   translate as t,
 } from '../../../../helpers/api-integration.helper';
+import { v4 as generateUUID } from 'uuid';
 
 describe('GET /tasks/:id', () => {
   let user, api;
@@ -18,18 +19,51 @@ describe('GET /tasks/:id', () => {
     let task;
 
     beforeEach(() => {
-      // generate task
-      // task = generatedTask;
+      return api.post('/tasks', {
+        text: 'test habit',
+        type: 'habit',
+      }).then((createdTask) => {
+        task = createdTask;
+      });
     });
 
-    it('gets specified task');
+    it('gets specified task', () => {
+      return api.get('/tasks/' + task._id)
+      .then((getTask) => {
+        expect(getTask).to.eql(task);
+      });
+    });
 
+    // TODO after challenges are implemented
     it('can get active challenge task that user does not own'); // Yes?
   });
 
   context('task cannot accessed', () => {
-    it('cannot get a non-existant task');
+    it('cannot get a non-existant task', () => {
+      return expect(api.get('/tasks/' + generateUUID())).to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('taskNotFound'),
+      });
+    });
 
-    it('cannot get a task owned by someone else');
+    it('cannot get a task owned by someone else', () => {
+      let api2;
+
+      return generateUser()
+        .then((user2) => {
+          api2 = requester(user2);
+          return api.post('/tasks', {
+            text: 'test habit',
+            type: 'habit',
+          })
+        }).then((task) => {
+          return expect(api2.get('/tasks/' + task._id)).to.eventually.be.rejected.and.eql({
+            code: 404,
+            error: 'NotFound',
+            message: t('taskNotFound'),
+          });
+        });
+    });
   });
 });

test/api/v3/integration/tasks/POST-tasks.test.js

@@ -37,9 +37,15 @@ describe('POST /tasks', () => {
       });
     });
 
-    it('returns an error if req.body.text is absent');
-
-    it('ignores setting userId field');
+    it('returns an error if req.body.text is absent', () => {
+      return expect(api.post('/tasks', {
+        type: 'habit',
+      })).to.eventually.be.rejected.and.eql({
+        code: 400,
+        error: 'BadRequest',
+        message: 'habit validation failed',
+      });
+    });
 
     it('automatically sets "task.userId" to user\'s uuid', () => {
       return api.post('/tasks', {
@@ -50,21 +56,41 @@ describe('POST /tasks', () => {
       });
     });
 
-    it('ignores setting history field');
+    it(`ignores setting userId, history, createdAt,
+                        updatedAt, challenge, completed, streak,
+                        dateCompleted fields`, () => {
+      return api.post('/tasks', {
+        text: 'test daily',
+        type: 'daily',
+        userId: 123,
+        history: [123],
+        createdAt: 'yesterday',
+        updatedAt: 'tomorrow',
+        challenge: 'no',
+        completed: true,
+        streak: 25,
+        dateCompleted: 'never',
+      }).then((task) => {
+        expect(task.userId).to.equal(user._id);
+        expect(task.history).to.eql([]);
+        expect(task.createdAt).not.to.equal('yesterday');
+        expect(task.updatedAt).not.to.equal('tomorrow');
+        expect(task.challenge).not.to.equal('no');
+        expect(task.completed).to.equal(false);
+        expect(task.streak).to.equal(0);
+        expect(task.streak).not.to.equal('never');
+      });
+    });
 
-    it('ignores setting createdAt field');
-
-    it('ignores setting updatedAt field');
-
-    it('ignores setting challenge field');
-
-    it('ignores setting completed field');
-
-    it('ignores setting streak field');
-
-    it('ignores setting dateCompleted field');
-
-    it('ignores invalid fields');
+    it('ignores invalid fields', () => {
+      return api.post('/tasks', {
+        text: 'test daily',
+        type: 'daily',
+        notValid: true,
+      }).then((task) => {
+        expect(task).not.to.have.property('notValid');
+      });
+    });
   });
 
   context('habits', () => {
@@ -85,9 +111,28 @@ describe('POST /tasks', () => {
       });
     });
 
-    it('defaults to setting up and down to true');
+    it('defaults to setting up and down to true', () => {
+      return api.post('/tasks', {
+        text: 'test habit',
+        type: 'habit',
+        notes: 1976,
+      }).then((task) => {
+        expect(task.up).to.eql(true);
+        expect(task.down).to.eql(true);
+      });
+    });
 
-    it('cannot create checklists');
+    it('cannot create checklists', () => {
+      return api.post('/tasks', {
+        text: 'test habit',
+        type: 'habit',
+        checklist: [
+          {_id: 123, completed: false, text: 'checklist'},
+        ],
+      }).then((task) => {
+        expect(task).not.to.have.property('checklist');
+      });
+    });
   });
 
   context('todos', () => {
@@ -104,7 +149,22 @@ describe('POST /tasks', () => {
       });
     });
 
-    it('can create checklists');
+    it('can create checklists', () => {
+      return api.post('/tasks', {
+        text: 'test todo',
+        type: 'todo',
+        checklist: [
+          {completed: false, text: 'checklist'},
+        ],
+      }).then((task) => {
+        expect(task.checklist).to.be.an('array');
+        expect(task.checklist.length).to.eql(1);
+        expect(task.checklist[0]).to.be.an('object');
+        expect(task.checklist[0].text).to.eql('checklist');
+        expect(task.checklist[0].completed).to.eql(false);
+        expect(task.checklist[0]._id).to.be.a('string');
+      });
+    });
   });
 
   context('dailys', () => {
@@ -129,13 +189,74 @@ describe('POST /tasks', () => {
       });
     });
 
-    it('defaults to a weekly frequency, with every day set');
+    it('defaults to a weekly frequency, with every day set', () => {
+      return api.post('/tasks', {
+        text: 'test daily',
+        type: 'daily',
+      }).then((task) => {
+        expect(task.frequency).to.eql('weekly');
+        expect(task.everyX).to.eql(1);
+        expect(task.repeat).to.eql({
+          m: true,
+          t: true,
+          w: true,
+          th: true,
+          f: true,
+          s: true,
+          su: true,
+        });
+      });
+    });
 
-    it('allows repeat field to be configured');
+    it('allows repeat field to be configured', () => {
+      return api.post('/tasks', {
+        text: 'test daily',
+        type: 'daily',
+        repeat: {
+          m: false,
+          w: false,
+          su: false,
+        },
+      }).then((task) => {
+        expect(task.repeat).to.eql({
+          m: false,
+          t: true,
+          w: false,
+          th: true,
+          f: true,
+          s: true,
+          su: false,
+        });
+      });
+    });
 
-    it('defaults startDate to today');
+    it('defaults startDate to today', () => {
+      let today = (new Date()).getDay();
 
-    it('can create checklists');
+      return api.post('/tasks', {
+        text: 'test daily',
+        type: 'daily',
+      }).then((task) => {
+        expect((new Date(task.startDate)).getDay()).to.eql(today);
+      });
+    });
+
+    it('can create checklists', () => {
+      return api.post('/tasks', {
+        text: 'test daily',
+        type: 'daily',
+        checklist: [
+          {completed: false, text: 'checklist'},
+        ],
+      }).then((task) => {
+        expect(task.checklist).to.be.an('array');
+        expect(task.checklist.length).to.eql(1);
+        expect(task.checklist[0]).to.be.an('object');
+        expect(task.checklist[0].text).to.eql('checklist');
+        expect(task.checklist[0].completed).to.eql(false);
+        expect(task.checklist[0]._id).to.be.a('string');
+      });
+    });
   });
 
   context('rewards', () => {
@@ -154,10 +275,35 @@ describe('POST /tasks', () => {
       });
     });
 
-    it('defaults to a 0 value');
+    it('defaults to a 0 value', () => {
+      return api.post('/tasks', {
+        text: 'test reward',
+        type: 'reward',
+      }).then((task) => {
+        expect(task.value).to.eql(0);
+      });
+    });
 
-    it('requires value to be coerced into a number');
+    it('requires value to be coerced into a number', () => {
+      return api.post('/tasks', {
+        text: 'test reward',
+        type: 'reward',
+        value: "10",
+      }).then((task) => {
+        expect(task.value).to.eql(10);
+      });
+    });
 
-    it('cannot create checklists');
+    it('cannot create checklists', () => {
+      return api.post('/tasks', {
+        text: 'test reward',
+        type: 'reward',
+        checklist: [
+          {_id: 123, completed: false, text: 'checklist'},
+        ],
+      }).then((task) => {
+        expect(task).not.to.have.property('checklist');
+      });
+    });
   });
 });

test/api/v3/integration/tasks/POST-tasks_id_score_direction.test.js

@@ -0,0 +1,343 @@
+import {
+  generateUser,
+  requester,
+  translate as t,
+} from '../../../../helpers/api-integration.helper';
+import { v4 as generateUUID } from 'uuid';
+
+describe('POST /tasks/:id/score/:direction', () => {
+  let user, api;
+
+  beforeEach(() => {
+    return generateUser({
+      'stats.gp': 100,
+    }).then((generatedUser) => {
+      user = generatedUser;
+      api = requester(user);
+    });
+  });
+
+  context('all', () => {
+    it('requires a task id', () => {
+      return expect(api.post('/tasks/123/score/up')).to.eventually.be.rejected.and.eql({
+        code: 400,
+        error: 'BadRequest',
+        message: t('invalidReqParams'),
+      });
+    });
+
+    it('requires a task direction', () => {
+      return expect(api.post(`/tasks/${generateUUID()}/score/tt`)).to.eventually.be.rejected.and.eql({
+        code: 400,
+        error: 'BadRequest',
+        message: t('invalidReqParams'),
+      });
+    });
+  });
+
+  context('todos', () => {
+    let todo;
+
+    beforeEach(() => {
+      return api.post('/tasks', {
+        text: 'test todo',
+        type: 'todo',
+      }).then((task) => {
+        todo = task;
+      });
+    });
+
+    it('completes todo when direction is up', () => {
+      return api.post(`/tasks/${todo._id}/score/up`)
+      .then((res) => api.get(`/tasks/${todo._id}`))
+      .then((task) => expect(task.completed).to.equal(true));
+    });
+
+    it('moves completed todos out of user.tasksOrder.todos', () => {
+      return api.get('/user')
+      .then(user => {
+        expect(user.tasksOrder.todos.indexOf(todo._id)).to.not.equal(-1)
+      }).then(() => api.post(`/tasks/${todo._id}/score/up`))
+      .then(() => api.get(`/tasks/${todo._id}`))
+      .then((updatedTask) => {
+        expect(updatedTask.completed).to.equal(true);
+        return api.get('/user');
+      })
+      .then((user) => {
+        expect(user.tasksOrder.todos.indexOf(todo._id)).to.equal(-1)
+      });
+    });
+
+    it('moves un-completed todos back into user.tasksOrder.todos', () => {
+      return api.get('/user')
+      .then(user => {
+        expect(user.tasksOrder.todos.indexOf(todo._id)).to.not.equal(-1)
+      }).then(() => api.post(`/tasks/${todo._id}/score/up`))
+      .then(() => api.post(`/tasks/${todo._id}/score/down`))
+      .then(() => api.get(`/tasks/${todo._id}`))
+      .then((updatedTask) => {
+        expect(updatedTask.completed).to.equal(false);
+        return api.get('/user');
+      })
+      .then((user) => {
+        let l = user.tasksOrder.todos.length;
+        expect(user.tasksOrder.todos.indexOf(todo._id)).not.to.equal(-1);
+        expect(user.tasksOrder.todos.indexOf(todo._id)).to.equal(l - 1); // Check that it was pushed at the bottom
+      });
+    });
+
+    it('uncompletes todo when direction is down', () => {
+      return api.post(`/tasks/${todo._id}/score/down`)
+      .then((res) => api.get(`/tasks/${todo._id}`))
+      .then((updatedTask) => {
+        expect(updatedTask.completed).to.equal(false);
+      });
+    });
+
+    it('scores up todo even if it is already completed'); // Yes?
+
+    it('scores down todo even if it is already uncompleted'); // Yes?
+
+    it('increases user\'s mp when direction is up', () => {
+      return api.post(`/tasks/${todo._id}/score/up`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.mp).to.be.greaterThan(user.stats.mp);
+      });
+    });
+
+    it('decreases user\'s mp when direction is down', () => {
+      return api.post(`/tasks/${todo._id}/score/down`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.mp).to.be.lessThan(user.stats.mp);
+      });
+    });
+
+    it('increases user\'s exp when direction is up', () => {
+      return api.post(`/tasks/${todo._id}/score/up`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.exp).to.be.greaterThan(user.stats.exp);
+      });
+    });
+
+    it('decreases user\'s exp when direction is down', () => {
+      return api.post(`/tasks/${todo._id}/score/down`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.exp).to.be.lessThan(user.stats.exp);
+      });
+    });
+
+    it('increases user\'s gold when direction is up', () => {
+      return api.post(`/tasks/${todo._id}/score/up`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.gp).to.be.greaterThan(user.stats.gp);
+      });
+    });
+
+    it('decreases user\'s gold when direction is down', () => {
+      return api.post(`/tasks/${todo._id}/score/down`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.gp).to.be.lessThan(user.stats.gp);
+      });
+    });
+  });
+
+  context('dailys', () => {
+    let daily;
+
+    beforeEach(() => {
+      return api.post('/tasks', {
+        text: 'test daily',
+        type: 'daily',
+      }).then((task) => {
+        daily = task;
+      });
+    });
+
+    it('completes daily when direction is up', () => {
+      return api.post(`/tasks/${daily._id}/score/up`)
+      .then((res) => api.get(`/tasks/${daily._id}`))
+      .then((task) => expect(task.completed).to.equal(true));
+    });
+
+    it('uncompletes daily when direction is down', () => {
+      return api.post(`/tasks/${daily._id}/score/down`)
+      .then((res) => api.get(`/tasks/${daily._id}`))
+      .then((task) => expect(task.completed).to.equal(false));
+    });
+
+    it('scores up daily even if it is already completed'); // Yes?
+
+    it('scores down daily even if it is already uncompleted'); // Yes?
+
+    it('increases user\'s mp when direction is up', () => {
+      return api.post(`/tasks/${daily._id}/score/up`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.mp).to.be.greaterThan(user.stats.mp);
+      });
+    });
+
+    it('decreases user\'s mp when direction is down', () => {
+      return api.post(`/tasks/${daily._id}/score/down`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.mp).to.be.lessThan(user.stats.mp);
+      });
+    });
+
+    it('increases user\'s exp when direction is up', () => {
+      return api.post(`/tasks/${daily._id}/score/up`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.exp).to.be.greaterThan(user.stats.exp);
+      });
+    });
+
+    it('decreases user\'s exp when direction is down', () => {
+      return api.post(`/tasks/${daily._id}/score/down`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.exp).to.be.lessThan(user.stats.exp);
+      });
+    });
+
+    it('increases user\'s gold when direction is up', () => {
+      return api.post(`/tasks/${daily._id}/score/up`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.gp).to.be.greaterThan(user.stats.gp);
+      });
+    });
+
+    it('decreases user\'s gold when direction is down', () => {
+      return api.post(`/tasks/${daily._id}/score/down`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.gp).to.be.lessThan(user.stats.gp);
+      });
+    });
+  });
+
+  context('habits', () => {
+    let habit, minusHabit, plusHabit, neitherHabit;
+
+    beforeEach(() => {
+      return api.post('/tasks', {
+        text: 'test habit',
+        type: 'habit',
+      }).then((task) => {
+        habit = task;
+        return api.post('/tasks', {
+          text: 'test min habit',
+          type: 'habit',
+          up: false,
+        });
+      }).then((task) => {
+        minusHabit = task;
+        return api.post('/tasks', {
+          text: 'test plus habit',
+          type: 'habit',
+          down: false,
+        })
+      }).then((task) => {
+        plusHabit = task;
+        api.post('/tasks', {
+          text: 'test neither habit',
+          type: 'habit',
+          up: false,
+          down: false,
+        })
+      }).then((task) => {
+        neitherHabit = task;
+      });
+    });
+
+    it('prevents plus only habit from scoring down'); // Yes?
+
+    it('prevents minus only habit from scoring up'); // Yes?
+
+    it('increases user\'s mp when direction is up', () => {
+      return api.post(`/tasks/${habit._id}/score/up`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.mp).to.be.greaterThan(user.stats.mp);
+      });
+    });
+
+    it('decreases user\'s mp when direction is down', () => {
+      return api.post(`/tasks/${habit._id}/score/down`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.mp).to.be.lessThan(user.stats.mp);
+      });
+    });
+
+    it('increases user\'s exp when direction is up', () => {
+      return api.post(`/tasks/${habit._id}/score/up`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.exp).to.be.greaterThan(user.stats.exp);
+      });
+    });
+
+    it('increases user\'s gold when direction is up', () => {
+      return api.post(`/tasks/${habit._id}/score/up`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(updatedUser.stats.gp).to.be.greaterThan(user.stats.gp);
+      });
+    });
+  });
+
+  context('reward', () => {
+    let reward;
+
+    beforeEach(() => {
+      return api.post('/tasks', {
+        text: 'test reward',
+        type: 'reward',
+        value: 5,
+      }).then((task) => {
+        reward = task;
+      });
+    });
+
+    it('purchases reward', () => {
+      return api.post(`/tasks/${reward._id}/score/up`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(user.stats.gp).to.equal(updatedUser.stats.gp + 5);
+      });
+    });
+
+    it('does not change user\'s mp', () => {
+      return api.post(`/tasks/${reward._id}/score/up`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(user.stats.mp).to.equal(updatedUser.stats.mp);
+      });
+    });
+
+    it('does not change user\'s exp', () => {
+      return api.post(`/tasks/${reward._id}/score/up`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(user.stats.exp).to.equal(updatedUser.stats.exp);
+      });
+    });
+
+    it('does not allow a down direction', () => {
+      return api.post(`/tasks/${reward._id}/score/up`)
+      .then((res) => api.get(`/user`))
+      .then((updatedUser) => {
+        expect(user.stats.mp).to.equal(updatedUser.stats.mp);
+      });
+    });
+  });
+});

test/api/v3/integration/tasks/POST-tasks_score_id_direction.test.js

@@ -1,121 +0,0 @@
-import {
-  generateUser,
-  requester,
-  translate as t,
-} from '../../../../helpers/api-integration.helper';
-
-describe('POST /tasks/score/:id/:direction', () => {
-  let user, api;
-
-  before(() => {
-    return generateUser().then((generatedUser) => {
-      user = generatedUser;
-      api = requester(user);
-    });
-  });
-
-  context('all', () => {
-    it('requires a task id');
-
-    it('requires a task direction');
-  });
-
-  context('todos', () => {
-    let todo;
-
-    beforeEach(() => {
-      // todo = createdTodo
-    });
-
-    it('completes todo when direction is up');
-
-    it('uncompletes todo when direction is down');
-
-    it('scores up todo even if it is already completed'); // Yes?
-
-    it('scores down todo even if it is already uncompleted'); // Yes?
-
-    it('increases user\'s mp when direction is up');
-
-    it('decreases user\'s mp when direction is down');
-
-    it('increases user\'s exp when direction is up');
-
-    it('decreases user\'s exp when direction is down');
-
-    it('increases user\'s gold when direction is up');
-
-    it('decreases user\'s gold when direction is down');
-  });
-
-  context('dailys', () => {
-    let daily;
-
-    beforeEach(() => {
-      // daily = createdDaily
-    });
-
-    it('completes daily when direction is up');
-
-    it('uncompletes daily when direction is down');
-
-    it('scores up daily even if it is already completed'); // Yes?
-
-    it('scores down daily even if it is already uncompleted'); // Yes?
-
-    it('increases user\'s mp when direction is up');
-
-    it('decreases user\'s mp when direction is down');
-
-    it('increases user\'s exp when direction is up');
-
-    it('decreases user\'s exp when direction is down');
-
-    it('increases user\'s gold when direction is up');
-
-    it('decreases user\'s gold when direction is down');
-  });
-
-  context('habits', () => {
-    let habit, minusHabit, plusHabit, neitherHabit;
-
-    beforeEach(() => {
-      // habit = createdHabit
-      // plusHabit = createdPlusHabit
-      // minusHabit = createdMinusHabit
-      // neitherHabit = createdNeitherHabit
-    });
-
-    it('prevents plus only habit from scoring down'); // Yes?
-
-    it('prevents minus only habit from scoring up'); // Yes?
-
-    it('increases user\'s mp when direction is up');
-
-    it('decreases user\'s mp when direction is down');
-
-    it('increases user\'s exp when direction is up');
-
-    it('decreases user\'s exp when direction is down');
-
-    it('increases user\'s gold when direction is up');
-
-    it('decreases user\'s gold when direction is down');
-  });
-
-  context('reward', () => {
-    let reward;
-
-    beforeEach(() => {
-      // reward = createdReward
-    });
-
-    it('purchases reward');
-
-    it('does not change user\'s mp');
-
-    it('does not change user\'s exp');
-
-    it('does not allow a down direction');
-  });
-});

test/api/v3/integration/tasks/PUT-tasks_id.test.js

@@ -3,6 +3,7 @@ import {
   requester,
   translate as t,
 } from '../../../../helpers/api-integration.helper';
+import { v4 as generateUUID } from 'uuid';
 
 describe('PUT /tasks/:id', () => {
   let user, api;
@@ -18,31 +19,49 @@ describe('PUT /tasks/:id', () => {
     let task;
 
     beforeEach(() => {
-      // create sample task
-      // task = createdTask
+      return api.post('/tasks', {
+        text: 'test habit',
+        type: 'habit',
+      }).then((createdTask) => {
+        task = createdTask;
+      });
     });
 
-    it('ignores setting type field');
+    it(`ignores setting _id, type, userId, history, createdAt,
+                        updatedAt, challenge, completed, streak,
+                        dateCompleted fields`, () => {
+      api.put('/tasks/' + task._id, {
+        _id: 123,
+        type: 'daily',
+        userId: 123,
+        history: [123],
+        createdAt: 'yesterday',
+        updatedAt: 'tomorrow',
+        challenge: 'no',
+        completed: true,
+        streak: 25,
+        dateCompleted: 'never',
+      }).then((savedTask) => {
+        expect(savedTask._id).to.equal(task._id);
+        expect(savedTask.type).to.equal(task.type);
+        expect(savedTask.userId).to.equal(user._id);
+        expect(savedTask.history).to.eql([]);
+        expect(savedTask.createdAt).not.to.equal('yesterday');
+        expect(savedTask.updatedAt).not.to.equal('tomorrow');
+        expect(savedTask.challenge).not.to.equal('no');
+        expect(savedTask.completed).to.equal(false);
+        expect(savedTask.streak).to.equal(0);
+        expect(savedTask.streak).not.to.equal('never');
+      });
+    });
 
-    it('ignores setting userId field');
-
-    it('ignores setting history field');
-
-    it('ignores setting createdAt field');
-
-    it('ignores setting updatedAt field');
-
-    it('ignores setting challenge field');
-
-    it('ignores setting value field');
-
-    it('ignores setting completed field');
-
-    it('ignores setting streak field');
-
-    it('ignores setting dateCompleted field');
-
-    it('ignores invalid fields');
+    it('ignores invalid fields', () => {
+      api.put('/tasks/' + task._id, {
+        notValid: true,
+      }).then((savedTask) => {
+        expect(savedTask.notValid).to.be.a('undefined');
+      });
+    });
   });
 
   context('habits', () => {
@@ -96,7 +115,38 @@ describe('PUT /tasks/:id', () => {
       });
     });
 
-    it('can update checklists'); // Can it?
+    it('can update checklists (replace it)', () => {
+      return api.put(`/tasks/${todo._id}`, {
+        checklist: [
+          {text: 123, completed: false},
+          {text: 456, completed: true},
+        ]
+      }).then((savedTodo) => {
+        return api.put(`/tasks/${todo._id}`, {
+          checklist: [
+            {text: 789, completed: false},
+          ]
+        });
+      }).then((savedTodo2) => {
+        expect(savedTodo2.checklist.length).to.equal(1);
+        expect(savedTodo2.checklist[0].text).to.equal("789");
+        expect(savedTodo2.checklist[0].completed).to.equal(false);
+      });
+    });
+
+    it('can update tags (replace them)', () => {
+      let finalUUID = generateUUID();
+      return api.put(`/tasks/${todo._id}`, {
+        tags: [generateUUID(), generateUUID()],
+      }).then((savedTodo) => {
+        return api.put(`/tasks/${todo._id}`, {
+          tags: [finalUUID]
+        });
+      }).then((savedTodo2) => {
+        expect(savedTodo2.tags.length).to.equal(1);
+        expect(savedTodo2.tags[0]).to.equal(finalUUID);
+      });
+    });
   });
 
   context('dailys', () => {
@@ -128,13 +178,81 @@ describe('PUT /tasks/:id', () => {
       });
     });
 
-    it('can update checklists'); // Can it?
+    it('can update checklists (replace it)', () => {
+      return api.put(`/tasks/${daily._id}`, {
+        checklist: [
+          {text: 123, completed: false},
+          {text: 456, completed: true},
+        ]
+      }).then((savedDaily) => {
+        return api.put(`/tasks/${daily._id}`, {
+          checklist: [
+            {text: 789, completed: false},
+          ]
+        });
+      }).then((savedDaily2) => {
+        expect(savedDaily2.checklist.length).to.equal(1);
+        expect(savedDaily2.checklist[0].text).to.equal("789");
+        expect(savedDaily2.checklist[0].completed).to.equal(false);
+      });
+    });
 
-    it('updates repeat, even if frequency is set to daily');
+    it('can update tags (replace them)', () => {
+      let finalUUID = generateUUID();
+      return api.put(`/tasks/${daily._id}`, {
+        tags: [generateUUID(), generateUUID()],
+      }).then((savedDaily) => {
+        return api.put(`/tasks/${daily._id}`, {
+          tags: [finalUUID]
+        });
+      }).then((savedDaily2) => {
+        expect(savedDaily2.tags.length).to.equal(1);
+        expect(savedDaily2.tags[0]).to.equal(finalUUID);
+      });
+    });
 
-    it('updates everyX, even if frequency is set to weekly');
+    it('updates repeat, even if frequency is set to daily', () => {
+      return api.put(`/tasks/${daily._id}`, {
+        frequency: 'daily',
+      }).then((savedDaily) => {
+        return api.put(`/tasks/${daily._id}`, {
+          repeat: {
+            m: false,
+            su: false
+          }
+        });
+      }).then((savedDaily2) => {
+        expect(savedDaily2.repeat).to.eql({
+          m: false,
+          t: true,
+          w: true,
+          th: true,
+          f: true,
+          s: true,
+          su: false,
+        });
+      });
+    });
 
-    it('defaults startDate to today if none date object is passed in');
+    it('updates everyX, even if frequency is set to weekly', () => {
+      return api.put(`/tasks/${daily._id}`, {
+        frequency: 'weekly',
+      }).then((savedDaily) => {
+        return api.put(`/tasks/${daily._id}`, {
+          everyX: 5,
+        });
+      }).then((savedDaily2) => {
+        expect(savedDaily2.everyX).to.eql(5);
+      });
+    });
+
+    it('defaults startDate to today if none date object is passed in', () => {
+      return api.put(`/tasks/${daily._id}`, {
+        frequency: 'weekly',
+      }).then((savedDaily2) => {
+        expect((new Date(savedDaily2.startDate)).getDay()).to.eql((new Date()).getDay());
+      });
+    });
   });
 
   context('rewards', () => {
@@ -163,6 +281,12 @@ describe('PUT /tasks/:id', () => {
       });
     });
 
-    it('requires value to be coerced into a number');
+    it('requires value to be coerced into a number', () => {
+      return api.put(`/tasks/${reward._id}`, {
+        value: "100",
+      }).then((task) => {
+        expect(task.value).to.eql(100);
+      });
+    });
   });
 });

test/api/v3/integration/tasks/checklists/DELETE-tasks_taskId_checklist_itemId.test.js

@@ -0,0 +1,86 @@
+import {
+  generateUser,
+  requester,
+  translate as t,
+} from '../../../../../helpers/api-integration.helper';
+import { v4 as generateUUID } from 'uuid';
+
+describe('DELETE /tasks/:taskId/checklist/:itemId', () => {
+  let user, api;
+
+  before(() => {
+    return generateUser().then((generatedUser) => {
+      user = generatedUser;
+      api = requester(user);
+    });
+  });
+
+  it('deletes a checklist item', () => {
+    let task;
+
+    return api.post('/tasks', {
+      type: 'daily',
+      text: 'Daily with checklist',
+    }).then(createdTask => {
+      task = createdTask;
+      return api.post(`/tasks/${task._id}/checklist`, {text: 'Checklist Item 1', completed: false});
+    }).then((savedTask) => {
+      return api.del(`/tasks/${task._id}/checklist/${savedTask.checklist[0]._id}`);
+    }).then(() => {
+      return api.get(`/tasks/${task._id}`);
+    }).then((savedTask) => {
+      expect(savedTask.checklist.length).to.equal(0);
+    });
+  });
+
+  it('does not work with habits', () => {
+    let habit;
+    return expect(api.post('/tasks', {
+      type: 'habit',
+      text: 'habit with checklist',
+    }).then(createdTask => {
+      habit = createdTask;
+      return api.del(`/tasks/${habit._id}/checklist/${generateUUID()}`);
+    })).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('checklistOnlyDailyTodo'),
+    });
+  });
+
+  it('does not work with rewards', () => {
+    let reward;
+    return expect(api.post('/tasks', {
+      type: 'reward',
+      text: 'reward with checklist',
+    }).then(createdTask => {
+      reward = createdTask;
+      return api.del(`/tasks/${reward._id}/checklist/${generateUUID()}`);
+    }).then(checklistItem => {})).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('checklistOnlyDailyTodo'),
+    });
+  });
+
+  it('fails on task not found', () => {
+    return expect(api.del(`/tasks/${generateUUID()}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
+      code: 404,
+      error: 'NotFound',
+      message: t('taskNotFound'),
+    });
+  });
+
+  it('fails on checklist item not found', () => {
+    return expect(api.post('/tasks', {
+      type: 'daily',
+      text: 'daily with checklist',
+    }).then(createdTask => {
+      return api.del(`/tasks/${createdTask._id}/checklist/${generateUUID()}`);
+    })).to.eventually.be.rejected.and.eql({
+      code: 404,
+      error: 'NotFound',
+      message: t('checklistItemNotFound'),
+    });
+  });
+});

test/api/v3/integration/tasks/checklists/POST-tasks_taskId_checklist.test.js

@@ -0,0 +1,76 @@
+import {
+  generateUser,
+  requester,
+  translate as t,
+} from '../../../../../helpers/api-integration.helper';
+import { v4 as generateUUID } from 'uuid';
+
+describe('POST /tasks/:taskId/checklist/', () => {
+  let user, api;
+
+  before(() => {
+    return generateUser().then((generatedUser) => {
+      user = generatedUser;
+      api = requester(user);
+    });
+  });
+
+  it('adds a checklist item to a task', () => {
+    let task;
+
+    return api.post('/tasks', {
+      type: 'daily',
+      text: 'Daily with checklist',
+    }).then(createdTask => {
+      task = createdTask;
+      return api.post(`/tasks/${task._id}/checklist`, {text: 'Checklist Item 1', ignored: false, _id: 123});
+    }).then((savedTask) => {
+      expect(savedTask.checklist.length).to.equal(1);
+      expect(savedTask.checklist[0].text).to.equal('Checklist Item 1');
+      expect(savedTask.checklist[0].completed).to.equal(false);
+      expect(savedTask.checklist[0]._id).to.be.a('string');
+      expect(savedTask.checklist[0]._id).to.not.equal('123');
+      expect(savedTask.checklist[0].ignored).to.be.an('undefined');
+    });
+  });
+
+  it('does not add a checklist to habits', () => {
+    let habit;
+    return expect(api.post('/tasks', {
+      type: 'habit',
+      text: 'habit with checklist',
+    }).then(createdTask => {
+      habit = createdTask;
+      return api.post(`/tasks/${habit._id}/checklist`, {text: 'Checklist Item 1'});
+    })).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('checklistOnlyDailyTodo'),
+    });
+  });
+
+  it('does not add a checklist to rewards', () => {
+    let reward;
+    return expect(api.post('/tasks', {
+      type: 'reward',
+      text: 'reward with checklist',
+    }).then(createdTask => {
+      reward = createdTask;
+      return api.post(`/tasks/${reward._id}/checklist`, {text: 'Checklist Item 1'});
+    })).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('checklistOnlyDailyTodo'),
+    });
+  });
+
+  it('fails on task not found', () => {
+    return expect(api.post(`/tasks/${generateUUID()}/checklist`, {
+      text: 'Checklist Item 1'
+    })).to.eventually.be.rejected.and.eql({
+      code: 404,
+      error: 'NotFound',
+      message: t('taskNotFound'),
+    });
+  });
+});

test/api/v3/integration/tasks/checklists/POST-tasks_taskId_checklist_itemId_score.test.js

@@ -0,0 +1,85 @@
+import {
+  generateUser,
+  requester,
+  translate as t,
+} from '../../../../../helpers/api-integration.helper';
+import { v4 as generateUUID } from 'uuid';
+
+describe('POST /tasks/:taskId/checklist/:itemId/score', () => {
+  let user, api;
+
+  before(() => {
+    return generateUser().then((generatedUser) => {
+      user = generatedUser;
+      api = requester(user);
+    });
+  });
+
+  it('scores a checklist item', () => {
+    let task;
+
+    return api.post('/tasks', {
+      type: 'daily',
+      text: 'Daily with checklist',
+    }).then(createdTask => {
+      task = createdTask;
+      return api.post(`/tasks/${task._id}/checklist`, {text: 'Checklist Item 1', completed: false});
+    }).then((savedTask) => {
+      return api.post(`/tasks/${task._id}/checklist/${savedTask.checklist[0]._id}/score`);
+    }).then((savedTask) => {
+      expect(savedTask.checklist.length).to.equal(1);
+      expect(savedTask.checklist[0].completed).to.equal(true);
+    });
+  });
+
+  it('fails on habits', () => {
+    let habit;
+    return expect(api.post('/tasks', {
+      type: 'habit',
+      text: 'habit with checklist',
+    }).then(createdTask => {
+      habit = createdTask;
+      return api.post(`/tasks/${habit._id}/checklist/${generateUUID()}/score`, {text: 'Checklist Item 1'});
+    })).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('checklistOnlyDailyTodo'),
+    });
+  });
+
+  it('fails on rewards', () => {
+    let reward;
+    return expect(api.post('/tasks', {
+      type: 'reward',
+      text: 'reward with checklist',
+    }).then(createdTask => {
+      reward = createdTask;
+      return api.post(`/tasks/${reward._id}/checklist/${generateUUID()}/score`);
+    }).then(checklistItem => {})).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('checklistOnlyDailyTodo'),
+    });
+  });
+
+  it('fails on task not found', () => {
+    return expect(api.post(`/tasks/${generateUUID()}/checklist/${generateUUID()}/score`)).to.eventually.be.rejected.and.eql({
+      code: 404,
+      error: 'NotFound',
+      message: t('taskNotFound'),
+    });
+  });
+
+  it('fails on checklist item not found', () => {
+    return expect(api.post('/tasks', {
+      type: 'daily',
+      text: 'daily with checklist',
+    }).then(createdTask => {
+      return api.post(`/tasks/${createdTask._id}/checklist/${generateUUID()}/score`);
+    })).to.eventually.be.rejected.and.eql({
+      code: 404,
+      error: 'NotFound',
+      message: t('checklistItemNotFound'),
+    });
+  });
+});

test/api/v3/integration/tasks/checklists/PUT-tasks_taskId_checklist_itemId.test.js

@@ -0,0 +1,87 @@
+import {
+  generateUser,
+  requester,
+  translate as t,
+} from '../../../../../helpers/api-integration.helper';
+import { v4 as generateUUID } from 'uuid';
+
+describe('PUT /tasks/:taskId/checklist/:itemId', () => {
+  let user, api;
+
+  before(() => {
+    return generateUser().then((generatedUser) => {
+      user = generatedUser;
+      api = requester(user);
+    });
+  });
+
+  it('updates a checklist item', () => {
+    let task;
+
+    return api.post('/tasks', {
+      type: 'daily',
+      text: 'Daily with checklist',
+    }).then(createdTask => {
+      task = createdTask;
+      return api.post(`/tasks/${task._id}/checklist`, {text: 'Checklist Item 1', completed: false});
+    }).then((savedTask) => {
+      return api.put(`/tasks/${task._id}/checklist/${savedTask.checklist[0]._id}`, {text: 'updated', completed: true, _id: 123});
+    }).then((savedTask) => {
+      expect(savedTask.checklist.length).to.equal(1);
+      expect(savedTask.checklist[0].text).to.equal('updated');
+      expect(savedTask.checklist[0].completed).to.equal(true);
+      expect(savedTask.checklist[0]._id).to.not.equal('123');
+    });
+  });
+
+  it('fails on habits', () => {
+    let habit;
+    return expect(api.post('/tasks', {
+      type: 'habit',
+      text: 'habit with checklist',
+    }).then(createdTask => {
+      habit = createdTask;
+      return api.put(`/tasks/${habit._id}/checklist/${generateUUID()}`);
+    })).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('checklistOnlyDailyTodo'),
+    });
+  });
+
+  it('fails on rewards', () => {
+    let reward;
+    return expect(api.post('/tasks', {
+      type: 'reward',
+      text: 'reward with checklist',
+    }).then(createdTask => {
+      reward = createdTask;
+      return api.put(`/tasks/${reward._id}/checklist/${generateUUID()}`);
+    }).then(checklistItem => {})).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('checklistOnlyDailyTodo'),
+    });
+  });
+
+  it('fails on task not found', () => {
+    return expect(api.put(`/tasks/${generateUUID()}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
+      code: 404,
+      error: 'NotFound',
+      message: t('taskNotFound'),
+    });
+  });
+
+  it('fails on checklist item not found', () => {
+    return expect(api.post('/tasks', {
+      type: 'daily',
+      text: 'daily with checklist',
+    }).then(createdTask => {
+      return api.put(`/tasks/${createdTask._id}/checklist/${generateUUID()}`);
+    })).to.eventually.be.rejected.and.eql({
+      code: 404,
+      error: 'NotFound',
+      message: t('checklistItemNotFound'),
+    });
+  });
+});

test/api/v3/integration/tasks/tags/DELETE-tasks_taskId_tags_tagId.test.js

@@ -0,0 +1,53 @@
+import {
+  generateUser,
+  requester,
+  translate as t,
+} from '../../../../../helpers/api-integration.helper';
+import { v4 as generateUUID } from 'uuid';
+
+describe('DELETE /tasks/:taskId/tags/:tagId', () => {
+  let user, api;
+
+  before(() => {
+    return generateUser().then((generatedUser) => {
+      user = generatedUser;
+      api = requester(user);
+    });
+  });
+
+  it('removes a tag from a task', () => {
+    let tag;
+    let task;
+
+    return api.post('/tasks', {
+      type: 'habit',
+      text: 'Task with tag',
+    }).then(createdTask => {
+      task = createdTask;
+      return api.post('/tags', {name: 'Tag 1'});
+    }).then(createdTag => {
+      tag = createdTag;
+      return api.post(`/tasks/${task._id}/tags/${tag._id}`);
+    }).then(savedTask => {
+      return api.del(`/tasks/${task._id}/tags/${tag._id}`);
+    }).then(() => api.get(`/tasks/${task._id}`))
+    .then(updatedTask => {
+      expect(updatedTask.tags.length).to.equal(0);
+    });
+  });
+
+  it('only deletes existing tags', () => {
+    let task;
+
+    return expect(api.post('/tasks', {
+      type: 'habit',
+      text: 'Task with tag',
+    }).then(createdTask => {
+      return api.del(`/tasks/${createdTask._id}/tags/${generateUUID()}`);
+    })).to.eventually.be.rejected.and.eql({
+      code: 404,
+      error: 'NotFound',
+      message: t('tagNotFound'),
+    });
+  });
+});

test/api/v3/integration/tasks/tags/POST-tasks_taskId_tags_tagId.test.js

@@ -0,0 +1,70 @@
+import {
+  generateUser,
+  requester,
+  translate as t,
+} from '../../../../../helpers/api-integration.helper';
+import { v4 as generateUUID } from 'uuid';
+
+describe('POST /tasks/:taskId/tags/:tagId', () => {
+  let user, api;
+
+  before(() => {
+    return generateUser().then((generatedUser) => {
+      user = generatedUser;
+      api = requester(user);
+    });
+  });
+
+  it('adds a tag to a task', () => {
+    let tag;
+    let task;
+
+    return api.post('/tasks', {
+      type: 'habit',
+      text: 'Task with tag',
+    }).then(createdTask => {
+      task = createdTask;
+      return api.post('/tags', {name: 'Tag 1'});
+    }).then(createdTag => {
+      tag = createdTag;
+      return api.post(`/tasks/${task._id}/tags/${tag._id}`);
+    }).then(savedTask => {
+      expect(savedTask.tags[0]).to.equal(tag._id);
+    });
+  });
+
+  it('does not add a tag to a task twice', () => {
+    let tag;
+    let task;
+
+    return expect(api.post('/tasks', {
+      type: 'habit',
+      text: 'Task with tag',
+    }).then(createdTask => {
+      task = createdTask;
+      return api.post('/tags', {name: 'Tag 1'});
+    }).then(createdTag => {
+      tag = createdTag;
+      return api.post(`/tasks/${task._id}/tags/${tag._id}`);
+    }).then(() => {
+      return api.post(`/tasks/${task._id}/tags/${tag._id}`);
+    })).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('alreadyTagged'),
+    });
+  });
+
+  it('does not add a non existing tag to a task', () => {
+    return expect(api.post('/tasks', {
+      type: 'habit',
+      text: 'Task with tag',
+    }).then((task) => {
+      return api.post(`/tasks/${task._id}/tags/${generateUUID()}`);
+    })).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('invalidReqParams'),
+    });
+  });
+});

test/api/v3/integration/user/GET-user.test.js

@@ -0,0 +1,31 @@
+import {
+  generateUser,
+  requester,
+} from '../../../../helpers/api-integration.helper';
+
+describe('GET /user', () => {
+  let user, api;
+
+  before(() => {
+    return generateUser().then((generatedUser) => {
+      user = generatedUser;
+      api = requester(user);
+    });
+  });
+
+  it('returns the authenticated user', () => {
+    return api.get('/user')
+    .then(returnedUser => {
+      expect(returnedUser._id).to.equal(user._id);
+    });
+  });
+
+  it('does not return private paths (and apiToken)', () => {
+    return api.get('/user')
+    .then(returnedUser => {
+      expect(returnedUser.auth.local.hashed_password).to.be.a('undefined');
+      expect(returnedUser.auth.local.salt).to.be.a('undefined');
+      expect(returnedUser.apiToken).to.be.a('undefined');
+    });
+  });
+});