Added initial challenge model tests

test/api/v3/unit/models/challenge.test.js

@@ -0,0 +1,121 @@
+import { model as Challenge } from '../../../../../website/src/models/challenge';
+import { model as Group } from '../../../../../website/src/models/group';
+import { model as User } from '../../../../../website/src/models/user';
+import * as Tasks from '../../../../../website/src/models/task';
+import { each } from 'lodash';
+
+describe('Challenge Model', () => {
+  let guild, leader, challenge, task;
+  let tasksToTest = {
+    habit: {
+      text: 'test habit',
+      type: 'habit',
+      up: false,
+      down: true,
+      notes: 1976,
+    },
+    todo: {
+      text: 'test todo',
+      type: 'todo',
+      notes: 1976,
+    },
+    daily: {
+      text: 'test daily',
+      type: 'daily',
+      notes: 1976,
+      frequency: 'daily',
+      everyX: 5,
+      startDate: new Date(),
+    },
+    reward: {
+      text: 'test reward',
+      type: 'reward',
+      notes: 1976,
+    },
+  };
+
+  beforeEach(async () => {
+    guild = new Group({
+      name: 'test party',
+      type: 'guild',
+    });
+
+    leader = new User({
+      guilds: [guild._id],
+    });
+
+    guild.leader = leader._id;
+
+    challenge = new Challenge({
+      name: 'Test Challenge',
+      shortName: 'Test',
+      leader: leader._id,
+      group: guild._id,
+    });
+
+    leader.challenges = [challenge._id];
+
+    await Promise.all([
+      guild.save(),
+      leader.save(),
+      challenge.save(),
+    ]);
+  });
+
+  each(tasksToTest, (taskValue, taskType) => {
+    context(`${taskType}`, () => {
+      before(async() => {
+        task = new Tasks[`${taskType}`](Tasks.Task.sanitizeCreate(taskValue));
+      });
+
+      it('adds tasks to challenge and challenge members', async () => {
+        await challenge.addTasks([task]);
+
+        let updatedLeader = await User.findOne({_id: leader._id});
+
+        expect(updatedLeader.tasksOrder[`${taskType}s`].length).to.be.above(0);
+      });
+
+      it('syncs a challenge to a user', async () => {
+        await challenge.addTasks([task]);
+
+        let newMember = new User({
+          guilds: [guild._id],
+        });
+        await newMember.save();
+
+        await challenge.syncToUser(newMember);
+
+        let updatedNewMember = await User.findById(newMember._id);
+
+        expect(updatedNewMember.challenges).to.contain(challenge._id);
+        expect(updatedNewMember.tags[3]._id).to.equal(challenge._id);
+        expect(updatedNewMember.tags[3].name).to.equal(challenge.shortName);
+        expect(updatedNewMember.tasksOrder[`${taskType}s`].length).to.be.above(0);
+      });
+
+      it('updates tasks to challenge and challenge members', async () => {
+        let updatedTaskName = 'Updated Test Habit';
+        await challenge.addTasks([task]);
+
+        _.assign(task, _.merge(task.toObject(), Tasks.Task.sanitizeUpdate({ text: updatedTaskName })));
+        await challenge.updateTask(task);
+
+        let updatedLeader = await User.findOne({_id: leader._id});
+        let updatedUserTask = await Tasks.Task.findById(updatedLeader.tasksOrder[`${taskType}s`][0]);
+
+        expect(updatedUserTask.text).to.equal(updatedTaskName);
+      });
+
+      it('removes a tasks to challenge and challenge members', async () => {
+        await challenge.addTasks([task]);
+        await challenge.removeTask(task);
+
+        let updatedLeader = await User.findOne({_id: leader._id});
+        let updatedUserTask = await Tasks.Task.findOne({_id: updatedLeader.tasksOrder[`${taskType}s`][0]}).exec();
+
+        expect(updatedUserTask.challenge.broken).to.equal('TASK_DELETED');
+      });
+    });
+  });
+});

website/src/models/challenge.js

@@ -97,7 +97,6 @@ schema.methods.syncToUser = async function syncChallengeToUser (user) {
   let [challengeTasks, userTasks] = await Q.all([
     // Find original challenge tasks
     Tasks.Task.find({
-      userId: {$exists: false},
       'challenge.id': challenge._id,
     }).exec(),
     // Find user's tasks linked to this challenge
@@ -186,9 +185,10 @@ schema.methods.updateTask = async function challengeUpdateTask (task) {
 
   let updateCmd = {$set: {}};
 
-  _syncableAttrs(task).forEach((value, key) => {
+  let syncableAttrs = _syncableAttrs(task);
-    updateCmd.$set[key] = value;
+  for (let key in syncableAttrs) {
-  });
+    updateCmd.$set[key] = syncableAttrs[key];
+  }
 
   // TODO reveiw
   // Updating instead of loading and saving for performances, risks becoming a problem if we introduce more complexity in tasks