tests(api): bring in await format tests

test/api/v3/integration/notFound.test.js

@@ -1,10 +1,10 @@
 import { requester } from '../../../helpers/api-integration.helper';
 
 describe('notFound Middleware', () => {
-  it('returns a 404 error when the resource is not found', () => {
+  it('returns a 404 error when the resource is not found', async () => {
     let request = requester().get('/api/v3/dummy-url');
 
-    return expect(request).to.eventually.be.rejected.and.eql({
+    await expect(request).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
       message: 'Not found.',

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

@@ -5,29 +5,23 @@ import {
 describe('DELETE /tags/:tagId', () => {
   let user;
 
-  before(() => {
+  before(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
-  it('deletes a tag given it\'s id', () => {
+  it('deletes a tag given it\'s id', async () => {
-    let length;
+    let tagName = 'Tag 1';
-    let tag;
+    let tag = await user.post('/tags', {name: tagName});
+    let numberOfTags = (await user.get('/tags')).length;
 
-    return user.post('/tags', {name: 'Tag 1'})
+    await user.del(`/tags/${tag._id}`);
-    .then((createdTag) => {
+
-      tag = createdTag;
+    let tags = await user.get('/tags');
-      return user.get(`/tags`);
+    let tagNames = tags.map((t) => {
-    })
+      return t.name;
-    .then((tags) => {
-      length = tags.length;
-      return user.del(`/tags/${tag._id}`);
-    })
-    .then(() => user.get(`/tags`))
-    .then((tags) => {
-      expect(tags.length).to.equal(length - 1);
-      expect(tags[tags.length - 1].name).to.not.equal('Tag 1');
     });
+
+    expect(tags.length).to.equal(numberOfTags - 1);
+    expect(tagNames).to.not.include(tagName);
   });
 });

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

@@ -5,20 +5,18 @@ import {
 describe('GET /tags', () => {
   let user;
 
-  before(() => {
+  before(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
-  it('returns all user\'s tags', () => {
+  it('returns all user\'s tags', async () => {
-    return user.post('/tags', {name: 'Tag 1'})
+    let tag1 = await user.post('/tags', {name: 'Tag 1'});
-    .then(() => user.post('/tags', {name: 'Tag 2'}))
+    let tag2 = await user.post('/tags', {name: 'Tag 2'});
-    .then(() => user.get('/tags'))
+
-    .then((tags) => {
+    let tags = await user.get('/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.length).to.equal(2 + 3); // + 3 because 1 is a default task
-      expect(tags[tags.length - 1].name).to.equal('Tag 2');
+    expect(tags[tags.length - 2].name).to.equal(tag1.name);
-    });
+    expect(tags[tags.length - 1].name).to.equal(tag2.name);
   });
 });

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

@@ -5,22 +5,14 @@ import {
 describe('GET /tags/:tagId', () => {
   let user;
 
-  before(() => {
+  before(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
-  it('returns a tag given it\'s id', () => {
+  it('returns a tag given it\'s id', async () => {
-    let createdTag;
+    let createdTag = await user.post('/tags', {name: 'Tag 1'});
+    let tag = await user.get(`/tags/${createdTag._id}`);
 
-    return user.post('/tags', {name: 'Tag 1'})
+    expect(tag).to.deep.equal(createdTag);
-    .then((tag) => {
-      createdTag = tag;
-      return user.get(`/tags/${createdTag._id}`);
-    })
-    .then((tag) => {
-      expect(tag).to.deep.equal(createdTag);
-    });
   });
 });

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

@@ -5,28 +5,21 @@ import {
 describe('POST /tags', () => {
   let user;
 
-  before(() => {
+  beforeEach(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
-  it('creates a tag correctly', () => {
+  it('creates a tag correctly', async () => {
-    let createdTag;
+    let tagName = 'Tag 1';
-
+    let createdTag = await user.post('/tags', {
-    return user.post('/tags', {
+      name: tagName,
-      name: 'Tag 1',
       ignored: false,
-    }).then((tag) => {
-      createdTag = tag;
-
-      expect(tag.name).to.equal('Tag 1');
-      expect(tag.ignored).to.be.a('undefined');
-
-      return user.get(`/tags/${createdTag._id}`);
-    })
-    .then((tag) => {
-      expect(tag).to.deep.equal(createdTag);
     });
+
+    let tag = await user.get(`/tags/${createdTag._id}`);
+
+    expect(tag.name).to.equal(tagName);
+    expect(tag.ignored).to.not.exist;
+    expect(tag).to.deep.equal(createdTag);
   });
 });

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

@@ -5,29 +5,24 @@ import {
 describe('PUT /tags/:tagId', () => {
   let user;
 
-  before(() => {
+  before(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
-  it('updates a tag given it\'s id', () => {
+  it('updates a tag given it\'s id', async () => {
-    return user.post('/tags', {name: 'Tag 1'})
+    let updatedTagName = 'Tag updated';
-    .then((createdTag) => {
+    let createdTag = await user.post('/tags', {name: 'Tag 1'});
-      return user.put(`/tags/${createdTag._id}`, {
+    let updatedTag = await user.put(`/tags/${createdTag._id}`, {
-        name: 'Tag updated',
+      name: updatedTagName,
-        ignored: true,
+      ignored: true,
-      });
-    })
-    .then((updatedTag) => {
-      expect(updatedTag.name).to.equal('Tag updated');
-      expect(updatedTag.ignored).to.be.a('undefined');
-
-      return user.get(`/tags/${updatedTag._id}`);
-    })
-    .then((tag) => {
-      expect(tag.name).to.equal('Tag updated');
-      expect(tag.ignored).to.be.a('undefined');
     });
+
+    createdTag = await user.get(`/tags/${updatedTag._id}`);
+
+    expect(updatedTag.name).to.equal(updatedTagName);
+    expect(updatedTag.ignored).to.not.exist;
+
+    expect(createdTag.name).to.equal(updatedTagName);
+    expect(createdTag.ignored).to.not.exist;
   });
 });

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

@@ -6,60 +6,52 @@ import {
 describe('DELETE /tasks/:id', () => {
   let user;
 
-  before(() => {
+  before(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
   context('task can be deleted', () => {
     let task;
 
-    beforeEach(() => {
+    beforeEach(async () => {
-      return user.post('/tasks', {
+      task = await user.post('/tasks', {
         text: 'test habit',
         type: 'habit',
-      }).then((createdTask) => {
-        task = createdTask;
       });
     });
 
-    it('deletes a user\'s task', () => {
+    it('deletes a user\'s task', async () => {
-      return user.del(`/tasks/${task._id}`)
+      await user.del(`/tasks/${task._id}`);
-        .then(() => {
+
-          return expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
+      await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
-            code: 404,
+        code: 404,
-            error: 'NotFound',
+        error: 'NotFound',
-            message: t('taskNotFound'),
+        message: t('taskNotFound'),
-          });
+      });
-        });
     });
   });
 
   context('task cannot be deleted', () => {
-    it('cannot delete a non-existant task', () => {
+    it('cannot delete a non-existant task', async () => {
-      return expect(user.del('/tasks/550e8400-e29b-41d4-a716-446655440000')).to.eventually.be.rejected.and.eql({
+      await expect(user.del('/tasks/550e8400-e29b-41d4-a716-446655440000')).to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
         message: t('taskNotFound'),
       });
     });
 
-    it('cannot delete a task owned by someone else', () => {
+    it('cannot delete a task owned by someone else', async () => {
-      return generateUser()
+      let anotherUser = await generateUser();
-        .then((anotherUser) => {
+      let anotherUsersTask = await anotherUser.post('/tasks', {
-          return anotherUser.post('/tasks', {
+        text: 'test habit',
-            text: 'test habit',
+        type: 'habit',
-            type: 'habit',
+      });
-          });
+
-        })
+      await expect(user.del(`/tasks/${anotherUsersTask._id}`)).to.eventually.be.rejected.and.eql({
-        .then((task2) => {
+        code: 404,
-          return expect(user.del(`/tasks/${task2._id}`)).to.eventually.be.rejected.and.eql({
+        error: 'NotFound',
-            code: 404,
+        message: t('taskNotFound'),
-            error: 'NotFound',
+      });
-            message: t('taskNotFound'),
-          });
-        });
     });
 
     it('cannot delete active challenge tasks'); // TODO after challenges are implemented

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

@@ -6,37 +6,27 @@ import Q from 'q';
 describe('GET /tasks', () => {
   let user;
 
-  before(() => {
+  beforeEach(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
-  it('returns all user\'s tasks', () => {
+  it('returns all user\'s tasks', async () => {
-    let length;
+    let createdTasks = await Q.all([
-    return Q.all([
       user.post('/tasks', {text: 'test habit', type: 'habit'}),
-    ])
+    ]);
-    .then((createdTasks) => {
+
-      length = createdTasks.length;
+    let length = createdTasks.length;
-      return user.get('/tasks');
+    let tasks = await user.get('/tasks');
-    })
+
-    .then((tasks) => {
+    expect(tasks.length).to.equal(length + 1); // + 1 because 1 is a default task
-      expect(tasks.length).to.equal(length + 1); // + 1 because 1 is a default task
-    });
   });
 
-  it('returns only a type of user\'s tasks if req.query.type is specified', () => {
+  it('returns only a type of user\'s tasks if req.query.type is specified', async () => {
-    let habitId;
+    let task = await user.post('/tasks', {text: 'test habit', type: 'habit'});
-    user.post('/tasks', {text: 'test habit', type: 'habit'})
+    let tasks = await user.get('/tasks?type=habit');
-    .then((task) => {
+
-      habitId = task._id;
+    expect(tasks.length).to.equal(1);
-      return user.get('/tasks?type=habit');
+    expect(tasks[0]._id).to.equal(task._id);
-    })
-    .then((tasks) => {
-      expect(tasks.length).to.equal(1);
-      expect(tasks[0]._id).to.equal(habitId);
-    });
   });
 
   // TODO complete after task scoring is done

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

@@ -7,29 +7,23 @@ import { v4 as generateUUID } from 'uuid';
 describe('GET /tasks/:id', () => {
   let user;
 
-  before(() => {
+  before(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
-  context('task can be accessed', () => {
+  context('task can be accessed', async () => {
     let task;
 
-    beforeEach(() => {
+    beforeEach(async () => {
-      return user.post('/tasks', {
+      task = await user.post('/tasks', {
         text: 'test habit',
         type: 'habit',
-      }).then((createdTask) => {
-        task = createdTask;
       });
     });
 
-    it('gets specified task', () => {
+    it('gets specified task', async () => {
-      return user.get(`/tasks/${task._id}`)
+      let getTask = await user.get(`/tasks/${task._id}`);
-      .then((getTask) => {
+      expect(getTask).to.eql(task);
-        expect(getTask).to.eql(task);
-      });
     });
 
     // TODO after challenges are implemented
@@ -37,34 +31,28 @@ describe('GET /tasks/:id', () => {
   });
 
   context('task cannot be accessed', () => {
-    it('cannot get a non-existant task', () => {
+    it('cannot get a non-existant task', async () => {
       let dummyId = generateUUID();
 
-      return expect(user.get(`/tasks/${dummyId}`)).to.eventually.be.rejected.and.eql({
+      await expect(user.get(`/tasks/${dummyId}`)).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', async () => {
-      let anotherUser;
+      let anotherUser = await generateUser();
+      let task = await user.post('/tasks', {
+        text: 'test habit',
+        type: 'habit',
+      });
 
-      return generateUser()
+      await expect(anotherUser.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
-        .then((user2) => {
+        code: 404,
-          anotherUser = user2;
+        error: 'NotFound',
-
+        message: t('taskNotFound'),
-          return user.post('/tasks', {
+      });
-            text: 'test habit',
-            type: 'habit',
-          });
-        }).then((task) => {
-          return expect(anotherUser.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

@@ -7,14 +7,12 @@ describe('POST /tasks', () => {
   let user;
 
   before(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
-  context('validates params', () => {
+  context('validates params', async () => {
     it('returns an error if req.body.type is absent', async () => {
-      return expect(user.post('/tasks', {
+      await expect(user.post('/tasks', {
         notType: 'habit',
       })).to.eventually.be.rejected.and.eql({
         code: 400,
@@ -24,7 +22,7 @@ describe('POST /tasks', () => {
     });
 
     it('returns an error if req.body.type is not valid', async () => {
-      return expect(user.post('/tasks', {
+      await expect(user.post('/tasks', {
         type: 'habitF',
       })).to.eventually.be.rejected.and.eql({
         code: 400,
@@ -34,7 +32,7 @@ describe('POST /tasks', () => {
     });
 
     it('returns an error if req.body.text is absent', async () => {
-      return expect(user.post('/tasks', {
+      await expect(user.post('/tasks', {
         type: 'habit',
       })).to.eventually.be.rejected.and.eql({
         code: 400,

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

@@ -7,25 +7,23 @@ import { v4 as generateUUID } from 'uuid';
 describe('POST /tasks/:id/score/:direction', () => {
   let user;
 
-  beforeEach(() => {
+  beforeEach(async () => {
-    return generateUser({
+    user = await generateUser({
       'stats.gp': 100,
-    }).then((generatedUser) => {
-      user = generatedUser;
     });
   });
 
   context('all', () => {
-    it('requires a task id', () => {
+    it('requires a task id', async () => {
-      return expect(user.post('/tasks/123/score/up')).to.eventually.be.rejected.and.eql({
+      await expect(user.post('/tasks/123/score/up')).to.eventually.be.rejected.and.eql({
         code: 400,
         error: 'BadRequest',
         message: t('invalidReqParams'),
       });
     });
 
-    it('requires a task direction', () => {
+    it('requires a task direction', async () => {
-      return expect(user.post(`/tasks/${generateUUID()}/score/tt`)).to.eventually.be.rejected.and.eql({
+      await expect(user.post(`/tasks/${generateUUID()}/score/tt`)).to.eventually.be.rejected.and.eql({
         code: 400,
         error: 'BadRequest',
         message: t('invalidReqParams'),
@@ -36,110 +34,97 @@ describe('POST /tasks/:id/score/:direction', () => {
   context('todos', () => {
     let todo;
 
-    beforeEach(() => {
+    beforeEach(async () => {
-      return user.post('/tasks', {
+      todo = await user.post('/tasks', {
         text: 'test todo',
         type: 'todo',
-      }).then((task) => {
-        todo = task;
       });
     });
 
-    it('completes todo when direction is up', () => {
+    it('completes todo when direction is up', async () => {
-      return user.post(`/tasks/${todo._id}/score/up`)
+      await user.post(`/tasks/${todo._id}/score/up`);
-      .then(() => user.get(`/tasks/${todo._id}`))
+      let task = await user.get(`/tasks/${todo._id}`);
-      .then((task) => expect(task.completed).to.equal(true));
+
+      expect(task.completed).to.equal(true);
     });
 
-    it('moves completed todos out of user.tasksOrder.todos', () => {
+    it('moves completed todos out of user.tasksOrder.todos', async () => {
-      return user.get('/user')
+      let getUser = await user.get('/user');
-      .then(usr => {
+      expect(getUser.tasksOrder.todos.indexOf(todo._id)).to.not.equal(-1);
-        expect(usr.tasksOrder.todos.indexOf(todo._id)).to.not.equal(-1);
+
-      }).then(() => user.post(`/tasks/${todo._id}/score/up`))
+      await user.post(`/tasks/${todo._id}/score/up`);
-      .then(() => user.get(`/tasks/${todo._id}`))
+      let updatedTask = await user.get(`/tasks/${todo._id}`);
-      .then((updatedTask) => {
+      expect(updatedTask.completed).to.equal(true);
-        expect(updatedTask.completed).to.equal(true);
+
-        return user.get('/user');
+      let updatedUser = await user.get('/user');
-      })
+      expect(updatedUser.tasksOrder.todos.indexOf(todo._id)).to.equal(-1);
-      .then((usr) => {
-        expect(usr.tasksOrder.todos.indexOf(todo._id)).to.equal(-1);
-      });
     });
 
-    it('moves un-completed todos back into user.tasksOrder.todos', () => {
+    it('moves un-completed todos back into user.tasksOrder.todos', async () => {
-      return user.get('/user')
+      let getUser = await user.get('/user');
-      .then(usr => {
+      expect(getUser.tasksOrder.todos.indexOf(todo._id)).to.not.equal(-1);
-        expect(usr.tasksOrder.todos.indexOf(todo._id)).to.not.equal(-1);
+
-      }).then(() => user.post(`/tasks/${todo._id}/score/up`))
+      await user.post(`/tasks/${todo._id}/score/up`);
-      .then(() => user.post(`/tasks/${todo._id}/score/down`))
+      await user.post(`/tasks/${todo._id}/score/down`);
-      .then(() => user.get(`/tasks/${todo._id}`))
+
-      .then((updatedTask) => {
+      let updatedTask = await user.get(`/tasks/${todo._id}`);
-        expect(updatedTask.completed).to.equal(false);
+      expect(updatedTask.completed).to.equal(false);
-        return user.get('/user');
+
-      })
+      let updatedUser = await user.get('/user');
-      .then((usr) => {
+      let l = updatedUser.tasksOrder.todos.length;
-        let l = usr.tasksOrder.todos.length;
+      expect(updatedUser.tasksOrder.todos.indexOf(todo._id)).not.to.equal(-1);
-        expect(usr.tasksOrder.todos.indexOf(todo._id)).not.to.equal(-1);
+      expect(updatedUser.tasksOrder.todos.indexOf(todo._id)).to.equal(l - 1); // Check that it was pushed at the bottom
-        expect(usr.tasksOrder.todos.indexOf(todo._id)).to.equal(l - 1); // Check that it was pushed at the bottom
-      });
     });
 
-    it('uncompletes todo when direction is down', () => {
+    it('uncompletes todo when direction is down', async () => {
-      return user.post(`/tasks/${todo._id}/score/down`)
+      await user.post(`/tasks/${todo._id}/score/down`);
-      .then(() => user.get(`/tasks/${todo._id}`))
+      let updatedTask = await user.get(`/tasks/${todo._id}`);
-      .then((updatedTask) => {
+
-        expect(updatedTask.completed).to.equal(false);
+      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', () => {
+    context('user stats when direction is up', () => {
-      return user.post(`/tasks/${todo._id}/score/up`)
+      let updatedUser;
-      .then(() => user.get(`/user`))
+
-      .then((updatedUser) => {
+      beforeEach(async () => {
+        await user.post(`/tasks/${todo._id}/score/up`);
+        updatedUser = await user.get(`/user`);
+      });
+
+      it('increases user\'s mp', () => {
         expect(updatedUser.stats.mp).to.be.greaterThan(user.stats.mp);
       });
-    });
 
-    it('decreases user\'s mp when direction is down', () => {
+      it('increases user\'s exp', () => {
-      return user.post(`/tasks/${todo._id}/score/down`)
-      .then(() => user.get(`/user`))
-      .then((updatedUser) => {
-        expect(updatedUser.stats.mp).to.be.lessThan(user.stats.mp);
-      });
-    });
-
-    it('increases user\'s exp when direction is up', () => {
-      return user.post(`/tasks/${todo._id}/score/up`)
-      .then(() => user.get(`/user`))
-      .then((updatedUser) => {
         expect(updatedUser.stats.exp).to.be.greaterThan(user.stats.exp);
       });
-    });
 
-    it('decreases user\'s exp when direction is down', () => {
+      it('increases user\'s gold', () => {
-      return user.post(`/tasks/${todo._id}/score/down`)
-      .then(() => user.get(`/user`))
-      .then((updatedUser) => {
-        expect(updatedUser.stats.exp).to.be.lessThan(user.stats.exp);
-      });
-    });
-
-    it('increases user\'s gold when direction is up', () => {
-      return user.post(`/tasks/${todo._id}/score/up`)
-      .then(() => user.get(`/user`))
-      .then((updatedUser) => {
         expect(updatedUser.stats.gp).to.be.greaterThan(user.stats.gp);
       });
     });
 
-    it('decreases user\'s gold when direction is down', () => {
+    context('user stats when direction is down', () => {
-      return user.post(`/tasks/${todo._id}/score/down`)
+      let updatedUser;
-      .then(() => user.get(`/user`))
+
-      .then((updatedUser) => {
+      beforeEach(async () => {
+        await user.post(`/tasks/${todo._id}/score/down`);
+        updatedUser = await user.get(`/user`);
+      });
+
+      it('decreases user\'s mp', () => {
+        expect(updatedUser.stats.mp).to.be.lessThan(user.stats.mp);
+      });
+
+      it('decreases user\'s exp', () => {
+        expect(updatedUser.stats.exp).to.be.lessThan(user.stats.exp);
+      });
+
+      it('decreases user\'s gold', () => {
         expect(updatedUser.stats.gp).to.be.lessThan(user.stats.gp);
       });
     });
@@ -148,75 +133,69 @@ describe('POST /tasks/:id/score/:direction', () => {
   context('dailys', () => {
     let daily;
 
-    beforeEach(() => {
+    beforeEach(async () => {
-      return user.post('/tasks', {
+      daily = await user.post('/tasks', {
         text: 'test daily',
         type: 'daily',
-      }).then((task) => {
-        daily = task;
       });
     });
 
-    it('completes daily when direction is up', () => {
+    it('completes daily when direction is up', async () => {
-      return user.post(`/tasks/${daily._id}/score/up`)
+      await user.post(`/tasks/${daily._id}/score/up`);
-      .then(() => user.get(`/tasks/${daily._id}`))
+      let task = await user.get(`/tasks/${daily._id}`);
-      .then((task) => expect(task.completed).to.equal(true));
+
+      expect(task.completed).to.equal(true);
     });
 
-    it('uncompletes daily when direction is down', () => {
+    it('uncompletes daily when direction is down', async () => {
-      return user.post(`/tasks/${daily._id}/score/down`)
+      await user.post(`/tasks/${daily._id}/score/down`);
-      .then(() => user.get(`/tasks/${daily._id}`))
+      let task = await user.get(`/tasks/${daily._id}`);
-      .then((task) => expect(task.completed).to.equal(false));
+
+      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', () => {
+    context('user stats when direction is up', () => {
-      return user.post(`/tasks/${daily._id}/score/up`)
+      let updatedUser;
-      .then(() => user.get(`/user`))
+
-      .then((updatedUser) => {
+      beforeEach(async () => {
+        await user.post(`/tasks/${daily._id}/score/up`);
+        updatedUser = await user.get(`/user`);
+      });
+
+      it('increases user\'s mp', () => {
         expect(updatedUser.stats.mp).to.be.greaterThan(user.stats.mp);
       });
-    });
 
-    it('decreases user\'s mp when direction is down', () => {
+      it('increases user\'s exp', () => {
-      return user.post(`/tasks/${daily._id}/score/down`)
-      .then(() => user.get(`/user`))
-      .then((updatedUser) => {
-        expect(updatedUser.stats.mp).to.be.lessThan(user.stats.mp);
-      });
-    });
-
-    it('increases user\'s exp when direction is up', () => {
-      return user.post(`/tasks/${daily._id}/score/up`)
-      .then(() => user.get(`/user`))
-      .then((updatedUser) => {
         expect(updatedUser.stats.exp).to.be.greaterThan(user.stats.exp);
       });
-    });
 
-    it('decreases user\'s exp when direction is down', () => {
+      it('increases user\'s gold', () => {
-      return user.post(`/tasks/${daily._id}/score/down`)
-      .then(() => user.get(`/user`))
-      .then((updatedUser) => {
-        expect(updatedUser.stats.exp).to.be.lessThan(user.stats.exp);
-      });
-    });
-
-    it('increases user\'s gold when direction is up', () => {
-      return user.post(`/tasks/${daily._id}/score/up`)
-      .then(() => user.get(`/user`))
-      .then((updatedUser) => {
         expect(updatedUser.stats.gp).to.be.greaterThan(user.stats.gp);
       });
     });
 
-    it('decreases user\'s gold when direction is down', () => {
+    context('user stats when direction is down', () => {
-      return user.post(`/tasks/${daily._id}/score/down`)
+      let updatedUser;
-      .then(() => user.get(`/user`))
+
-      .then((updatedUser) => {
+      beforeEach(async () => {
+        await user.post(`/tasks/${daily._id}/score/down`);
+        updatedUser = await user.get(`/user`);
+      });
+
+      it('decreases user\'s mp', () => {
+        expect(updatedUser.stats.mp).to.be.lessThan(user.stats.mp);
+      });
+
+      it('decreases user\'s exp', () => {
+        expect(updatedUser.stats.exp).to.be.lessThan(user.stats.exp);
+      });
+
+      it('decreases user\'s gold', () => {
         expect(updatedUser.stats.gp).to.be.lessThan(user.stats.gp);
       });
     });
@@ -225,34 +204,29 @@ describe('POST /tasks/:id/score/:direction', () => {
   context('habits', () => {
     let habit, minusHabit, plusHabit, neitherHabit; // eslint-disable-line no-unused-vars
 
-    beforeEach(() => {
+    beforeEach(async () => {
-      return user.post('/tasks', {
+      habit = await user.post('/tasks', {
         text: 'test habit',
         type: 'habit',
-      }).then((task) => {
+      });
-        habit = task;
+
-        return user.post('/tasks', {
+      minusHabit = await user.post('/tasks', {
-          text: 'test min habit',
+        text: 'test min habit',
-          type: 'habit',
+        type: 'habit',
-          up: false,
+        up: false,
-        });
+      });
-      }).then((task) => {
+
-        minusHabit = task;
+      plusHabit = await user.post('/tasks', {
-        return user.post('/tasks', {
+        text: 'test plus habit',
-          text: 'test plus habit',
+        type: 'habit',
-          type: 'habit',
+        down: false,
-          down: false,
+      });
-        });
+
-      }).then((task) => {
+      neitherHabit = await user.post('/tasks', {
-        plusHabit = task;
+        text: 'test neither habit',
-        user.post('/tasks', {
+        type: 'habit',
-          text: 'test neither habit',
+        up: false,
-          type: 'habit',
+        down: false,
-          up: false,
-          down: false,
-        });
-      }).then((task) => {
-        neitherHabit = task;
       });
     });
 
@@ -260,82 +234,63 @@ describe('POST /tasks/:id/score/:direction', () => {
 
     it('prevents minus only habit from scoring up'); // Yes?
 
-    it('increases user\'s mp when direction is up', () => {
+    it('increases user\'s mp when direction is up', async () => {
-      return user.post(`/tasks/${habit._id}/score/up`)
+      await user.post(`/tasks/${habit._id}/score/up`);
-      .then(() => user.get(`/user`))
+      let updatedUser = await user.get(`/user`);
-      .then((updatedUser) => {
+
-        expect(updatedUser.stats.mp).to.be.greaterThan(user.stats.mp);
+      expect(updatedUser.stats.mp).to.be.greaterThan(user.stats.mp);
-      });
     });
 
-    it('decreases user\'s mp when direction is down', () => {
+    it('decreases user\'s mp when direction is down', async () => {
-      return user.post(`/tasks/${habit._id}/score/down`)
+      await user.post(`/tasks/${habit._id}/score/down`);
-      .then(() => user.get(`/user`))
+      let updatedUser = await user.get(`/user`);
-      .then((updatedUser) => {
+
-        expect(updatedUser.stats.mp).to.be.lessThan(user.stats.mp);
+      expect(updatedUser.stats.mp).to.be.lessThan(user.stats.mp);
-      });
     });
 
-    it('increases user\'s exp when direction is up', () => {
+    it('increases user\'s exp when direction is up', async () => {
-      return user.post(`/tasks/${habit._id}/score/up`)
+      await user.post(`/tasks/${habit._id}/score/up`);
-      .then(() => user.get(`/user`))
+      let updatedUser = await user.get(`/user`);
-      .then((updatedUser) => {
+
-        expect(updatedUser.stats.exp).to.be.greaterThan(user.stats.exp);
+      expect(updatedUser.stats.exp).to.be.greaterThan(user.stats.exp);
-      });
     });
 
-    it('increases user\'s gold when direction is up', () => {
+    it('increases user\'s gold when direction is up', async () => {
-      return user.post(`/tasks/${habit._id}/score/up`)
+      await user.post(`/tasks/${habit._id}/score/up`);
-      .then(() => user.get(`/user`))
+      let updatedUser = await user.get(`/user`);
-      .then((updatedUser) => {
+
-        expect(updatedUser.stats.gp).to.be.greaterThan(user.stats.gp);
+      expect(updatedUser.stats.gp).to.be.greaterThan(user.stats.gp);
-      });
     });
   });
 
   context('reward', () => {
-    let reward;
+    let reward, updatedUser;
 
-    beforeEach(() => {
+    beforeEach(async () => {
-      return user.post('/tasks', {
+      reward = await user.post('/tasks', {
         text: 'test reward',
         type: 'reward',
         value: 5,
-      }).then((task) => {
-        reward = task;
       });
+
+      await user.post(`/tasks/${reward._id}/score/up`);
+      updatedUser = await user.get(`/user`);
     });
 
     it('purchases reward', () => {
-      return user.post(`/tasks/${reward._id}/score/up`)
+      expect(user.stats.gp).to.equal(updatedUser.stats.gp + 5);
-      .then(() => user.get(`/user`))
-      .then((updatedUser) => {
-        expect(user.stats.gp).to.equal(updatedUser.stats.gp + 5);
-      });
     });
 
     it('does not change user\'s mp', () => {
-      return user.post(`/tasks/${reward._id}/score/up`)
+      expect(user.stats.mp).to.equal(updatedUser.stats.mp);
-      .then(() => user.get(`/user`))
-      .then((updatedUser) => {
-        expect(user.stats.mp).to.equal(updatedUser.stats.mp);
-      });
     });
 
     it('does not change user\'s exp', () => {
-      return user.post(`/tasks/${reward._id}/score/up`)
+      expect(user.stats.exp).to.equal(updatedUser.stats.exp);
-      .then(() => user.get(`/user`))
-      .then((updatedUser) => {
-        expect(user.stats.exp).to.equal(updatedUser.stats.exp);
-      });
     });
 
     it('does not allow a down direction', () => {
-      return user.post(`/tasks/${reward._id}/score/up`)
+      expect(user.stats.mp).to.equal(updatedUser.stats.mp);
-      .then(() => user.get(`/user`))
-      .then((updatedUser) => {
-        expect(user.stats.mp).to.equal(updatedUser.stats.mp);
-      });
     });
   });
 });

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

@@ -6,28 +6,24 @@ import { v4 as generateUUID } from 'uuid';
 describe('PUT /tasks/:id', () => {
   let user;
 
-  before(() => {
+  before(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
   context('validates params', () => {
     let task;
 
-    beforeEach(() => {
+    beforeEach(async () => {
-      return user.post('/tasks', {
+      task = await user.post('/tasks', {
         text: 'test habit',
         type: 'habit',
-      }).then((createdTask) => {
-        task = createdTask;
       });
     });
 
     it(`ignores setting _id, type, userId, history, createdAt,
                         updatedAt, challenge, completed, streak,
-                        dateCompleted fields`, () => {
+                        dateCompleted fields`, async () => {
-      user.put(`/tasks/${task._id}`, {
+      let savedTask = await user.put(`/tasks/${task._id}`, {
         _id: 123,
         type: 'daily',
         userId: 123,
@@ -38,250 +34,242 @@ describe('PUT /tasks/:id', () => {
         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');
       });
+
+      expect(savedTask._id).to.equal(task._id);
+      expect(savedTask.type).to.equal(task.type);
+      expect(savedTask.userId).to.equal(task.userId);
+      expect(savedTask.history).to.eql(task.history);
+      expect(savedTask.createdAt).to.equal(task.createdAt);
+      expect(savedTask.updatedAt).to.be.greaterThan(task.updatedAt);
+      expect(savedTask.challenge).to.equal(task.challenge);
+      expect(savedTask.completed).to.equal(task.completed);
+      expect(savedTask.streak).to.equal(task.streak);
+      expect(savedTask.dateCompleted).to.equal(task.dateCompleted);
     });
 
-    it('ignores invalid fields', () => {
+    it('ignores invalid fields', async () => {
-      user.put(`/tasks/${task._id}`, {
+      let savedTask = await  user.put(`/tasks/${task._id}`, {
         notValid: true,
-      }).then((savedTask) => {
-        expect(savedTask.notValid).to.be.a('undefined');
       });
+
+      expect(savedTask.notValid).to.be.undefined;
     });
   });
 
   context('habits', () => {
     let habit;
 
-    beforeEach(() => {
+    beforeEach(async () => {
-      return user.post('/tasks', {
+      habit = await user.post('/tasks', {
         text: 'test habit',
         type: 'habit',
         notes: 1976,
-      }).then((createdHabit) => {
-        habit = createdHabit;
       });
     });
 
-    it('updates a habit', () => {
+    it('updates a habit', async () => {
-      return user.put(`/tasks/${habit._id}`, {
+      let savedHabit = await user.put(`/tasks/${habit._id}`, {
         text: 'some new text',
         up: false,
         down: false,
         notes: 'some new notes',
-      }).then((task) => {
-        expect(task.text).to.eql('some new text');
-        expect(task.notes).to.eql('some new notes');
-        expect(task.up).to.eql(false);
-        expect(task.down).to.eql(false);
       });
+
+      expect(savedHabit.text).to.eql('some new text');
+      expect(savedHabit.notes).to.eql('some new notes');
+      expect(savedHabit.up).to.eql(false);
+      expect(savedHabit.down).to.eql(false);
     });
   });
 
   context('todos', () => {
     let todo;
 
-    beforeEach(() => {
+    beforeEach(async () => {
-      return user.post('/tasks', {
+      todo = await user.post('/tasks', {
         text: 'test todo',
         type: 'todo',
         notes: 1976,
-      }).then((createdTodo) => {
-        todo = createdTodo;
       });
     });
 
-    it('updates a todo', () => {
+    it('updates a todo', async () => {
-      return user.put(`/tasks/${todo._id}`, {
+      let savedTodo = await user.put(`/tasks/${todo._id}`, {
         text: 'some new text',
         notes: 'some new notes',
-      }).then((task) => {
-        expect(task.text).to.eql('some new text');
-        expect(task.notes).to.eql('some new notes');
       });
+
+      expect(savedTodo.text).to.eql('some new text');
+      expect(savedTodo.notes).to.eql('some new notes');
     });
 
-    it('can update checklists (replace it)', () => {
+    it('can update checklists (replace it)', async () => {
-      return user.put(`/tasks/${todo._id}`, {
+      await user.put(`/tasks/${todo._id}`, {
         checklist: [
           {text: 123, completed: false},
           {text: 456, completed: true},
         ],
-      }).then(() => {
-        return user.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);
       });
+
+      let savedTodo = await user.put(`/tasks/${todo._id}`, {
+        checklist: [
+          {text: 789, completed: false},
+        ],
+      });
+
+      expect(savedTodo.checklist.length).to.equal(1);
+      expect(savedTodo.checklist[0].text).to.equal('789');
+      expect(savedTodo.checklist[0].completed).to.equal(false);
     });
 
-    it('can update tags (replace them)', () => {
+    it('can update tags (replace them)', async () => {
       let finalUUID = generateUUID();
-      return user.put(`/tasks/${todo._id}`, {
+      await user.put(`/tasks/${todo._id}`, {
         tags: [generateUUID(), generateUUID()],
-      }).then(() => {
-        return user.put(`/tasks/${todo._id}`, {
-          tags: [finalUUID],
-        });
-      }).then((savedTodo2) => {
-        expect(savedTodo2.tags.length).to.equal(1);
-        expect(savedTodo2.tags[0]).to.equal(finalUUID);
       });
+
+      let savedTodo = await user.put(`/tasks/${todo._id}`, {
+        tags: [finalUUID],
+      });
+
+      expect(savedTodo.tags.length).to.equal(1);
+      expect(savedTodo.tags[0]).to.equal(finalUUID);
     });
   });
 
   context('dailys', () => {
     let daily;
 
-    beforeEach(() => {
+    beforeEach(async () => {
-      return user.post('/tasks', {
+      daily = await user.post('/tasks', {
         text: 'test daily',
         type: 'daily',
         notes: 1976,
-      }).then((createdDaily) => {
-        daily = createdDaily;
       });
     });
 
-    it('updates a daily', () => {
+    it('updates a daily', async () => {
-      return user.put(`/tasks/${daily._id}`, {
+      let savedDaily = await user.put(`/tasks/${daily._id}`, {
         text: 'some new text',
         notes: 'some new notes',
         frequency: 'daily',
         everyX: 5,
-      }).then((task) => {
-        expect(task.text).to.eql('some new text');
-        expect(task.notes).to.eql('some new notes');
-        expect(task.frequency).to.eql('daily');
-        expect(task.everyX).to.eql(5);
       });
+
+      expect(savedDaily.text).to.eql('some new text');
+      expect(savedDaily.notes).to.eql('some new notes');
+      expect(savedDaily.frequency).to.eql('daily');
+      expect(savedDaily.everyX).to.eql(5);
     });
 
-    it('can update checklists (replace it)', () => {
+    it('can update checklists (replace it)', async () => {
-      return user.put(`/tasks/${daily._id}`, {
+      await user.put(`/tasks/${daily._id}`, {
         checklist: [
           {text: 123, completed: false},
           {text: 456, completed: true},
         ],
-      }).then(() => {
-        return user.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);
       });
+
+      let savedDaily = await user.put(`/tasks/${daily._id}`, {
+        checklist: [
+          {text: 789, completed: false},
+        ],
+      });
+
+      expect(savedDaily.checklist.length).to.equal(1);
+      expect(savedDaily.checklist[0].text).to.equal('789');
+      expect(savedDaily.checklist[0].completed).to.equal(false);
     });
 
-    it('can update tags (replace them)', () => {
+    it('can update tags (replace them)', async () => {
       let finalUUID = generateUUID();
-      return user.put(`/tasks/${daily._id}`, {
+      await user.put(`/tasks/${daily._id}`, {
         tags: [generateUUID(), generateUUID()],
-      }).then(() => {
-        return user.put(`/tasks/${daily._id}`, {
-          tags: [finalUUID],
-        });
-      }).then((savedDaily2) => {
-        expect(savedDaily2.tags.length).to.equal(1);
-        expect(savedDaily2.tags[0]).to.equal(finalUUID);
       });
+
+      let savedDaily = await user.put(`/tasks/${daily._id}`, {
+        tags: [finalUUID],
+      });
+
+      expect(savedDaily.tags.length).to.equal(1);
+      expect(savedDaily.tags[0]).to.equal(finalUUID);
     });
 
-    it('updates repeat, even if frequency is set to daily', () => {
+    it('updates repeat, even if frequency is set to daily', async () => {
-      return user.put(`/tasks/${daily._id}`, {
+      await user.put(`/tasks/${daily._id}`, {
         frequency: 'daily',
-      }).then(() => {
+      });
-        return user.put(`/tasks/${daily._id}`, {
+
-          repeat: {
+      let savedDaily = await user.put(`/tasks/${daily._id}`, {
-            m: false,
+        repeat: {
-            su: false,
-          },
-        });
-      }).then((savedDaily2) => {
-        expect(savedDaily2.repeat).to.eql({
           m: false,
-          t: true,
-          w: true,
-          th: true,
-          f: true,
-          s: true,
           su: false,
-        });
+        },
+      });
+
+      expect(savedDaily.repeat).to.eql({
+        m: false,
+        t: true,
+        w: true,
+        th: true,
+        f: true,
+        s: true,
+        su: false,
       });
     });
 
-    it('updates everyX, even if frequency is set to weekly', () => {
+    it('updates everyX, even if frequency is set to weekly', async () => {
-      return user.put(`/tasks/${daily._id}`, {
+      await user.put(`/tasks/${daily._id}`, {
         frequency: 'weekly',
-      }).then(() => {
-        return user.put(`/tasks/${daily._id}`, {
-          everyX: 5,
-        });
-      }).then((savedDaily2) => {
-        expect(savedDaily2.everyX).to.eql(5);
       });
+
+      let savedDaily = await user.put(`/tasks/${daily._id}`, {
+        everyX: 5,
+      });
+
+      expect(savedDaily.everyX).to.eql(5);
     });
 
-    it('defaults startDate to today if none date object is passed in', () => {
+    it('defaults startDate to today if none date object is passed in', async () => {
-      return user.put(`/tasks/${daily._id}`, {
+      let savedDaily = await user.put(`/tasks/${daily._id}`, {
         frequency: 'weekly',
-      }).then((savedDaily2) => {
-        expect((new Date(savedDaily2.startDate)).getDay()).to.eql((new Date()).getDay());
       });
+
+      expect((new Date(savedDaily.startDate)).getDay()).to.eql((new Date()).getDay());
     });
   });
 
   context('rewards', () => {
     let reward;
 
-    beforeEach(() => {
+    beforeEach(async () => {
-      return user.post('/tasks', {
+      reward = await user.post('/tasks', {
         text: 'test reward',
         type: 'reward',
         notes: 1976,
         value: 10,
-      }).then((createdReward) => {
-        reward = createdReward;
       });
     });
 
-    it('updates a reward', () => {
+    it('updates a reward', async () => {
-      return user.put(`/tasks/${reward._id}`, {
+      let savedReward = await user.put(`/tasks/${reward._id}`, {
         text: 'some new text',
         notes: 'some new notes',
         value: 10,
-      }).then((task) => {
-        expect(task.text).to.eql('some new text');
-        expect(task.notes).to.eql('some new notes');
-        expect(task.value).to.eql(10);
       });
+
+      expect(savedReward.text).to.eql('some new text');
+      expect(savedReward.notes).to.eql('some new notes');
+      expect(savedReward.value).to.eql(10);
     });
 
-    it('requires value to be coerced into a number', () => {
+    it('requires value to be coerced into a number', async () => {
-      return user.put(`/tasks/${reward._id}`, {
+      let savedReward = await user.put(`/tasks/${reward._id}`, {
         value: '100',
-      }).then((task) => {
-        expect(task.value).to.eql(100);
       });
+
+      expect(savedReward.value).to.eql(100);
     });
   });
 });

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

@@ -7,39 +7,31 @@ import { v4 as generateUUID } from 'uuid';
 describe('DELETE /tasks/:taskId/checklist/:itemId', () => {
   let user;
 
-  before(() => {
+  before(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
-  it('deletes a checklist item', () => {
+  it('deletes a checklist item', async () => {
-    let task;
+    let task = await user.post('/tasks', {
-
-    return user.post('/tasks', {
       type: 'daily',
       text: 'Daily with checklist',
-    }).then(createdTask => {
-      task = createdTask;
-      return user.post(`/tasks/${task._id}/checklist`, {text: 'Checklist Item 1', completed: false});
-    }).then((savedTask) => {
-      return user.del(`/tasks/${task._id}/checklist/${savedTask.checklist[0]._id}`);
-    }).then(() => {
-      return user.get(`/tasks/${task._id}`);
-    }).then((savedTask) => {
-      expect(savedTask.checklist.length).to.equal(0);
     });
+
+    let savedTask = await user.post(`/tasks/${task._id}/checklist`, {text: 'Checklist Item 1', completed: false});
+
+    await user.del(`/tasks/${task._id}/checklist/${savedTask.checklist[0]._id}`);
+    savedTask = await user.get(`/tasks/${task._id}`);
+
+    expect(savedTask.checklist.length).to.equal(0);
   });
 
-  it('does not work with habits', () => {
+  it('does not work with habits', async () => {
-    let habit;
+    let habit = await user.post('/tasks', {
-    return expect(user.post('/tasks', {
       type: 'habit',
       text: 'habit with checklist',
-    }).then(createdTask => {
+    });
-      habit = createdTask;
+
-      return user.del(`/tasks/${habit._id}/checklist/${generateUUID()}`);
+    await expect(user.del(`/tasks/${habit._id}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
-    })).to.eventually.be.rejected.and.eql({
       code: 400,
       error: 'BadRequest',
       message: t('checklistOnlyDailyTodo'),
@@ -59,21 +51,21 @@ describe('DELETE /tasks/:taskId/checklist/:itemId', () => {
     });
   });
 
-  it('fails on task not found', () => {
+  it('fails on task not found', async () => {
-    return expect(user.del(`/tasks/${generateUUID()}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
+    await expect(user.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', () => {
+  it('fails on checklist item not found', async () => {
-    return expect(user.post('/tasks', {
+    let createdTask = await user.post('/tasks', {
       type: 'daily',
       text: 'daily with checklist',
-    }).then(createdTask => {
+    });
-      return user.del(`/tasks/${createdTask._id}/checklist/${generateUUID()}`);
+
-    })).to.eventually.be.rejected.and.eql({
+    await expect(user.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

@@ -7,41 +7,38 @@ import { v4 as generateUUID } from 'uuid';
 describe('POST /tasks/:taskId/checklist/', () => {
   let user;
 
-  before(() => {
+  before(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
-  it('adds a checklist item to a task', () => {
+  it('adds a checklist item to a task', async () => {
-    let task;
+    let task = await user.post('/tasks', {
-
-    return user.post('/tasks', {
       type: 'daily',
       text: 'Daily with checklist',
-    }).then(createdTask => {
-      task = createdTask;
-
-      return user.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');
     });
+
+    let savedTask = await user.post(`/tasks/${task._id}/checklist`, {
+      text: 'Checklist Item 1',
+      ignored: false,
+      _id: 123,
+    });
+
+    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', () => {
+  it('does not add a checklist to habits', async () => {
-    let habit;
+    let habit = await user.post('/tasks', {
-
-    return expect(user.post('/tasks', {
       type: 'habit',
       text: 'habit with checklist',
-    }).then(createdTask => {
+    });
-      habit = createdTask;
+
-      return user.post(`/tasks/${habit._id}/checklist`, {text: 'Checklist Item 1'});
+    await expect(user.post(`/tasks/${habit._id}/checklist`, {
+      text: 'Checklist Item 1',
     })).to.eventually.be.rejected.and.eql({
       code: 400,
       error: 'BadRequest',
@@ -49,14 +46,14 @@ describe('POST /tasks/:taskId/checklist/', () => {
     });
   });
 
-  it('does not add a checklist to rewards', () => {
+  it('does not add a checklist to rewards', async () => {
-    let reward;
+    let reward = await user.post('/tasks', {
-    return expect(user.post('/tasks', {
       type: 'reward',
       text: 'reward with checklist',
-    }).then(createdTask => {
+    });
-      reward = createdTask;
+
-      return user.post(`/tasks/${reward._id}/checklist`, {text: 'Checklist Item 1'});
+    await expect(user.post(`/tasks/${reward._id}/checklist`, {
+      text: 'Checklist Item 1',
     })).to.eventually.be.rejected.and.eql({
       code: 400,
       error: 'BadRequest',
@@ -64,8 +61,8 @@ describe('POST /tasks/:taskId/checklist/', () => {
     });
   });
 
-  it('fails on task not found', () => {
+  it('fails on task not found', async () => {
-    return expect(user.post(`/tasks/${generateUUID()}/checklist`, {
+    await expect(user.post(`/tasks/${generateUUID()}/checklist`, {
       text: 'Checklist Item 1',
     })).to.eventually.be.rejected.and.eql({
       code: 404,

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

@@ -7,37 +7,35 @@ import { v4 as generateUUID } from 'uuid';
 describe('POST /tasks/:taskId/checklist/:itemId/score', () => {
   let user;
 
-  before(() => {
+  before(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
-  it('scores a checklist item', () => {
+  it('scores a checklist item', async () => {
-    let task;
+    let task = await user.post('/tasks', {
-
-    return user.post('/tasks', {
       type: 'daily',
       text: 'Daily with checklist',
-    }).then(createdTask => {
-      task = createdTask;
-      return user.post(`/tasks/${task._id}/checklist`, {text: 'Checklist Item 1', completed: false});
-    }).then((savedTask) => {
-      return user.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);
     });
+
+    let savedTask = await user.post(`/tasks/${task._id}/checklist`, {
+      text: 'Checklist Item 1',
+      completed: false,
+    });
+
+    savedTask = await user.post(`/tasks/${task._id}/checklist/${savedTask.checklist[0]._id}/score`);
+
+    expect(savedTask.checklist.length).to.equal(1);
+    expect(savedTask.checklist[0].completed).to.equal(true);
   });
 
-  it('fails on habits', () => {
+  it('fails on habits', async () => {
-    let habit;
+    let habit = await user.post('/tasks', {
-    return expect(user.post('/tasks', {
       type: 'habit',
       text: 'habit with checklist',
-    }).then(createdTask => {
+    });
-      habit = createdTask;
+
-      return user.post(`/tasks/${habit._id}/checklist/${generateUUID()}/score`, {text: 'Checklist Item 1'});
+    await expect(user.post(`/tasks/${habit._id}/checklist/${generateUUID()}/score`, {
+      text: 'Checklist Item 1',
     })).to.eventually.be.rejected.and.eql({
       code: 400,
       error: 'BadRequest',
@@ -58,21 +56,21 @@ describe('POST /tasks/:taskId/checklist/:itemId/score', () => {
     });
   });
 
-  it('fails on task not found', () => {
+  it('fails on task not found', async () => {
-    return expect(user.post(`/tasks/${generateUUID()}/checklist/${generateUUID()}/score`)).to.eventually.be.rejected.and.eql({
+    await expect(user.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', () => {
+  it('fails on checklist item not found', async () => {
-    return expect(user.post('/tasks', {
+    let createdTask = await user.post('/tasks', {
       type: 'daily',
       text: 'daily with checklist',
-    }).then(createdTask => {
+    });
-      return user.post(`/tasks/${createdTask._id}/checklist/${generateUUID()}/score`);
+
-    })).to.eventually.be.rejected.and.eql({
+    await expect(user.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

@@ -7,29 +7,31 @@ import { v4 as generateUUID } from 'uuid';
 describe('PUT /tasks/:taskId/checklist/:itemId', () => {
   let user;
 
-  before(() => {
+  before(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
-  it('updates a checklist item', () => {
+  it('updates a checklist item', async () => {
-    let task;
+    let task = await user.post('/tasks', {
-
-    return user.post('/tasks', {
       type: 'daily',
       text: 'Daily with checklist',
-    }).then(createdTask => {
-      task = createdTask;
-      return user.post(`/tasks/${task._id}/checklist`, {text: 'Checklist Item 1', completed: false});
-    }).then((savedTask) => {
-      return user.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');
     });
+
+    let savedTask = await user.post(`/tasks/${task._id}/checklist`, {
+      text: 'Checklist Item 1',
+      completed: false,
+    });
+
+    savedTask = await user.put(`/tasks/${task._id}/checklist/${savedTask.checklist[0]._id}`, {
+      text: 'updated',
+      completed: true,
+      _id: 123,
+    });
+
+    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', async () => {
@@ -58,21 +60,21 @@ describe('PUT /tasks/:taskId/checklist/:itemId', () => {
     });
   });
 
-  it('fails on task not found', () => {
+  it('fails on task not found', async () => {
-    return expect(user.put(`/tasks/${generateUUID()}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
+    await expect(user.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', () => {
+  it('fails on checklist item not found', async () => {
-    return expect(user.post('/tasks', {
+    let createdTask = await user.post('/tasks', {
       type: 'daily',
       text: 'daily with checklist',
-    }).then(createdTask => {
+    });
-      return user.put(`/tasks/${createdTask._id}/checklist/${generateUUID()}`);
+
-    })).to.eventually.be.rejected.and.eql({
+    await expect(user.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

@@ -7,40 +7,33 @@ import { v4 as generateUUID } from 'uuid';
 describe('DELETE /tasks/:taskId/tags/:tagId', () => {
   let user;
 
-  before(() => {
+  before(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
-  it('removes a tag from a task', () => {
+  it('removes a tag from a task', async () => {
-    let tag;
+    let task = await user.post('/tasks', {
-    let task;
-
-    return user.post('/tasks', {
       type: 'habit',
       text: 'Task with tag',
-    }).then(createdTask => {
-      task = createdTask;
-      return user.post('/tags', {name: 'Tag 1'});
-    }).then(createdTag => {
-      tag = createdTag;
-      return user.post(`/tasks/${task._id}/tags/${tag._id}`);
-    }).then(() => {
-      return user.del(`/tasks/${task._id}/tags/${tag._id}`);
-    }).then(() => user.get(`/tasks/${task._id}`))
-    .then(updatedTask => {
-      expect(updatedTask.tags.length).to.equal(0);
     });
+
+    let tag = await user.post('/tags', {name: 'Tag 1'});
+
+    await user.post(`/tasks/${task._id}/tags/${tag._id}`);
+    await user.del(`/tasks/${task._id}/tags/${tag._id}`);
+
+    let updatedTask = await user.get(`/tasks/${task._id}`);
+
+    expect(updatedTask.tags.length).to.equal(0);
   });
 
-  it('only deletes existing tags', () => {
+  it('only deletes existing tags', async () => {
-    return expect(user.post('/tasks', {
+    let createdTask = await user.post('/tasks', {
       type: 'habit',
       text: 'Task with tag',
-    }).then(createdTask => {
+    });
-      return user.del(`/tasks/${createdTask._id}/tags/${generateUUID()}`);
+
-    })).to.eventually.be.rejected.and.eql({
+    await expect(user.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

@@ -7,59 +7,46 @@ import { v4 as generateUUID } from 'uuid';
 describe('POST /tasks/:taskId/tags/:tagId', () => {
   let user;
 
-  before(() => {
+  before(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
-  it('adds a tag to a task', () => {
+  it('adds a tag to a task', async () => {
-    let tag;
+    let task = await user.post('/tasks', {
-    let task;
-
-    return user.post('/tasks', {
       type: 'habit',
       text: 'Task with tag',
-    }).then(createdTask => {
-      task = createdTask;
-      return user.post('/tags', {name: 'Tag 1'});
-    }).then(createdTag => {
-      tag = createdTag;
-      return user.post(`/tasks/${task._id}/tags/${tag._id}`);
-    }).then(savedTask => {
-      expect(savedTask.tags[0]).to.equal(tag._id);
     });
+
+    let tag = await user.post('/tags', {name: 'Tag 1'});
+    let savedTask = await user.post(`/tasks/${task._id}/tags/${tag._id}`);
+
+    expect(savedTask.tags[0]).to.equal(tag._id);
   });
 
-  it('does not add a tag to a task twice', () => {
+  it('does not add a tag to a task twice', async () => {
-    let tag;
+    let task = await user.post('/tasks', {
-    let task;
-
-    return expect(user.post('/tasks', {
       type: 'habit',
       text: 'Task with tag',
-    }).then(createdTask => {
+    });
-      task = createdTask;
+
-      return user.post('/tags', {name: 'Tag 1'});
+    let tag = await user.post('/tags', {name: 'Tag 1'});
-    }).then(createdTag => {
+
-      tag = createdTag;
+    await user.post(`/tasks/${task._id}/tags/${tag._id}`);
-      return user.post(`/tasks/${task._id}/tags/${tag._id}`);
+
-    }).then(() => {
+    await expect(user.post(`/tasks/${task._id}/tags/${tag._id}`)).to.eventually.be.rejected.and.eql({
-      return user.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', () => {
+  it('does not add a non existing tag to a task', async () => {
-    return expect(user.post('/tasks', {
+    let task = await user.post('/tasks', {
       type: 'habit',
       text: 'Task with tag',
-    }).then((task) => {
+    });
-      return user.post(`/tasks/${task._id}/tags/${generateUUID()}`);
+
-    })).to.eventually.be.rejected.and.eql({
+    await expect(user.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

@@ -5,25 +5,20 @@ import {
 describe('GET /user', () => {
   let user;
 
-  before(() => {
+  before(async () => {
-    return generateUser().then((generatedUser) => {
+    user = await generateUser();
-      user = generatedUser;
-    });
   });
 
-  it('returns the authenticated user', () => {
+  it('returns the authenticated user', async () => {
-    return user.get('/user')
+    let returnedUser = await user.get('/user');
-    .then(returnedUser => {
+    expect(returnedUser._id).to.equal(user._id);
-      expect(returnedUser._id).to.equal(user._id);
-    });
   });
 
-  it('does not return private paths (and apiToken)', () => {
+  it('does not return private paths (and apiToken)', async () => {
-    return user.get('/user')
+    let returnedUser = await user.get('/user');
-    .then(returnedUser => {
+
-      expect(returnedUser.auth.local.hashed_password).to.not.exist;
+    expect(returnedUser.auth.local.hashed_password).to.not.exist;
-      expect(returnedUser.auth.local.salt).to.not.exist;
+    expect(returnedUser.auth.local.salt).to.not.exist;
-      expect(returnedUser.apiToken).to.not.exist;
+    expect(returnedUser.apiToken).to.not.exist;
-    });
   });
 });

test/api/v3/integration/user/auth/POST-register_local.test.js

@@ -8,32 +8,36 @@ import { each } from 'lodash';
 
 describe('POST /user/auth/local/register', () => {
   context('username and email are free', () => {
-    it('registers a new user', () => {
+    let api;
-      let api = requester();
+
+    beforeEach(async () => {
+      api = requester();
+    });
+
+    it('registers a new user', async () => {
       let username = generateRandomUserName();
       let email = `${username}@example.com`;
       let password = 'password';
 
-      return api.post('/user/auth/local/register', {
+      let user = await api.post('/user/auth/local/register', {
         username,
         email,
         password,
         confirmPassword: password,
-      }).then((user) => {
-        expect(user._id).to.exist;
-        expect(user.apiToken).to.exist;
-        expect(user.auth.local.username).to.eql(username);
       });
+
+      expect(user._id).to.exist;
+      expect(user.apiToken).to.exist;
+      expect(user.auth.local.username).to.eql(username);
     });
 
-    it('requires password and confirmPassword to match', () => {
+    it('requires password and confirmPassword to match', async () => {
-      let api = requester();
       let username = generateRandomUserName();
       let email = `${username}@example.com`;
       let password = 'password';
       let confirmPassword = 'not password';
 
-      return expect(api.post('/user/auth/local/register', {
+      await expect(api.post('/user/auth/local/register', {
         username,
         email,
         password,
@@ -45,13 +49,12 @@ describe('POST /user/auth/local/register', () => {
       });
     });
 
-    it('requires a username', () => {
+    it('requires a username', async () => {
-      let api = requester();
       let email = `${generateRandomUserName()}@example.com`;
       let password = 'password';
       let confirmPassword = 'password';
 
-      return expect(api.post('/user/auth/local/register', {
+      await expect(api.post('/user/auth/local/register', {
         email,
         password,
         confirmPassword,
@@ -62,12 +65,11 @@ describe('POST /user/auth/local/register', () => {
       });
     });
 
-    it('requires an email', () => {
+    it('requires an email', async () => {
-      let api = requester();
       let username = generateRandomUserName();
       let password = 'password';
 
-      return expect(api.post('/user/auth/local/register', {
+      await expect(api.post('/user/auth/local/register', {
         username,
         password,
         confirmPassword: password,
@@ -78,13 +80,12 @@ describe('POST /user/auth/local/register', () => {
       });
     });
 
-    it('requires a valid email', () => {
+    it('requires a valid email', async () => {
-      let api = requester();
       let username = generateRandomUserName();
       let email = 'notanemail@sdf';
       let password = 'password';
 
-      return expect(api.post('/user/auth/local/register', {
+      await expect(api.post('/user/auth/local/register', {
         username,
         email,
         password,
@@ -96,13 +97,12 @@ describe('POST /user/auth/local/register', () => {
       });
     });
 
-    it('requires a password', () => {
+    it('requires a password', async () => {
-      let api = requester();
       let username = generateRandomUserName();
       let email = `${username}@example.com`;
       let confirmPassword = 'password';
 
-      return expect(api.post('/user/auth/local/register', {
+      await expect(api.post('/user/auth/local/register', {
         username,
         email,
         confirmPassword,
@@ -115,11 +115,13 @@ describe('POST /user/auth/local/register', () => {
   });
 
   context('login is already taken', () => {
-    let username, email;
+    let username, email, api;
 
-    beforeEach(() => {
+    beforeEach(async () => {
+      api = requester();
       username = generateRandomUserName();
       email = `${username}@example.com`;
+
       return generateUser({
         'auth.local.username': username,
         'auth.local.lowerCaseUsername': username,
@@ -127,12 +129,11 @@ describe('POST /user/auth/local/register', () => {
       });
     });
 
-    it('rejects if username is already taken', () => {
+    it('rejects if username is already taken', async () => {
-      let api = requester();
       let uniqueEmail = `${generateRandomUserName()}@exampe.com`;
       let password = 'password';
 
-      return expect(api.post('/user/auth/local/register', {
+      await expect(api.post('/user/auth/local/register', {
         username,
         email: uniqueEmail,
         password,
@@ -144,12 +145,11 @@ describe('POST /user/auth/local/register', () => {
       });
     });
 
-    it('rejects if email is already taken', () => {
+    it('rejects if email is already taken', async () => {
-      let api = requester();
       let uniqueUsername = generateRandomUserName();
       let password = 'password';
 
-      return expect(api.post('/user/auth/local/register', {
+      await expect(api.post('/user/auth/local/register', {
         username: uniqueUsername,
         email,
         password,
@@ -172,44 +172,44 @@ describe('POST /user/auth/local/register', () => {
       password = 'password';
     });
 
-    it('sets all site tour values to -2 (already seen)', () => {
+    it('sets all site tour values to -2 (already seen)', async () => {
-      return api.post('/user/auth/local/register', {
+      let user = await api.post('/user/auth/local/register', {
         username,
         email,
         password,
         confirmPassword: password,
-      }).then((user) => {
+      });
-        expect(user.flags.tour).to.not.be.empty;
 
-        each(user.flags.tour, (value) => {
+      expect(user.flags.tour).to.not.be.empty;
-          expect(value).to.eql(-2);
+
-        });
+      each(user.flags.tour, (value) => {
+        expect(value).to.eql(-2);
       });
     });
 
-    it('populates user with default todos, not no other task types', () => {
+    it('populates user with default todos, not no other task types', async () => {
-      return api.post('/user/auth/local/register', {
+      let user = await api.post('/user/auth/local/register', {
         username,
         email,
         password,
         confirmPassword: password,
-      }).then((user) => {
-        expect(user.tasksOrder.todos).to.not.be.empty;
-        expect(user.tasksOrder.dailys).to.be.empty;
-        expect(user.tasksOrder.habits).to.be.empty;
-        expect(user.tasksOrder.rewards).to.be.empty;
       });
+
+      expect(user.tasksOrder.todos).to.not.be.empty;
+      expect(user.tasksOrder.dailys).to.be.empty;
+      expect(user.tasksOrder.habits).to.be.empty;
+      expect(user.tasksOrder.rewards).to.be.empty;
     });
 
-    it('populates user with default tags', () => {
+    it('populates user with default tags', async () => {
-      return api.post('/user/auth/local/register', {
+      let user = await api.post('/user/auth/local/register', {
         username,
         email,
         password,
         confirmPassword: password,
-      }).then((user) => {
-        expect(user.tags).to.not.be.empty;
       });
+
+      expect(user.tags).to.not.be.empty;
     });
   });
 
@@ -223,44 +223,44 @@ describe('POST /user/auth/local/register', () => {
       password = 'password';
     });
 
-    it('sets all common tutorial flags to true', () => {
+    it('sets all common tutorial flags to true', async () => {
-      return api.post('/user/auth/local/register', {
+      let user = await api.post('/user/auth/local/register', {
         username,
         email,
         password,
         confirmPassword: password,
-      }).then((user) => {
+      });
-        expect(user.flags.tour).to.not.be.empty;
 
-        each(user.flags.tutorial.common, (value) => {
+      expect(user.flags.tour).to.not.be.empty;
-          expect(value).to.eql(true);
+
-        });
+      each(user.flags.tutorial.common, (value) => {
+        expect(value).to.eql(true);
       });
     });
 
-    it('populates user with default todos, habits, and rewards', () => {
+    it('populates user with default todos, habits, and rewards', async () => {
-      return api.post('/user/auth/local/register', {
+      let user = await api.post('/user/auth/local/register', {
         username,
         email,
         password,
         confirmPassword: password,
-      }).then((user) => {
-        expect(user.tasksOrder.todos).to.not.be.empty;
-        expect(user.tasksOrder.dailys).to.be.empty;
-        expect(user.tasksOrder.habits).to.not.be.empty;
-        expect(user.tasksOrder.rewards).to.not.be.empty;
       });
+
+      expect(user.tasksOrder.todos).to.not.be.empty;
+      expect(user.tasksOrder.dailys).to.be.empty;
+      expect(user.tasksOrder.habits).to.not.be.empty;
+      expect(user.tasksOrder.rewards).to.not.be.empty;
     });
 
-    it('populates user with default tags', () => {
+    it('populates user with default tags', async () => {
-      return api.post('/user/auth/local/register', {
+      let user = await api.post('/user/auth/local/register', {
         username,
         email,
         password,
         confirmPassword: password,
-      }).then((user) => {
-        expect(user.tags).to.not.be.empty;
       });
+
+      expect(user.tags).to.not.be.empty;
     });
   });
 });