4.65.2

Misc fixes

.gitignore

@@ -39,6 +39,7 @@ dist-client
 test/client/unit/coverage
 test/client/e2e/reports
 test/client-old/spec/mocks/translations.js
+yarn.lock
 
 # Elastic Beanstalk Files
 .elasticbeanstalk/*

.travis.yml

@@ -20,8 +20,9 @@ env:
     - DISABLE_REQUEST_LOGGING=true
   matrix:
     - TEST="lint"
-    - TEST="test:api-v3:unit" REQUIRES_SERVER=true COVERAGE=true
+    - TEST="test:api:unit" REQUIRES_SERVER=true COVERAGE=true
     - TEST="test:api-v3:integration" REQUIRES_SERVER=true COVERAGE=true
+    - TEST="test:api-v4:integration" REQUIRES_SERVER=true COVERAGE=true
     - TEST="test:sanity"
     - TEST="test:content" COVERAGE=true
     - TEST="test:common" COVERAGE=true

Dockerfile

@@ -1,18 +1,29 @@
-FROM node:8
-
-# Install global packages
-RUN npm install -g gulp-cli mocha
-
-# Clone Habitica repo and install dependencies
-RUN mkdir -p /usr/src/habitrpg
-WORKDIR /usr/src/habitrpg
-RUN git clone https://github.com/HabitRPG/habitica.git /usr/src/habitrpg
-RUN cp config.json.example config.json
-RUN npm install
-
-# Create Build dir
-RUN mkdir -p ./website/build
-
-# Start Habitica
-EXPOSE 3000
-CMD ["npm", "start"]
+FROM node:8
+
+ENV ADMIN_EMAIL admin@habitica.com
+ENV AMAZON_PAYMENTS_CLIENT_ID amzn1.application-oa2-client.68ed9e6904ef438fbc1bf86bf494056e
+ENV AMAZON_PAYMENTS_SELLER_ID AMQ3SB4SG5E91
+ENV AMPLITUDE_KEY e8d4c24b3d6ef3ee73eeba715023dd43
+ENV BASE_URL https://habitica.com
+ENV FACEBOOK_KEY 128307497299777
+ENV GA_ID UA-33510635-1
+ENV GOOGLE_CLIENT_ID 1035232791481-32vtplgnjnd1aufv3mcu1lthf31795fq.apps.googleusercontent.com
+ENV NODE_ENV production
+ENV STRIPE_PUB_KEY pk_85fQ0yMECHNfHTSsZoxZXlPSwSNfA
+
+# Install global packages
+RUN npm install -g gulp-cli mocha
+
+# Clone Habitica repo and install dependencies
+RUN mkdir -p /usr/src/habitrpg
+WORKDIR /usr/src/habitrpg
+RUN git clone --branch release https://github.com/HabitRPG/habitica.git /usr/src/habitrpg
+RUN npm install
+RUN gulp build:prod --force
+
+# Create Build dir
+RUN mkdir -p ./website/build
+
+# Start Habitica
+EXPOSE 3000
+CMD ["node", "./website/transpiled-babel/index.js"]

Dockerfile-Dev

@@ -0,0 +1,18 @@
+FROM node:8
+
+# Install global packages
+RUN npm install -g gulp-cli mocha
+
+# Clone Habitica repo and install dependencies
+RUN mkdir -p /usr/src/habitrpg
+WORKDIR /usr/src/habitrpg
+RUN git clone https://github.com/HabitRPG/habitica.git /usr/src/habitrpg
+RUN cp config.json.example config.json
+RUN npm install
+
+# Create Build dir
+RUN mkdir -p ./website/build
+
+# Start Habitica
+EXPOSE 3000
+CMD ["npm", "start"]

Dockerfile-Production

@@ -1,29 +0,0 @@
-FROM node:8
-
-ENV ADMIN_EMAIL admin@habitica.com
-ENV AMAZON_PAYMENTS_CLIENT_ID amzn1.application-oa2-client.68ed9e6904ef438fbc1bf86bf494056e
-ENV AMAZON_PAYMENTS_SELLER_ID AMQ3SB4SG5E91
-ENV AMPLITUDE_KEY e8d4c24b3d6ef3ee73eeba715023dd43
-ENV BASE_URL https://habitica.com
-ENV FACEBOOK_KEY 128307497299777
-ENV GA_ID UA-33510635-1
-ENV GOOGLE_CLIENT_ID 1035232791481-32vtplgnjnd1aufv3mcu1lthf31795fq.apps.googleusercontent.com
-ENV NODE_ENV production
-ENV STRIPE_PUB_KEY pk_85fQ0yMECHNfHTSsZoxZXlPSwSNfA
-
-# Install global packages
-RUN npm install -g gulp-cli mocha
-
-# Clone Habitica repo and install dependencies
-RUN mkdir -p /usr/src/habitrpg
-WORKDIR /usr/src/habitrpg
-RUN git clone --branch v4.42.6 https://github.com/HabitRPG/habitica.git /usr/src/habitrpg
-RUN npm install
-RUN gulp build:prod --force
-
-# Create Build dir
-RUN mkdir -p ./website/build
-
-# Start Habitica
-EXPOSE 3000
-CMD ["node", "./website/transpiled-babel/index.js"]

config.json.example

@@ -17,7 +17,7 @@
     "NODE_DB_URI":"mongodb://localhost/habitrpg",
     "TEST_DB_URI":"mongodb://localhost/habitrpg_test",
     "NODE_ENV":"development",
-    "ENABLE_CONSOLE_LOGS_IN_TEST": false,
+    "ENABLE_CONSOLE_LOGS_IN_TEST": "false",
     "CRON_SAFE_MODE":"false",
     "CRON_SEMI_SAFE_MODE":"false",
     "MAINTENANCE_MODE": "false",
@@ -78,6 +78,9 @@
     "PUSH_CONFIGS": {
         "GCM_SERVER_API_KEY": "",
         "APN_ENABLED": "false",
+        "APN_KEY_ID": "xxxxxxxxxx",
+        "APN_KEY": "xxxxxxxxxx",
+        "APN_TEAM_ID": "aaabbbcccd",
         "FCM_SERVER_API_KEY": ""
     },
     "SITE_HTTP_AUTH": {
@@ -112,5 +115,6 @@
       "CLOUDKARAFKA_USERNAME": "",
       "CLOUDKARAFKA_PASSWORD": "",
       "CLOUDKARAFKA_TOPIC_PREFIX": ""
-    }
+    },
+    "MIGRATION_CONNECT_STRING": "mongodb://localhost:27017/habitrpg?auto_reconnect=true"
 }

database_reports/20180607_subscriber_histories.js

@@ -0,0 +1,100 @@
+import max from 'lodash/max';
+import mean from 'lodash/mean';
+import monk from 'monk';
+import round from 'lodash/round';
+import sum from 'lodash/sum';
+
+/*
+ * Output data on subscribers' task histories, formatted for CSV.
+ * User ID,Count of Dailies,Count of Habits,Total History Size,Max History Size,Mean History Size,Median History Size
+ */
+const connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
+
+let dbUsers = monk(connectionString).get('users', { castIds: false });
+let dbTasks = monk(connectionString).get('tasks', { castIds: false });
+
+function usersReport () {
+  let allHistoryLengths = [];
+
+  console.info('User ID,Count of Dailies,Count of Habits,Total History Size,Max History Size,Mean History Size,Median History Size');
+
+  dbUsers.find(
+    {
+      $and:
+        [
+          {'purchased.plan.planId': {$ne:null}},
+          {'purchased.plan.planId': {$ne:''}},
+        ],
+      $or:
+        [
+          {'purchased.plan.dateTerminated': null},
+          {'purchased.plan.dateTerminated': ''},
+          {'purchased.plan.dateTerminated': {$gt:new Date()}},
+        ],
+    },
+    {
+      fields: {_id: 1},
+    }
+  ).each((user, {close, pause, resume}) => {
+    let historyLengths = [];
+    let habitCount = 0;
+    let dailyCount = 0;
+
+    pause();
+    return dbTasks.find(
+      {
+        userId: user._id,
+        $or:
+          [
+            {type: 'habit'},
+            {type: 'daily'},
+          ],
+      },
+      {
+        fields: {
+          type: 1,
+          history: 1,
+        },
+      }
+    ).each((task) => {
+      if (task.type === 'habit') {
+        habitCount++;
+      }
+      if (task.type === 'daily') {
+        dailyCount++;
+      }
+      if (task.history.length > 0) {
+        allHistoryLengths.push(task.history.length);
+        historyLengths.push(task.history.length);
+      }
+    }).then(() => {
+      const totalHistory = sum(historyLengths);
+      const maxHistory = historyLengths.length > 0 ? max(historyLengths) : 0;
+      const meanHistory = historyLengths.length > 0 ? round(mean(historyLengths)) : 0;
+      const medianHistory = historyLengths.length > 0 ? median(historyLengths) : 0;
+      console.info(`${user._id},${dailyCount},${habitCount},${totalHistory},${maxHistory},${meanHistory},${medianHistory}`);
+      resume();
+    });
+  }).then(() => {
+    console.info(`Total Subscriber History Entries: ${sum(allHistoryLengths)}`);
+    console.info(`Largest History Size: ${max(allHistoryLengths)}`);
+    console.info(`Mean History Size: ${round(mean(allHistoryLengths))}`);
+    console.info(`Median History Size: ${median(allHistoryLengths)}`);
+    return process.exit(0);
+  });
+}
+
+function median(values) { // https://gist.github.com/caseyjustus/1166258
+  values.sort( function(a,b) {return a - b;} );
+
+  var half = Math.floor(values.length/2);
+
+  if (values.length % 2) {
+    return values[half];
+  }
+  else {
+    return (values[half-1] + values[half]) / 2.0;
+  }
+}
+
+module.exports = usersReport;

docker-compose.dev.yml

@@ -2,9 +2,13 @@ version: "3"
 services:
 
   client:
+    environment:
+      - NODE_ENV=development
     volumes:
       - '.:/usr/src/habitrpg'
 
   server:
+    environment:
+      - NODE_ENV=development
     volumes:
       - '.:/usr/src/habitrpg'

gulp/gulp-tests.js

@@ -165,9 +165,9 @@ gulp.task('test:content:safe', gulp.series('test:prepare:build', (cb) => {
   pipe(runner);
 }));
 
-gulp.task('test:api-v3:unit', (done) => {
+gulp.task('test:api:unit', (done) => {
   let runner = exec(
-    testBin('node_modules/.bin/istanbul cover --dir coverage/api-v3-unit node_modules/mocha/bin/_mocha -- test/api/v3/unit --recursive --require ./test/helpers/start-server'),
+    testBin('node_modules/.bin/istanbul cover --dir coverage/api-unit node_modules/mocha/bin/_mocha -- test/api/unit --recursive --require ./test/helpers/start-server'),
     (err) => {
       if (err) {
         process.exit(1);
@@ -179,8 +179,8 @@ gulp.task('test:api-v3:unit', (done) => {
   pipe(runner);
 });
 
-gulp.task('test:api-v3:unit:watch', () => {
-  return gulp.watch(['website/server/libs/*', 'test/api/v3/unit/**/*', 'website/server/controllers/**/*'], gulp.series('test:api-v3:unit', done => done()));
+gulp.task('test:api:unit:watch', () => {
+  return gulp.watch(['website/server/libs/*', 'test/api/v3/unit/**/*', 'website/server/controllers/**/*'], gulp.series('test:api:unit', done => done()));
 });
 
 gulp.task('test:api-v3:integration', (done) => {
@@ -215,17 +215,43 @@ gulp.task('test:api-v3:integration:separate-server', (done) => {
   pipe(runner);
 });
 
+gulp.task('test:api-v4:integration', (done) => {
+  let runner = exec(
+    testBin('node_modules/.bin/istanbul cover --dir coverage/api-v4-integration --report lcovonly node_modules/mocha/bin/_mocha -- test/api/v4 --recursive --require ./test/helpers/start-server'),
+    {maxBuffer: 500 * 1024},
+    (err) => {
+      if (err) {
+        process.exit(1);
+      }
+      done();
+    }
+  );
+
+  pipe(runner);
+});
+
+gulp.task('test:api-v4:integration:separate-server', (done) => {
+  let runner = exec(
+    testBin('mocha test/api/v4 --recursive --require ./test/helpers/start-server', 'LOAD_SERVER=0'),
+    {maxBuffer: 500 * 1024},
+    (err) => done(err)
+  );
+
+  pipe(runner);
+});
+
 gulp.task('test', gulp.series(
   'test:sanity',
   'test:content',
   'test:common',
-  'test:api-v3:unit',
+  'test:api:unit',
   'test:api-v3:integration',
+  'test:api-v4:integration',
   done => done()
 ));
 
 gulp.task('test:api-v3', gulp.series(
-  'test:api-v3:unit',
+  'test:api:unit',
   'test:api-v3:integration',
   done => done()
-));
+));

migrations/20180811_inboxOutsideUser.js

@@ -0,0 +1,123 @@
+const migrationName = '20180811_inboxOutsideUser.js';
+const authorName = 'paglias'; // in case script author needs to know when their ...
+const authorUuid = 'ed4c688c-6652-4a92-9d03-a5a79844174a'; // ... own data is done
+
+/*
+ * Move inbox messages from the user model to their own collection
+ */
+
+const monk = require('monk');
+const nconf = require('nconf');
+
+const Inbox = require('../website/server/models/message').inboxModel;
+const connectionString = nconf.get('MIGRATION_CONNECT_STRING'); // FOR TEST DATABASE
+const dbInboxes = monk(connectionString).get('inboxes', { castIds: false });
+const dbUsers = monk(connectionString).get('users', { castIds: false });
+
+function processUsers (lastId) {
+  let query = {
+    migration: {$ne: migrationName},
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 1000,
+    fields: ['_id', 'inbox'],
+  })
+    .then(updateUsers)
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+let progressCount = 1000;
+let count = 0;
+let msgCount = 0;
+
+function updateUsers (users) {
+  if (!users || users.length === 0) {
+    console.warn('All appropriate users and their tasks found and modified.');
+    displayData();
+    return;
+  }
+
+  let usersPromises = users.map(updateUser);
+  let lastUser = users[users.length - 1];
+
+  return Promise.all(usersPromises)
+    .then(() => {
+      return processUsers(lastUser._id);
+    });
+}
+
+function updateUser (user) {
+  count++;
+
+  if (count % progressCount === 0) console.warn(`${count  } ${  user._id}`);
+  if (msgCount % progressCount === 0) console.warn(`${msgCount  } messages processed`);
+  if (user._id === authorUuid) console.warn(`${authorName  } being processed`);
+
+  const oldInboxMessages = user.inbox.messages || {};
+  const oldInboxMessagesIds = Object.keys(oldInboxMessages);
+
+  msgCount += oldInboxMessagesIds.length;
+
+  const newInboxMessages = oldInboxMessagesIds.map(msgId => {
+    const msg = oldInboxMessages[msgId];
+    if (!msg || (!msg.id && !msg._id)) { // eslint-disable-line no-extra-parens
+      console.log('missing message or message _id and id', msg);
+      throw new Error('error!');
+    }
+
+    if (msg.id && !msg._id) msg._id = msg.id;
+    if (msg._id && !msg.id) msg.id = msg._id;
+
+    const newMsg = new Inbox(msg);
+    newMsg.ownerId = user._id;
+    return newMsg.toJSON();
+  });
+
+  return dbInboxes.insert(newInboxMessages)
+    .then(() => {
+      return dbUsers.update({_id: user._id}, {
+        $set: {
+          migration: migrationName,
+          'inbox.messages': {},
+        },
+      });
+    })
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+function displayData () {
+  console.warn(`\n${  count  } users processed\n`);
+  console.warn(`\n${  msgCount  } messages processed\n`);
+  return exiting(0);
+}
+
+function exiting (code, msg) {
+  code = code || 0; // 0 = success
+  if (code && !msg) {
+    msg = 'ERROR!';
+  }
+  if (msg) {
+    if (code) {
+      console.error(msg);
+    } else      {
+      console.log(msg);
+    }
+  }
+  process.exit(code);
+}
+
+module.exports = processUsers;

migrations/groups/reconcile-group-plan-members.js

@@ -0,0 +1,107 @@
+import monk from 'monk';
+import nconf from 'nconf';
+import stripePayments from '../../website/server/libs/payments/stripe';
+
+/*
+ * Ensure that group plan billing is accurate by doing the following:
+ * 1. Correct the memberCount in all paid groups whose counts are wrong
+ * 2. Where the above uses Stripe, update their subscription counts in Stripe
+ *
+ * Provides output on what groups were fixed, which can be piped to CSV.
+ */
+
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING');
+
+let dbGroups = monk(CONNECTION_STRING).get('groups', { castIds: false });
+let dbUsers = monk(CONNECTION_STRING).get('users', { castIds: false });
+
+async function fixGroupPlanMembers () {
+  console.info('Group ID, Customer ID, Plan ID, Quantity, Recorded Member Count, Actual Member Count');
+  let groupPlanCount = 0;
+  let fixedGroupCount = 0;
+
+  dbGroups.find(
+    {
+      $and:
+        [
+          {'purchased.plan.planId': {$ne: null}},
+          {'purchased.plan.planId': {$ne: ''}},
+          {'purchased.plan.customerId': {$ne: 'cus_9f0DV4g7WHRzpM'}}, // Demo groups
+          {'purchased.plan.customerId': {$ne: 'cus_9maalqDOFTrvqx'}},
+        ],
+      $or:
+        [
+          {'purchased.plan.dateTerminated': null},
+          {'purchased.plan.dateTerminated': ''},
+        ],
+    },
+    {
+      fields: {
+        memberCount: 1,
+        'purchased.plan': 1,
+      },
+    }
+  ).each(async (group, {close, pause, resume}) => { // eslint-disable-line no-unused-vars
+    pause();
+    groupPlanCount++;
+
+    const canonicalMemberCount = await dbUsers.count(
+      {
+        $or:
+          [
+            {'party._id': group._id},
+            {guilds: group._id},
+          ],
+      }
+    );
+    const incorrectMemberCount = group.memberCount !== canonicalMemberCount;
+
+    const isMonthlyPlan = group.purchased.plan.planId === 'group_monthly';
+    const quantityMismatch = group.purchased.plan.quantity !== group.memberCount + 2;
+    const incorrectQuantity = isMonthlyPlan && quantityMismatch;
+
+    if (!incorrectMemberCount && !incorrectQuantity) {
+      resume();
+      return;
+    }
+
+    console.info(`${group._id}, ${group.purchased.plan.customerId}, ${group.purchased.plan.planId}, ${group.purchased.plan.quantity}, ${group.memberCount}, ${canonicalMemberCount}`);
+
+    const groupUpdate = await dbGroups.update(
+      { _id: group._id },
+      {
+        $set: {
+          memberCount: canonicalMemberCount,
+        },
+      }
+    );
+
+    if (!groupUpdate) return;
+
+    fixedGroupCount++;
+    if (group.purchased.plan.paymentMethod === 'Stripe') {
+      await stripePayments.chargeForAdditionalGroupMember(group);
+      await dbGroups.update(
+        {_id: group._id},
+        {$set: {'purchased.plan.quantity': canonicalMemberCount + 2}}
+      );
+    }
+
+    if (incorrectQuantity) {
+      await dbGroups.update(
+        {_id: group._id},
+        {$set: {'purchased.plan.quantity': canonicalMemberCount + 2}}
+      );
+    }
+
+    resume();
+  }).then(() => {
+    console.info(`Fixed ${fixedGroupCount} out of ${groupPlanCount} active Group Plans`);
+    return process.exit(0);
+  }).catch((err) => {
+    console.log(err);
+    return process.exit(1);
+  });
+}
+
+module.exports = fixGroupPlanMembers;

migrations/migration-runner.js

@@ -17,5 +17,5 @@ function setUpServer () {
 setUpServer();
 
 // Replace this with your migration
-const processUsers = require('./groups/migrate-chat.js');
+const processUsers = require('./users/takeThis.js');
 processUsers();

migrations/tasks/habits-one-history-entry-per-day-challenges.js

@@ -0,0 +1,138 @@
+// const migrationName = 'habits-one-history-entry-per-day';
+// const authorName = 'paglias'; // in case script author needs to know when their ...
+// const authorUuid = 'ed4c688c-6652-4a92-9d03-a5a79844174a'; // ... own data is done
+
+/*
+ * Iterates over all habits and condense multiple history entries for the same day into a single entry
+ */
+
+const monk = require('monk');
+const _ = require('lodash');
+const moment = require('moment');
+const connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
+const dbTasks = monk(connectionString).get('tasks', { castIds: false });
+
+function processChallengeHabits (lastId) {
+  let query = {
+    'challenge.id': {$exists: true},
+    userId: {$exists: false},
+    type: 'habit',
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbTasks.find(query, {
+    sort: {_id: 1},
+    limit: 500,
+  })
+    .then(updateChallengeHabits)
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+let progressCount = 1000;
+let count = 0;
+
+function updateChallengeHabits (habits) {
+  if (!habits || habits.length === 0) {
+    console.warn('All appropriate challenge habits found and modified.');
+    displayData();
+    return;
+  }
+
+  let habitsPromises = habits.map(updateChallengeHabit);
+  let lastHabit = habits[habits.length - 1];
+
+  return Promise.all(habitsPromises)
+    .then(() => {
+      return processChallengeHabits(lastHabit._id);
+    });
+}
+
+function updateChallengeHabit (habit) {
+  count++;
+
+  if (habit && habit.history && habit.history.length > 0) {
+    // First remove missing entries
+    habit.history = habit.history.filter(entry => Boolean(entry));
+
+    habit.history = _.chain(habit.history)
+      // processes all entries to identify an up or down score
+      .forEach((entry, index) => {
+        if (index === 0) { // first entry doesn't have a previous one
+          // first value < 0 identifies a negative score as the first action
+          entry.scoreDirection = entry.value >= 0 ? 'up' : 'down';
+        } else {
+          // could be missing if the previous entry was null and thus excluded
+          const previousEntry = habit.history[index - 1];
+          const previousValue = previousEntry.value;
+
+          entry.scoreDirection = entry.value > previousValue ? 'up' : 'down';
+        }
+      })
+      .groupBy(entry => { // group entries by aggregateBy
+        return moment(entry.date).format('YYYYMMDD');
+      })
+      .toPairs() // [key, entry]
+      .sortBy(([key]) => key) // sort by date
+      .map(keyEntryPair => {
+        let entries = keyEntryPair[1]; // 1 is entry, 0 is key
+        let scoredUp = 0;
+        let scoredDown = 0;
+
+        entries.forEach(entry => {
+          if (entry.scoreDirection === 'up') {
+            scoredUp += 1;
+          } else {
+            scoredDown += 1;
+          }
+
+          // delete the unnecessary scoreDirection and scoreNotes prop
+          delete entry.scoreDirection;
+          delete entry.scoreNotes;
+        });
+
+        return {
+          date: Number(entries[entries.length - 1].date), // keep last value
+          value: entries[entries.length - 1].value, // keep last value,
+          scoredUp,
+          scoredDown,
+        };
+      })
+      .value();
+
+    return dbTasks.update({_id: habit._id}, {
+      $set: {history: habit.history},
+    });
+  }
+
+  if (count % progressCount === 0) console.warn(`${count  } habits processed`);
+}
+
+function displayData () {
+  console.warn(`\n${  count  } tasks processed\n`);
+  return exiting(0);
+}
+
+function exiting (code, msg) {
+  code = code || 0; // 0 = success
+  if (code && !msg) {
+    msg = 'ERROR!';
+  }
+  if (msg) {
+    if (code) {
+      console.error(msg);
+    } else      {
+      console.log(msg);
+    }
+  }
+  process.exit(code);
+}
+
+module.exports = processChallengeHabits;

migrations/tasks/habits-one-history-entry-per-day-users.js

@@ -0,0 +1,163 @@
+const migrationName = 'habits-one-history-entry-per-day';
+const authorName = 'paglias'; // in case script author needs to know when their ...
+const authorUuid = 'ed4c688c-6652-4a92-9d03-a5a79844174a'; // ... own data is done
+
+/*
+ * Iterates over all habits and condense multiple history entries for the same day into a single entry
+ */
+
+const monk = require('monk');
+const _ = require('lodash');
+const moment = require('moment');
+const connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
+const dbTasks = monk(connectionString).get('tasks', { castIds: false });
+const dbUsers = monk(connectionString).get('users', { castIds: false });
+
+function processUsers (lastId) {
+  let query = {
+    migration: {$ne: migrationName},
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 50, // just 50 users per time since we have to process all their habits as well
+    fields: ['_id', 'preferences.timezoneOffset', 'preferences.dayStart'],
+  })
+    .then(updateUsers)
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+let progressCount = 1000;
+let count = 0;
+
+function updateUsers (users) {
+  if (!users || users.length === 0) {
+    console.warn('All appropriate users and their tasks found and modified.');
+    displayData();
+    return;
+  }
+
+  let usersPromises = users.map(updateUser);
+  let lastUser = users[users.length - 1];
+
+  return Promise.all(usersPromises)
+    .then(() => {
+      return processUsers(lastUser._id);
+    });
+}
+
+function updateHabit (habit, timezoneOffset, dayStart) {
+  if (habit && habit.history && habit.history.length > 0) {
+    // First remove missing entries
+    habit.history = habit.history.filter(entry => Boolean(entry));
+
+    habit.history = _.chain(habit.history)
+      // processes all entries to identify an up or down score
+      .forEach((entry, index) => {
+        if (index === 0) { // first entry doesn't have a previous one
+          // first value < 0 identifies a negative score as the first action
+          entry.scoreDirection = entry.value >= 0 ? 'up' : 'down';
+        } else {
+          // could be missing if the previous entry was null and thus excluded
+          const previousEntry = habit.history[index - 1];
+          const previousValue = previousEntry.value;
+
+          entry.scoreDirection = entry.value > previousValue ? 'up' : 'down';
+        }
+      })
+      .groupBy(entry => { // group entries by aggregateBy
+        const entryDate = moment(entry.date).zone(timezoneOffset || 0);
+        if (entryDate.hour() < dayStart) entryDate.subtract(1, 'day');
+        return entryDate.format('YYYYMMDD');
+      })
+      .toPairs() // [key, entry]
+      .sortBy(([key]) => key) // sort by date
+      .map(keyEntryPair => {
+        let entries = keyEntryPair[1]; // 1 is entry, 0 is key
+        let scoredUp = 0;
+        let scoredDown = 0;
+
+        entries.forEach(entry => {
+          if (entry.scoreDirection === 'up') {
+            scoredUp += 1;
+          } else {
+            scoredDown += 1;
+          }
+
+          // delete the unnecessary scoreDirection and scoreNotes prop
+          delete entry.scoreDirection;
+          delete entry.scoreNotes;
+        });
+
+        return {
+          date: Number(entries[entries.length - 1].date), // keep last value
+          value: entries[entries.length - 1].value, // keep last value,
+          scoredUp,
+          scoredDown,
+        };
+      })
+      .value();
+
+    return dbTasks.update({_id: habit._id}, {
+      $set: {history: habit.history},
+    });
+  }
+}
+
+function updateUser (user) {
+  count++;
+
+  const timezoneOffset = user.preferences.timezoneOffset;
+  const dayStart = user.preferences.dayStart;
+
+  if (count % progressCount === 0) console.warn(`${count  } ${  user._id}`);
+  if (user._id === authorUuid) console.warn(`${authorName  } being processed`);
+
+  return dbTasks.find({
+    type: 'habit',
+    userId: user._id,
+  })
+    .then(habits => {
+      return Promise.all(habits.map(habit => updateHabit(habit, timezoneOffset, dayStart)));
+    })
+    .then(() => {
+      return dbUsers.update({_id: user._id}, {
+        $set: {migration: migrationName},
+      });
+    })
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+function displayData () {
+  console.warn(`\n${  count  } tasks processed\n`);
+  return exiting(0);
+}
+
+function exiting (code, msg) {
+  code = code || 0; // 0 = success
+  if (code && !msg) {
+    msg = 'ERROR!';
+  }
+  if (msg) {
+    if (code) {
+      console.error(msg);
+    } else      {
+      console.log(msg);
+    }
+  }
+  process.exit(code);
+}
+
+module.exports = processUsers;

migrations/tasks/tasks-set-everyX.js

@@ -7,7 +7,7 @@ let authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
  */
 
 let monk = require('monk');
-let connectionString = 'mongodb://sabrecat:z8e8jyRA8CTofMQ@ds013393-a0.mlab.com:13393/habitica?auto_reconnect=true';
+let connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true';
 let dbTasks = monk(connectionString).get('tasks', { castIds: false });
 
 function processTasks (lastId) {

migrations/users/generate-usernames.js

@@ -0,0 +1,99 @@
+let authorName = 'Sabe'; // in case script author needs to know when their ...
+let authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
+
+/*
+ * Generate usernames for users who lack them
+ */
+
+import monk from 'monk';
+import nconf from 'nconf';
+import { generateUsername } from '../../website/server/libs/auth/utils';
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING'); // FOR TEST DATABASE
+let dbUsers = monk(CONNECTION_STRING).get('users', { castIds: false });
+
+function processUsers (lastId) {
+  // specify a query to limit the affected users (empty for all users):
+  let query = {
+    'auth.local.username': {$exists: false},
+    'auth.timestamps.loggedin': {$gt: new Date('2018-04-01')}, // Initial coverage for users active within last 6 months
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 250,
+    fields: [
+      'auth',
+    ], // specify fields we are interested in to limit retrieved data (empty if we're not reading data):
+  })
+    .then(updateUsers)
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+let progressCount = 1000;
+let count = 0;
+
+function updateUsers (users) {
+  if (!users || users.length === 0) {
+    console.warn('All appropriate users found and modified.');
+    displayData();
+    return;
+  }
+
+  let userPromises = users.map(updateUser);
+  let lastUser = users[users.length - 1];
+
+  return Promise.all(userPromises)
+    .then(() => {
+      processUsers(lastUser._id);
+    });
+}
+
+function updateUser (user) {
+  count++;
+
+  if (!user.auth.local.username) {
+    const newName = generateUsername();
+    dbUsers.update(
+      {_id: user._id},
+      {$set:
+        {
+          'auth.local.username': newName,
+          'auth.local.lowerCaseUsername': newName,
+        },
+      }
+    );
+  }
+  if (count % progressCount === 0) console.warn(`${count  } ${  user._id}`);
+  if (user._id === authorUuid) console.warn(`${authorName  } processed`);
+}
+
+function displayData () {
+  console.warn(`\n${  count  } users processed\n`);
+  return exiting(0);
+}
+
+function exiting (code, msg) {
+  code = code || 0; // 0 = success
+  if (code && !msg) {
+    msg = 'ERROR!';
+  }
+  if (msg) {
+    if (code) {
+      console.error(msg);
+    } else      {
+      console.log(msg);
+    }
+  }
+  process.exit(code);
+}
+
+module.exports = processUsers;

migrations/users/mystery-items.js

@@ -1,15 +1,17 @@
-const migrationName = 'mystery-items-201805.js'; // Update per month
+import monk from 'monk';
+import nconf from 'nconf';
+
+const migrationName = 'mystery-items-201808.js'; // Update per month
 const authorName = 'Sabe'; // in case script author needs to know when their ...
 const authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
 
 /*
  * Award this month's mystery items to subscribers
  */
-const MYSTERY_ITEMS = ['back_mystery_201805', 'head_mystery_201805'];
-const connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
+const MYSTERY_ITEMS = ['armor_mystery_201809', 'head_mystery_201809'];
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING');
 
-let monk = require('monk');
-let dbUsers = monk(connectionString).get('users', { castIds: false });
+let dbUsers = monk(CONNECTION_STRING).get('users', { castIds: false });
 let UserNotification = require('../../website/server/models/userNotification').model;
 
 function processUsers (lastId) {

migrations/users/naming-day.js

@@ -0,0 +1,123 @@
+let migrationName = '20180731_naming-day.js'; // Update when running in future years
+let authorName = 'Sabe'; // in case script author needs to know when their ...
+let authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
+
+/*
+ * Award Naming Day ladder items to participants in this month's Naming Day festivities
+ */
+
+import monk from 'monk';
+import nconf from 'nconf';
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING'); // FOR TEST DATABASE
+let dbUsers = monk(CONNECTION_STRING).get('users', { castIds: false });
+
+function processUsers (lastId) {
+  // specify a query to limit the affected users (empty for all users):
+  let query = {
+    migration: {$ne: migrationName},
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 250,
+    fields: [
+      'items.gear.owned',
+      'items.mounts',
+      'items.pets',
+    ], // specify fields we are interested in to limit retrieved data (empty if we're not reading data):
+  })
+    .then(updateUsers)
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+let progressCount = 1000;
+let count = 0;
+
+function updateUsers (users) {
+  if (!users || users.length === 0) {
+    console.warn('All appropriate users found and modified.');
+    displayData();
+    return;
+  }
+
+  let userPromises = users.map(updateUser);
+  let lastUser = users[users.length - 1];
+
+  return Promise.all(userPromises)
+    .then(() => {
+      processUsers(lastUser._id);
+    });
+}
+
+function updateUser (user) {
+  count++;
+
+  let set = {};
+  let push;
+
+  const inc = {
+    'items.food.Cake_Base': 1,
+    'items.food.Cake_CottonCandyBlue': 1,
+    'items.food.Cake_CottonCandyPink': 1,
+    'items.food.Cake_Desert': 1,
+    'items.food.Cake_Golden': 1,
+    'items.food.Cake_Red': 1,
+    'items.food.Cake_Shade': 1,
+    'items.food.Cake_Skeleton': 1,
+    'items.food.Cake_White': 1,
+    'items.food.Cake_Zombie': 1,
+    'achievements.habiticaDays': 1,
+  };
+
+  if (user && user.items && user.items.gear && user.items.gear.owned && typeof user.items.gear.owned.head_special_namingDay2017 !== 'undefined') {
+    set = {migration: migrationName, 'items.gear.owned.body_special_namingDay2018': false};
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.body_special_namingDay2018', _id: monk.id()}};
+  } else if (user && user.items && user.items.pets && typeof user.items.pets['Gryphon-RoyalPurple'] !== 'undefined') {
+    set = {migration: migrationName, 'items.gear.owned.head_special_namingDay2017': false};
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.head_special_namingDay2017', _id: monk.id()}};
+  } else if (user && user.items && user.items.mounts && typeof user.items.mounts['Gryphon-RoyalPurple'] !== 'undefined') {
+    set = {migration: migrationName, 'items.pets.Gryphon-RoyalPurple': 5};
+  } else {
+    set = {migration: migrationName, 'items.mounts.Gryphon-RoyalPurple': true};
+  }
+
+  if (push) {
+    dbUsers.update({_id: user._id}, {$set: set, $push: push, $inc: inc});
+  } else {
+    dbUsers.update({_id: user._id}, {$set: set, $inc: inc});
+  }
+
+  if (count % progressCount === 0) console.warn(`${count  } ${  user._id}`);
+  if (user._id === authorUuid) console.warn(`${authorName  } processed`);
+}
+
+function displayData () {
+  console.warn(`\n${  count  } users processed\n`);
+  return exiting(0);
+}
+
+function exiting (code, msg) {
+  code = code || 0; // 0 = success
+  if (code && !msg) {
+    msg = 'ERROR!';
+  }
+  if (msg) {
+    if (code) {
+      console.error(msg);
+    } else      {
+      console.log(msg);
+    }
+  }
+  process.exit(code);
+}
+
+module.exports = processUsers;

migrations/users/remove-social-users-extra-data.js

@@ -0,0 +1,109 @@
+const migrationName = 'remove-social-users-extra-data.js';
+const authorName = 'paglias'; // in case script author needs to know when their ...
+const authorUuid = 'ed4c688c-6652-4a92-9d03-a5a79844174a'; // ... own data is done
+
+/*
+ * Remove not needed data from social profiles
+ */
+const connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
+
+const monk = require('monk');
+const dbUsers = monk(connectionString).get('users', { castIds: false });
+
+function processUsers (lastId) {
+  // specify a query to limit the affected users (empty for all users):
+  let query = {
+    migration: {$ne: migrationName},
+    $or: [
+      { 'auth.facebook.id': { $exists: true } },
+      { 'auth.google.id': { $exists: true } },
+    ],
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 250,
+  })
+    .then(updateUsers)
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+let progressCount = 1000;
+let count = 0;
+
+function updateUsers (users) {
+  if (!users || users.length === 0) {
+    console.warn('All appropriate users found and modified.');
+    displayData();
+    return;
+  }
+
+  let userPromises = users.map(updateUser);
+  let lastUser = users[users.length - 1];
+
+  return Promise.all(userPromises)
+    .then(() => {
+      processUsers(lastUser._id);
+    });
+}
+
+function updateUser (user) {
+  count++;
+
+  const isFacebook = user.auth.facebook && user.auth.facebook.id;
+  const isGoogle = user.auth.google && user.auth.google.id;
+
+  const update = { $set: {} };
+
+  if (isFacebook) {
+    update.$set['auth.facebook'] = {
+      id: user.auth.facebook.id,
+      emails: user.auth.facebook.emails,
+    };
+  }
+
+  if (isGoogle) {
+    update.$set['auth.google'] = {
+      id: user.auth.google.id,
+      emails: user.auth.google.emails,
+    };
+  }
+
+  dbUsers.update({
+    _id: user._id,
+  }, update);
+
+  if (count % progressCount === 0) console.warn(`${count  } ${  user._id}`);
+  if (user._id === authorUuid) console.warn(`${authorName  } processed`);
+}
+
+function displayData () {
+  console.warn(`\n${  count  } users processed\n`);
+  return exiting(0);
+}
+
+function exiting (code, msg) {
+  code = code || 0; // 0 = success
+  if (code && !msg) {
+    msg = 'ERROR!';
+  }
+  if (msg) {
+    if (code) {
+      console.error(msg);
+    } else      {
+      console.log(msg);
+    }
+  }
+  process.exit(code);
+}
+
+module.exports = processUsers;

migrations/users/summer-splash-orcas.js

@@ -0,0 +1,99 @@
+let migrationName = '20180724_summer-splash-orcas.js'; // Update per month
+let authorName = 'Sabe'; // in case script author needs to know when their ...
+let authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
+
+/*
+ * Award ladder items to participants in this year's Summer Splash festivities
+ */
+
+import monk from 'monk';
+import nconf from 'nconf';
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING');
+let dbUsers = monk(CONNECTION_STRING).get('users', { castIds: false });
+
+function processUsers (lastId) {
+  // specify a query to limit the affected users (empty for all users):
+  let query = {
+    migration: {$ne: migrationName},
+    'auth.timestamps.loggedin': {$gt: new Date('2018-07-01')}, // rerun without date restriction after initial run
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 250,
+    fields: [
+      'items.mounts',
+    ], // specify fields we are interested in to limit retrieved data (empty if we're not reading data):
+  })
+    .then(updateUsers)
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+let progressCount = 1000;
+let count = 0;
+
+function updateUsers (users) {
+  if (!users || users.length === 0) {
+    console.warn('All appropriate users found and modified.');
+    displayData();
+    return;
+  }
+
+  let userPromises = users.map(updateUser);
+  let lastUser = users[users.length - 1];
+
+  return Promise.all(userPromises)
+    .then(() => {
+      processUsers(lastUser._id);
+    });
+}
+
+function updateUser (user) {
+  count++;
+
+  let set = {};
+
+  if (user && user.items && user.items.pets && typeof user.items.pets['Orca-Base'] !== 'undefined') {
+    set = {migration: migrationName};
+  } else if (user && user.items && user.items.mounts && typeof user.items.mounts['Orca-Base'] !== 'undefined') {
+    set = {migration: migrationName, 'items.pets.Orca-Base': 5};
+  } else {
+    set = {migration: migrationName, 'items.mounts.Orca-Base': true};
+  }
+
+  dbUsers.update({_id: user._id}, {$set: set});
+
+  if (count % progressCount === 0) console.warn(`${count  } ${  user._id}`);
+  if (user._id === authorUuid) console.warn(`${authorName  } processed`);
+}
+
+function displayData () {
+  console.warn(`\n${  count  } users processed\n`);
+  return exiting(0);
+}
+
+function exiting (code, msg) {
+  code = code || 0; // 0 = success
+  if (code && !msg) {
+    msg = 'ERROR!';
+  }
+  if (msg) {
+    if (code) {
+      console.error(msg);
+    } else      {
+      console.log(msg);
+    }
+  }
+  process.exit(code);
+}
+
+module.exports = processUsers;

migrations/users/takeThis.js

@@ -1,4 +1,4 @@
-let migrationName = '20180102_takeThis.js'; // Update per month
+let migrationName = '20180904_takeThis.js'; // Update per month
 let authorName = 'Sabe'; // in case script author needs to know when their ...
 let authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
 
@@ -6,15 +6,16 @@ let authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
  * Award Take This ladder items to participants in this month's challenge
  */
 
-let monk = require('monk');
-let connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
-let dbUsers = monk(connectionString).get('users', { castIds: false });
+import monk from 'monk';
+import nconf from 'nconf';
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING'); // FOR TEST DATABASE
+let dbUsers = monk(CONNECTION_STRING).get('users', { castIds: false });
 
 function processUsers (lastId) {
   // specify a query to limit the affected users (empty for all users):
   let query = {
     migration: {$ne: migrationName},
-    challenges: {$in: ['5f70ce5b-2d82-4114-8e44-ca65615aae62']}, // Update per month
+    challenges: {$in: ['1044ec0c-4a85-48c5-9f36-d51c0c62c7d3']}, // Update per month
   };
 
   if (lastId) {

package.json

@@ -1,7 +1,7 @@
 {
   "name": "habitica",
   "description": "A habit tracker app which treats your goals like a Role Playing Game.",
-  "version": "4.43.1",
+  "version": "4.65.2",
   "main": "./website/server/index.js",
   "dependencies": {
     "@slack/client": "^3.8.1",
@@ -9,6 +9,7 @@
     "amazon-payments": "^0.2.7",
     "amplitude": "^3.5.0",
     "apidoc": "^0.17.5",
+    "apn": "^2.2.0",
     "autoprefixer": "^8.5.0",
     "aws-sdk": "^2.239.1",
     "axios": "^0.18.0",
@@ -25,7 +26,7 @@
     "babel-preset-es2015": "^6.6.0",
     "babel-register": "^6.6.0",
     "babel-runtime": "^6.11.6",
-    "bcrypt": "^2.0.0",
+    "bcrypt": "^3.0.1",
     "body-parser": "^1.18.3",
     "bootstrap": "^4.1.1",
     "bootstrap-vue": "^2.0.0-rc.9",
@@ -34,7 +35,7 @@
     "coupon-code": "^0.4.5",
     "cross-env": "^5.1.5",
     "css-loader": "^0.28.11",
-    "csv-stringify": "^2.1.0",
+    "csv-stringify": "^3.0.0",
     "cwait": "^1.1.1",
     "domain-middleware": "~0.1.0",
     "express": "^4.16.3",
@@ -42,7 +43,7 @@
     "express-validator": "^5.2.0",
     "extract-text-webpack-plugin": "^3.0.2",
     "glob": "^7.1.2",
-    "got": "^8.3.1",
+    "got": "^9.0.0",
     "gulp": "^4.0.0",
     "gulp-babel": "^7.0.1",
     "gulp-imagemin": "^4.1.0",
@@ -61,7 +62,7 @@
     "method-override": "^2.3.5",
     "moment": "^2.22.1",
     "moment-recur": "^1.0.7",
-    "mongoose": "^5.1.1",
+    "mongoose": "^5.1.3",
     "morgan": "^1.7.0",
     "nconf": "^0.10.0",
     "node-gcm": "^0.14.4",
@@ -78,11 +79,12 @@
     "postcss-easy-import": "^3.0.0",
     "ps-tree": "^1.0.0",
     "pug": "^2.0.3",
-    "push-notify": "git://github.com/habitrpg/push-notify.git#6bc2b5fdb1bdc9649b9ec1964d79ca50187fc8a9",
     "pusher": "^1.3.0",
     "rimraf": "^2.4.3",
     "sass-loader": "^7.0.0",
     "shelljs": "^0.8.2",
+    "short-uuid": "^3.0.0",
+    "smartbanner.js": "^1.9.1",
     "stripe": "^5.9.0",
     "superagent": "^3.8.3",
     "svg-inline-loader": "^0.8.0",
@@ -90,10 +92,12 @@
     "svgo": "^1.0.5",
     "svgo-loader": "^2.1.0",
     "universal-analytics": "^0.4.16",
+    "update": "^0.7.4",
+    "upgrade": "^1.1.0",
     "url-loader": "^1.0.0",
     "useragent": "^2.1.9",
     "uuid": "^3.0.1",
-    "validator": "^9.4.1",
+    "validator": "^10.5.0",
     "vinyl-buffer": "^1.0.1",
     "vue": "^2.5.16",
     "vue-loader": "^14.2.2",
@@ -119,9 +123,11 @@
     "test": "npm run lint && gulp test && gulp apidoc",
     "test:build": "gulp test:prepare:build",
     "test:api-v3": "gulp test:api-v3",
-    "test:api-v3:unit": "gulp test:api-v3:unit",
+    "test:api:unit": "gulp test:api:unit",
     "test:api-v3:integration": "gulp test:api-v3:integration",
     "test:api-v3:integration:separate-server": "NODE_ENV=test gulp test:api-v3:integration:separate-server",
+    "test:api-v4:integration": "gulp test:api-v4:integration",
+    "test:api-v4:integration:separate-server": "NODE_ENV=test gulp test:api-v4:integration:separate-server",
     "test:sanity": "istanbul cover --dir coverage/sanity --report lcovonly node_modules/mocha/bin/_mocha -- test/sanity --recursive",
     "test:common": "istanbul cover --dir coverage/common --report lcovonly node_modules/mocha/bin/_mocha -- test/common --recursive",
     "test:content": "istanbul cover --dir coverage/content --report lcovonly node_modules/mocha/bin/_mocha -- test/content --recursive",
@@ -159,19 +165,19 @@
     "expect.js": "^0.3.1",
     "http-proxy-middleware": "^0.18.0",
     "istanbul": "^1.1.0-alpha.1",
-    "karma": "^2.0.2",
+    "karma": "^3.0.0",
     "karma-babel-preprocessor": "^7.0.0",
     "karma-chai-plugins": "^0.9.0",
     "karma-chrome-launcher": "^2.2.0",
     "karma-coverage": "^1.1.2",
     "karma-mocha": "^1.3.0",
     "karma-mocha-reporter": "^2.2.5",
-    "karma-sinon-chai": "^1.3.4",
+    "karma-sinon-chai": "^2.0.0",
     "karma-sinon-stub-promise": "^1.0.0",
     "karma-sourcemap-loader": "^0.3.7",
     "karma-spec-reporter": "0.0.32",
     "karma-webpack": "^3.0.0",
-    "lcov-result-merger": "^2.0.0",
+    "lcov-result-merger": "^3.0.0",
     "mocha": "^5.1.1",
     "monk": "^6.0.6",
     "nightwatch": "^0.9.21",

test/api/unit/libs/analyticsService.test.js

@@ -1,5 +1,5 @@
 /* eslint-disable camelcase */
-import analyticsService from '../../../../../website/server/libs/analyticsService';
+import analyticsService from '../../../../website/server/libs/analyticsService';
 import Amplitude from 'amplitude';
 import { Visitor } from 'universal-analytics';
 

test/api/unit/libs/apiError.js

@@ -1,4 +1,4 @@
-import apiError from '../../../../../website/server/libs/apiError';
+import apiError from '../../../../website/server/libs/apiError';
 
 describe('API Messages', () => {
   const message = 'Only public guilds support pagination.';

test/api/unit/libs/baseModel.test.js

@@ -1,4 +1,4 @@
-import baseModel from '../../../../../website/server/libs/baseModel';
+import baseModel from '../../../../website/server/libs/baseModel';
 import mongoose from 'mongoose';
 
 describe('Base model plugin', () => {

test/api/unit/libs/collectionManipulators.test.js

@@ -1,7 +1,7 @@
 import mongoose from 'mongoose';
 import {
   removeFromArray,
-} from '../../../../../website/server/libs/collectionManipulators';
+} from '../../../../website/server/libs/collectionManipulators';
 
 describe('Collection Manipulators', () => {
   describe('removeFromArray', () => {

test/api/unit/libs/cron.test.js

@@ -2,17 +2,18 @@
 import moment from 'moment';
 import nconf from 'nconf';
 import requireAgain from 'require-again';
-import { recoverCron, cron } from '../../../../../website/server/libs/cron';
-import { model as User } from '../../../../../website/server/models/user';
-import * as Tasks from '../../../../../website/server/models/task';
-import common from '../../../../../website/common';
-import analytics from '../../../../../website/server/libs/analyticsService';
+import { recoverCron, cron } from '../../../../website/server/libs/cron';
+import { model as User } from '../../../../website/server/models/user';
+import * as Tasks from '../../../../website/server/models/task';
+import common from '../../../../website/common';
+import analytics from '../../../../website/server/libs/analyticsService';
 
 // const scoreTask = common.ops.scoreTask;
 
-let pathToCronLib = '../../../../../website/server/libs/cron';
+let pathToCronLib = '../../../../website/server/libs/cron';
 
 describe('cron', () => {
+  let clock = null;
   let user;
   let tasksByType = {habits: [], dailys: [], todos: [], rewards: []};
   let daysMissed = 0;
@@ -34,6 +35,8 @@ describe('cron', () => {
   });
 
   afterEach(() => {
+    if (clock !== null)
+      clock.restore();
     analytics.track.restore();
   });
 
@@ -62,6 +65,12 @@ describe('cron', () => {
     expect(analytics.track.callCount).to.equal(1);
   });
 
+  it('calls analytics when user is sleeping', () => {
+    user.preferences.sleep = true;
+    cron({user, tasksByType, daysMissed, analytics});
+    expect(analytics.track.callCount).to.equal(1);
+  });
+
   describe('end of the month perks', () => {
     beforeEach(() => {
       user.purchased.plan.customerId = 'subscribedId';
@@ -82,14 +91,12 @@ describe('cron', () => {
     });
 
     it('does not reset plan.gemsBought within the month', () => {
-      let clock = sinon.useFakeTimers(moment().startOf('month').add(2, 'days').toDate());
+      clock = sinon.useFakeTimers(moment().startOf('month').add(2, 'days').toDate());
       user.purchased.plan.dateUpdated = moment().startOf('month').toDate();
 
       user.purchased.plan.gemsBought = 10;
       cron({user, tasksByType, daysMissed, analytics});
       expect(user.purchased.plan.gemsBought).to.equal(10);
-
-      clock.restore();
     });
 
     it('resets plan.dateUpdated on a new month', () => {
@@ -156,7 +163,6 @@ describe('cron', () => {
     });
 
     describe('for a 1-month recurring subscription', () => {
-      let clock;
       // create a user that will be used for all of these tests without a reset before each
       let user1 = new User({
         auth: {
@@ -187,7 +193,6 @@ describe('cron', () => {
         expect(user1.purchased.plan.consecutive.offset).to.equal(0);
         expect(user1.purchased.plan.consecutive.trinkets).to.equal(0);
         expect(user1.purchased.plan.consecutive.gemCapExtra).to.equal(0);
-        clock.restore();
       });
 
       it('does not increment consecutive benefits after the second month', () => {
@@ -199,7 +204,6 @@ describe('cron', () => {
         expect(user1.purchased.plan.consecutive.offset).to.equal(0);
         expect(user1.purchased.plan.consecutive.trinkets).to.equal(0);
         expect(user1.purchased.plan.consecutive.gemCapExtra).to.equal(0);
-        clock.restore();
       });
 
       it('increments consecutive benefits after the third month', () => {
@@ -211,7 +215,6 @@ describe('cron', () => {
         expect(user1.purchased.plan.consecutive.offset).to.equal(0);
         expect(user1.purchased.plan.consecutive.trinkets).to.equal(1);
         expect(user1.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
       });
 
       it('does not increment consecutive benefits after the fourth month', () => {
@@ -223,7 +226,6 @@ describe('cron', () => {
         expect(user1.purchased.plan.consecutive.offset).to.equal(0);
         expect(user1.purchased.plan.consecutive.trinkets).to.equal(1);
         expect(user1.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
       });
 
       it('increments consecutive benefits correctly if user has been absent with continuous subscription', () => {
@@ -233,12 +235,10 @@ describe('cron', () => {
         expect(user1.purchased.plan.consecutive.offset).to.equal(0);
         expect(user1.purchased.plan.consecutive.trinkets).to.equal(3);
         expect(user1.purchased.plan.consecutive.gemCapExtra).to.equal(15);
-        clock.restore();
       });
     });
 
     describe('for a 3-month recurring subscription', () => {
-      let clock;
       let user3 = new User({
         auth: {
           local: {
@@ -266,7 +266,6 @@ describe('cron', () => {
         expect(user3.purchased.plan.consecutive.offset).to.equal(2);
         expect(user3.purchased.plan.consecutive.trinkets).to.equal(1);
         expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
       });
 
       it('does not increment consecutive benefits in the middle of the period that they already have benefits for', () => {
@@ -276,7 +275,6 @@ describe('cron', () => {
         expect(user3.purchased.plan.consecutive.offset).to.equal(1);
         expect(user3.purchased.plan.consecutive.trinkets).to.equal(1);
         expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
       });
 
       it('does not increment consecutive benefits in the final month of the period that they already have benefits for', () => {
@@ -286,7 +284,6 @@ describe('cron', () => {
         expect(user3.purchased.plan.consecutive.offset).to.equal(0);
         expect(user3.purchased.plan.consecutive.trinkets).to.equal(1);
         expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
       });
 
       it('increments consecutive benefits the month after the second paid period has started', () => {
@@ -296,7 +293,6 @@ describe('cron', () => {
         expect(user3.purchased.plan.consecutive.offset).to.equal(2);
         expect(user3.purchased.plan.consecutive.trinkets).to.equal(2);
         expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(10);
-        clock.restore();
       });
 
       it('does not increment consecutive benefits in the second month of the second period that they already have benefits for', () => {
@@ -306,7 +302,6 @@ describe('cron', () => {
         expect(user3.purchased.plan.consecutive.offset).to.equal(1);
         expect(user3.purchased.plan.consecutive.trinkets).to.equal(2);
         expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(10);
-        clock.restore();
       });
 
       it('does not increment consecutive benefits in the final month of the second period that they already have benefits for', () => {
@@ -316,7 +311,6 @@ describe('cron', () => {
         expect(user3.purchased.plan.consecutive.offset).to.equal(0);
         expect(user3.purchased.plan.consecutive.trinkets).to.equal(2);
         expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(10);
-        clock.restore();
       });
 
       it('increments consecutive benefits the month after the third paid period has started', () => {
@@ -326,7 +320,6 @@ describe('cron', () => {
         expect(user3.purchased.plan.consecutive.offset).to.equal(2);
         expect(user3.purchased.plan.consecutive.trinkets).to.equal(3);
         expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(15);
-        clock.restore();
       });
 
       it('increments consecutive benefits correctly if user has been absent with continuous subscription', () => {
@@ -336,12 +329,10 @@ describe('cron', () => {
         expect(user3.purchased.plan.consecutive.offset).to.equal(2);
         expect(user3.purchased.plan.consecutive.trinkets).to.equal(4);
         expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(20);
-        clock.restore();
       });
     });
 
     describe('for a 6-month recurring subscription', () => {
-      let clock;
       let user6 = new User({
         auth: {
           local: {
@@ -369,7 +360,6 @@ describe('cron', () => {
         expect(user6.purchased.plan.consecutive.offset).to.equal(5);
         expect(user6.purchased.plan.consecutive.trinkets).to.equal(2);
         expect(user6.purchased.plan.consecutive.gemCapExtra).to.equal(10);
-        clock.restore();
       });
 
       it('does not increment consecutive benefits in the final month of the period that they already have benefits for', () => {
@@ -379,7 +369,6 @@ describe('cron', () => {
         expect(user6.purchased.plan.consecutive.offset).to.equal(0);
         expect(user6.purchased.plan.consecutive.trinkets).to.equal(2);
         expect(user6.purchased.plan.consecutive.gemCapExtra).to.equal(10);
-        clock.restore();
       });
 
       it('increments consecutive benefits the month after the second paid period has started', () => {
@@ -389,7 +378,6 @@ describe('cron', () => {
         expect(user6.purchased.plan.consecutive.offset).to.equal(5);
         expect(user6.purchased.plan.consecutive.trinkets).to.equal(4);
         expect(user6.purchased.plan.consecutive.gemCapExtra).to.equal(20);
-        clock.restore();
       });
 
       it('increments consecutive benefits the month after the third paid period has started', () => {
@@ -399,7 +387,6 @@ describe('cron', () => {
         expect(user6.purchased.plan.consecutive.offset).to.equal(5);
         expect(user6.purchased.plan.consecutive.trinkets).to.equal(6);
         expect(user6.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
       });
 
       it('increments consecutive benefits correctly if user has been absent with continuous subscription', () => {
@@ -409,13 +396,10 @@ describe('cron', () => {
         expect(user6.purchased.plan.consecutive.offset).to.equal(5);
         expect(user6.purchased.plan.consecutive.trinkets).to.equal(8);
         expect(user6.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
       });
     });
 
     describe('for a 12-month recurring subscription', () => {
-      let clock;
-
       let user12 = new User({
         auth: {
           local: {
@@ -443,7 +427,6 @@ describe('cron', () => {
         expect(user12.purchased.plan.consecutive.offset).to.equal(11);
         expect(user12.purchased.plan.consecutive.trinkets).to.equal(4);
         expect(user12.purchased.plan.consecutive.gemCapExtra).to.equal(20);
-        clock.restore();
       });
 
       it('does not increment consecutive benefits in the final month of the period that they already have benefits for', () => {
@@ -453,7 +436,6 @@ describe('cron', () => {
         expect(user12.purchased.plan.consecutive.offset).to.equal(0);
         expect(user12.purchased.plan.consecutive.trinkets).to.equal(4);
         expect(user12.purchased.plan.consecutive.gemCapExtra).to.equal(20);
-        clock.restore();
       });
 
       it('increments consecutive benefits the month after the second paid period has started', () => {
@@ -463,7 +445,6 @@ describe('cron', () => {
         expect(user12.purchased.plan.consecutive.offset).to.equal(11);
         expect(user12.purchased.plan.consecutive.trinkets).to.equal(8);
         expect(user12.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
       });
 
       it('increments consecutive benefits the month after the third paid period has started', () => {
@@ -473,7 +454,6 @@ describe('cron', () => {
         expect(user12.purchased.plan.consecutive.offset).to.equal(11);
         expect(user12.purchased.plan.consecutive.trinkets).to.equal(12);
         expect(user12.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
       });
 
       it('increments consecutive benefits correctly if user has been absent with continuous subscription', () => {
@@ -483,12 +463,10 @@ describe('cron', () => {
         expect(user12.purchased.plan.consecutive.offset).to.equal(11);
         expect(user12.purchased.plan.consecutive.trinkets).to.equal(16);
         expect(user12.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
       });
     });
 
     describe('for a 3-month gift subscription (non-recurring)', () => {
-      let clock;
       let user3g = new User({
         auth: {
           local: {
@@ -503,7 +481,7 @@ describe('cron', () => {
       // user3g has a 3-month gift subscription starting today
       user3g.purchased.plan.customerId = 'Gift';
       user3g.purchased.plan.dateUpdated = moment().toDate();
-      user3g.purchased.plan.dateTerminated = moment().add(3, 'months').toDate();
+      user3g.purchased.plan.dateTerminated = moment().startOf('month').add(3, 'months').add(15, 'days').toDate();
       user3g.purchased.plan.planId = null;
       user3g.purchased.plan.consecutive.count = 0;
       user3g.purchased.plan.consecutive.offset = 3;
@@ -517,7 +495,6 @@ describe('cron', () => {
         expect(user3g.purchased.plan.consecutive.offset).to.equal(2);
         expect(user3g.purchased.plan.consecutive.trinkets).to.equal(1);
         expect(user3g.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
       });
 
       it('does not increment consecutive benefits in the second month of the gift subscription', () => {
@@ -527,7 +504,6 @@ describe('cron', () => {
         expect(user3g.purchased.plan.consecutive.offset).to.equal(1);
         expect(user3g.purchased.plan.consecutive.trinkets).to.equal(1);
         expect(user3g.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
       });
 
       it('does not increment consecutive benefits in the third month of the gift subscription', () => {
@@ -537,7 +513,6 @@ describe('cron', () => {
         expect(user3g.purchased.plan.consecutive.offset).to.equal(0);
         expect(user3g.purchased.plan.consecutive.trinkets).to.equal(1);
         expect(user3g.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
       });
 
       it('does not increment consecutive benefits in the month after the gift subscription has ended', () => {
@@ -547,12 +522,10 @@ describe('cron', () => {
         expect(user3g.purchased.plan.consecutive.offset).to.equal(0);
         expect(user3g.purchased.plan.consecutive.trinkets).to.equal(1);
         expect(user3g.purchased.plan.consecutive.gemCapExtra).to.equal(0); // erased
-        clock.restore();
       });
     });
 
     describe('for a 6-month recurring subscription where the user has incorrect consecutive month data from prior bugs', () => {
-      let clock;
       let user6x = new User({
         auth: {
           local: {
@@ -580,7 +553,6 @@ describe('cron', () => {
         expect(user6x.purchased.plan.consecutive.offset).to.equal(5);
         expect(user6x.purchased.plan.consecutive.trinkets).to.equal(5);
         expect(user6x.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
       });
 
       it('does not increment consecutive benefits in the second month after the fix goes live', () => {
@@ -590,7 +562,6 @@ describe('cron', () => {
         expect(user6x.purchased.plan.consecutive.offset).to.equal(4);
         expect(user6x.purchased.plan.consecutive.trinkets).to.equal(5);
         expect(user6x.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
       });
 
       it('does not increment consecutive benefits in the third month after the fix goes live', () => {
@@ -600,7 +571,6 @@ describe('cron', () => {
         expect(user6x.purchased.plan.consecutive.offset).to.equal(3);
         expect(user6x.purchased.plan.consecutive.trinkets).to.equal(5);
         expect(user6x.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
       });
 
       it('increments consecutive benefits in the seventh month after the fix goes live', () => {
@@ -610,7 +580,6 @@ describe('cron', () => {
         expect(user6x.purchased.plan.consecutive.offset).to.equal(5);
         expect(user6x.purchased.plan.consecutive.trinkets).to.equal(7);
         expect(user6x.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
       });
     });
   });
@@ -627,14 +596,12 @@ describe('cron', () => {
     });
 
     it('does not reset plan.gemsBought within the month', () => {
-      let clock = sinon.useFakeTimers(moment().startOf('month').add(2, 'days').unix());
+      clock = sinon.useFakeTimers(moment().startOf('month').add(2, 'days').unix());
       user.purchased.plan.dateUpdated = moment().startOf('month').toDate();
 
       user.purchased.plan.gemsBought = 10;
       cron({user, tasksByType, daysMissed, analytics});
       expect(user.purchased.plan.gemsBought).to.equal(10);
-
-      clock.restore();
     });
 
     it('does not reset plan.dateUpdated on a new month', () => {
@@ -694,76 +661,6 @@ describe('cron', () => {
     });
   });
 
-  describe('user is sleeping', () => {
-    beforeEach(() => {
-      user.preferences.sleep = true;
-    });
-
-    it('calls analytics', () => {
-      cron({user, tasksByType, daysMissed, analytics});
-      expect(analytics.track.callCount).to.equal(1);
-    });
-
-    it('clears user buffs', () => {
-      user.stats.buffs = {
-        str: 1,
-        int: 1,
-        per: 1,
-        con: 1,
-        stealth: 1,
-        streaks: true,
-      };
-
-      cron({user, tasksByType, daysMissed, analytics});
-
-      expect(user.stats.buffs.str).to.equal(0);
-      expect(user.stats.buffs.int).to.equal(0);
-      expect(user.stats.buffs.per).to.equal(0);
-      expect(user.stats.buffs.con).to.equal(0);
-      expect(user.stats.buffs.stealth).to.equal(0);
-      expect(user.stats.buffs.streaks).to.be.false;
-    });
-
-    it('resets all dailies without damaging user', () => {
-      let daily = {
-        text: 'test daily',
-        type: 'daily',
-        frequency: 'daily',
-        everyX: 5,
-        startDate: new Date(),
-      };
-
-      let task = new Tasks.daily(Tasks.Task.sanitize(daily)); // eslint-disable-line new-cap
-      tasksByType.dailys.push(task);
-      tasksByType.dailys[0].completed = true;
-
-      let healthBefore = user.stats.hp;
-
-      cron({user, tasksByType, daysMissed, analytics});
-
-      expect(tasksByType.dailys[0].completed).to.be.false;
-      expect(user.stats.hp).to.equal(healthBefore);
-    });
-
-    it('sets isDue for daily', () => {
-      let daily = {
-        text: 'test daily',
-        type: 'daily',
-        frequency: 'daily',
-        everyX: 5,
-        startDate: new Date(),
-      };
-
-      let task = new Tasks.daily(Tasks.Task.sanitize(daily)); // eslint-disable-line new-cap
-      tasksByType.dailys.push(task);
-      tasksByType.dailys[0].completed = true;
-
-      cron({user, tasksByType, daysMissed, analytics});
-
-      expect(tasksByType.dailys[0].isDue).to.be.exist;
-    });
-  });
-
   describe('todos', () => {
     beforeEach(() => {
       let todo = {
@@ -885,6 +782,15 @@ describe('cron', () => {
       expect(tasksByType.dailys[0].isDue).to.be.false;
     });
 
+    it('computes isDue when user is sleeping', () => {
+      user.preferences.sleep = true;
+      tasksByType.dailys[0].frequency = 'daily';
+      tasksByType.dailys[0].everyX = 5;
+      tasksByType.dailys[0].startDate = moment().toDate();
+      cron({user, tasksByType, daysMissed, analytics});
+      expect(tasksByType.dailys[0].isDue).to.exist;
+    });
+
     it('computes nextDue', () => {
       tasksByType.dailys[0].frequency = 'daily';
       tasksByType.dailys[0].everyX = 5;
@@ -904,6 +810,13 @@ describe('cron', () => {
       expect(tasksByType.dailys[0].completed).to.be.false;
     });
 
+    it('should set tasks completed to false when user is sleeping', () => {
+      user.preferences.sleep = true;
+      tasksByType.dailys[0].completed = true;
+      cron({user, tasksByType, daysMissed, analytics});
+      expect(tasksByType.dailys[0].completed).to.be.false;
+    });
+
     it('should reset task checklist for completed dailys', () => {
       tasksByType.dailys[0].checklist.push({title: 'test', completed: false});
       tasksByType.dailys[0].completed = true;
@@ -911,6 +824,14 @@ describe('cron', () => {
       expect(tasksByType.dailys[0].checklist[0].completed).to.be.false;
     });
 
+    it('should reset task checklist for completed dailys when user is sleeping', () => {
+      user.preferences.sleep = true;
+      tasksByType.dailys[0].checklist.push({title: 'test', completed: false});
+      tasksByType.dailys[0].completed = true;
+      cron({user, tasksByType, daysMissed, analytics});
+      expect(tasksByType.dailys[0].checklist[0].completed).to.be.false;
+    });
+
     it('should reset task checklist for dailys with scheduled misses', () => {
       daysMissed = 10;
       tasksByType.dailys[0].checklist.push({title: 'test', completed: false});
@@ -923,12 +844,19 @@ describe('cron', () => {
       daysMissed = 1;
       let hpBefore = user.stats.hp;
       tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
-
       cron({user, tasksByType, daysMissed, analytics});
-
       expect(user.stats.hp).to.be.lessThan(hpBefore);
     });
 
+    it('should not do damage for missing a daily when user is sleeping', () => {
+      user.preferences.sleep = true;
+      daysMissed = 1;
+      let hpBefore = user.stats.hp;
+      tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
+      cron({user, tasksByType, daysMissed, analytics});
+      expect(user.stats.hp).to.equal(hpBefore);
+    });
+
     it('should not do damage for missing a daily when CRON_SAFE_MODE is set', () => {
       sandbox.stub(nconf, 'get').withArgs('CRON_SAFE_MODE').returns('true');
       let cronOverride = requireAgain(pathToCronLib).cron;
@@ -969,7 +897,7 @@ describe('cron', () => {
       expect(hpDifferenceOfPartiallyIncompleteDaily).to.be.lessThan(hpDifferenceOfFullyIncompleteDaily);
     });
 
-    it('should decrement quest progress down for missing a daily', () => {
+    it('should decrement quest.progress.down for missing a daily', () => {
       daysMissed = 1;
       tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
 
@@ -978,6 +906,16 @@ describe('cron', () => {
       expect(progress.down).to.equal(-1);
     });
 
+    it('should not decrement quest.progress.down for missing a daily when user is sleeping', () => {
+      user.preferences.sleep = true;
+      daysMissed = 1;
+      tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
+
+      let progress = cron({user, tasksByType, daysMissed, analytics});
+
+      expect(progress.down).to.equal(0);
+    });
+
     it('should do damage for only yesterday\'s dailies', () => {
       daysMissed = 3;
       tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
@@ -1040,15 +978,11 @@ describe('cron', () => {
 
     describe('counters', () => {
       let notStartOfWeekOrMonth = new Date(2016, 9, 28).getTime(); // a Friday
-      let clock;
 
       beforeEach(() => {
         // Replace system clocks so we can get predictable results
         clock = sinon.useFakeTimers(notStartOfWeekOrMonth);
       });
-      afterEach(() => {
-        return clock.restore();
-      });
 
       it('should reset a daily habit counter each day', () => {
         tasksByType.habits[0].counterUp = 1;
@@ -1060,7 +994,7 @@ describe('cron', () => {
         expect(tasksByType.habits[0].counterDown).to.equal(0);
       });
 
-      it('should reset habit counters even if user is resting in the Inn', () => {
+      it('should reset habit counters even if user is sleeping', () => {
         user.preferences.sleep = true;
         tasksByType.habits[0].counterUp = 1;
         tasksByType.habits[0].counterDown = 1;
@@ -1321,7 +1255,23 @@ describe('cron', () => {
       expect(user.achievements.perfect).to.equal(0);
     });
 
-    it('increments user buffs if all (at least 1) due dailies were completed', () => {
+    it('gives perfect day buff if all (at least 1) due dailies were completed', () => {
+      daysMissed = 1;
+      tasksByType.dailys[0].completed = true;
+      tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
+
+      let previousBuffs = user.stats.buffs.toObject();
+
+      cron({user, tasksByType, daysMissed, analytics});
+
+      expect(user.stats.buffs.str).to.be.greaterThan(previousBuffs.str);
+      expect(user.stats.buffs.int).to.be.greaterThan(previousBuffs.int);
+      expect(user.stats.buffs.per).to.be.greaterThan(previousBuffs.per);
+      expect(user.stats.buffs.con).to.be.greaterThan(previousBuffs.con);
+    });
+
+    it('gives perfect day buff if all (at least 1) due dailies were completed when user is sleeping', () => {
+      user.preferences.sleep = true;
       daysMissed = 1;
       tasksByType.dailys[0].completed = true;
       tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
@@ -1360,6 +1310,31 @@ describe('cron', () => {
       expect(user.stats.buffs.streaks).to.be.false;
     });
 
+    it('clears buffs if user does not have a perfect day (no due dailys) when user is sleeping', () => {
+      user.preferences.sleep = true;
+      daysMissed = 1;
+      tasksByType.dailys[0].completed = true;
+      tasksByType.dailys[0].startDate = moment(new Date()).add({days: 1});
+
+      user.stats.buffs = {
+        str: 1,
+        int: 1,
+        per: 1,
+        con: 1,
+        stealth: 0,
+        streaks: true,
+      };
+
+      cron({user, tasksByType, daysMissed, analytics});
+
+      expect(user.stats.buffs.str).to.equal(0);
+      expect(user.stats.buffs.int).to.equal(0);
+      expect(user.stats.buffs.per).to.equal(0);
+      expect(user.stats.buffs.con).to.equal(0);
+      expect(user.stats.buffs.stealth).to.equal(0);
+      expect(user.stats.buffs.streaks).to.be.false;
+    });
+
     it('clears buffs if user does not have a perfect day (at least one due daily not completed)', () => {
       daysMissed = 1;
       tasksByType.dailys[0].completed = false;
@@ -1384,7 +1359,50 @@ describe('cron', () => {
       expect(user.stats.buffs.streaks).to.be.false;
     });
 
-    it('still grants a perfect day when CRON_SAFE_MODE is set', () => {
+    it('clears buffs if user does not have a perfect day (at least one due daily not completed) when user is sleeping', () => {
+      user.preferences.sleep = true;
+      daysMissed = 1;
+      tasksByType.dailys[0].completed = false;
+      tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
+
+      user.stats.buffs = {
+        str: 1,
+        int: 1,
+        per: 1,
+        con: 1,
+        stealth: 0,
+        streaks: true,
+      };
+
+      cron({user, tasksByType, daysMissed, analytics});
+
+      expect(user.stats.buffs.str).to.equal(0);
+      expect(user.stats.buffs.int).to.equal(0);
+      expect(user.stats.buffs.per).to.equal(0);
+      expect(user.stats.buffs.con).to.equal(0);
+      expect(user.stats.buffs.stealth).to.equal(0);
+      expect(user.stats.buffs.streaks).to.be.false;
+    });
+
+    it('always grants a perfect day buff when CRON_SAFE_MODE is set', () => {
+      sandbox.stub(nconf, 'get').withArgs('CRON_SAFE_MODE').returns('true');
+      let cronOverride = requireAgain(pathToCronLib).cron;
+      daysMissed = 1;
+      tasksByType.dailys[0].completed = false;
+      tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
+
+      let previousBuffs = user.stats.buffs.toObject();
+
+      cronOverride({user, tasksByType, daysMissed, analytics});
+
+      expect(user.stats.buffs.str).to.be.greaterThan(previousBuffs.str);
+      expect(user.stats.buffs.int).to.be.greaterThan(previousBuffs.int);
+      expect(user.stats.buffs.per).to.be.greaterThan(previousBuffs.per);
+      expect(user.stats.buffs.con).to.be.greaterThan(previousBuffs.con);
+    });
+
+    it('always grants a perfect day buff when CRON_SAFE_MODE is set when user is sleeping', () => {
+      user.preferences.sleep = true;
       sandbox.stub(nconf, 'get').withArgs('CRON_SAFE_MODE').returns('true');
       let cronOverride = requireAgain(pathToCronLib).cron;
       daysMissed = 1;
@@ -1416,6 +1434,20 @@ describe('cron', () => {
       common.statsComputed.restore();
     });
 
+    it('should not add mp to user when user is sleeping', () => {
+      const statsComputedRes = common.statsComputed(user);
+      const stubbedStatsComputed = sinon.stub(common, 'statsComputed');
+
+      user.preferences.sleep = true;
+      let mpBefore = user.stats.mp;
+      tasksByType.dailys[0].completed = true;
+      stubbedStatsComputed.returns(Object.assign(statsComputedRes, {maxMP: 100}));
+      cron({user, tasksByType, daysMissed, analytics});
+      expect(user.stats.mp).to.equal(mpBefore);
+
+      common.statsComputed.restore();
+    });
+
     it('set user\'s mp to statsComputed.maxMP when user.stats.mp is greater', () => {
       const statsComputedRes = common.statsComputed(user);
       const stubbedStatsComputed = sinon.stub(common, 'statsComputed');
@@ -1557,27 +1589,6 @@ describe('cron', () => {
         flagCount: 0,
       };
     });
-
-    xit('does not clear pms under 200', () => {
-      cron({user, tasksByType, daysMissed, analytics});
-      expect(user.inbox.messages[lastMessageId]).to.exist;
-    });
-
-    xit('clears pms over 200', () => {
-      let messageId = common.uuid();
-      user.inbox.messages[messageId] = {
-        id: messageId,
-        text: `test ${messageId}`,
-        timestamp: Number(new Date()),
-        likes: {},
-        flags: {},
-        flagCount: 0,
-      };
-
-      cron({user, tasksByType, daysMissed, analytics});
-
-      expect(user.inbox.messages[messageId]).to.not.exist;
-    });
   });
 
   describe('login incentives', () => {
@@ -1611,7 +1622,7 @@ describe('cron', () => {
       expect(user.loginIncentives).to.eql(1);
     });
 
-    it('increments loginIncentives by 1 even if user has Dailies paused', () => {
+    it('increments loginIncentives by 1 even if user is sleeping', () => {
       user.preferences.sleep = true;
       cron({user, tasksByType, daysMissed, analytics});
       expect(user.loginIncentives).to.eql(1);

test/api/unit/libs/email.test.js

@@ -3,9 +3,9 @@ import got from 'got';
 import nconf from 'nconf';
 import nodemailer from 'nodemailer';
 import requireAgain from 'require-again';
-import logger from '../../../../../website/server/libs/logger';
-import { TAVERN_ID } from '../../../../../website/server/models/group';
-import { defer } from '../../../../helpers/api-unit.helper';
+import logger from '../../../../website/server/libs/logger';
+import { TAVERN_ID } from '../../../../website/server/models/group';
+import { defer } from '../../../helpers/api-unit.helper';
 
 function getUser () {
   return {
@@ -19,7 +19,6 @@ function getUser () {
         emails: [{
           value: 'email@facebook',
         }],
-        displayName: 'fb display name',
       },
     },
     profile: {
@@ -34,7 +33,7 @@ function getUser () {
 }
 
 describe('emails', () => {
-  let pathToEmailLib = '../../../../../website/server/libs/email';
+  let pathToEmailLib = '../../../../website/server/libs/email';
 
   describe('sendEmail', () => {
     let sendMailSpy;
@@ -100,7 +99,7 @@ describe('emails', () => {
 
       let data = getUserInfo(user, ['name', 'email', '_id', 'canSend']);
 
-      expect(data).to.have.property('name', user.auth.facebook.displayName);
+      expect(data).to.have.property('name', user.profile.name);
       expect(data).to.have.property('email', user.auth.facebook.emails[0].value);
       expect(data).to.have.property('_id', user._id);
       expect(data).to.have.property('canSend', true);
@@ -110,13 +109,12 @@ describe('emails', () => {
       let attachEmail = requireAgain(pathToEmailLib);
       let getUserInfo = attachEmail.getUserInfo;
       let user = getUser();
-      delete user.profile.name;
       delete user.auth.local.email;
       delete user.auth.facebook;
 
       let data = getUserInfo(user, ['name', 'email', '_id', 'canSend']);
 
-      expect(data).to.have.property('name', user.auth.local.username);
+      expect(data).to.have.property('name', user.profile.name);
       expect(data).not.to.have.property('email');
       expect(data).to.have.property('_id', user._id);
       expect(data).to.have.property('canSend', true);

test/api/unit/libs/encryption.test.js

@@ -1,7 +1,7 @@
 import {
   encrypt,
   decrypt,
-} from '../../../../../website/server/libs/encryption';
+} from '../../../../website/server/libs/encryption';
 
 describe('encryption', () => {
   it('can encrypt and decrypt', () => {

test/api/unit/libs/errors.test.js

@@ -5,7 +5,7 @@ import {
   BadRequest,
   InternalServerError,
   NotFound,
-} from '../../../../../website/server/libs/errors';
+} from '../../../../website/server/libs/errors';
 
 describe('Custom Errors', () => {
   describe('CustomError', () => {

test/api/unit/libs/i18n.test.js

@@ -2,7 +2,7 @@ import {
   translations,
   localePath,
   langCodes,
-} from '../../../../../website/server/libs/i18n';
+} from '../../../../website/server/libs/i18n';
 import fs from 'fs';
 import path from 'path';
 

test/api/unit/libs/logger.js

@@ -1,8 +1,8 @@
 import winston from 'winston';
-import logger from '../../../../../website/server/libs/logger';
+import logger from '../../../../website/server/libs/logger';
 import {
   NotFound,
-} from '../../../../../website/server/libs//errors';
+} from '../../../../website/server/libs//errors';
 
 describe('logger', () => {
   let logSpy;

test/api/unit/libs/password.test.js

@@ -2,11 +2,11 @@
 
 import {
   encrypt,
-} from '../../../../../website/server/libs/encryption';
+} from '../../../../website/server/libs/encryption';
 import moment from 'moment';
 import {
   generateUser,
-} from '../../../../helpers/api-integration/v3';
+} from '../../../helpers/api-integration/v3';
 import {
   sha1Encrypt as sha1EncryptPassword,
   sha1MakeSalt,
@@ -15,7 +15,7 @@ import {
   compare,
   convertToBcrypt,
   validatePasswordResetCodeAndFindUser,
-} from '../../../../../website/server/libs/password';
+} from '../../../../website/server/libs/password';
 
 describe('Password Utilities', () => {
   describe('compare', () => {
@@ -107,6 +107,25 @@ describe('Password Utilities', () => {
       }
     });
 
+    it('defaults to SHA1 encryption if salt is provided', async () => {
+      let textPassword = 'mySecretPassword';
+      let salt = sha1MakeSalt();
+      let hashedPassword = sha1EncryptPassword(textPassword, salt);
+
+      let user = {
+        auth: {
+          local: {
+            hashed_password: hashedPassword,
+            salt,
+            passwordHashMethod: '',
+          },
+        },
+      };
+
+      let isValidPassword = await compare(user, textPassword);
+      expect(isValidPassword).to.eql(true);
+    });
+
     it('throws an error if an invalid hashing method is used', async () => {
       try {
         await compare({

test/api/unit/libs/payments/amazon/cancel.test.js

@@ -2,11 +2,11 @@ import moment from 'moment';
 
 import {
   generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import amzLib from '../../../../../../../website/server/libs/payments/amazon';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import common from '../../../../../../../website/common';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import amzLib from '../../../../../../website/server/libs/payments/amazon';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import common from '../../../../../../website/common';
 import { createNonLeaderGroupMember } from '../paymentHelpers';
 
 const i18n = common.i18n;

test/api/unit/libs/payments/amazon/checkout.test.js

@@ -1,7 +1,7 @@
-import { model as User } from '../../../../../../../website/server/models/user';
-import amzLib from '../../../../../../../website/server/libs/payments/amazon';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import common from '../../../../../../../website/common';
+import { model as User } from '../../../../../../website/server/models/user';
+import amzLib from '../../../../../../website/server/libs/payments/amazon';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import common from '../../../../../../website/common';
 
 const i18n = common.i18n;
 

test/api/unit/libs/payments/amazon/subscribe.test.js

@@ -2,12 +2,12 @@ import cc from 'coupon-code';
 
 import {
   generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Coupon } from '../../../../../../../website/server/models/coupon';
-import amzLib from '../../../../../../../website/server/libs/payments/amazon';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import common from '../../../../../../../website/common';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import { model as Coupon } from '../../../../../../website/server/models/coupon';
+import amzLib from '../../../../../../website/server/libs/payments/amazon';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import common from '../../../../../../website/common';
 
 const i18n = common.i18n;
 

test/api/unit/libs/payments/amazon/upgrade-groupplan.test.js

@@ -2,11 +2,11 @@ import uuid from 'uuid';
 
 import {
   generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Group } from '../../../../../../../website/server/models/group';
-import amzLib from '../../../../../../../website/server/libs/payments/amazon';
-import payments from '../../../../../../../website/server/libs/payments/payments';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import { model as Group } from '../../../../../../website/server/models/group';
+import amzLib from '../../../../../../website/server/libs/payments/amazon';
+import payments from '../../../../../../website/server/libs/payments/payments';
 
 describe('#upgradeGroupPlan', () => {
   let spy, data, user, group, uuidString;

test/api/unit/libs/payments/apple.test.js

@@ -1,10 +1,10 @@
 /* eslint-disable camelcase */
-import iapModule from '../../../../../../website/server/libs/inAppPurchases';
-import payments from '../../../../../../website/server/libs/payments/payments';
-import applePayments from '../../../../../../website/server/libs/payments/apple';
-import iap from '../../../../../../website/server/libs/inAppPurchases';
-import {model as User} from '../../../../../../website/server/models/user';
-import common from '../../../../../../website/common';
+import iapModule from '../../../../../website/server/libs/inAppPurchases';
+import payments from '../../../../../website/server/libs/payments/payments';
+import applePayments from '../../../../../website/server/libs/payments/apple';
+import iap from '../../../../../website/server/libs/inAppPurchases';
+import {model as User} from '../../../../../website/server/models/user';
+import common from '../../../../../website/common';
 import moment from 'moment';
 
 const i18n = common.i18n;

test/api/unit/libs/payments/google.test.js

@@ -1,10 +1,10 @@
 /* eslint-disable camelcase */
-import iapModule from '../../../../../../website/server/libs/inAppPurchases';
-import payments from '../../../../../../website/server/libs/payments/payments';
-import googlePayments from '../../../../../../website/server/libs/payments/google';
-import iap from '../../../../../../website/server/libs/inAppPurchases';
-import {model as User} from '../../../../../../website/server/models/user';
-import common from '../../../../../../website/common';
+import iapModule from '../../../../../website/server/libs/inAppPurchases';
+import payments from '../../../../../website/server/libs/payments/payments';
+import googlePayments from '../../../../../website/server/libs/payments/google';
+import iap from '../../../../../website/server/libs/inAppPurchases';
+import {model as User} from '../../../../../website/server/models/user';
+import common from '../../../../../website/common';
 import moment from 'moment';
 
 const i18n = common.i18n;

test/api/unit/libs/payments/group-plans/group-payments-cancel.test.js

@@ -1,13 +1,13 @@
 import moment from 'moment';
 
-import * as sender from '../../../../../../../website/server/libs/email';
-import * as api from '../../../../../../../website/server/libs/payments/payments';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Group } from '../../../../../../../website/server/models/group';
+import * as sender from '../../../../../../website/server/libs/email';
+import * as api from '../../../../../../website/server/libs/payments/payments';
+import { model as User } from '../../../../../../website/server/models/user';
+import { model as Group } from '../../../../../../website/server/models/group';
 import {
   generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import i18n from '../../../../../../../website/common/script/i18n';
+} from '../../../../../helpers/api-unit.helper.js';
+import i18n from '../../../../../../website/common/script/i18n';
 
 describe('Canceling a subscription for group', () => {
   let plan, group, user, data;

test/api/unit/libs/payments/group-plans/group-payments-create.test.js

@@ -2,16 +2,16 @@ import moment from 'moment';
 import stripeModule from 'stripe';
 import nconf from 'nconf';
 
-import * as sender from '../../../../../../../website/server/libs/email';
-import * as api from '../../../../../../../website/server/libs/payments/payments';
-import amzLib from '../../../../../../../website/server/libs/payments/amazon';
-import paypalPayments from '../../../../../../../website/server/libs/payments/paypal';
-import stripePayments from '../../../../../../../website/server/libs/payments/stripe';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Group } from '../../../../../../../website/server/models/group';
+import * as sender from '../../../../../../website/server/libs/email';
+import * as api from '../../../../../../website/server/libs/payments/payments';
+import amzLib from '../../../../../../website/server/libs/payments/amazon';
+import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
+import stripePayments from '../../../../../../website/server/libs/payments/stripe';
+import { model as User } from '../../../../../../website/server/models/user';
+import { model as Group } from '../../../../../../website/server/models/group';
 import {
   generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
+} from '../../../../../helpers/api-unit.helper.js';
 
 describe('Purchasing a group plan for group', () => {
   const EMAIL_TEMPLATE_SUBSCRIPTION_TYPE_GOOGLE = 'Google_subscription';

test/api/unit/libs/payments/paymentHelpers.js

@@ -1,4 +1,4 @@
-import { model as User } from '../../../../../../website/server/models/user';
+import { model as User } from '../../../../../website/server/models/user';
 
 export async function createNonLeaderGroupMember (group) {
   let nonLeader = new User();

test/api/unit/libs/payments/payments.test.js

@@ -1,14 +1,14 @@
 import moment from 'moment';
 
-import * as sender from '../../../../../../website/server/libs/email';
-import * as api from '../../../../../../website/server/libs/payments/payments';
-import analytics from '../../../../../../website/server/libs/analyticsService';
-import notifications from '../../../../../../website/server/libs/pushNotifications';
-import { model as User } from '../../../../../../website/server/models/user';
-import { translate as t } from '../../../../../helpers/api-v3-integration.helper';
+import * as sender from '../../../../../website/server/libs/email';
+import * as api from '../../../../../website/server/libs/payments/payments';
+import analytics from '../../../../../website/server/libs/analyticsService';
+import notifications from '../../../../../website/server/libs/pushNotifications';
+import { model as User } from '../../../../../website/server/models/user';
+import { translate as t } from '../../../../helpers/api-integration/v3';
 import {
   generateGroup,
-} from '../../../../../helpers/api-unit.helper.js';
+} from '../../../../helpers/api-unit.helper.js';
 
 describe('payments/index', () => {
   let user, group, data, plan;
@@ -210,7 +210,7 @@ describe('payments/index', () => {
         let msg = '\`Hello recipient, sender has sent you 3 months of subscription!\`';
 
         expect(user.sendMessage).to.be.calledOnce;
-        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: msg, senderMsg: msg });
+        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: msg, senderMsg: msg, save: false });
       });
 
       it('sends an email about the gift', async () => {
@@ -629,7 +629,7 @@ describe('payments/index', () => {
         await api.buyGems(data);
         let msg = '\`Hello recipient, sender has sent you 4 gems!\`';
 
-        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: msg, senderMsg: msg });
+        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: msg, senderMsg: msg, save: false });
       });
 
       it('sends a message from purchaser to recipient wtih custom message', async () => {
@@ -638,7 +638,7 @@ describe('payments/index', () => {
         await api.buyGems(data);
 
         const msg = `\`Hello recipient, sender has sent you 4 gems!\` ${data.gift.message}`;
-        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: msg, senderMsg: msg });
+        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: msg, senderMsg: msg, save: false });
       });
 
       it('sends a push notification if user did not gift to self', async () => {
@@ -667,7 +667,7 @@ describe('payments/index', () => {
           return `\`${messageContent}\``;
         });
 
-        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: recipientsMessageContent, senderMsg: sendersMessageContent });
+        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: recipientsMessageContent, senderMsg: sendersMessageContent, save: false });
       });
     });
   });

test/api/unit/libs/payments/paypal/checkout-success.test.js

@@ -1,7 +1,7 @@
 /* eslint-disable camelcase */
-import paypalPayments from '../../../../../../../website/server/libs/payments/paypal';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import { model as User } from '../../../../../../../website/server/models/user';
+import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import { model as User } from '../../../../../../website/server/models/user';
 
 describe('checkout success', () => {
   const subKey = 'basic_3mo';

test/api/unit/libs/payments/paypal/checkout.test.js

@@ -1,9 +1,9 @@
 /* eslint-disable camelcase */
 import nconf from 'nconf';
 
-import paypalPayments from '../../../../../../../website/server/libs/payments/paypal';
-import { model as User } from '../../../../../../../website/server/models/user';
-import common from '../../../../../../../website/common';
+import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
+import { model as User } from '../../../../../../website/server/models/user';
+import common from '../../../../../../website/common';
 
 const BASE_URL = nconf.get('BASE_URL');
 const i18n = common.i18n;

test/api/unit/libs/payments/paypal/ipn.test.js

@@ -1,10 +1,10 @@
 /* eslint-disable camelcase */
-import paypalPayments from '../../../../../../../website/server/libs/payments/paypal';
-import payments from '../../../../../../../website/server/libs/payments/payments';
+import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
+import payments from '../../../../../../website/server/libs/payments/payments';
 import {
   generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
 
 describe('ipn', () => {
   const subKey = 'basic_3mo';

test/api/unit/libs/payments/paypal/subscribe-cancel.test.js

@@ -1,11 +1,11 @@
 /* eslint-disable camelcase */
-import paypalPayments from '../../../../../../../website/server/libs/payments/paypal';
-import payments from '../../../../../../../website/server/libs/payments/payments';
+import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
+import payments from '../../../../../../website/server/libs/payments/payments';
 import {
   generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import common from '../../../../../../../website/common';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import common from '../../../../../../website/common';
 import { createNonLeaderGroupMember } from '../paymentHelpers';
 
 const i18n = common.i18n;

test/api/unit/libs/payments/paypal/subscribe-success.test.js

@@ -1,11 +1,11 @@
 /* eslint-disable camelcase */
-import paypalPayments from '../../../../../../../website/server/libs/payments/paypal';
-import payments from '../../../../../../../website/server/libs/payments/payments';
+import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
+import payments from '../../../../../../website/server/libs/payments/payments';
 import {
   generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import common from '../../../../../../../website/common';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import common from '../../../../../../website/common';
 
 describe('subscribeSuccess', () => {
   const subKey = 'basic_3mo';

test/api/unit/libs/payments/paypal/subscribe.test.js

@@ -2,9 +2,9 @@
 import moment from 'moment';
 import cc from 'coupon-code';
 
-import paypalPayments from '../../../../../../../website/server/libs/payments/paypal';
-import { model as Coupon } from '../../../../../../../website/server/models/coupon';
-import common from '../../../../../../../website/common';
+import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
+import { model as Coupon } from '../../../../../../website/server/models/coupon';
+import common from '../../../../../../website/common';
 
 const i18n = common.i18n;
 

test/api/unit/libs/payments/stripe/cancel-subscription.test.js

@@ -2,11 +2,11 @@ import stripeModule from 'stripe';
 
 import {
   generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import stripePayments from '../../../../../../../website/server/libs/payments/stripe';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import common from '../../../../../../../website/common';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import stripePayments from '../../../../../../website/server/libs/payments/stripe';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import common from '../../../../../../website/common';
 
 const i18n = common.i18n;
 

test/api/unit/libs/payments/stripe/checkout-subscription.test.js

@@ -3,12 +3,12 @@ import cc from 'coupon-code';
 
 import {
   generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Coupon } from '../../../../../../../website/server/models/coupon';
-import stripePayments from '../../../../../../../website/server/libs/payments/stripe';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import common from '../../../../../../../website/common';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import { model as Coupon } from '../../../../../../website/server/models/coupon';
+import stripePayments from '../../../../../../website/server/libs/payments/stripe';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import common from '../../../../../../website/common';
 
 const i18n = common.i18n;
 

test/api/unit/libs/payments/stripe/checkout.test.js

@@ -1,9 +1,9 @@
 import stripeModule from 'stripe';
 
-import { model as User } from '../../../../../../../website/server/models/user';
-import stripePayments from '../../../../../../../website/server/libs/payments/stripe';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import common from '../../../../../../../website/common';
+import { model as User } from '../../../../../../website/server/models/user';
+import stripePayments from '../../../../../../website/server/libs/payments/stripe';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import common from '../../../../../../website/common';
 
 const i18n = common.i18n;
 

test/api/unit/libs/payments/stripe/edit-subscription.test.js

@@ -2,10 +2,10 @@ import stripeModule from 'stripe';
 
 import {
   generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import stripePayments from '../../../../../../../website/server/libs/payments/stripe';
-import common from '../../../../../../../website/common';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import stripePayments from '../../../../../../website/server/libs/payments/stripe';
+import common from '../../../../../../website/common';
 
 const i18n = common.i18n;
 

test/api/unit/libs/payments/stripe/handle-webhook.test.js

@@ -2,12 +2,12 @@ import stripeModule from 'stripe';
 
 import {
   generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import stripePayments from '../../../../../../../website/server/libs/payments/stripe';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import common from '../../../../../../../website/common';
-import logger from '../../../../../../../website/server/libs/logger';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import stripePayments from '../../../../../../website/server/libs/payments/stripe';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import common from '../../../../../../website/common';
+import logger from '../../../../../../website/server/libs/logger';
 import { v4 as uuid } from 'uuid';
 import moment from 'moment';
 

test/api/unit/libs/payments/stripe/upgrade-group-plan.test.js

@@ -2,11 +2,11 @@ import stripeModule from 'stripe';
 
 import {
   generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Group } from '../../../../../../../website/server/models/group';
-import stripePayments from '../../../../../../../website/server/libs/payments/stripe';
-import payments from '../../../../../../../website/server/libs/payments/payments';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import { model as Group } from '../../../../../../website/server/models/group';
+import stripePayments from '../../../../../../website/server/libs/payments/stripe';
+import payments from '../../../../../../website/server/libs/payments/payments';
 
 describe('Stripe - Upgrade Group Plan', () => {
   const stripe = stripeModule('test');

test/api/unit/libs/preening.test.js

@@ -1,7 +1,7 @@
-import { preenHistory } from '../../../../../website/server/libs/preening';
+import { preenHistory } from '../../../../website/server/libs/preening';
 import moment from 'moment';
 import sinon from 'sinon'; // eslint-disable-line no-shadow
-import { generateHistory } from '../../../../helpers/api-unit.helper.js';
+import { generateHistory } from '../../../helpers/api-unit.helper.js';
 
 describe('preenHistory', () => {
   let clock;

test/api/unit/libs/pushNotifications.js

@@ -1,13 +1,13 @@
-import { model as User } from '../../../../../website/server/models/user';
+import { model as User } from '../../../../website/server/models/user';
 import requireAgain from 'require-again';
-import pushNotify from 'push-notify';
+import apn from 'apn/mock';
 import nconf from 'nconf';
 import gcmLib from 'node-gcm'; // works with FCM notifications too
 
 describe('pushNotifications', () => {
   let user;
   let sendPushNotification;
-  let pathToPushNotifications = '../../../../../website/server/libs/pushNotifications';
+  let pathToPushNotifications = '../../../../website/server/libs/pushNotifications';
   let fcmSendSpy;
   let apnSendSpy;
 
@@ -24,7 +24,7 @@ describe('pushNotifications', () => {
 
     sandbox.stub(gcmLib.Sender.prototype, 'send').callsFake(fcmSendSpy);
 
-    sandbox.stub(pushNotify, 'apn').returns({
+    sandbox.stub(apn.Provider.prototype, 'send').returns({
       on: () => null,
       send: apnSendSpy,
     });
@@ -104,10 +104,7 @@ describe('pushNotifications', () => {
       },
     };
 
-    sendPushNotification(user, details);
-    expect(apnSendSpy).to.have.been.calledOnce;
-    expect(apnSendSpy).to.have.been.calledWithMatch({
-      token: '123',
+    const expectedNotification = new apn.Notification({
       alert: message,
       sound: 'default',
       category: 'fun',
@@ -117,6 +114,10 @@ describe('pushNotifications', () => {
         b: true,
       },
     });
+
+    sendPushNotification(user, details);
+    expect(apnSendSpy).to.have.been.calledOnce;
+    expect(apnSendSpy).to.have.been.calledWithMatch(expectedNotification, '123');
     expect(fcmSendSpy).to.not.have.been.called;
   });
 });

test/api/unit/libs/setupNconf.test.js

@@ -1,4 +1,4 @@
-import setupNconf from '../../../../../website/server/libs/setupNconf';
+import setupNconf from '../../../../website/server/libs/setupNconf';
 
 import path from 'path';
 import nconf from 'nconf';

test/api/unit/libs/slack.js

@@ -1,10 +1,11 @@
 /* eslint-disable camelcase */
 import { IncomingWebhook } from '@slack/client';
 import requireAgain from 'require-again';
-import slack from '../../../../../website/server/libs/slack';
-import logger from '../../../../../website/server/libs/logger';
-import { TAVERN_ID } from '../../../../../website/server/models/group';
+import slack from '../../../../website/server/libs/slack';
+import logger from '../../../../website/server/libs/logger';
+import { TAVERN_ID } from '../../../../website/server/models/group';
 import nconf from 'nconf';
+import moment from 'moment';
 
 describe('slack', () => {
   describe('sendFlagNotification', () => {
@@ -45,17 +46,19 @@ describe('slack', () => {
     it('sends a slack webhook', () => {
       slack.sendFlagNotification(data);
 
+      const timestamp = `${moment(data.message.timestamp).utc().format('YYYY-MM-DD HH:mm')} UTC`;
+
       expect(IncomingWebhook.prototype.send).to.be.calledOnce;
       expect(IncomingWebhook.prototype.send).to.be.calledWith({
         text: 'flagger (flagger-id; language: flagger-lang) flagged a message',
         attachments: [{
           fallback: 'Flag Message',
           color: 'danger',
-          author_name: 'Author - author@example.com - author-id',
+          author_name: `Author - author@example.com - author-id\n${timestamp}`,
           title: 'Flag in Some group - (private guild)',
           title_link: undefined,
           text: 'some text',
-          footer: sandbox.match(/<.*?groupId=group-id&chatId=chat-id\|Flag this message>/),
+          footer: sandbox.match(/<.*?groupId=group-id&chatId=chat-id\|Flag this message.>/),
           mrkdwn_in: [
             'text',
           ],
@@ -97,9 +100,11 @@ describe('slack', () => {
 
       slack.sendFlagNotification(data);
 
+      const timestamp = `${moment(data.message.timestamp).utc().format('YYYY-MM-DD HH:mm')} UTC`;
+
       expect(IncomingWebhook.prototype.send).to.be.calledWithMatch({
         attachments: [sandbox.match({
-          author_name: 'System Message',
+          author_name: `System Message\n${timestamp}`,
         })],
       });
     });
@@ -107,7 +112,7 @@ describe('slack', () => {
     it('noops if no flagging url is provided', () => {
       sandbox.stub(nconf, 'get').withArgs('SLACK:FLAGGING_URL').returns('');
       sandbox.stub(logger, 'error');
-      let reRequiredSlack = requireAgain('../../../../../website/server/libs/slack');
+      let reRequiredSlack = requireAgain('../../../../website/server/libs/slack');
 
       expect(logger.error).to.be.calledOnce;
 

test/api/unit/libs/taskManager.js

@@ -3,13 +3,13 @@ import {
   getTasks,
   syncableAttrs,
   moveTask,
-} from '../../../../../website/server/libs/taskManager';
-import i18n from '../../../../../website/common/script/i18n';
+} from '../../../../website/server/libs/taskManager';
+import i18n from '../../../../website/common/script/i18n';
 import {
   generateUser,
   generateGroup,
   generateChallenge,
-} from '../../../../helpers/api-unit.helper.js';
+} from '../../../helpers/api-unit.helper.js';
 
 describe('taskManager', () => {
   let user, group, challenge;
@@ -178,4 +178,12 @@ describe('taskManager', () => {
 
     expect(order).to.eql(['task-id-2', 'task-id-1']);
   });
+
+  it('moves tasks to a specified position out of length', async () => {
+    let order = ['task-id-1'];
+
+    moveTask(order, 'task-id-2', 2);
+
+    expect(order).to.eql(['task-id-1', 'task-id-2']);
+  });
 });

test/api/unit/libs/webhooks.test.js

@@ -6,11 +6,14 @@ import {
   taskActivityWebhook,
   questActivityWebhook,
   userActivityWebhook,
-} from '../../../../../website/server/libs/webhook';
+} from '../../../../website/server/libs/webhook';
+import {
+  model as User,
+} from '../../../../website/server/models/user';
 import {
   generateUser,
-} from '../../../../helpers/api-unit.helper.js';
-import { defer } from '../../../../helpers/api-unit.helper';
+} from '../../../helpers/api-unit.helper.js';
+import { defer } from '../../../helpers/api-unit.helper';
 
 describe('webhooks', () => {
   let webhooks, user;
@@ -306,17 +309,6 @@ describe('webhooks', () => {
               return this;
             },
           },
-          addComputedStatsToJSONObj () {
-            let mockStats = Object.assign({
-              maxHealth: 50,
-              maxMP: 103,
-              toNextLevel: 40,
-            }, this.stats);
-
-            delete mockStats.toJSON;
-
-            return mockStats;
-          },
         },
         task: {
           text: 'text',
@@ -324,6 +316,15 @@ describe('webhooks', () => {
         direction: 'up',
         delta: 176,
       };
+
+      let mockStats = Object.assign({
+        maxHealth: 50,
+        maxMP: 103,
+        toNextLevel: 40,
+      }, data.user.stats);
+      delete mockStats.toJSON;
+
+      sandbox.stub(User, 'addComputedStatsToJSONObj').returns(mockStats);
     });
 
     it('sends task and stats data', () => {

test/api/unit/middlewares/analytics.test.js

@@ -3,14 +3,14 @@ import {
   generateRes,
   generateReq,
   generateNext,
-} from '../../../../helpers/api-unit.helper';
-import analyticsService from '../../../../../website/server/libs/analyticsService';
+} from '../../../helpers/api-unit.helper';
+import analyticsService from '../../../../website/server/libs/analyticsService';
 import nconf from 'nconf';
 import requireAgain from 'require-again';
 
 describe('analytics middleware', () => {
   let res, req, next;
-  let pathToAnalyticsMiddleware = '../../../../../website/server/middlewares/analytics';
+  let pathToAnalyticsMiddleware = '../../../../website/server/middlewares/analytics';
 
   beforeEach(() => {
     res = generateRes();

test/api/unit/middlewares/auth.test.js

@@ -1,8 +1,8 @@
 import {
   generateRes,
   generateReq,
-} from '../../../../helpers/api-unit.helper';
-import { authWithHeaders as authWithHeadersFactory } from '../../../../../website/server/middlewares/auth';
+} from '../../../helpers/api-unit.helper';
+import { authWithHeaders as authWithHeadersFactory } from '../../../../website/server/middlewares/auth';
 
 describe('auth middleware', () => {
   let res, req, user;

test/api/unit/middlewares/cors.test.js

@@ -3,8 +3,8 @@ import {
   generateRes,
   generateReq,
   generateNext,
-} from '../../../../helpers/api-unit.helper';
-import cors from '../../../../../website/server/middlewares/cors';
+} from '../../../helpers/api-unit.helper';
+import cors from '../../../../website/server/middlewares/cors';
 
 describe('cors middleware', () => {
   let res, req, next;

test/api/unit/middlewares/cronMiddleware.js

@@ -3,14 +3,14 @@ import {
   generateReq,
   generateTodo,
   generateDaily,
-} from '../../../../helpers/api-unit.helper';
-import cronMiddleware from '../../../../../website/server/middlewares/cron';
+} from '../../../helpers/api-unit.helper';
+import cronMiddleware from '../../../../website/server/middlewares/cron';
 import moment from 'moment';
-import { model as User } from '../../../../../website/server/models/user';
-import { model as Group } from '../../../../../website/server/models/group';
-import * as Tasks from '../../../../../website/server/models/task';
-import analyticsService from '../../../../../website/server/libs/analyticsService';
-import * as cronLib from '../../../../../website/server/libs/cron';
+import { model as User } from '../../../../website/server/models/user';
+import { model as Group } from '../../../../website/server/models/group';
+import * as Tasks from '../../../../website/server/models/task';
+import analyticsService from '../../../../website/server/libs/analyticsService';
+import * as cronLib from '../../../../website/server/libs/cron';
 import { v4 as generateUUID } from 'uuid';
 
 const CRON_TIMEOUT_WAIT = new Date(60 * 60 * 1000).getTime();
@@ -166,8 +166,11 @@ describe('cron middleware', () => {
     await new Promise((resolve, reject) => {
       cronMiddleware(req, res, (err) => {
         if (err) return reject(err);
-        expect(user.stats.hp).to.be.lessThan(hpBefore);
-        resolve();
+        User.findOne({_id: user._id}, function (secondErr, updatedUser) {
+          if (secondErr) return reject(secondErr);
+          expect(updatedUser.stats.hp).to.be.lessThan(hpBefore);
+          resolve();
+        });
       });
     });
   });
@@ -176,7 +179,7 @@ describe('cron middleware', () => {
     user.lastCron = moment(new Date()).subtract({days: 2});
     let todo = generateTodo(user);
     let todoValueBefore = todo.value;
-    await user.save();
+    await Promise.all([todo.save(), user.save()]);
 
     await new Promise((resolve, reject) => {
       cronMiddleware(req, res, (err) => {
@@ -217,8 +220,11 @@ describe('cron middleware', () => {
     await new Promise((resolve, reject) => {
       cronMiddleware(req, res, (err) => {
         if (err) return reject(err);
-        expect(user.stats.hp).to.be.lessThan(hpBefore);
-        resolve();
+        User.findOne({_id: user._id}, function (secondErr, updatedUser) {
+          if (secondErr) return reject(secondErr);
+          expect(updatedUser.stats.hp).to.be.lessThan(hpBefore);
+          resolve();
+        });
       });
     });
   });

test/api/unit/middlewares/ensureAccessRight.test.js

@@ -3,11 +3,11 @@ import {
   generateRes,
   generateReq,
   generateNext,
-} from '../../../../helpers/api-unit.helper';
-import i18n from '../../../../../website/common/script/i18n';
-import { ensureAdmin, ensureSudo } from '../../../../../website/server/middlewares/ensureAccessRight';
-import { NotAuthorized } from '../../../../../website/server/libs/errors';
-import apiError from '../../../../../website/server/libs/apiError';
+} from '../../../helpers/api-unit.helper';
+import i18n from '../../../../website/common/script/i18n';
+import { ensureAdmin, ensureSudo } from '../../../../website/server/middlewares/ensureAccessRight';
+import { NotAuthorized } from '../../../../website/server/libs/errors';
+import apiError from '../../../../website/server/libs/apiError';
 
 describe('ensure access middlewares', () => {
   let res, req, next;

test/api/unit/middlewares/ensureDevelpmentMode.js

@@ -3,9 +3,9 @@ import {
   generateRes,
   generateReq,
   generateNext,
-} from '../../../../helpers/api-unit.helper';
-import ensureDevelpmentMode from '../../../../../website/server/middlewares/ensureDevelpmentMode';
-import { NotFound } from '../../../../../website/server/libs/errors';
+} from '../../../helpers/api-unit.helper';
+import ensureDevelpmentMode from '../../../../website/server/middlewares/ensureDevelpmentMode';
+import { NotFound } from '../../../../website/server/libs/errors';
 import nconf from 'nconf';
 
 describe('developmentMode middleware', () => {

test/api/unit/middlewares/errorHandler.test.js

@@ -2,17 +2,17 @@ import {
   generateRes,
   generateReq,
   generateNext,
-} from '../../../../helpers/api-unit.helper';
+} from '../../../helpers/api-unit.helper';
 
-import errorHandler from '../../../../../website/server/middlewares/errorHandler';
-import responseMiddleware from '../../../../../website/server/middlewares/response';
+import errorHandler from '../../../../website/server/middlewares/errorHandler';
+import responseMiddleware from '../../../../website/server/middlewares/response';
 import {
   getUserLanguage,
   attachTranslateFunction,
-} from '../../../../../website/server/middlewares/language';
+} from '../../../../website/server/middlewares/language';
 
-import { BadRequest } from '../../../../../website/server/libs/errors';
-import logger from '../../../../../website/server/libs/logger';
+import { BadRequest } from '../../../../website/server/libs/errors';
+import logger from '../../../../website/server/libs/logger';
 
 describe('errorHandler', () => {
   let res, req, next;

test/api/unit/middlewares/language.test.js

@@ -2,13 +2,13 @@ import {
   generateRes,
   generateReq,
   generateNext,
-} from '../../../../helpers/api-unit.helper';
+} from '../../../helpers/api-unit.helper';
 import {
   getUserLanguage,
   attachTranslateFunction,
-} from '../../../../../website/server/middlewares/language';
-import common from '../../../../../website/common';
-import { model as User } from '../../../../../website/server/models/user';
+} from '../../../../website/server/middlewares/language';
+import common from '../../../../website/common';
+import { model as User } from '../../../../website/server/models/user';
 
 const i18n = common.i18n;
 

test/api/unit/middlewares/maintenanceMode.test.js

@@ -2,13 +2,13 @@ import {
   generateRes,
   generateReq,
   generateNext,
-} from '../../../../helpers/api-unit.helper';
+} from '../../../helpers/api-unit.helper';
 import nconf from 'nconf';
 import requireAgain from 'require-again';
 
 describe('maintenance mode middleware', () => {
   let res, req, next;
-  let pathToMaintenanceModeMiddleware = '../../../../../website/server/middlewares/maintenanceMode';
+  let pathToMaintenanceModeMiddleware = '../../../../website/server/middlewares/maintenanceMode';
 
   beforeEach(() => {
     res = generateRes();

test/api/unit/middlewares/redirects.js

@@ -2,13 +2,13 @@ import {
   generateRes,
   generateReq,
   generateNext,
-} from '../../../../helpers/api-unit.helper';
+} from '../../../helpers/api-unit.helper';
 import nconf from 'nconf';
 import requireAgain from 'require-again';
 
 describe('redirects middleware', () => {
   let res, req, next;
-  let pathToRedirectsMiddleware = '../../../../../website/server/middlewares/redirects';
+  let pathToRedirectsMiddleware = '../../../../website/server/middlewares/redirects';
 
   beforeEach(() => {
     res = generateRes();

test/api/unit/middlewares/response.js

@@ -2,9 +2,9 @@ import {
   generateRes,
   generateReq,
   generateNext,
-} from '../../../../helpers/api-unit.helper';
-import responseMiddleware from '../../../../../website/server/middlewares/response';
-import packageInfo from '../../../../../package.json';
+} from '../../../helpers/api-unit.helper';
+import responseMiddleware from '../../../../website/server/middlewares/response';
+import packageInfo from '../../../../package.json';
 
 describe('response middleware', () => {
   let res, req, next;

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

@@ -1,8 +1,8 @@
-import { model as Challenge } from '../../../../../website/server/models/challenge';
-import { model as Group } from '../../../../../website/server/models/group';
-import { model as User } from '../../../../../website/server/models/user';
-import * as Tasks from '../../../../../website/server/models/task';
-import common from '../../../../../website/common/';
+import { model as Challenge } from '../../../../website/server/models/challenge';
+import { model as Group } from '../../../../website/server/models/group';
+import { model as User } from '../../../../website/server/models/user';
+import * as Tasks from '../../../../website/server/models/task';
+import common from '../../../../website/common/';
 import { each, find } from 'lodash';
 
 describe('Challenge Model', () => {

test/api/unit/models/group.test.js

@@ -1,26 +1,26 @@
 import moment from 'moment';
 import { v4 as generateUUID } from 'uuid';
 import validator from 'validator';
-import { sleep } from '../../../../helpers/api-unit.helper';
+import { sleep } from '../../../helpers/api-unit.helper';
 import {
   SPAM_MESSAGE_LIMIT,
   SPAM_MIN_EXEMPT_CONTRIB_LEVEL,
   SPAM_WINDOW_LENGTH,
   INVITES_LIMIT,
   model as Group,
-} from '../../../../../website/server/models/group';
-import { model as User } from '../../../../../website/server/models/user';
-import { quests as questScrolls } from '../../../../../website/common/script/content';
+} from '../../../../website/server/models/group';
+import { model as User } from '../../../../website/server/models/user';
+import { quests as questScrolls } from '../../../../website/common/script/content';
 import {
   groupChatReceivedWebhook,
   questActivityWebhook,
-} from '../../../../../website/server/libs/webhook';
-import * as email from '../../../../../website/server/libs/email';
-import { TAVERN_ID } from '../../../../../website/common/script/';
-import shared from '../../../../../website/common';
+} from '../../../../website/server/libs/webhook';
+import * as email from '../../../../website/server/libs/email';
+import { TAVERN_ID } from '../../../../website/common/script/';
+import shared from '../../../../website/common';
 
 describe('Group Model', () => {
-  let party, questLeader, participatingMember, nonParticipatingMember, undecidedMember;
+  let party, questLeader, participatingMember, sleepingParticipatingMember, nonParticipatingMember, undecidedMember;
 
   beforeEach(async () => {
     sandbox.stub(email, 'sendTxn');
@@ -48,6 +48,11 @@ describe('Group Model', () => {
       party: { _id: party._id },
       profile: { name: 'Participating Member' },
     });
+    sleepingParticipatingMember = new User({
+      party: { _id: party._id },
+      profile: { name: 'Sleeping Participating Member' },
+      preferences: { sleep: true },
+    });
     nonParticipatingMember = new User({
       party: { _id: party._id },
       profile: { name: 'Non-Participating Member' },
@@ -61,6 +66,7 @@ describe('Group Model', () => {
       party.save(),
       questLeader.save(),
       participatingMember.save(),
+      sleepingParticipatingMember.save(),
       nonParticipatingMember.save(),
       undecidedMember.save(),
     ]);
@@ -80,6 +86,7 @@ describe('Group Model', () => {
         party.quest.members = {
           [questLeader._id]: true,
           [participatingMember._id]: true,
+          [sleepingParticipatingMember._id]: true,
           [nonParticipatingMember._id]: false,
           [undecidedMember._id]: null,
         };
@@ -175,6 +182,34 @@ describe('Group Model', () => {
           expect(party._processBossQuest).to.not.be.called;
           expect(Group.prototype._processCollectionQuest).to.be.calledOnce;
         });
+
+        it('does not call _processBossQuest when user is resting in the inn', async () => {
+          party.quest.key = 'whale';
+
+          await party.startQuest(questLeader);
+          await party.save();
+
+          await Group.processQuestProgress(sleepingParticipatingMember, progress);
+
+          party = await Group.findOne({_id: party._id});
+
+          expect(party._processBossQuest).to.not.be.called;
+          expect(party._processCollectionQuest).to.not.be.called;
+        });
+
+        it('does not call _processCollectionQuest when user is resting in the inn', async () => {
+          party.quest.key = 'evilsanta2';
+
+          await party.startQuest(questLeader);
+          await party.save();
+
+          await Group.processQuestProgress(sleepingParticipatingMember, progress);
+
+          party = await Group.findOne({_id: party._id});
+
+          expect(party._processBossQuest).to.not.be.called;
+          expect(party._processCollectionQuest).to.not.be.called;
+        });
       });
 
       context('Boss Quests', () => {
@@ -216,17 +251,20 @@ describe('Group Model', () => {
           let [
             updatedLeader,
             updatedParticipatingMember,
+            updatedSleepingParticipatingMember,
             updatedNonParticipatingMember,
             updatedUndecidedMember,
           ] = await Promise.all([
             User.findById(questLeader._id),
             User.findById(participatingMember._id),
+            User.findById(sleepingParticipatingMember._id),
             User.findById(nonParticipatingMember._id),
             User.findById(undecidedMember._id),
           ]);
 
           expect(updatedLeader.stats.hp).to.eql(42.5);
           expect(updatedParticipatingMember.stats.hp).to.eql(42.5);
+          expect(updatedSleepingParticipatingMember.stats.hp).to.eql(42.5);
           expect(updatedNonParticipatingMember.stats.hp).to.eql(50);
           expect(updatedUndecidedMember.stats.hp).to.eql(50);
         });
@@ -236,6 +274,7 @@ describe('Group Model', () => {
           party.quest.members = {
             [questLeader._id]: true,
             [participatingMember._id]: true,
+            [sleepingParticipatingMember._id]: true,
             [nonParticipatingMember._id]: false,
             [undecidedMember._id]: null,
           };
@@ -248,17 +287,20 @@ describe('Group Model', () => {
           let [
             updatedLeader,
             updatedParticipatingMember,
+            updatedSleepingParticipatingMember,
             updatedNonParticipatingMember,
             updatedUndecidedMember,
           ] = await Promise.all([
             User.findById(questLeader._id),
             User.findById(participatingMember._id),
+            User.findById(sleepingParticipatingMember._id),
             User.findById(nonParticipatingMember._id),
             User.findById(undecidedMember._id),
           ]);
 
           expect(updatedLeader.stats.hp).to.eql(42.5);
           expect(updatedParticipatingMember.stats.hp).to.eql(42.5);
+          expect(updatedSleepingParticipatingMember.stats.hp).to.eql(42.5);
           expect(updatedNonParticipatingMember.stats.hp).to.eql(50);
           expect(updatedUndecidedMember.stats.hp).to.eql(50);
         });
@@ -497,9 +539,11 @@ describe('Group Model', () => {
           let [
             updatedLeader,
             updatedParticipatingMember,
+            updatedSleepingParticipatingMember,
           ] = await Promise.all([
             User.findById(questLeader._id),
             User.findById(participatingMember._id),
+            User.findById(sleepingParticipatingMember._id),
           ]);
 
           expect(updatedLeader.achievements.quests[party.quest.key]).to.eql(1);
@@ -508,6 +552,9 @@ describe('Group Model', () => {
           expect(updatedParticipatingMember.achievements.quests[party.quest.key]).to.eql(1);
           expect(updatedParticipatingMember.stats.exp).to.be.greaterThan(0);
           expect(updatedParticipatingMember.stats.gp).to.be.greaterThan(0);
+          expect(updatedSleepingParticipatingMember.achievements.quests[party.quest.key]).to.eql(1);
+          expect(updatedSleepingParticipatingMember.stats.exp).to.be.greaterThan(0);
+          expect(updatedSleepingParticipatingMember.stats.gp).to.be.greaterThan(0);
         });
       });
     });
@@ -647,6 +694,7 @@ describe('Group Model', () => {
       it('returns an array of members whose quest status set to true', () => {
         party.quest.members = {
           [participatingMember._id]: true,
+          [sleepingParticipatingMember._id]: true,
           [questLeader._id]: true,
           [nonParticipatingMember._id]: false,
           [undecidedMember._id]: null,
@@ -654,6 +702,7 @@ describe('Group Model', () => {
 
         expect(party.getParticipatingQuestMembers()).to.eql([
           participatingMember._id,
+          sleepingParticipatingMember._id,
           questLeader._id,
         ]);
       });
@@ -756,11 +805,12 @@ describe('Group Model', () => {
       it('removes user from group quest', async () => {
         party.quest.members = {
           [participatingMember._id]: true,
+          [sleepingParticipatingMember._id]: true,
           [questLeader._id]: true,
           [nonParticipatingMember._id]: false,
           [undecidedMember._id]: null,
         };
-        party.memberCount = 4;
+        party.memberCount = 5;
         await party.save();
 
         await party.leave(participatingMember);
@@ -768,6 +818,7 @@ describe('Group Model', () => {
         party = await Group.findOne({_id: party._id});
         expect(party.quest.members).to.eql({
           [questLeader._id]: true,
+          [sleepingParticipatingMember._id]: true,
           [nonParticipatingMember._id]: false,
           [undecidedMember._id]: null,
         });
@@ -775,6 +826,7 @@ describe('Group Model', () => {
 
       it('deletes a private party when the last member leaves', async () => {
         await party.leave(participatingMember);
+        await party.leave(sleepingParticipatingMember);
         await party.leave(questLeader);
         await party.leave(nonParticipatingMember);
         await party.leave(undecidedMember);
@@ -846,6 +898,7 @@ describe('Group Model', () => {
         party.privacy = 'public';
 
         await party.leave(participatingMember);
+        await party.leave(sleepingParticipatingMember);
         await party.leave(questLeader);
         await party.leave(nonParticipatingMember);
         await party.leave(undecidedMember);
@@ -967,32 +1020,6 @@ describe('Group Model', () => {
         expect(chat.user).to.not.exist;
       });
 
-      it('cuts down chat to 200 messages', () => {
-        for (let i = 0; i < 220; i++) {
-          party.chat.push({ text: 'a message' });
-        }
-
-        expect(party.chat).to.have.a.lengthOf(220);
-
-        party.sendChat('message');
-
-        expect(party.chat).to.have.a.lengthOf(200);
-      });
-
-      it('cuts down chat to 400 messages when group is subcribed', () => {
-        party.purchased.plan.customerId = 'test-customer-id';
-
-        for (let i = 0; i < 420; i++) {
-          party.chat.push({ text: 'a message' });
-        }
-
-        expect(party.chat).to.have.a.lengthOf(420);
-
-        party.sendChat('message');
-
-        expect(party.chat).to.have.a.lengthOf(400);
-      });
-
       it('updates users about new messages in party', () => {
         party.sendChat('message');
 
@@ -1074,6 +1101,7 @@ describe('Group Model', () => {
           party.quest.members = {
             [questLeader._id]: true,
             [participatingMember._id]: true,
+            [sleepingParticipatingMember._id]: true,
             [nonParticipatingMember._id]: false,
             [undecidedMember._id]: null,
           };
@@ -1130,6 +1158,7 @@ describe('Group Model', () => {
           let expectedQuestMembers = {};
           expectedQuestMembers[questLeader._id] = true;
           expectedQuestMembers[participatingMember._id] = true;
+          expectedQuestMembers[sleepingParticipatingMember._id] = true;
 
           expect(party.quest.members).to.eql(expectedQuestMembers);
         });
@@ -1148,12 +1177,18 @@ describe('Group Model', () => {
 
           questLeader = await User.findById(questLeader._id);
           participatingMember = await User.findById(participatingMember._id);
+          sleepingParticipatingMember = await User.findById(sleepingParticipatingMember._id);
 
           expect(participatingMember.party.quest.key).to.eql('whale');
           expect(participatingMember.party.quest.progress.down).to.eql(0);
           expect(participatingMember.party.quest.progress.collectedItems).to.eql(0);
           expect(participatingMember.party.quest.completed).to.eql(null);
 
+          expect(sleepingParticipatingMember.party.quest.key).to.eql('whale');
+          expect(sleepingParticipatingMember.party.quest.progress.down).to.eql(0);
+          expect(sleepingParticipatingMember.party.quest.progress.collectedItems).to.eql(0);
+          expect(sleepingParticipatingMember.party.quest.completed).to.eql(null);
+
           expect(questLeader.party.quest.key).to.eql('whale');
           expect(questLeader.party.quest.progress.down).to.eql(0);
           expect(questLeader.party.quest.progress.collectedItems).to.eql(0);
@@ -1172,9 +1207,11 @@ describe('Group Model', () => {
 
         it('sends email to participating members that quest has started', async () => {
           participatingMember.preferences.emailNotifications.questStarted = true;
+          sleepingParticipatingMember.preferences.emailNotifications.questStarted = true;
           questLeader.preferences.emailNotifications.questStarted = true;
           await Promise.all([
             participatingMember.save(),
+            sleepingParticipatingMember.save(),
             questLeader.save(),
           ]);
 
@@ -1187,8 +1224,9 @@ describe('Group Model', () => {
           let memberIds = _.map(email.sendTxn.args[0][0], '_id');
           let typeOfEmail = email.sendTxn.args[0][1];
 
-          expect(memberIds).to.have.a.lengthOf(2);
+          expect(memberIds).to.have.a.lengthOf(3);
           expect(memberIds).to.include(participatingMember._id);
+          expect(memberIds).to.include(sleepingParticipatingMember._id);
           expect(memberIds).to.include(questLeader._id);
           expect(typeOfEmail).to.eql('quest-started');
         });
@@ -1202,6 +1240,13 @@ describe('Group Model', () => {
               questStarted: true,
             },
           }];
+          sleepingParticipatingMember.webhooks = [{
+            type: 'questActivity',
+            url: 'http://someurl.com',
+            options: {
+              questStarted: true,
+            },
+          }];
           questLeader.webhooks = [{
             type: 'questActivity',
             url: 'http://someurl.com',
@@ -1210,13 +1255,13 @@ describe('Group Model', () => {
             },
           }];
 
-          await Promise.all([participatingMember.save(), questLeader.save()]);
+          await Promise.all([participatingMember.save(), sleepingParticipatingMember.save(), questLeader.save()]);
 
           await party.startQuest(nonParticipatingMember);
 
           await sleep(0.5);
 
-          expect(questActivityWebhook.send).to.be.calledTwice; // for 2 participating members
+          expect(questActivityWebhook.send).to.be.calledThrice; // for 3 participating members
 
           let args = questActivityWebhook.send.args[0];
           let webhooks = args[0].webhooks;
@@ -1226,6 +1271,8 @@ describe('Group Model', () => {
           expect(webhooks).to.have.a.lengthOf(1);
           if (webhookOwner === questLeader._id) {
             expect(webhooks[0].id).to.eql(questLeader.webhooks[0].id);
+          } else if (webhookOwner === sleepingParticipatingMember._id) {
+            expect(webhooks[0].id).to.eql(sleepingParticipatingMember.webhooks[0].id);
           } else {
             expect(webhooks[0].id).to.eql(participatingMember.webhooks[0].id);
           }
@@ -1236,9 +1283,11 @@ describe('Group Model', () => {
 
         it('sends email only to members who have not opted out', async () => {
           participatingMember.preferences.emailNotifications.questStarted = false;
+          sleepingParticipatingMember.preferences.emailNotifications.questStarted = false;
           questLeader.preferences.emailNotifications.questStarted = true;
           await Promise.all([
             participatingMember.save(),
+            sleepingParticipatingMember.save(),
             questLeader.save(),
           ]);
 
@@ -1252,14 +1301,17 @@ describe('Group Model', () => {
 
           expect(memberIds).to.have.a.lengthOf(1);
           expect(memberIds).to.not.include(participatingMember._id);
+          expect(memberIds).to.not.include(sleepingParticipatingMember._id);
           expect(memberIds).to.include(questLeader._id);
         });
 
         it('does not send email to initiating member', async () => {
           participatingMember.preferences.emailNotifications.questStarted = true;
+          sleepingParticipatingMember.preferences.emailNotifications.questStarted = true;
           questLeader.preferences.emailNotifications.questStarted = true;
           await Promise.all([
             participatingMember.save(),
+            sleepingParticipatingMember.save(),
             questLeader.save(),
           ]);
 
@@ -1271,8 +1323,9 @@ describe('Group Model', () => {
 
           let memberIds = _.map(email.sendTxn.args[0][0], '_id');
 
-          expect(memberIds).to.have.a.lengthOf(1);
+          expect(memberIds).to.have.a.lengthOf(2);
           expect(memberIds).to.not.include(participatingMember._id);
+          expect(memberIds).to.include(sleepingParticipatingMember._id);
           expect(memberIds).to.include(questLeader._id);
         });
 
@@ -1281,7 +1334,7 @@ describe('Group Model', () => {
 
           await party.startQuest(nonParticipatingMember);
 
-          let members = [questLeader._id, participatingMember._id];
+          let members = [questLeader._id, participatingMember._id, sleepingParticipatingMember._id];
 
           expect(User.update).to.be.calledWith(
             { _id: { $in: members } },
@@ -1346,6 +1399,7 @@ describe('Group Model', () => {
         party.quest.members = {
           [questLeader._id]: true,
           [participatingMember._id]: true,
+          [sleepingParticipatingMember._id]: true,
           [nonParticipatingMember._id]: false,
           [undecidedMember._id]: null,
         };
@@ -1368,7 +1422,7 @@ describe('Group Model', () => {
 
           await party.finishQuest(quest);
 
-          expect(User.update).to.be.calledTwice;
+          expect(User.update).to.be.calledThrice;
         });
 
         it('stops retrying when a successful update has occurred', async () => {
@@ -1378,7 +1432,7 @@ describe('Group Model', () => {
 
           await party.finishQuest(quest);
 
-          expect(User.update).to.be.calledThrice;
+          expect(User.update.callCount).to.equal(4);
         });
 
         it('retries failed updates at most five times per user', async () => {
@@ -1386,7 +1440,7 @@ describe('Group Model', () => {
 
           await expect(party.finishQuest(quest)).to.eventually.be.rejected;
 
-          expect(User.update.callCount).to.eql(10);
+          expect(User.update.callCount).to.eql(15); // for 3 users
         });
       });
 
@@ -1396,17 +1450,19 @@ describe('Group Model', () => {
         let [
           updatedLeader,
           updatedParticipatingMember,
+          updatedSleepingParticipatingMember,
         ] = await Promise.all([
           User.findById(questLeader._id),
           User.findById(participatingMember._id),
+          User.findById(sleepingParticipatingMember._id),
         ]);
 
         expect(updatedLeader.achievements.quests[quest.key]).to.eql(1);
         expect(updatedParticipatingMember.achievements.quests[quest.key]).to.eql(1);
+        expect(updatedSleepingParticipatingMember.achievements.quests[quest.key]).to.eql(1);
       });
 
-      // Disable test, it fails on TravisCI, but only there
-      xit('gives out super awesome Masterclasser achievement to the deserving', async () => {
+      it('gives out super awesome Masterclasser achievement to the deserving', async () => {
         quest = questScrolls.lostMasterclasser4;
         party.quest.key = quest.key;
 
@@ -1433,17 +1489,19 @@ describe('Group Model', () => {
         let [
           updatedLeader,
           updatedParticipatingMember,
+          updatedSleepingParticipatingMember,
         ] = await Promise.all([
           User.findById(questLeader._id).exec(),
           User.findById(participatingMember._id).exec(),
+          User.findById(sleepingParticipatingMember._id).exec(),
         ]);
 
         expect(updatedLeader.achievements.lostMasterclasser).to.eql(true);
         expect(updatedParticipatingMember.achievements.lostMasterclasser).to.not.eql(true);
+        expect(updatedSleepingParticipatingMember.achievements.lostMasterclasser).to.not.eql(true);
       });
 
-      // Disable test, it fails on TravisCI, but only there
-      xit('gives out super awesome Masterclasser achievement when quests done out of order', async () => {
+      it('gives out super awesome Masterclasser achievement when quests done out of order', async () => {
         quest = questScrolls.lostMasterclasser1;
         party.quest.key = quest.key;
 
@@ -1470,13 +1528,16 @@ describe('Group Model', () => {
         let [
           updatedLeader,
           updatedParticipatingMember,
+          updatedSleepingParticipatingMember,
         ] = await Promise.all([
           User.findById(questLeader._id).exec(),
           User.findById(participatingMember._id).exec(),
+          User.findById(sleepingParticipatingMember._id).exec(),
         ]);
 
         expect(updatedLeader.achievements.lostMasterclasser).to.eql(true);
         expect(updatedParticipatingMember.achievements.lostMasterclasser).to.not.eql(true);
+        expect(updatedSleepingParticipatingMember.achievements.lostMasterclasser).to.not.eql(true);
       });
 
       it('gives xp and gold', async () => {
@@ -1485,15 +1546,19 @@ describe('Group Model', () => {
         let [
           updatedLeader,
           updatedParticipatingMember,
+          updatedSleepingParticipatingMember,
         ] = await Promise.all([
           User.findById(questLeader._id),
           User.findById(participatingMember._id),
+          User.findById(sleepingParticipatingMember._id),
         ]);
 
         expect(updatedLeader.stats.exp).to.eql(quest.drop.exp);
         expect(updatedLeader.stats.gp).to.eql(quest.drop.gp);
         expect(updatedParticipatingMember.stats.exp).to.eql(quest.drop.exp);
         expect(updatedParticipatingMember.stats.gp).to.eql(quest.drop.gp);
+        expect(updatedSleepingParticipatingMember.stats.exp).to.eql(quest.drop.exp);
+        expect(updatedSleepingParticipatingMember.stats.gp).to.eql(quest.drop.gp);
       });
 
       context('drops', () => {
@@ -1593,13 +1658,16 @@ describe('Group Model', () => {
           sandbox.spy(User, 'update');
           await party.finishQuest(quest);
 
-          expect(User.update).to.be.calledTwice;
+          expect(User.update).to.be.calledThrice;
           expect(User.update).to.be.calledWithMatch({
             _id: questLeader._id,
           });
           expect(User.update).to.be.calledWithMatch({
             _id: participatingMember._id,
           });
+          expect(User.update).to.be.calledWithMatch({
+            _id: sleepingParticipatingMember._id,
+          });
         });
 
         it('sets user quest object to a clean state', async () => {
@@ -1632,7 +1700,7 @@ describe('Group Model', () => {
           },
         }];
 
-        await Promise.all([participatingMember.save(), questLeader.save()]);
+        await Promise.all([participatingMember.save(), sleepingParticipatingMember.save(), questLeader.save()]);
 
         await party.finishQuest(quest);
 

test/api/unit/models/group_tasks.test.js

@@ -1,7 +1,7 @@
-import { model as Challenge } from '../../../../../website/server/models/challenge';
-import { model as Group } from '../../../../../website/server/models/group';
-import { model as User } from '../../../../../website/server/models/user';
-import * as Tasks from '../../../../../website/server/models/task';
+import { model as Challenge } from '../../../../website/server/models/challenge';
+import { model as Group } from '../../../../website/server/models/group';
+import { model as User } from '../../../../website/server/models/user';
+import * as Tasks from '../../../../website/server/models/task';
 import { each, find, findIndex } from 'lodash';
 
 describe('Group Task Methods', () => {

test/api/unit/models/task.test.js

@@ -1,10 +1,10 @@
-import { model as Challenge } from '../../../../../website/server/models/challenge';
-import { model as Group } from '../../../../../website/server/models/group';
-import { model as User } from '../../../../../website/server/models/user';
-import * as Tasks from '../../../../../website/server/models/task';
-import { InternalServerError } from '../../../../../website/server/libs/errors';
+import { model as Challenge } from '../../../../website/server/models/challenge';
+import { model as Group } from '../../../../website/server/models/group';
+import { model as User } from '../../../../website/server/models/user';
+import * as Tasks from '../../../../website/server/models/task';
+import { InternalServerError } from '../../../../website/server/libs/errors';
 import { each } from 'lodash';
-import { generateHistory } from '../../../../helpers/api-unit.helper.js';
+import { generateHistory } from '../../../helpers/api-unit.helper.js';
 
 describe('Task Model', () => {
   let guild, leader, challenge, task;

test/api/unit/models/user.test.js

@@ -1,7 +1,7 @@
 import moment from 'moment';
-import { model as User } from '../../../../../website/server/models/user';
-import { model as Group } from '../../../../../website/server/models/group';
-import common from '../../../../../website/common';
+import { model as User } from '../../../../website/server/models/user';
+import { model as Group } from '../../../../website/server/models/group';
+import common from '../../../../website/common';
 
 describe('User Model', () => {
   it('keeps user._tmp when calling .toJSON', () => {
@@ -42,13 +42,48 @@ describe('User Model', () => {
     expect(userToJSON.stats.maxHealth).to.not.exist;
     expect(userToJSON.stats.toNextLevel).to.not.exist;
 
-    user.addComputedStatsToJSONObj(userToJSON.stats);
+    User.addComputedStatsToJSONObj(userToJSON.stats, userToJSON);
 
     expect(userToJSON.stats.maxMP).to.exist;
     expect(userToJSON.stats.maxHealth).to.equal(common.maxHealth);
     expect(userToJSON.stats.toNextLevel).to.equal(common.tnl(user.stats.lvl));
   });
 
+  it('can transform user object without mongoose helpers', async () => {
+    let user = new User();
+    await user.save();
+    let userToJSON = await User.findById(user._id).lean().exec();
+
+    expect(userToJSON.stats.maxMP).to.not.exist;
+    expect(userToJSON.stats.maxHealth).to.not.exist;
+    expect(userToJSON.stats.toNextLevel).to.not.exist;
+    expect(userToJSON.id).to.not.exist;
+
+    User.transformJSONUser(userToJSON);
+
+    expect(userToJSON.id).to.equal(userToJSON._id);
+    expect(userToJSON.stats.maxMP).to.not.exist;
+    expect(userToJSON.stats.maxHealth).to.not.exist;
+    expect(userToJSON.stats.toNextLevel).to.not.exist;
+  });
+
+  it('can transform user object without mongoose helpers (including computed stats)', async () => {
+    let user = new User();
+    await user.save();
+    let userToJSON = await User.findById(user._id).lean().exec();
+
+    expect(userToJSON.stats.maxMP).to.not.exist;
+    expect(userToJSON.stats.maxHealth).to.not.exist;
+    expect(userToJSON.stats.toNextLevel).to.not.exist;
+
+    User.transformJSONUser(userToJSON, true);
+
+    expect(userToJSON.id).to.equal(userToJSON._id);
+    expect(userToJSON.stats.maxMP).to.exist;
+    expect(userToJSON.stats.maxHealth).to.equal(common.maxHealth);
+    expect(userToJSON.stats.toNextLevel).to.equal(common.tnl(user.stats.lvl));
+  });
+
   context('notifications', () => {
     it('can add notifications without data', () => {
       let user = new User();

test/api/unit/models/userNotification.test.js

@@ -1,4 +1,4 @@
-import { model as UserNotification } from '../../../../../website/server/models/userNotification';
+import { model as UserNotification } from '../../../../website/server/models/userNotification';
 
 describe('UserNotification Model', () => {
   context('convertNotificationsToSafeJson', () => {

test/api/unit/models/webhook.test.js

@@ -1,7 +1,7 @@
-import { model as Webhook } from '../../../../../website/server/models/webhook';
-import { BadRequest } from '../../../../../website/server/libs/errors';
+import { model as Webhook } from '../../../../website/server/models/webhook';
+import { BadRequest } from '../../../../website/server/libs/errors';
 import { v4 as generateUUID } from 'uuid';
-import apiError from '../../../../../website/server/libs/apiError';
+import apiError from '../../../../website/server/libs/apiError';
 
 describe('Webhook Model', () => {
   context('Instance Methods', () => {

test/api/v3/integration/challenges/DELETE-challenges_challengeId.test.js

@@ -5,7 +5,7 @@ import {
   sleep,
   checkExistence,
   translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';
 
 describe('DELETE /challenges/:challengeId', () => {
@@ -41,6 +41,7 @@ describe('DELETE /challenges/:challengeId', () => {
       group = populatedGroup.group;
 
       challenge = await generateChallenge(groupLeader, group);
+      await groupLeader.post(`/challenges/${challenge._id}/join`);
 
       await groupLeader.post(`/tasks/challenge/${challenge._id}`, [
         {type: 'habit', text: taskText},

test/api/v3/integration/challenges/GET-challenges_challengeId.test.js

@@ -3,7 +3,7 @@ import {
   createAndPopulateGroup,
   generateChallenge,
   translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';
 
 describe('GET /challenges/:challengeId', () => {
@@ -33,9 +33,11 @@ describe('GET /challenges/:challengeId', () => {
       group = populatedGroup.group;
 
       challenge = await generateChallenge(groupLeader, group);
+      await groupLeader.post(`/challenges/${challenge._id}/join`);
     });
 
     it('should return challenge data', async () => {
+      await challenge.sync();
       let chal = await user.get(`/challenges/${challenge._id}`);
       expect(chal.memberCount).to.equal(challenge.memberCount);
       expect(chal.name).to.equal(challenge.name);
@@ -61,44 +63,48 @@ describe('GET /challenges/:challengeId', () => {
 
   context('private guild', () => {
     let groupLeader;
+    let challengeLeader;
     let group;
     let challenge;
     let members;
-    let user;
+    let nonMember;
+    let otherMember;
 
     beforeEach(async () => {
-      user = await generateUser();
+      nonMember = await generateUser();
 
       let populatedGroup = await createAndPopulateGroup({
         groupDetails: {type: 'guild', privacy: 'private'},
-        members: 1,
+        members: 2,
       });
 
       groupLeader = populatedGroup.groupLeader;
       group = populatedGroup.group;
       members = populatedGroup.members;
 
-      challenge = await generateChallenge(groupLeader, group);
-      await members[0].post(`/challenges/${challenge._id}/join`);
+      challengeLeader = members[0];
+      otherMember = members[1];
+
+      challenge = await generateChallenge(challengeLeader, group);
     });
 
-    it('fails if user doesn\'t have access to the challenge', async () => {
-      await expect(user.get(`/challenges/${challenge._id}`)).to.eventually.be.rejected.and.eql({
+    it('fails if user isn\'t in the guild and isn\'t challenge leader', async () => {
+      await expect(nonMember.get(`/challenges/${challenge._id}`)).to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
         message: t('challengeNotFound'),
       });
     });
 
-    it('should return challenge data', async () => {
-      let chal = await members[0].get(`/challenges/${challenge._id}`);
+    it('returns challenge data for any user in the guild', async () => {
+      let chal = await otherMember.get(`/challenges/${challenge._id}`);
       expect(chal.name).to.equal(challenge.name);
       expect(chal._id).to.equal(challenge._id);
 
       expect(chal.leader).to.eql({
-        _id: groupLeader._id,
-        id: groupLeader._id,
-        profile: {name: groupLeader.profile.name},
+        _id: challengeLeader._id,
+        id: challengeLeader._id,
+        profile: {name: challengeLeader.profile.name},
       });
       expect(chal.group).to.eql({
         _id: group._id,
@@ -111,52 +117,72 @@ describe('GET /challenges/:challengeId', () => {
         leader: groupLeader.id,
       });
     });
+
+    it('returns challenge data if challenge leader isn\'t in the guild or challenge', async () => {
+      await challengeLeader.post(`/groups/${group._id}/leave`);
+      await challengeLeader.sync();
+      expect(challengeLeader.guilds).to.be.empty; // check that leaving worked
+
+      let chal = await challengeLeader.get(`/challenges/${challenge._id}`);
+      expect(chal.name).to.equal(challenge.name);
+      expect(chal._id).to.equal(challenge._id);
+
+      expect(chal.leader).to.eql({
+        _id: challengeLeader._id,
+        id: challengeLeader._id,
+        profile: {name: challengeLeader.profile.name},
+      });
+    });
   });
 
   context('party', () => {
     let groupLeader;
+    let challengeLeader;
     let group;
     let challenge;
     let members;
-    let user;
+    let nonMember;
+    let otherMember;
 
     beforeEach(async () => {
-      user = await generateUser();
+      nonMember = await generateUser();
 
       let populatedGroup = await createAndPopulateGroup({
-        groupDetails: {type: 'party'},
-        members: 1,
+        groupDetails: {type: 'party', privacy: 'private'},
+        members: 2,
       });
 
       groupLeader = populatedGroup.groupLeader;
       group = populatedGroup.group;
       members = populatedGroup.members;
 
-      challenge = await generateChallenge(groupLeader, group);
-      await members[0].post(`/challenges/${challenge._id}/join`);
+      challengeLeader = members[0];
+      otherMember = members[1];
+
+      challenge = await generateChallenge(challengeLeader, group);
     });
 
-    it('fails if user doesn\'t have access to the challenge', async () => {
-      await expect(user.get(`/challenges/${challenge._id}`)).to.eventually.be.rejected.and.eql({
+    it('fails if user isn\'t in the party and isn\'t challenge leader', async () => {
+      await expect(nonMember.get(`/challenges/${challenge._id}`)).to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
         message: t('challengeNotFound'),
       });
     });
 
-    it('should return challenge data', async () => {
-      let chal = await members[0].get(`/challenges/${challenge._id}`);
+    it('returns challenge data for any user in the party', async () => {
+      let chal = await otherMember.get(`/challenges/${challenge._id}`);
       expect(chal.name).to.equal(challenge.name);
       expect(chal._id).to.equal(challenge._id);
 
       expect(chal.leader).to.eql({
-        _id: groupLeader._id,
-        id: groupLeader.id,
-        profile: {name: groupLeader.profile.name},
+        _id: challengeLeader._id,
+        id: challengeLeader._id,
+        profile: {name: challengeLeader.profile.name},
       });
       expect(chal.group).to.eql({
         _id: group._id,
-        id: group.id,
+        id: group._id,
         categories: [],
         name: group.name,
         summary: group.name,
@@ -165,5 +191,21 @@ describe('GET /challenges/:challengeId', () => {
         leader: groupLeader.id,
       });
     });
+
+    it('returns challenge data if challenge leader isn\'t in the party or challenge', async () => {
+      await challengeLeader.post('/groups/party/leave');
+      await challengeLeader.sync();
+      expect(challengeLeader.party._id).to.be.undefined; // check that leaving worked
+
+      let chal = await challengeLeader.get(`/challenges/${challenge._id}`);
+      expect(chal.name).to.equal(challenge.name);
+      expect(chal._id).to.equal(challenge._id);
+
+      expect(chal.leader).to.eql({
+        _id: challengeLeader._id,
+        id: challengeLeader._id,
+        profile: {name: challengeLeader.profile.name},
+      });
+    });
   });
 });

test/api/v3/integration/challenges/GET-challenges_challengeId_export_csv.test.js

@@ -4,7 +4,7 @@ import {
   generateChallenge,
   translate as t,
   sleep,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';
 
 describe('GET /challenges/:challengeId/export/csv', () => {
@@ -24,6 +24,7 @@ describe('GET /challenges/:challengeId/export/csv', () => {
     members = populatedGroup.members;
 
     challenge = await generateChallenge(groupLeader, group);
+    await groupLeader.post(`/challenges/${challenge._id}/join`);
     await members[0].post(`/challenges/${challenge._id}/join`);
     await members[1].post(`/challenges/${challenge._id}/join`);
     await members[2].post(`/challenges/${challenge._id}/join`);

test/api/v3/integration/challenges/GET-challenges_challengeId_members.test.js

@@ -1,16 +1,17 @@
 import {
   generateUser,
   generateGroup,
+  createAndPopulateGroup,
   generateChallenge,
   translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';
 
 describe('GET /challenges/:challengeId/members', () => {
   let user;
 
   beforeEach(async () => {
-    user = await generateUser();
+    user = await generateUser({ balance: 1 });
   });
 
   it('validates optional req.query.lastId to be an UUID', async () => {
@@ -21,7 +22,7 @@ describe('GET /challenges/:challengeId/members', () => {
     });
   });
 
-  it('fails if challenge doesn\'t exists', async () => {
+  it('fails if challenge doesn\'t exist', async () => {
     await expect(user.get(`/challenges/${generateUUID()}/members`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
@@ -29,8 +30,8 @@ describe('GET /challenges/:challengeId/members', () => {
     });
   });
 
-  it('fails if user doesn\'t have access to the challenge', async () => {
-    let group = await generateGroup(user);
+  it('fails if user isn\'t in the private group and isn\'t challenge leader', async () => {
+    let group = await generateGroup(user, {type: 'party', privacy: 'private'});
     let challenge = await generateChallenge(user, group);
     let anotherUser = await generateUser();
 
@@ -41,10 +42,32 @@ describe('GET /challenges/:challengeId/members', () => {
     });
   });
 
+  it('works if user isn\'t in the private group but is challenge leader', async () => {
+    let populatedGroup = await createAndPopulateGroup({
+      groupDetails: {type: 'party', privacy: 'private'},
+      members: 1,
+    });
+    let groupLeader = populatedGroup.groupLeader;
+    let challengeLeader = populatedGroup.members[0];
+    let challenge = await generateChallenge(challengeLeader, populatedGroup.group);
+    await groupLeader.post(`/challenges/${challenge._id}/join`);
+    await challengeLeader.post('/groups/party/leave');
+    await challengeLeader.sync();
+    expect(challengeLeader.party._id).to.be.undefined; // check that leaving worked
+
+    let res = await challengeLeader.get(`/challenges/${challenge._id}/members`);
+    expect(res[0]).to.eql({
+      _id: groupLeader._id,
+      id: groupLeader._id,
+      profile: {name: groupLeader.profile.name},
+    });
+  });
+
   it('works with challenges belonging to public guild', async () => {
     let leader = await generateUser({balance: 4});
     let group = await generateGroup(leader, {type: 'guild', privacy: 'public', name: generateUUID()});
     let challenge = await generateChallenge(leader, group);
+    await leader.post(`/challenges/${challenge._id}/join`);
     let res = await user.get(`/challenges/${challenge._id}/members`);
     expect(res[0]).to.eql({
       _id: leader._id,
@@ -59,6 +82,7 @@ describe('GET /challenges/:challengeId/members', () => {
     let anotherUser = await generateUser({balance: 3});
     let group = await generateGroup(anotherUser, {type: 'guild', privacy: 'public', name: generateUUID()});
     let challenge = await generateChallenge(anotherUser, group);
+    await anotherUser.post(`/challenges/${challenge._id}/join`);
     let res = await user.get(`/challenges/${challenge._id}/members`);
     expect(res[0]).to.eql({
       _id: anotherUser._id,
@@ -72,6 +96,7 @@ describe('GET /challenges/:challengeId/members', () => {
   it('returns only first 30 members if req.query.includeAllMembers is not true', async () => {
     let group = await generateGroup(user, {type: 'party', name: generateUUID()});
     let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
 
     let usersToGenerate = [];
     for (let i = 0; i < 31; i++) {
@@ -90,6 +115,7 @@ describe('GET /challenges/:challengeId/members', () => {
   it('returns only first 30 members if req.query.includeAllMembers is not defined', async () => {
     let group = await generateGroup(user, {type: 'party', name: generateUUID()});
     let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
 
     let usersToGenerate = [];
     for (let i = 0; i < 31; i++) {
@@ -108,6 +134,7 @@ describe('GET /challenges/:challengeId/members', () => {
   it('returns all members if req.query.includeAllMembers is true', async () => {
     let group = await generateGroup(user, {type: 'party', name: generateUUID()});
     let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
 
     let usersToGenerate = [];
     for (let i = 0; i < 31; i++) {
@@ -127,6 +154,7 @@ describe('GET /challenges/:challengeId/members', () => {
     this.timeout(30000); // @TODO: times out after 8 seconds
     let group = await generateGroup(user, {type: 'party', name: generateUUID()});
     let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
 
     let usersToGenerate = [];
     for (let i = 0; i < 57; i++) {
@@ -147,6 +175,7 @@ describe('GET /challenges/:challengeId/members', () => {
   it('supports using req.query.search to get search members', async () => {
     let group = await generateGroup(user, {type: 'party', name: generateUUID()});
     let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
 
     let usersToGenerate = [];
     for (let i = 0; i < 3; i++) {

test/api/v3/integration/challenges/GET-challenges_challengeId_members_memberId.test.js

@@ -3,7 +3,7 @@ import {
   generateChallenge,
   generateGroup,
   translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';
 
 describe('GET /challenges/:challengeId/members/:memberId', () => {
@@ -50,6 +50,7 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
   it('fails if user doesn\'t have access to the challenge', async () => {
     let group = await generateGroup(user, {type: 'party', name: generateUUID()});
     let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
     let anotherUser = await generateUser();
     let member = await generateUser();
     await expect(anotherUser.get(`/challenges/${challenge._id}/members/${member._id}`)).to.eventually.be.rejected.and.eql({
@@ -62,6 +63,7 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
   it('fails if member is not part of the challenge', async () => {
     let group = await generateGroup(user, {type: 'party', name: generateUUID()});
     let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
     let member = await generateUser();
     await expect(user.get(`/challenges/${challenge._id}/members/${member._id}`)).to.eventually.be.rejected.and.eql({
       code: 404,
@@ -74,6 +76,7 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
     let groupLeader = await generateUser({balance: 4});
     let group = await generateGroup(groupLeader, {type: 'guild', privacy: 'public', name: generateUUID()});
     let challenge = await generateChallenge(groupLeader, group);
+    await groupLeader.post(`/challenges/${challenge._id}/join`);
     let taskText = 'Test Text';
     await groupLeader.post(`/tasks/challenge/${challenge._id}`, [{type: 'habit', text: taskText}]);
 
@@ -86,6 +89,7 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
   it('returns the member tasks for the challenges', async () => {
     let group = await generateGroup(user, {type: 'party', name: generateUUID()});
     let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
     await user.post(`/tasks/challenge/${challenge._id}`, [{type: 'habit', text: 'Test Text'}]);
 
     let memberProgress = await user.get(`/challenges/${challenge._id}/members/${user._id}`);
@@ -98,6 +102,7 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
   it('returns the tasks without the tags and checklist', async () => {
     let group = await generateGroup(user, {type: 'party', name: generateUUID()});
     let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
     let taskText = 'Test Text';
     await user.post(`/tasks/challenge/${challenge._id}`, [{
       type: 'todo',

test/api/v3/integration/challenges/GET-challenges_group_groupid.test.js

@@ -3,7 +3,7 @@ import {
   generateChallenge,
   createAndPopulateGroup,
   translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { TAVERN_ID } from '../../../../../website/common/script/constants';
 
 describe('GET challenges/groups/:groupId', () => {
@@ -25,7 +25,9 @@ describe('GET challenges/groups/:groupId', () => {
       nonMember = await generateUser();
 
       challenge = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge._id}/join`);
       challenge2 = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge2._id}/join`);
     });
 
     it('should return group challenges for non member with populated leader', async () => {
@@ -73,6 +75,7 @@ describe('GET challenges/groups/:groupId', () => {
       expect(foundChallengeIndex).to.eql(0);
 
       let newChallenge = await generateChallenge(user, publicGuild);
+      await user.post(`/challenges/${newChallenge._id}/join`);
 
       challenges = await user.get(`/challenges/groups/${publicGuild._id}`);
 
@@ -99,7 +102,9 @@ describe('GET challenges/groups/:groupId', () => {
       nonMember = await generateUser();
 
       challenge = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge._id}/join`);
       challenge2 = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge2._id}/join`);
     });
 
     it('should prevent non-member from seeing challenges', async () => {
@@ -156,9 +161,12 @@ describe('GET challenges/groups/:groupId', () => {
           slug: 'habitica_official',
         }],
       });
+      await user.post(`/challenges/${officialChallenge._id}/join`);
 
       challenge = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge._id}/join`);
       challenge2 = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge2._id}/join`);
     });
 
     it('should return official challenges first', async () => {
@@ -178,6 +186,7 @@ describe('GET challenges/groups/:groupId', () => {
       expect(foundChallengeIndex).to.eql(1);
 
       let newChallenge = await generateChallenge(user, publicGuild);
+      await user.post(`/challenges/${newChallenge._id}/join`);
 
       challenges = await user.get(`/challenges/groups/${publicGuild._id}`);
 
@@ -203,7 +212,9 @@ describe('GET challenges/groups/:groupId', () => {
       nonMember = await generateUser();
 
       challenge = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge._id}/join`);
       challenge2 = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge2._id}/join`);
     });
 
     it('should prevent non-member from seeing challenges', async () => {
@@ -263,7 +274,9 @@ describe('GET challenges/groups/:groupId', () => {
       tavern = await user.get(`/groups/${TAVERN_ID}`);
 
       challenge = await generateChallenge(user, tavern, {prize: 1});
+      await user.post(`/challenges/${challenge._id}/join`);
       challenge2 = await generateChallenge(user, tavern, {prize: 1});
+      await user.post(`/challenges/${challenge2._id}/join`);
     });
 
     it('should return tavern challenges with populated leader', async () => {

test/api/v3/integration/challenges/GET-challenges_user.test.js

@@ -2,7 +2,7 @@ import {
   generateUser,
   generateChallenge,
   createAndPopulateGroup,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 
 describe('GET challenges/user', () => {
   context('no official challenges', () => {
@@ -24,7 +24,9 @@ describe('GET challenges/user', () => {
       nonMember = await generateUser();
 
       challenge = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge._id}/join`);
       challenge2 = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge2._id}/join`);
     });
 
     it('should return challenges user has joined', async () => {
@@ -146,6 +148,7 @@ describe('GET challenges/user', () => {
       expect(foundChallengeIndex).to.eql(0);
 
       let newChallenge = await generateChallenge(user, publicGuild);
+      await user.post(`/challenges/${newChallenge._id}/join`);
 
       challenges = await user.get('/challenges/user');
 
@@ -164,6 +167,7 @@ describe('GET challenges/user', () => {
       });
 
       let privateChallenge = await generateChallenge(groupLeader, group);
+      await groupLeader.post(`/challenges/${privateChallenge._id}/join`);
 
       let challenges = await nonMember.get('/challenges/user');
 
@@ -198,9 +202,12 @@ describe('GET challenges/user', () => {
           slug: 'habitica_official',
         }],
       });
+      await user.post(`/challenges/${officialChallenge._id}/join`);
 
       challenge = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge._id}/join`);
       challenge2 = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge2._id}/join`);
     });
 
     it('should return official challenges first', async () => {
@@ -220,6 +227,7 @@ describe('GET challenges/user', () => {
       expect(foundChallengeIndex).to.eql(1);
 
       let newChallenge = await generateChallenge(user, publicGuild);
+      await user.post(`/challenges/${newChallenge._id}/join`);
 
       challenges = await user.get('/challenges/user');
 
@@ -252,12 +260,14 @@ describe('GET challenges/user', () => {
       await user.update({balance: 20});
 
       for (let i = 0; i < 11; i += 1) {
-        await generateChallenge(user, group); // eslint-disable-line
+        let challenge = await generateChallenge(user, group); // eslint-disable-line
+        await user.post(`/challenges/${challenge._id}/join`); // eslint-disable-line
       }
     });
 
     it('returns public guilds filtered by category', async () => {
       const categoryChallenge = await generateChallenge(user, guild, {categories});
+      await user.post(`/challenges/${categoryChallenge._id}/join`);
       const challenges = await user.get(`/challenges/user?categories=${categories[0].slug}`);
 
       expect(challenges[0]._id).to.eql(categoryChallenge._id);

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

@@ -2,7 +2,7 @@ import {
   generateUser,
   createAndPopulateGroup,
   translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';
 
 describe('POST /challenges', () => {
@@ -94,16 +94,6 @@ describe('POST /challenges', () => {
       });
     });
 
-    it('returns an error when non-leader member creates a challenge in leaderOnly group', async () => {
-      await expect(groupMember.post('/challenges', {
-        group: group._id,
-      })).to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('onlyGroupLeaderChal'),
-      });
-    });
-
     it('allows non-leader member to create a challenge', async () => {
       let populatedGroup = await createAndPopulateGroup({
         members: 1,
@@ -242,7 +232,6 @@ describe('POST /challenges', () => {
     it('returns an error when challenge validation fails; doesn\'s save user or group', async () => {
       let oldChallengeCount = group.challengeCount;
       let oldUserBalance = groupLeader.balance;
-      let oldUserChallenges = groupLeader.challenges;
       let oldGroupBalance = group.balance;
 
       await expect(groupLeader.post('/challenges', {
@@ -260,7 +249,6 @@ describe('POST /challenges', () => {
       expect(group.challengeCount).to.eql(oldChallengeCount);
       expect(group.balance).to.eql(oldGroupBalance);
       expect(groupLeader.balance).to.eql(oldUserBalance);
-      expect(groupLeader.challenges).to.eql(oldUserChallenges);
     });
 
     it('sets all properites of the challenge as passed', async () => {
@@ -291,28 +279,29 @@ describe('POST /challenges', () => {
         name: group.name,
         type: group.type,
       });
-      expect(challenge.memberCount).to.eql(1);
+      expect(challenge.memberCount).to.eql(0);
       expect(challenge.prize).to.eql(prize);
     });
 
-    it('adds challenge to creator\'s challenges', async () => {
-      let challenge = await groupLeader.post('/challenges', {
+    it('does not add challenge to creator\'s challenges', async () => {
+      await groupLeader.post('/challenges', {
         group: group._id,
         name: 'Test Challenge',
         shortName: 'TC Label',
       });
 
-      await expect(groupLeader.sync()).to.eventually.have.property('challenges').to.include(challenge._id);
+      await groupLeader.sync();
+      expect(groupLeader.challenges.length).to.equal(0);
     });
 
-    it('awards achievement if this is creator\'s first challenge', async () => {
+    it('does not award joinedChallenge achievement for creating a challenge', async () => {
       await groupLeader.post('/challenges', {
         group: group._id,
         name: 'Test Challenge',
         shortName: 'TC Label',
       });
       groupLeader = await groupLeader.sync();
-      expect(groupLeader.achievements.joinedChallenge).to.be.true;
+      expect(groupLeader.achievements.joinedChallenge).to.not.be.true;
     });
 
     it('sets summary to challenges name when not supplied', async () => {

test/api/v3/integration/challenges/POST-challenges_challengeId_join.test.js

@@ -3,7 +3,7 @@ import {
   generateChallenge,
   createAndPopulateGroup,
   translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';
 
 describe('POST /challenges/:challengeId/join', () => {
@@ -43,9 +43,10 @@ describe('POST /challenges/:challengeId/join', () => {
       authorizedUser = populatedGroup.members[0];
 
       challenge = await generateChallenge(groupLeader, group);
+      await groupLeader.post(`/challenges/${challenge._id}/join`);
     });
 
-    it('returns an error when user doesn\'t have permissions to access the challenge', async () => {
+    it('returns an error when user isn\'t in the private group and isn\'t challenge leader', async () => {
       let unauthorizedUser = await generateUser();
 
       await expect(unauthorizedUser.post(`/challenges/${challenge._id}/join`)).to.eventually.be.rejected.and.eql({
@@ -55,6 +56,16 @@ describe('POST /challenges/:challengeId/join', () => {
       });
     });
 
+    it('succeeds when user isn\'t in the private group but is challenge leader', async () => {
+      await groupLeader.post(`/challenges/${challenge._id}/leave`);
+      await groupLeader.post(`/groups/${group._id}/leave`);
+      await groupLeader.sync();
+      expect(groupLeader.guilds).to.be.empty; // check that leaving worked
+
+      let res = await groupLeader.post(`/challenges/${challenge._id}/join`);
+      expect(res.name).to.equal(challenge.name);
+    });
+
     it('returns challenge data', async () => {
       let res = await authorizedUser.post(`/challenges/${challenge._id}/join`);
 
@@ -91,6 +102,7 @@ describe('POST /challenges/:challengeId/join', () => {
     });
 
     it('increases memberCount of challenge', async () => {
+      await challenge.sync();
       let oldMemberCount = challenge.memberCount;
 
       await authorizedUser.post(`/challenges/${challenge._id}/join`);

test/api/v3/integration/challenges/POST-challenges_challengeId_leave.test.js

@@ -3,7 +3,7 @@ import {
   generateChallenge,
   createAndPopulateGroup,
   translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';
 
 describe('POST /challenges/:challengeId/leave', () => {
@@ -48,6 +48,7 @@ describe('POST /challenges/:challengeId/leave', () => {
       notInGroupLeavingUser = populatedGroup.members[2];
 
       challenge = await generateChallenge(groupLeader, group);
+      await groupLeader.post(`/challenges/${challenge._id}/join`);
 
       taskText = 'A challenge task text';
 

test/api/v3/integration/challenges/POST-challenges_challengeId_winner_winnerId.test.js

@@ -5,7 +5,7 @@ import {
   sleep,
   checkExistence,
   translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';
 
 describe('POST /challenges/:challengeId/winner/:winnerId', () => {
@@ -58,6 +58,7 @@ describe('POST /challenges/:challengeId/winner/:winnerId', () => {
       challenge = await generateChallenge(groupLeader, group, {
         prize: 1,
       });
+      await groupLeader.post(`/challenges/${challenge._id}/join`);
 
       await groupLeader.post(`/tasks/challenge/${challenge._id}`, [
         {type: 'habit', text: taskText},

test/api/v3/integration/challenges/POST_challenges_id_clone.test.js

@@ -1,7 +1,7 @@
 import {
   generateUser,
   generateGroup,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 
 describe('POST /challenges/:challengeId/clone', () => {
   it('clones a challenge', async () => {

test/api/v3/integration/challenges/PUT-challenges_challengeId.test.js

@@ -3,7 +3,7 @@ import {
   generateChallenge,
   createAndPopulateGroup,
   translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 
 describe('PUT /challenges/:challengeId', () => {
   let privateGuild, user, nonMember, challenge, member;
@@ -25,6 +25,7 @@ describe('PUT /challenges/:challengeId', () => {
     member = members[0];
 
     challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
     await member.post(`/challenges/${challenge._id}/join`);
   });
 

test/api/v3/integration/chat/DELETE-chat_id.test.js

@@ -2,7 +2,7 @@ import {
   createAndPopulateGroup,
   generateUser,
   translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';
 
 describe('DELETE /groups/:groupId/chat/:chatId', () => {

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

@@ -2,7 +2,7 @@ import {
   generateUser,
   generateGroup,
   translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 
 describe('GET /groups/:groupId/chat', () => {
   let user;

test/api/v3/integration/chat/POST-chat.flag.test.js

@@ -1,17 +1,25 @@
 import {
   generateUser,
   translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { find } from 'lodash';
+import moment from 'moment';
+import nconf from 'nconf';
+import { IncomingWebhook } from '@slack/client';
+
+const BASE_URL = nconf.get('BASE_URL');
 
 describe('POST /chat/:chatId/flag', () => {
-  let user, admin, anotherUser, group;
+  let user, admin, anotherUser, newUser, group;
   const TEST_MESSAGE = 'Test Message';
+  const USER_AGE_FOR_FLAGGING = 3;
 
   beforeEach(async () => {
-    user = await generateUser({balance: 1});
+    user = await generateUser({balance: 1, 'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate()});
     admin = await generateUser({balance: 1, 'contributor.admin': true});
-    anotherUser = await generateUser();
+    anotherUser = await generateUser({'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate()});
+    newUser = await generateUser({'auth.timestamps.created': moment().subtract(1, 'days').toDate()});
+    sandbox.stub(IncomingWebhook.prototype, 'send');
 
     group = await user.post('/groups', {
       name: 'Test Guild',
@@ -20,6 +28,10 @@ describe('POST /chat/:chatId/flag', () => {
     });
   });
 
+  afterEach(() => {
+    sandbox.restore();
+  });
+
   it('Returns an error when chat message is not found', async () => {
     await expect(user.post(`/groups/${group._id}/chat/incorrectMessage/flag`))
       .to.eventually.be.rejected.and.eql({
@@ -34,7 +46,7 @@ describe('POST /chat/:chatId/flag', () => {
     await expect(user.post(`/groups/${group._id}/chat/${message.message.id}/flag`)).to.eventually.be.ok;
   });
 
-  it('Flags a chat', async () => {
+  it('Flags a chat and sends normal message to moderator Slack when user is not new', async () => {
     let { message } = await anotherUser.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
 
     let flagResult = await user.post(`/groups/${group._id}/chat/${message.id}/flag`);
@@ -45,6 +57,62 @@ describe('POST /chat/:chatId/flag', () => {
 
     let messageToCheck = find(groupWithFlags.chat, {id: message.id});
     expect(messageToCheck.flags[user._id]).to.equal(true);
+
+    // Slack message to mods
+    const timestamp = `${moment(message.timestamp).utc().format('YYYY-MM-DD HH:mm')} UTC`;
+
+    /* eslint-disable camelcase */
+    expect(IncomingWebhook.prototype.send).to.be.calledWith({
+      text: `${user.profile.name} (${user.id}; language: en) flagged a message`,
+      attachments: [{
+        fallback: 'Flag Message',
+        color: 'danger',
+        author_name: `${anotherUser.profile.name} - ${anotherUser.auth.local.email} - ${anotherUser._id}\n${timestamp}`,
+        title: 'Flag in Test Guild',
+        title_link: `${BASE_URL}/groups/guild/${group._id}`,
+        text: TEST_MESSAGE,
+        footer: `<https://habitrpg.github.io/flag-o-rama/?groupId=${group._id}&chatId=${message.id}|Flag this message.>`,
+        mrkdwn_in: [
+          'text',
+        ],
+      }],
+    });
+    /* eslint-ensable camelcase */
+  });
+
+  it('Does not increment message flag count and sends different message to moderator Slack when user is new', async () => {
+    let automatedComment = `The post's flag count has not been increased because the flagger's account is less than ${USER_AGE_FOR_FLAGGING} days old.`;
+    let { message } = await newUser.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
+
+    let flagResult = await newUser.post(`/groups/${group._id}/chat/${message.id}/flag`);
+    expect(flagResult.flags[newUser._id]).to.equal(true);
+    expect(flagResult.flagCount).to.equal(0);
+
+    let groupWithFlags = await admin.get(`/groups/${group._id}`);
+
+    let messageToCheck = find(groupWithFlags.chat, {id: message.id});
+    expect(messageToCheck.flags[newUser._id]).to.equal(true);
+
+    // Slack message to mods
+    const timestamp = `${moment(message.timestamp).utc().format('YYYY-MM-DD HH:mm')} UTC`;
+
+    /* eslint-disable camelcase */
+    expect(IncomingWebhook.prototype.send).to.be.calledWith({
+      text: `${newUser.profile.name} (${newUser.id}; language: en) flagged a message`,
+      attachments: [{
+        fallback: 'Flag Message',
+        color: 'danger',
+        author_name: `${newUser.profile.name} - ${newUser.auth.local.email} - ${newUser._id}\n${timestamp}`,
+        title: 'Flag in Test Guild',
+        title_link: `${BASE_URL}/groups/guild/${group._id}`,
+        text: TEST_MESSAGE,
+        footer: `<https://habitrpg.github.io/flag-o-rama/?groupId=${group._id}&chatId=${message.id}|Flag this message.> ${automatedComment}`,
+        mrkdwn_in: [
+          'text',
+        ],
+      }],
+    });
+    /* eslint-ensable camelcase */
   });
 
   it('Flags a chat when the author\'s account was deleted', async () => {
@@ -117,7 +185,7 @@ describe('POST /chat/:chatId/flag', () => {
       });
   });
 
-  it('Returns an error when user tries to flag a message that is already flagged', async () => {
+  it('Returns an error when user tries to flag a message that they already flagged', async () => {
     let { message } = await anotherUser.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
 
     await user.post(`/groups/${group._id}/chat/${message.id}/flag`);

test/api/v3/integration/chat/POST-chat.like.test.js

@@ -1,7 +1,7 @@
 import {
   createAndPopulateGroup,
   translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { find } from 'lodash';
 
 describe('POST /chat/:chatId/like', () => {

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

@@ -1,10 +1,12 @@
+import { IncomingWebhook } from '@slack/client';
+import nconf from 'nconf';
 import {
   createAndPopulateGroup,
   generateUser,
   translate as t,
   sleep,
   server,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import {
   SPAM_MESSAGE_LIMIT,
   SPAM_MIN_EXEMPT_CONTRIB_LEVEL,
@@ -15,8 +17,6 @@ import { getMatchesByWordArray } from '../../../../../website/server/libs/string
 import bannedWords from '../../../../../website/server/libs/bannedWords';
 import guildsAllowingBannedWords from '../../../../../website/server/libs/guildsAllowingBannedWords';
 import * as email from '../../../../../website/server/libs/email';
-import { IncomingWebhook } from '@slack/client';
-import nconf from 'nconf';
 
 const BASE_URL = nconf.get('BASE_URL');
 
@@ -80,12 +80,14 @@ describe('POST /chat', () => {
     });
   });
 
-  it('returns an error when chat privileges are revoked when sending a message to a public guild', async () => {
-    let userWithChatRevoked = await member.update({'flags.chatRevoked': true});
-    await expect(userWithChatRevoked.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage})).to.eventually.be.rejected.and.eql({
-      code: 401,
-      error: 'NotAuthorized',
-      message: t('chatPrivilegesRevoked'),
+  describe('mute user', () => {
+    it('returns an error when chat privileges are revoked when sending a message to a public guild', async () => {
+      const userWithChatRevoked = await member.update({'flags.chatRevoked': true});
+      await expect(userWithChatRevoked.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage})).to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('chatPrivilegesRevoked'),
+      });
     });
   });
 
@@ -259,7 +261,6 @@ describe('POST /chat', () => {
           title: 'Slur in Test Guild',
           title_link: `${BASE_URL}/groups/guild/${groupWithChat.id}`,
           text: testSlurMessage,
-          // footer: sandbox.match(/<.*?groupId=group-id&chatId=chat-id\|Flag this message>/),
           mrkdwn_in: [
             'text',
           ],
@@ -274,6 +275,7 @@ describe('POST /chat', () => {
         message: t('chatPrivilegesRevoked'),
       });
 
+      // @TODO: The next test should not depend on this. We should reset the user test in a beforeEach
       // Restore chat privileges to continue testing
       user.flags.chatRevoked = false;
       await user.update({'flags.chatRevoked': false});
@@ -312,7 +314,6 @@ describe('POST /chat', () => {
           title: 'Slur in Party - (private party)',
           title_link: undefined,
           text: testSlurMessage,
-          // footer: sandbox.match(/<.*?groupId=group-id&chatId=chat-id\|Flag this message>/),
           mrkdwn_in: [
             'text',
           ],
@@ -388,6 +389,23 @@ describe('POST /chat', () => {
     expect(groupMessages[0].id).to.exist;
   });
 
+  it('creates a chat with a max length of 3000 chars', async () => {
+    const veryLongMessage = `
+    123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789.
+    THIS PART WON'T BE IN THE MESSAGE (over 3000)
+    `;
+
+    const newMessage = await user.post(`/groups/${groupWithChat._id}/chat`, { message: veryLongMessage});
+    const groupMessages = await user.get(`/groups/${groupWithChat._id}/chat`);
+
+    expect(newMessage.message.id).to.exist;
+    expect(groupMessages[0].id).to.exist;
+
+    expect(newMessage.message.text.length).to.eql(3000);
+    expect(newMessage.message.text).to.not.contain('MESSAGE');
+    expect(groupMessages[0].text.length).to.eql(3000);
+  });
+
   it('creates a chat with user styles', async () => {
     const mount = 'test-mount';
     const pet = 'test-pet';

test/api/v3/integration/chat/POST-chat_seen.test.js

@@ -1,7 +1,7 @@
 import {
   createAndPopulateGroup,
   sleep,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 
 describe('POST /groups/:id/chat/seen', () => {
   context('Guild', () => {

test/api/v3/integration/chat/POST-groups_id_chat_id_clear_flags.test.js

@@ -2,25 +2,26 @@ import {
   createAndPopulateGroup,
   generateUser,
   translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import config from '../../../../../config.json';
+import moment from 'moment';
 import { v4 as generateUUID } from 'uuid';
 
 describe('POST /groups/:id/chat/:id/clearflags', () => {
+  const USER_AGE_FOR_FLAGGING = 3;
   let groupWithChat, message, author, nonAdmin, admin;
 
   before(async () => {
-    let { group, groupLeader, members } = await createAndPopulateGroup({
+    let { group, groupLeader } = await createAndPopulateGroup({
       groupDetails: {
         type: 'guild',
         privacy: 'public',
       },
-      members: 1,
     });
 
     groupWithChat = group;
     author = groupLeader;
-    nonAdmin = members[0];
+    nonAdmin = await generateUser({'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate()});
     admin = await generateUser({'contributor.admin': true});
 
     message = await author.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some message' });
@@ -69,9 +70,14 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
       privateMessage = privateMessage.message;
 
       await admin.post(`/groups/${group._id}/chat/${privateMessage.id}/flag`);
+
+      // first test that the flag was actually successful
+      let messages = await members[0].get(`/groups/${group._id}/chat`);
+      expect(messages[0].flagCount).to.eql(5);
+
       await admin.post(`/groups/${group._id}/chat/${privateMessage.id}/clearflags`);
 
-      let messages = await members[0].get(`/groups/${group._id}/chat`);
+      messages = await members[0].get(`/groups/${group._id}/chat`);
       expect(messages[0].flagCount).to.eql(0);
     });