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

Refactor Tasks tests to use await syntax

Browse Source
This commit is contained in:
Georgi Gardev
2016-01-12 19:11:59 +02:00
parent 2e3bee08d8
commit ac6a0276ab
12 changed files with 507 additions and 630 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -6,61 +6,53 @@ import {
describe('DELETE /tasks/:id', () => {
let user;
before(() => {
return generateUser().then((generatedUser) => {
user = generatedUser;
});
before(async () => {
user = await generateUser();
});
context('task can be deleted', () => {
let task;
beforeEach(() => {
return user.post('/tasks', {
beforeEach(async () => {
task = await user.post('/tasks', {
text: 'test habit',
type: 'habit',
}).then((createdTask) => {
task = createdTask;
});
});
it('deletes a user\'s task', () => {
return user.del(`/tasks/${task._id}`)
.then(() => {
return expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
it('deletes a user\'s task', async () => {
await user.del(`/tasks/${task._id}`);
await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
});
});
context('task cannot be deleted', () => {
it('cannot delete a non-existant task', () => {
return expect(user.del('/tasks/550e8400-e29b-41d4-a716-446655440000')).to.eventually.be.rejected.and.eql({
it('cannot delete a non-existant task', async () => {
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', () => {
return generateUser()
.then((anotherUser) => {
return anotherUser.post('/tasks', {
it('cannot delete a task owned by someone else', async () => {
let anotherUser = await generateUser();
let task2 = await anotherUser.post('/tasks', {
text: 'test habit',
type: 'habit',
});
})
.then((task2) => {
return expect(user.del(`/tasks/${task2._id}`)).to.eventually.be.rejected.and.eql({
await expect(user.del(`/tasks/${task2._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
});
it('cannot delete active challenge tasks'); // TODO after challenges are implemented
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', () => {
let user;
before(() => {
return generateUser().then((generatedUser) => {
user = generatedUser;
});
beforeEach(async () => {
user = await generateUser();
});
it('returns all user\'s tasks', () => {
let length;
return Q.all([
it('returns all user\'s tasks', async () => {
let createdTasks = await Q.all([
user.post('/tasks', {text: 'test habit', type: 'habit'}),
])
.then((createdTasks) => {
length = createdTasks.length;
return user.get('/tasks');
})
.then((tasks) => {
]);
let length = createdTasks.length;
let tasks = await user.get('/tasks');
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', () => {
let habitId;
user.post('/tasks', {text: 'test habit', type: 'habit'})
.then((task) => {
habitId = task._id;
return user.get('/tasks?type=habit');
})
.then((tasks) => {
it('returns only a type of user\'s tasks if req.query.type is specified', async () => {
let task = await user.post('/tasks', {text: 'test habit', type: 'habit'});
let tasks = await user.get('/tasks?type=habit');
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

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', () => {
let user;
before(() => {
return generateUser().then((generatedUser) => {
user = generatedUser;
});
before(async () => {
user = await generateUser();
});
context('task can be accessed', () => {
context('task can be accessed', async () => {
let task;
beforeEach(() => {
return user.post('/tasks', {
beforeEach(async () => {
task = await user.post('/tasks', {
text: 'test habit',
type: 'habit',
}).then((createdTask) => {
task = createdTask;
});
});
it('gets specified task', () => {
return user.get(`/tasks/${task._id}`)
.then((getTask) => {
it('gets specified task', async () => {
let getTask = await user.get(`/tasks/${task._id}`);
expect(getTask).to.eql(task);
});
});
// TODO after challenges are implemented
it('can get active challenge task that user does not own'); // Yes?
});
context('task cannot 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', () => {
let anotherUser;
return generateUser()
.then((user2) => {
anotherUser = user2;
return user.post('/tasks', {
it('cannot get a task owned by someone else', async () => {
let anotherUser = await generateUser();
let task = await user.post('/tasks', {
text: 'test 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,
error: 'NotFound',
message: t('taskNotFound'),
@@ -67,4 +56,3 @@ describe('GET /tasks/:id', () => {
});
});
});
});

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

@@ -7,14 +7,12 @@ describe('POST /tasks', () => {
let user;
before(async () => {
return generateUser().then((generatedUser) => {
user = generatedUser;
});
user = await generateUser();
});
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 one object inside an array is invalid', async () => {
return expect(user.post('/tasks', [
await expect(user.post('/tasks', [
{type: 'habitF'},
{type: 'habit'},
])).to.eventually.be.rejected.and.eql({
@@ -45,7 +43,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,
@@ -56,49 +54,46 @@ describe('POST /tasks', () => {
it('does not update user.tasksOrder.{taskType} when the task is not saved because invalid', async () => {
let originalHabitsOrder = (await user.get('/user')).tasksOrder.habits;
return expect(user.post('/tasks', {
await expect(user.post('/tasks', {
type: 'habit',
})).to.eventually.be.rejected.and.eql({ // this block is necessary
code: 400,
error: 'BadRequest',
message: 'habit validation failed',
}).then(async () => {
let updatedHabitsOrder = (await user.get('/user')).tasksOrder.habits;
expect(updatedHabitsOrder).to.eql(originalHabitsOrder);
});
let updatedHabitsOrder = (await user.get('/user')).tasksOrder.habits;
expect(updatedHabitsOrder).to.eql(originalHabitsOrder);
});
it('does not update user.tasksOrder.{taskType} when a task inside an array is not saved because invalid', async () => {
let originalHabitsOrder = (await user.get('/user')).tasksOrder.habits;
return expect(user.post('/tasks', [
await expect(user.post('/tasks', [
{type: 'habit'}, // Missing text
{type: 'habit', text: 'valid'}, // Valid
])).to.eventually.be.rejected.and.eql({ // this block is necessary
code: 400,
error: 'BadRequest',
message: 'habit validation failed',
}).then(async () => {
let updatedHabitsOrder = (await user.get('/user')).tasksOrder.habits;
expect(updatedHabitsOrder).to.eql(originalHabitsOrder);
});
let updatedHabitsOrder = (await user.get('/user')).tasksOrder.habits;
expect(updatedHabitsOrder).to.eql(originalHabitsOrder);
});
it('does not save any task sent in an array when 1 is invalid', async () => {
let originalTasks = await user.get('/tasks');
return expect(user.post('/tasks', [
await expect(user.post('/tasks', [
{type: 'habit'}, // Missing text
{type: 'habit', text: 'valid'}, // Valid
])).to.eventually.be.rejected.and.eql({ // this block is necessary
code: 400,
error: 'BadRequest',
message: 'habit validation failed',
}).then(async () => {
let updatedTasks = await user.get('/tasks');
expect(updatedTasks).to.eql(originalTasks);
});
let updatedTasks = await user.get('/tasks');
expect(updatedTasks).to.eql(originalTasks);
});
it('automatically sets "task.userId" to user\'s uuid', async () => {

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', () => {
let user;
beforeEach(() => {
return generateUser({
beforeEach(async () => {
user = await generateUser({
'stats.gp': 100,
}).then((generatedUser) => {
user = generatedUser;
});
});
context('all', () => {
it('requires a task id', () => {
return expect(user.post('/tasks/123/score/up')).to.eventually.be.rejected.and.eql({
it('requires a task id', async () => {
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', () => {
return expect(user.post(`/tasks/${generateUUID()}/score/tt`)).to.eventually.be.rejected.and.eql({
it('requires a task direction', async () => {
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(() => {
return user.post('/tasks', {
beforeEach(async () => {
todo = await user.post('/tasks', {
text: 'test todo',
type: 'todo',
}).then((task) => {
todo = task;
});
});
it('completes todo when direction is up', () => {
return user.post(`/tasks/${todo._id}/score/up`)
.then(() => user.get(`/tasks/${todo._id}`))
.then((task) => expect(task.completed).to.equal(true));
it('completes todo when direction is up', async () => {
await user.post(`/tasks/${todo._id}/score/up`);
let task = await user.get(`/tasks/${todo._id}`);
expect(task.completed).to.equal(true);
});
it('moves completed todos out of user.tasksOrder.todos', () => {
return user.get('/user')
.then(usr => {
expect(usr.tasksOrder.todos.indexOf(todo._id)).to.not.equal(-1);
}).then(() => user.post(`/tasks/${todo._id}/score/up`))
.then(() => user.get(`/tasks/${todo._id}`))
.then((updatedTask) => {
it('moves completed todos out of user.tasksOrder.todos', async () => {
let getUser = await user.get('/user');
expect(getUser.tasksOrder.todos.indexOf(todo._id)).to.not.equal(-1);
await user.post(`/tasks/${todo._id}/score/up`);
let updatedTask = await user.get(`/tasks/${todo._id}`);
expect(updatedTask.completed).to.equal(true);
return user.get('/user');
})
.then((usr) => {
expect(usr.tasksOrder.todos.indexOf(todo._id)).to.equal(-1);
});
let updatedUser = await user.get('/user');
expect(updatedUser.tasksOrder.todos.indexOf(todo._id)).to.equal(-1);
});
it('moves un-completed todos back into user.tasksOrder.todos', () => {
return user.get('/user')
.then(usr => {
expect(usr.tasksOrder.todos.indexOf(todo._id)).to.not.equal(-1);
}).then(() => user.post(`/tasks/${todo._id}/score/up`))
.then(() => user.post(`/tasks/${todo._id}/score/down`))
.then(() => user.get(`/tasks/${todo._id}`))
.then((updatedTask) => {
it('moves un-completed todos back into user.tasksOrder.todos', async () => {
let getUser = await user.get('/user');
expect(getUser.tasksOrder.todos.indexOf(todo._id)).to.not.equal(-1);
await user.post(`/tasks/${todo._id}/score/up`);
await user.post(`/tasks/${todo._id}/score/down`);
let updatedTask = await user.get(`/tasks/${todo._id}`);
expect(updatedTask.completed).to.equal(false);
return user.get('/user');
})
.then((usr) => {
let l = usr.tasksOrder.todos.length;
expect(usr.tasksOrder.todos.indexOf(todo._id)).not.to.equal(-1);
expect(usr.tasksOrder.todos.indexOf(todo._id)).to.equal(l - 1); // Check that it was pushed at the bottom
});
let updatedUser = await user.get('/user');
let l = updatedUser.tasksOrder.todos.length;
expect(updatedUser.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
});
it('uncompletes todo when direction is down', () => {
return user.post(`/tasks/${todo._id}/score/down`)
.then(() => user.get(`/tasks/${todo._id}`))
.then((updatedTask) => {
it('uncompletes todo when direction is down', async () => {
await user.post(`/tasks/${todo._id}/score/down`);
let updatedTask = await user.get(`/tasks/${todo._id}`);
expect(updatedTask.completed).to.equal(false);
});
});
it('scores up todo even if it is already completed'); // Yes?
it('scores down todo even if it is already uncompleted'); // Yes?
it('increases user\'s mp when direction is up', () => {
return user.post(`/tasks/${todo._id}/score/up`)
.then(() => user.get(`/user`))
.then((updatedUser) => {
context('user stats when direction is up', () => {
let 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', () => {
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) => {
it('increases user\'s exp', () => {
expect(updatedUser.stats.exp).to.be.greaterThan(user.stats.exp);
});
});
it('decreases user\'s exp when direction is down', () => {
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) => {
it('increases user\'s gold', () => {
expect(updatedUser.stats.gp).to.be.greaterThan(user.stats.gp);
});
});
it('decreases user\'s gold when direction is down', () => {
return user.post(`/tasks/${todo._id}/score/down`)
.then(() => user.get(`/user`))
.then((updatedUser) => {
context('user stats when direction is down', () => {
let 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(() => {
return user.post('/tasks', {
beforeEach(async () => {
daily = await user.post('/tasks', {
text: 'test daily',
type: 'daily',
}).then((task) => {
daily = task;
});
});
it('completes daily when direction is up', () => {
return user.post(`/tasks/${daily._id}/score/up`)
.then(() => user.get(`/tasks/${daily._id}`))
.then((task) => expect(task.completed).to.equal(true));
it('completes daily when direction is up', async () => {
await user.post(`/tasks/${daily._id}/score/up`);
let task = await user.get(`/tasks/${daily._id}`);
expect(task.completed).to.equal(true);
});
it('uncompletes daily when direction is down', () => {
return user.post(`/tasks/${daily._id}/score/down`)
.then(() => user.get(`/tasks/${daily._id}`))
.then((task) => expect(task.completed).to.equal(false));
it('uncompletes daily when direction is down', async () => {
await user.post(`/tasks/${daily._id}/score/down`);
let task = await user.get(`/tasks/${daily._id}`);
expect(task.completed).to.equal(false);
});
it('scores up daily even if it is already completed'); // Yes?
it('scores down daily even if it is already uncompleted'); // Yes?
it('increases user\'s mp when direction is up', () => {
return user.post(`/tasks/${daily._id}/score/up`)
.then(() => user.get(`/user`))
.then((updatedUser) => {
context('user stats when direction is up', () => {
let 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', () => {
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) => {
it('increases user\'s exp', () => {
expect(updatedUser.stats.exp).to.be.greaterThan(user.stats.exp);
});
});
it('decreases user\'s exp when direction is down', () => {
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) => {
it('increases user\'s gold', () => {
expect(updatedUser.stats.gp).to.be.greaterThan(user.stats.gp);
});
});
it('decreases user\'s gold when direction is down', () => {
return user.post(`/tasks/${daily._id}/score/down`)
.then(() => user.get(`/user`))
.then((updatedUser) => {
context('user stats when direction is down', () => {
let 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,117 +204,93 @@ describe('POST /tasks/:id/score/:direction', () => {
context('habits', () => {
let habit, minusHabit, plusHabit, neitherHabit; // eslint-disable-line no-unused-vars
beforeEach(() => {
return user.post('/tasks', {
beforeEach(async () => {
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',
type: 'habit',
up: false,
});
}).then((task) => {
minusHabit = task;
return user.post('/tasks', {
plusHabit = await user.post('/tasks', {
text: 'test plus habit',
type: 'habit',
down: false,
});
}).then((task) => {
plusHabit = task;
user.post('/tasks', {
neitherHabit = await user.post('/tasks', {
text: 'test neither habit',
type: 'habit',
up: false,
down: false,
});
}).then((task) => {
neitherHabit = task;
});
});
it('prevents plus only habit from scoring down'); // Yes?
it('prevents minus only habit from scoring up'); // Yes?
it('increases user\'s mp when direction is up', () => {
return user.post(`/tasks/${habit._id}/score/up`)
.then(() => user.get(`/user`))
.then((updatedUser) => {
it('increases user\'s mp when direction is up', async () => {
await user.post(`/tasks/${habit._id}/score/up`);
let updatedUser = await user.get(`/user`);
expect(updatedUser.stats.mp).to.be.greaterThan(user.stats.mp);
});
});
it('decreases user\'s mp when direction is down', () => {
return user.post(`/tasks/${habit._id}/score/down`)
.then(() => user.get(`/user`))
.then((updatedUser) => {
it('decreases user\'s mp when direction is down', async () => {
await user.post(`/tasks/${habit._id}/score/down`);
let updatedUser = await user.get(`/user`);
expect(updatedUser.stats.mp).to.be.lessThan(user.stats.mp);
});
});
it('increases user\'s exp when direction is up', () => {
return user.post(`/tasks/${habit._id}/score/up`)
.then(() => user.get(`/user`))
.then((updatedUser) => {
it('increases user\'s exp when direction is up', async () => {
await user.post(`/tasks/${habit._id}/score/up`);
let updatedUser = await user.get(`/user`);
expect(updatedUser.stats.exp).to.be.greaterThan(user.stats.exp);
});
});
it('increases user\'s gold when direction is up', () => {
return user.post(`/tasks/${habit._id}/score/up`)
.then(() => user.get(`/user`))
.then((updatedUser) => {
it('increases user\'s gold when direction is up', async () => {
await user.post(`/tasks/${habit._id}/score/up`);
let updatedUser = await user.get(`/user`);
expect(updatedUser.stats.gp).to.be.greaterThan(user.stats.gp);
});
});
});
context('reward', () => {
let reward;
let reward, updatedUser;
beforeEach(() => {
return user.post('/tasks', {
beforeEach(async () => {
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`)
.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`)
.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`)
.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`)
.then(() => user.get(`/user`))
.then((updatedUser) => {
expect(user.stats.mp).to.equal(updatedUser.stats.mp);
});
});
});
});

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

@@ -6,21 +6,17 @@ import { v4 as generateUUID } from 'uuid';
describe('PUT /tasks/:id', () => {
let user;
before(() => {
return generateUser().then((generatedUser) => {
user = generatedUser;
});
before(async () => {
user = await generateUser();
});
context('validates params', () => {
let task;
beforeEach(() => {
return user.post('/tasks', {
beforeEach(async () => {
task = await user.post('/tasks', {
text: 'test habit',
type: 'habit',
}).then((createdTask) => {
task = createdTask;
});
});
@@ -52,172 +48,167 @@ describe('PUT /tasks/:id', () => {
});
});
it('ignores invalid fields', () => {
user.put(`/tasks/${task._id}`, {
it('ignores invalid fields', async () => {
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(() => {
return user.post('/tasks', {
beforeEach(async () => {
habit = await user.post('/tasks', {
text: 'test habit',
type: 'habit',
notes: 1976,
}).then((createdHabit) => {
habit = createdHabit;
});
});
it('updates a habit', () => {
return user.put(`/tasks/${habit._id}`, {
it('updates a habit', async () => {
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(() => {
return user.post('/tasks', {
beforeEach(async () => {
todo = await user.post('/tasks', {
text: 'test todo',
type: 'todo',
notes: 1976,
}).then((createdTodo) => {
todo = createdTodo;
});
});
it('updates a todo', () => {
return user.put(`/tasks/${todo._id}`, {
it('updates a todo', async () => {
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');
});
});
it('can update checklists (replace it)', () => {
return user.put(`/tasks/${todo._id}`, {
expect(savedTodo.text).to.eql('some new text');
expect(savedTodo.notes).to.eql('some new notes');
});
it('can update checklists (replace it)', async () => {
await user.put(`/tasks/${todo._id}`, {
checklist: [
{text: 123, completed: false},
{text: 456, completed: true},
],
}).then(() => {
return user.put(`/tasks/${todo._id}`, {
});
let savedTodo = await 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);
});
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}`, {
});
let savedTodo = await user.put(`/tasks/${todo._id}`, {
tags: [finalUUID],
});
}).then((savedTodo2) => {
expect(savedTodo2.tags.length).to.equal(1);
expect(savedTodo2.tags[0]).to.equal(finalUUID);
});
expect(savedTodo.tags.length).to.equal(1);
expect(savedTodo.tags[0]).to.equal(finalUUID);
});
});
context('dailys', () => {
let daily;
beforeEach(() => {
return user.post('/tasks', {
beforeEach(async () => {
daily = await user.post('/tasks', {
text: 'test daily',
type: 'daily',
notes: 1976,
}).then((createdDaily) => {
daily = createdDaily;
});
});
it('updates a daily', () => {
return user.put(`/tasks/${daily._id}`, {
it('updates a daily', async () => {
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);
});
});
it('can update checklists (replace it)', () => {
return user.put(`/tasks/${daily._id}`, {
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)', async () => {
await user.put(`/tasks/${daily._id}`, {
checklist: [
{text: 123, completed: false},
{text: 456, completed: true},
],
}).then(() => {
return user.put(`/tasks/${daily._id}`, {
});
let savedDaily = await 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);
});
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}`, {
});
let savedDaily = await user.put(`/tasks/${daily._id}`, {
tags: [finalUUID],
});
}).then((savedDaily2) => {
expect(savedDaily2.tags.length).to.equal(1);
expect(savedDaily2.tags[0]).to.equal(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', () => {
return user.put(`/tasks/${daily._id}`, {
it('updates repeat, even if frequency is set to daily', async () => {
await user.put(`/tasks/${daily._id}`, {
frequency: 'daily',
}).then(() => {
return user.put(`/tasks/${daily._id}`, {
});
let savedDaily = await user.put(`/tasks/${daily._id}`, {
repeat: {
m: false,
su: false,
},
});
}).then((savedDaily2) => {
expect(savedDaily2.repeat).to.eql({
expect(savedDaily.repeat).to.eql({
m: false,
t: true,
w: true,
@@ -227,61 +218,58 @@ describe('PUT /tasks/:id', () => {
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', () => {
return user.put(`/tasks/${daily._id}`, {
frequency: 'weekly',
}).then(() => {
return user.put(`/tasks/${daily._id}`, {
let savedDaily = await user.put(`/tasks/${daily._id}`, {
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', () => {
return user.put(`/tasks/${daily._id}`, {
it('defaults startDate to today if none date object is passed in', async () => {
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(() => {
return user.post('/tasks', {
beforeEach(async () => {
reward = await user.post('/tasks', {
text: 'test reward',
type: 'reward',
notes: 1976,
value: 10,
}).then((createdReward) => {
reward = createdReward;
});
});
it('updates a reward', () => {
return user.put(`/tasks/${reward._id}`, {
it('updates a reward', async () => {
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);
});
});
it('requires value to be coerced into a number', () => {
return user.put(`/tasks/${reward._id}`, {
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', async () => {
let savedReward = await user.put(`/tasks/${reward._id}`, {
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', () => {
let user;
before(() => {
return generateUser().then((generatedUser) => {
user = generatedUser;
});
before(async () => {
user = await generateUser();
});
it('deletes a checklist item', () => {
let task;
return user.post('/tasks', {
it('deletes a checklist item', async () => {
let task = await 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);
});
});
it('does not work with habits', () => {
let habit;
return expect(user.post('/tasks', {
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', async () => {
let habit = await user.post('/tasks', {
type: 'habit',
text: 'habit with checklist',
}).then(createdTask => {
habit = createdTask;
return user.del(`/tasks/${habit._id}/checklist/${generateUUID()}`);
})).to.eventually.be.rejected.and.eql({
});
await expect(user.del(`/tasks/${habit._id}/checklist/${generateUUID()}`)).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', () => {
return expect(user.del(`/tasks/${generateUUID()}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
it('fails on task not found', async () => {
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', () => {
return expect(user.post('/tasks', {
it('fails on checklist item not found', async () => {
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'),

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/', () => {
let user;
before(() => {
return generateUser().then((generatedUser) => {
user = generatedUser;
});
before(async () => {
user = await generateUser();
});
it('adds a checklist item to a task', () => {
let task;
return user.post('/tasks', {
it('adds a checklist item to a task', async () => {
let task = await user.post('/tasks', {
type: 'daily',
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[0].text).to.equal('Checklist Item 1');
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].ignored).to.be.an('undefined');
});
});
it('does not add a checklist to habits', () => {
let habit;
return expect(user.post('/tasks', {
it('does not add a checklist to habits', async () => {
let habit = await 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', () => {
let reward;
return expect(user.post('/tasks', {
it('does not add a checklist to rewards', async () => {
let reward = await 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', () => {
return expect(user.post(`/tasks/${generateUUID()}/checklist`, {
it('fails on task not found', async () => {
await expect(user.post(`/tasks/${generateUUID()}/checklist`, {
text: 'Checklist Item 1',
})).to.eventually.be.rejected.and.eql({
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', () => {
let user;
before(() => {
return generateUser().then((generatedUser) => {
user = generatedUser;
});
before(async () => {
user = await generateUser();
});
it('scores a checklist item', () => {
let task;
return user.post('/tasks', {
it('scores a checklist item', async () => {
let task = await 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) => {
});
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', () => {
let habit;
return expect(user.post('/tasks', {
it('fails on habits', async () => {
let habit = await 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', () => {
return expect(user.post(`/tasks/${generateUUID()}/checklist/${generateUUID()}/score`)).to.eventually.be.rejected.and.eql({
it('fails on task not found', async () => {
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', () => {
return expect(user.post('/tasks', {
it('fails on checklist item not found', async () => {
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'),

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', () => {
let user;
before(() => {
return generateUser().then((generatedUser) => {
user = generatedUser;
});
before(async () => {
user = await generateUser();
});
it('updates a checklist item', () => {
let task;
return user.post('/tasks', {
it('updates a checklist item', async () => {
let task = await 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) => {
});
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 () => {
let habit = await user.post('/tasks', {
@@ -58,21 +60,21 @@ describe('PUT /tasks/:taskId/checklist/:itemId', () => {
});
});
it('fails on task not found', () => {
return expect(user.put(`/tasks/${generateUUID()}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
it('fails on task not found', async () => {
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', () => {
return expect(user.post('/tasks', {
it('fails on checklist item not found', async () => {
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'),

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', () => {
let user;
before(() => {
return generateUser().then((generatedUser) => {
user = generatedUser;
});
before(async () => {
user = await generateUser();
});
it('removes a tag from a task', () => {
let tag;
let task;
return user.post('/tasks', {
it('removes a tag from a task', async () => {
let task = await 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 => {
});
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', () => {
return expect(user.post('/tasks', {
it('only deletes existing tags', async () => {
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'),

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', () => {
let user;
before(() => {
return generateUser().then((generatedUser) => {
user = generatedUser;
});
before(async () => {
user = await generateUser();
});
it('adds a tag to a task', () => {
let tag;
let task;
return user.post('/tasks', {
it('adds a tag to a task', async () => {
let task = await 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 => {
});
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', () => {
let tag;
let task;
return expect(user.post('/tasks', {
it('does not add a tag to a task twice', async () => {
let task = await 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.post(`/tasks/${task._id}/tags/${tag._id}`);
})).to.eventually.be.rejected.and.eql({
});
let tag = await user.post('/tags', {name: 'Tag 1'});
await user.post(`/tasks/${task._id}/tags/${tag._id}`);
await expect(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', () => {
return expect(user.post('/tasks', {
it('does not add a non existing tag to a task', async () => {
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'),