krikkert/habitica
1
0
Fork 0
mirror of https://github.com/HabitRPG/habitica.git synced 2025-12-19 07:37:25 +01:00
Code Issues Packages Projects Releases Wiki Activity

tests(api): bring in await format tests

Browse Source
This commit is contained in:
Blade Barringer
2016-01-12 18:10:10 -06:00
parent f80f41f764
commit c9d378ab35
20 changed files with 645 additions and 798 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
test/api/v3/integration/notFound.test.js
View File

@@ -1,10 +1,10 @@
import { requester } from '../../../helpers/api-integration.helper'; import { requester } from '../../../helpers/api-integration.helper';
describe('notFound Middleware', () => { 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'); 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, code: 404,
error: 'NotFound', error: 'NotFound',
message: 'Not found.', message: 'Not found.',

36
test/api/v3/integration/tags/DELETE-tags_id.test.js
View File

@@ -5,29 +5,23 @@ import {
describe('DELETE /tags/:tagId', () => { describe('DELETE /tags/:tagId', () => {
let user; 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}`); expect(tags.length).to.equal(numberOfTags - 1);
}) expect(tagNames).to.not.include(tagName);
.then(() => user.get(`/tags`))
.then((tags) => {
expect(tags.length).to.equal(length - 1);
expect(tags[tags.length - 1].name).to.not.equal('Tag 1');
});
}); });
}); });

22
test/api/v3/integration/tags/GET-tags.test.js
View File

@@ -5,20 +5,18 @@ import {
describe('GET /tags', () => { describe('GET /tags', () => {
let user; 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.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 - 2].name).to.equal(tag1.name);
expect(tags[tags.length - 1].name).to.equal('Tag 2'); expect(tags[tags.length - 1].name).to.equal(tag2.name);
});
}); });
}); });

18
test/api/v3/integration/tags/GET-tags_id.test.js
View File

@@ -5,22 +5,14 @@ import {
describe('GET /tags/:tagId', () => { describe('GET /tags/:tagId', () => {
let user; 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'})
.then((tag) => {
createdTag = tag;
return user.get(`/tags/${createdTag._id}`);
})
.then((tag) => {
expect(tag).to.deep.equal(createdTag); expect(tag).to.deep.equal(createdTag);
}); });
}); });
});

27
test/api/v3/integration/tags/POST-tags.test.js
View File

@@ -5,28 +5,21 @@ import {
describe('POST /tags', () => { describe('POST /tags', () => {
let user; 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, ignored: false,
}).then((tag) => { });
createdTag = tag;
expect(tag.name).to.equal('Tag 1'); let tag = await user.get(`/tags/${createdTag._id}`);
expect(tag.ignored).to.be.a('undefined');
return user.get(`/tags/${createdTag._id}`); expect(tag.name).to.equal(tagName);
}) expect(tag.ignored).to.not.exist;
.then((tag) => {
expect(tag).to.deep.equal(createdTag); expect(tag).to.deep.equal(createdTag);
}); });
}); });
});

33
test/api/v3/integration/tags/PUT-tags_id.test.js
View File

@@ -5,29 +5,24 @@ import {
describe('PUT /tags/:tagId', () => { describe('PUT /tags/:tagId', () => {
let user; 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}`); createdTag = await user.get(`/tags/${updatedTag._id}`);
})
.then((tag) => { expect(updatedTag.name).to.equal(updatedTagName);
expect(tag.name).to.equal('Tag updated'); expect(updatedTag.ignored).to.not.exist;
expect(tag.ignored).to.be.a('undefined');
}); expect(createdTag.name).to.equal(updatedTagName);
expect(createdTag.ignored).to.not.exist;
}); });
}); });

38
test/api/v3/integration/tasks/DELETE-tasks_id.test.js
View File

@@ -6,61 +6,53 @@ import {
describe('DELETE /tasks/:id', () => { describe('DELETE /tasks/:id', () => {
let user; let user;
before(() => { before(async () => {
return generateUser().then((generatedUser) => { user = await generateUser();
user = generatedUser;
});
}); });
context('task can be deleted', () => { context('task can be deleted', () => {
let task; let task;
beforeEach(() => { beforeEach(async () => {
return user.post('/tasks', { task = await user.post('/tasks', {
text: 'test habit', text: 'test habit',
type: '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', () => { 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, code: 404,
error: 'NotFound', error: 'NotFound',
message: t('taskNotFound'), 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',
}); });
})
.then((task2) => { await expect(user.del(`/tasks/${anotherUsersTask._id}`)).to.eventually.be.rejected.and.eql({
return expect(user.del(`/tasks/${task2._id}`)).to.eventually.be.rejected.and.eql({
code: 404, code: 404,
error: 'NotFound', error: 'NotFound',
message: t('taskNotFound'), message: t('taskNotFound'),
}); });
}); });
});
it('cannot delete active challenge tasks'); // TODO after challenges are implemented it('cannot delete active challenge tasks'); // TODO after challenges are implemented
it('remove a task from user.tasksOrder'); // TODO it('remove a task from user.tasksOrder'); // TODO

38
test/api/v3/integration/tasks/GET-tasks.test.js
View File

@@ -6,37 +6,27 @@ import Q from 'q';
describe('GET /tasks', () => { describe('GET /tasks', () => {
let user; 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'}), 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;
return user.get('/tasks?type=habit');
})
.then((tasks) => {
expect(tasks.length).to.equal(1); expect(tasks.length).to.equal(1);
expect(tasks[0]._id).to.equal(habitId); expect(tasks[0]._id).to.equal(task._id);
});
}); });
// TODO complete after task scoring is done // TODO complete after task scoring is done

40
test/api/v3/integration/tasks/GET-tasks_id.test.js
View File

@@ -7,59 +7,48 @@ import { v4 as generateUUID } from 'uuid';
describe('GET /tasks/:id', () => { describe('GET /tasks/:id', () => {
let user; 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; let task;
beforeEach(() => { beforeEach(async () => {
return user.post('/tasks', { task = await user.post('/tasks', {
text: 'test habit', text: 'test habit',
type: '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 // TODO after challenges are implemented
it('can get active challenge task that user does not own'); // Yes? it('can get active challenge task that user does not own'); // Yes?
}); });
context('task cannot be accessed', () => { context('task cannot be accessed', () => {
it('cannot get a non-existant task', () => { it('cannot get a non-existant task', async () => {
let dummyId = generateUUID(); 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, code: 404,
error: 'NotFound', error: 'NotFound',
message: t('taskNotFound'), 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', {
return generateUser()
.then((user2) => {
anotherUser = user2;
return user.post('/tasks', {
text: 'test habit', text: 'test habit',
type: 'habit', type: 'habit',
}); });
}).then((task) => {
return expect(anotherUser.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({ await expect(anotherUser.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
code: 404, code: 404,
error: 'NotFound', error: 'NotFound',
message: t('taskNotFound'), message: t('taskNotFound'),
@@ -67,4 +56,3 @@ describe('GET /tasks/:id', () => {
}); });
}); });
}); });
});

12
test/api/v3/integration/tasks/POST-tasks.test.js
View File

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

321
test/api/v3/integration/tasks/POST-tasks_id_score_direction.test.js
View File

@@ -7,25 +7,23 @@ import { v4 as generateUUID } from 'uuid';
describe('POST /tasks/:id/score/:direction', () => { describe('POST /tasks/:id/score/:direction', () => {
let user; let user;
beforeEach(() => { beforeEach(async () => {
return generateUser({ user = await generateUser({
'stats.gp': 100, 'stats.gp': 100,
}).then((generatedUser) => {
user = generatedUser;
}); });
}); });
context('all', () => { 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, code: 400,
error: 'BadRequest', error: 'BadRequest',
message: t('invalidReqParams'), 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, code: 400,
error: 'BadRequest', error: 'BadRequest',
message: t('invalidReqParams'), message: t('invalidReqParams'),
@@ -36,110 +34,97 @@ describe('POST /tasks/:id/score/:direction', () => {
context('todos', () => { context('todos', () => {
let todo; let todo;
beforeEach(() => { beforeEach(async () => {
return user.post('/tasks', { todo = await user.post('/tasks', {
text: 'test todo', text: 'test todo',
type: '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');
.then((usr) => { expect(updatedUser.tasksOrder.todos.indexOf(todo._id)).to.equal(-1);
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 up todo even if it is already completed'); // Yes?
it('scores down todo even if it is already uncompleted'); // 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); 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); 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); 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); expect(updatedUser.stats.gp).to.be.lessThan(user.stats.gp);
}); });
}); });
@@ -148,75 +133,69 @@ describe('POST /tasks/:id/score/:direction', () => {
context('dailys', () => { context('dailys', () => {
let daily; let daily;
beforeEach(() => { beforeEach(async () => {
return user.post('/tasks', { daily = await user.post('/tasks', {
text: 'test daily', text: 'test daily',
type: '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 up daily even if it is already completed'); // Yes?
it('scores down daily even if it is already uncompleted'); // 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); 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); 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); 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); expect(updatedUser.stats.gp).to.be.lessThan(user.stats.gp);
}); });
}); });
@@ -225,117 +204,93 @@ describe('POST /tasks/:id/score/:direction', () => {
context('habits', () => { context('habits', () => {
let habit, minusHabit, plusHabit, neitherHabit; // eslint-disable-line no-unused-vars 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', text: 'test habit',
type: '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) => {
plusHabit = task; neitherHabit = await user.post('/tasks', {
user.post('/tasks', {
text: 'test neither habit', text: 'test neither habit',
type: 'habit', type: 'habit',
up: false, up: false,
down: false, down: false,
}); });
}).then((task) => {
neitherHabit = task;
});
}); });
it('prevents plus only habit from scoring down'); // Yes? it('prevents plus only habit from scoring down'); // Yes?
it('prevents minus only habit from scoring up'); // Yes? 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', () => { context('reward', () => {
let reward; let reward, updatedUser;
beforeEach(() => { beforeEach(async () => {
return user.post('/tasks', { reward = await user.post('/tasks', {
text: 'test reward', text: 'test reward',
type: 'reward', type: 'reward',
value: 5, value: 5,
}).then((task) => {
reward = task;
}); });
await user.post(`/tasks/${reward._id}/score/up`);
updatedUser = await user.get(`/user`);
}); });
it('purchases reward', () => { it('purchases reward', () => {
return user.post(`/tasks/${reward._id}/score/up`)
.then(() => user.get(`/user`))
.then((updatedUser) => {
expect(user.stats.gp).to.equal(updatedUser.stats.gp + 5); expect(user.stats.gp).to.equal(updatedUser.stats.gp + 5);
}); });
});
it('does not change user\'s mp', () => { it('does not change user\'s mp', () => {
return user.post(`/tasks/${reward._id}/score/up`)
.then(() => user.get(`/user`))
.then((updatedUser) => {
expect(user.stats.mp).to.equal(updatedUser.stats.mp); expect(user.stats.mp).to.equal(updatedUser.stats.mp);
}); });
});
it('does not change user\'s exp', () => { it('does not change user\'s exp', () => {
return user.post(`/tasks/${reward._id}/score/up`)
.then(() => user.get(`/user`))
.then((updatedUser) => {
expect(user.stats.exp).to.equal(updatedUser.stats.exp); expect(user.stats.exp).to.equal(updatedUser.stats.exp);
}); });
});
it('does not allow a down direction', () => { it('does not allow a down direction', () => {
return user.post(`/tasks/${reward._id}/score/up`)
.then(() => user.get(`/user`))
.then((updatedUser) => {
expect(user.stats.mp).to.equal(updatedUser.stats.mp); expect(user.stats.mp).to.equal(updatedUser.stats.mp);
}); });
}); });
}); });
});

244
test/api/v3/integration/tasks/PUT-tasks_id.test.js
View File

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

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

@@ -7,39 +7,31 @@ import { v4 as generateUUID } from 'uuid';
describe('DELETE /tasks/:taskId/checklist/:itemId', () => { describe('DELETE /tasks/:taskId/checklist/:itemId', () => {
let user; 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', type: 'daily',
text: 'Daily with checklist', 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);
});
}); });
it('does not work with habits', () => { let savedTask = await user.post(`/tasks/${task._id}/checklist`, {text: 'Checklist Item 1', completed: false});
let habit;
return expect(user.post('/tasks', { 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', async () => {
let habit = await user.post('/tasks', {
type: 'habit', type: 'habit',
text: 'habit with checklist', 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, code: 400,
error: 'BadRequest', error: 'BadRequest',
message: t('checklistOnlyDailyTodo'), 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, code: 404,
error: 'NotFound', error: 'NotFound',
message: t('taskNotFound'), 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', type: 'daily',
text: 'daily with checklist', 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, code: 404,
error: 'NotFound', error: 'NotFound',
message: t('checklistItemNotFound'), message: t('checklistItemNotFound'),

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

@@ -7,23 +7,22 @@ import { v4 as generateUUID } from 'uuid';
describe('POST /tasks/:taskId/checklist/', () => { describe('POST /tasks/:taskId/checklist/', () => {
let user; 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', type: 'daily',
text: 'Daily with checklist', text: 'Daily with checklist',
}).then(createdTask => { });
task = createdTask;
let savedTask = await user.post(`/tasks/${task._id}/checklist`, {
text: 'Checklist Item 1',
ignored: false,
_id: 123,
});
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.length).to.equal(1);
expect(savedTask.checklist[0].text).to.equal('Checklist Item 1'); expect(savedTask.checklist[0].text).to.equal('Checklist Item 1');
expect(savedTask.checklist[0].completed).to.equal(false); expect(savedTask.checklist[0].completed).to.equal(false);
@@ -31,17 +30,15 @@ describe('POST /tasks/:taskId/checklist/', () => {
expect(savedTask.checklist[0]._id).to.not.equal('123'); expect(savedTask.checklist[0]._id).to.not.equal('123');
expect(savedTask.checklist[0].ignored).to.be.an('undefined'); 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', type: 'habit',
text: 'habit with checklist', 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({ })).to.eventually.be.rejected.and.eql({
code: 400, code: 400,
error: 'BadRequest', 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', type: 'reward',
text: 'reward with checklist', 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({ })).to.eventually.be.rejected.and.eql({
code: 400, code: 400,
error: 'BadRequest', 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', text: 'Checklist Item 1',
})).to.eventually.be.rejected.and.eql({ })).to.eventually.be.rejected.and.eql({
code: 404, code: 404,

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

@@ -7,37 +7,35 @@ import { v4 as generateUUID } from 'uuid';
describe('POST /tasks/:taskId/checklist/:itemId/score', () => { describe('POST /tasks/:taskId/checklist/:itemId/score', () => {
let user; 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', type: 'daily',
text: 'Daily with checklist', text: 'Daily with checklist',
}).then(createdTask => { });
task = createdTask;
return user.post(`/tasks/${task._id}/checklist`, {text: 'Checklist Item 1', completed: false}); let savedTask = await user.post(`/tasks/${task._id}/checklist`, {
}).then((savedTask) => { text: 'Checklist Item 1',
return user.post(`/tasks/${task._id}/checklist/${savedTask.checklist[0]._id}/score`); completed: false,
}).then((savedTask) => { });
savedTask = await user.post(`/tasks/${task._id}/checklist/${savedTask.checklist[0]._id}/score`);
expect(savedTask.checklist.length).to.equal(1); expect(savedTask.checklist.length).to.equal(1);
expect(savedTask.checklist[0].completed).to.equal(true); 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', type: 'habit',
text: 'habit with checklist', 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({ })).to.eventually.be.rejected.and.eql({
code: 400, code: 400,
error: 'BadRequest', 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, code: 404,
error: 'NotFound', error: 'NotFound',
message: t('taskNotFound'), 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', type: 'daily',
text: 'daily with checklist', 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, code: 404,
error: 'NotFound', error: 'NotFound',
message: t('checklistItemNotFound'), message: t('checklistItemNotFound'),

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

@@ -7,30 +7,32 @@ import { v4 as generateUUID } from 'uuid';
describe('PUT /tasks/:taskId/checklist/:itemId', () => { describe('PUT /tasks/:taskId/checklist/:itemId', () => {
let user; 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', type: 'daily',
text: 'Daily with checklist', text: 'Daily with checklist',
}).then(createdTask => { });
task = createdTask;
return user.post(`/tasks/${task._id}/checklist`, {text: 'Checklist Item 1', completed: false}); let savedTask = await user.post(`/tasks/${task._id}/checklist`, {
}).then((savedTask) => { text: 'Checklist Item 1',
return user.put(`/tasks/${task._id}/checklist/${savedTask.checklist[0]._id}`, {text: 'updated', completed: true, _id: 123}); completed: false,
}).then((savedTask) => { });
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.length).to.equal(1);
expect(savedTask.checklist[0].text).to.equal('updated'); expect(savedTask.checklist[0].text).to.equal('updated');
expect(savedTask.checklist[0].completed).to.equal(true); expect(savedTask.checklist[0].completed).to.equal(true);
expect(savedTask.checklist[0]._id).to.not.equal('123'); expect(savedTask.checklist[0]._id).to.not.equal('123');
}); });
});
it('fails on habits', async () => { it('fails on habits', async () => {
let habit = await user.post('/tasks', { let habit = await user.post('/tasks', {
@@ -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, code: 404,
error: 'NotFound', error: 'NotFound',
message: t('taskNotFound'), 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', type: 'daily',
text: 'daily with checklist', 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, code: 404,
error: 'NotFound', error: 'NotFound',
message: t('checklistItemNotFound'), message: t('checklistItemNotFound'),

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

@@ -7,40 +7,33 @@ import { v4 as generateUUID } from 'uuid';
describe('DELETE /tasks/:taskId/tags/:tagId', () => { describe('DELETE /tasks/:taskId/tags/:tagId', () => {
let user; 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', type: 'habit',
text: 'Task with tag', 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}`); await user.del(`/tasks/${task._id}/tags/${tag._id}`);
}).then(() => {
return user.del(`/tasks/${task._id}/tags/${tag._id}`); let updatedTask = await user.get(`/tasks/${task._id}`);
}).then(() => user.get(`/tasks/${task._id}`))
.then(updatedTask => {
expect(updatedTask.tags.length).to.equal(0); 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', type: 'habit',
text: 'Task with tag', 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, code: 404,
error: 'NotFound', error: 'NotFound',
message: t('tagNotFound'), message: t('tagNotFound'),

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

@@ -7,59 +7,46 @@ import { v4 as generateUUID } from 'uuid';
describe('POST /tasks/:taskId/tags/:tagId', () => { describe('POST /tasks/:taskId/tags/:tagId', () => {
let user; 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', type: 'habit',
text: 'Task with tag', 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 => { let savedTask = await user.post(`/tasks/${task._id}/tags/${tag._id}`);
tag = createdTag;
return user.post(`/tasks/${task._id}/tags/${tag._id}`);
}).then(savedTask => {
expect(savedTask.tags[0]).to.equal(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', type: 'habit',
text: 'Task with tag', 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, code: 400,
error: 'BadRequest', error: 'BadRequest',
message: t('alreadyTagged'), 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', type: 'habit',
text: 'Task with tag', 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, code: 400,
error: 'BadRequest', error: 'BadRequest',
message: t('invalidReqParams'), message: t('invalidReqParams'),

19
test/api/v3/integration/user/GET-user.test.js
View File

@@ -5,25 +5,20 @@ import {
describe('GET /user', () => { describe('GET /user', () => {
let 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;
}); });
}); });
});

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

@@ -8,32 +8,36 @@ import { each } from 'lodash';
describe('POST /user/auth/local/register', () => { describe('POST /user/auth/local/register', () => {
context('username and email are free', () => { 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 username = generateRandomUserName();
let email = `${username}@example.com`; let email = `${username}@example.com`;
let password = 'password'; let password = 'password';
return api.post('/user/auth/local/register', { let user = await api.post('/user/auth/local/register', {
username, username,
email, email,
password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { });
expect(user._id).to.exist; expect(user._id).to.exist;
expect(user.apiToken).to.exist; expect(user.apiToken).to.exist;
expect(user.auth.local.username).to.eql(username); 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 username = generateRandomUserName();
let email = `${username}@example.com`; let email = `${username}@example.com`;
let password = 'password'; let password = 'password';
let confirmPassword = 'not password'; let confirmPassword = 'not password';
return expect(api.post('/user/auth/local/register', { await expect(api.post('/user/auth/local/register', {
username, username,
email, email,
password, 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 email = `${generateRandomUserName()}@example.com`;
let password = 'password'; let password = 'password';
let confirmPassword = 'password'; let confirmPassword = 'password';
return expect(api.post('/user/auth/local/register', { await expect(api.post('/user/auth/local/register', {
email, email,
password, password,
confirmPassword, 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 username = generateRandomUserName();
let password = 'password'; let password = 'password';
return expect(api.post('/user/auth/local/register', { await expect(api.post('/user/auth/local/register', {
username, username,
password, password,
confirmPassword: 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 username = generateRandomUserName();
let email = 'notanemail@sdf'; let email = 'notanemail@sdf';
let password = 'password'; let password = 'password';
return expect(api.post('/user/auth/local/register', { await expect(api.post('/user/auth/local/register', {
username, username,
email, email,
password, 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 username = generateRandomUserName();
let email = `${username}@example.com`; let email = `${username}@example.com`;
let confirmPassword = 'password'; let confirmPassword = 'password';
return expect(api.post('/user/auth/local/register', { await expect(api.post('/user/auth/local/register', {
username, username,
email, email,
confirmPassword, confirmPassword,
@@ -115,11 +115,13 @@ describe('POST /user/auth/local/register', () => {
}); });
context('login is already taken', () => { context('login is already taken', () => {
let username, email; let username, email, api;
beforeEach(() => { beforeEach(async () => {
api = requester();
username = generateRandomUserName(); username = generateRandomUserName();
email = `${username}@example.com`; email = `${username}@example.com`;
return generateUser({ return generateUser({
'auth.local.username': username, 'auth.local.username': username,
'auth.local.lowerCaseUsername': 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 uniqueEmail = `${generateRandomUserName()}@exampe.com`;
let password = 'password'; let password = 'password';
return expect(api.post('/user/auth/local/register', { await expect(api.post('/user/auth/local/register', {
username, username,
email: uniqueEmail, email: uniqueEmail,
password, 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 uniqueUsername = generateRandomUserName();
let password = 'password'; let password = 'password';
return expect(api.post('/user/auth/local/register', { await expect(api.post('/user/auth/local/register', {
username: uniqueUsername, username: uniqueUsername,
email, email,
password, password,
@@ -172,44 +172,44 @@ describe('POST /user/auth/local/register', () => {
password = 'password'; 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, username,
email, email,
password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { });
expect(user.flags.tour).to.not.be.empty; expect(user.flags.tour).to.not.be.empty;
each(user.flags.tour, (value) => { each(user.flags.tour, (value) => {
expect(value).to.eql(-2); 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, username,
email, email,
password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { });
expect(user.tasksOrder.todos).to.not.be.empty; expect(user.tasksOrder.todos).to.not.be.empty;
expect(user.tasksOrder.dailys).to.be.empty; expect(user.tasksOrder.dailys).to.be.empty;
expect(user.tasksOrder.habits).to.be.empty; expect(user.tasksOrder.habits).to.be.empty;
expect(user.tasksOrder.rewards).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, username,
email, email,
password, password,
confirmPassword: 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'; 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, username,
email, email,
password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { });
expect(user.flags.tour).to.not.be.empty; expect(user.flags.tour).to.not.be.empty;
each(user.flags.tutorial.common, (value) => { each(user.flags.tutorial.common, (value) => {
expect(value).to.eql(true); 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, username,
email, email,
password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { });
expect(user.tasksOrder.todos).to.not.be.empty; expect(user.tasksOrder.todos).to.not.be.empty;
expect(user.tasksOrder.dailys).to.be.empty; expect(user.tasksOrder.dailys).to.be.empty;
expect(user.tasksOrder.habits).to.not.be.empty; expect(user.tasksOrder.habits).to.not.be.empty;
expect(user.tasksOrder.rewards).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, username,
email, email,
password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { });
expect(user.tags).to.not.be.empty; expect(user.tags).to.not.be.empty;
}); });
}); });
}); });
});