5.14.0

commit 0e20f421645beaf231dd607b1c1d8db62e5804e4
Author: SabreCat <sabrecat@gmail.com>
Date:   Thu Dec 14 15:40:22 2023 -0600

    fix(g1g1): don't break modal off promo season

commit ca5436d05044d256303e9c5dcdf358b64467ae66
Author: SabreCat <sabe@habitica.com>
Date:   Tue Nov 28 20:42:55 2023 -0600

    fix(lint): move import

commit 08f58318da1a06c2d94227afd3224a5571990bac
Author: SabreCat <sabe@habitica.com>
Date:   Tue Nov 28 20:26:14 2023 -0600

    fix(vue): parenthesis

commit 8701ee330365ad0615b2179b801f8e15c3109bdd
Author: SabreCat <sabe@habitica.com>
Date:   Tue Nov 28 20:09:30 2023 -0600

    fix(g1g1): dynamically display end dates

.github/dependabot.yml

@@ -104,42 +104,6 @@ updates:
     - 7.7.0
     - 7.8.0
     - 7.9.0
-  - dependency-name: "@storybook/addon-knobs"
-    versions:
-    - 6.1.17
-    - 6.1.18
-    - 6.1.20
-    - 6.1.21
-    - 6.2.2
-    - 6.2.3
-    - 6.2.7
-  - dependency-name: "@storybook/addon-links"
-    versions:
-    - 6.1.17
-    - 6.1.18
-    - 6.1.20
-    - 6.1.21
-    - 6.2.2
-    - 6.2.3
-    - 6.2.7
-  - dependency-name: "@storybook/vue"
-    versions:
-    - 6.1.17
-    - 6.1.18
-    - 6.1.20
-    - 6.1.21
-    - 6.2.2
-    - 6.2.3
-    - 6.2.7
-  - dependency-name: "@storybook/addon-actions"
-    versions:
-    - 6.1.17
-    - 6.1.18
-    - 6.1.20
-    - 6.1.21
-    - 6.2.2
-    - 6.2.3
-    - 6.2.7
   - dependency-name: core-js
     versions:
     - 3.10.0

.github/workflows/test.yml

@@ -2,6 +2,9 @@ name: Test
 
 on: [push, pull_request]
 
+permissions:
+  contents: read
+
 jobs:
   lint:
     runs-on: ubuntu-latest

apidoc/apidoc.json

@@ -2,6 +2,7 @@
   "name": "Habitica V3 API Documentation",
   "title": "Habitica",
   "url": "https://habitica.com",
+  "version": "3.0.0",
   "sampleUrl": null,
   "header": {
     "title": "Introduction",

config.json.example

@@ -1,4 +1,5 @@
 {
+  "ACCOUNT_MIN_CHAT_AGE": "0",
   "ADMIN_EMAIL": "you@example.com",
   "AMAZON_PAYMENTS_CLIENT_ID": "CLIENT_ID",
   "AMAZON_PAYMENTS_MODE": "sandbox",
@@ -85,5 +86,6 @@
   "RATE_LIMITER_ENABLED": "false",
   "REDIS_HOST": "aaabbbcccdddeeefff",
   "REDIS_PORT": "1234",
-  "REDIS_PASSWORD": "12345678"
+  "REDIS_PASSWORD": "12345678",
+  "TRUSTED_DOMAINS": "localhost,habitica.com"
 }

docker-compose.dev.yml

@@ -1,4 +1,3 @@
-version: "3"
 services:
   client:
     build:
@@ -9,7 +8,6 @@ services:
       - server
     environment:
       - BASE_URL=http://server:3000
-    image: habitica
     networks:
       - habitica
     ports:
@@ -27,7 +25,6 @@ services:
       - mongo
     environment:
       - NODE_DB_URI=mongodb://mongo/habitrpg
-    image: habitica
     networks:
       - habitica
     ports:

gulp/gulp-build.js

@@ -51,7 +51,7 @@ gulp.task('build:prepare-mongo', async () => {
   console.log('MongoDB data folder is missing, setting up.'); // eslint-disable-line no-console
 
   // use run-rs without --keep, kill it as soon as the replica set starts
-  const runRsProcess = spawn('run-rs', ['-v', '4.2.8', '-l', 'ubuntu1804', '--dbpath', 'mongodb-data', '--number', '1', '--quiet']);
+  const runRsProcess = spawn('run-rs', ['-v', '4.1.1', '-l', 'ubuntu1804', '--dbpath', 'mongodb-data', '--number', '1', '--quiet']);
 
   for await (const chunk of runRsProcess.stdout) {
     const stringChunk = chunk.toString();

migrations/archive/2022/20220915_transactions_user_name.js

@@ -0,0 +1,97 @@
+/* eslint-disable no-console */
+import { model as UserModel } from '../../../website/server/models/user';
+import { TransactionModel } from '../../../website/server/models/transaction';
+
+const MIGRATION_NAME = '20220915_transactions_user_name';
+
+/* transaction config */
+const transactionPerRun = 500;
+const progressCount = 1000;
+const transactionQuery = {
+  migration: { $ne: MIGRATION_NAME }, // skip already migrated entries
+  'transactionType': { $in: ['gift_send', 'gift_receive'] },
+};
+
+let count = 0;
+async function updateTransaction (transaction, userNameMap) {
+  count++;
+
+  const set = {
+    migration: MIGRATION_NAME,
+  };
+
+  if (userNameMap.has(transaction.reference)) {
+    set['referenceText'] = userNameMap.get(transaction.reference);
+  } else {
+    set['referenceText'] = 'Account not found';
+  }
+
+  if (count % progressCount === 0) {
+    console.warn(`${count} ${transaction._id}`);
+  }
+
+  return TransactionModel.updateOne({
+    _id: transaction._id
+  }, { $set: set }).exec();
+}
+
+export default async function processTransactions () {
+  const fields = {
+    _id: 1,
+    reference: 1,
+    referenceText: 1,
+  };
+
+  const userNameMap = new Map();
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const foundTransactions = await TransactionModel // eslint-disable-line no-await-in-loop
+      .find(transactionQuery)
+      .limit(transactionPerRun)
+      .sort({reference: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (foundTransactions.length === 0) {
+      console.warn('All appropriate transactions found and modified.');
+      console.warn(`\n${count} transactions processed\n`);
+      break;
+    }
+
+    // check for unknown users and load the names
+    const userIdsToLoad = [];
+    for (const foundTransaction of foundTransactions) {
+      const userId = foundTransaction.reference;
+      if (userNameMap.has(userId))  {
+        continue;
+      }
+
+      userIdsToLoad.push(userId);
+    }
+
+    const users = await UserModel // eslint-disable-line no-await-in-loop
+      .find({
+        _id: { $in: userIdsToLoad }
+      })
+      .select({
+        _id: 1,
+        'auth.local.username': 1,
+      })
+      .lean()
+      .exec();
+
+    for (const user of users) {
+      const localUserName = user.auth?.local?.username;
+
+      if (!localUserName) {
+        console.warn(`\nNo Username found for ID: ${user._id}\n`);
+        continue;
+      }
+
+      userNameMap.set(user._id, localUserName)
+    }
+
+    await Promise.all(foundTransactions.map(t => updateTransaction(t, userNameMap))); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2022/20221031_habitoween_ladder.js

@@ -0,0 +1,86 @@
+/*
+ * Award Habitoween ladder items to participants in this month's Habitoween festivities
+ */
+/* eslint-disable no-console */
+
+const MIGRATION_NAME = '20221031_habitoween_ladder'; // Update when running in future years
+
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = {};
+  const inc = {
+    'items.food.Candy_Skeleton': 1,
+    'items.food.Candy_Base': 1,
+    'items.food.Candy_CottonCandyBlue': 1,
+    'items.food.Candy_CottonCandyPink': 1,
+    'items.food.Candy_Shade': 1,
+    'items.food.Candy_White': 1,
+    'items.food.Candy_Golden': 1,
+    'items.food.Candy_Zombie': 1,
+    'items.food.Candy_Desert': 1,
+    'items.food.Candy_Red': 1,
+  };
+
+  set.migration = MIGRATION_NAME;
+
+  if (user && user.items && user.items.pets && user.items.pets['JackOLantern-RoyalPurple']) {
+    set['items.mounts.JackOLantern-RoyalPurple'] = true;
+  } else if (user && user.items && user.items.mounts && user.items.mounts['JackOLantern-Glow']) {
+    set['items.pets.JackOLantern-RoyalPurple'] = 5;
+  } else if (user && user.items && user.items.pets && user.items.pets['JackOLantern-Glow']) {
+    set['items.mounts.JackOLantern-Glow'] = true;
+  } else if (user && user.items && user.items.mounts && user.items.mounts['JackOLantern-Ghost']) {
+    set['items.pets.JackOLantern-Glow'] = 5;
+  } else if (user && user.items && user.items.pets && user.items.pets['JackOLantern-Ghost']) {
+    set['items.mounts.JackOLantern-Ghost'] = true;
+  } else if (user && user.items && user.items.mounts && user.items.mounts['JackOLantern-Base']) {
+    set['items.pets.JackOLantern-Ghost'] = 5;
+  } else if (user && user.items && user.items.pets && user.items.pets['JackOLantern-Base']) {
+    set['items.mounts.JackOLantern-Base'] = true;
+  } else {
+    set['items.pets.JackOLantern-Base'] = 5;
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+  return await User.update({_id: user._id}, {$inc: inc, $set: set}).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'auth.timestamps.loggedin': {$gt: new Date('2022-10-01')},
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2022/20221031_pet_set_group_achievements.js

@@ -0,0 +1,119 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20221031_pet_set_group_achievements';
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = {
+    migration: MIGRATION_NAME,
+  };
+
+  if (user && user.items && user.items.pets) {
+    const pets = user.items.pets;
+    if (pets['Wolf-Skeleton']
+      && pets['TigerCub-Skeleton']
+      && pets['PandaCub-Skeleton']
+      && pets['LionCub-Skeleton']
+      && pets['Fox-Skeleton']
+      && pets['FlyingPig-Skeleton']
+      && pets['Dragon-Skeleton']
+      && pets['Cactus-Skeleton']
+      && pets['BearCub-Skeleton']
+      && pets['Gryphon-Skeleton']
+      && pets['Hedgehog-Skeleton']
+      && pets['Deer-Skeleton']
+      && pets['Egg-Skeleton']
+      && pets['Rat-Skeleton']
+      && pets['Octopus-Skeleton']
+      && pets['Seahorse-Skeleton']
+      && pets['Parrot-Skeleton']
+      && pets['Rooster-Skeleton']
+      && pets['Spider-Skeleton']
+      && pets['Owl-Skeleton']
+      && pets['Penguin-Skeleton']
+      && pets['TRex-Skeleton']
+      && pets['Rock-Skeleton']
+      && pets['Bunny-Skeleton']
+      && pets['Slime-Skeleton']
+      && pets['Sheep-Skeleton']
+      && pets['Cuttlefish-Skeleton']
+      && pets['Whale-Skeleton']
+      && pets['Cheetah-Skeleton']
+      && pets['Horse-Skeleton']
+      && pets['Frog-Skeleton']
+      && pets['Snake-Skeleton']
+      && pets['Unicorn-Skeleton']
+      && pets['Sabretooth-Skeleton']
+      && pets['Monkey-Skeleton']
+      && pets['Snail-Skeleton']
+      && pets['Falcon-Skeleton']
+      && pets['Treeling-Skeleton']
+      && pets['Axolotl-Skeleton']
+      && pets['Turtle-Skeleton']
+      && pets['Armadillo-Skeleton']
+      && pets['Cow-Skeleton']
+      && pets['Beetle-Skeleton']
+      && pets['Ferret-Skeleton']
+      && pets['Sloth-Skeleton']
+      && pets['Triceratops-Skeleton']
+      && pets['GuineaPig-Skeleton']
+      && pets['Peacock-Skeleton']
+      && pets['Butterfly-Skeleton']
+      && pets['Nudibranch-Skeleton']
+      && pets['Hippo-Skeleton']
+      && pets['Yarn-Skeleton']
+      && pets['Pterodactyl-Skeleton']
+      && pets['Badger-Skeleton']
+      && pets['Squirrel-Skeleton']
+      && pets['SeaSerpent-Skeleton']
+      && pets['Kangaroo-Skeleton']
+      && pets['Alligator-Skeleton']
+      && pets['Velociraptor-Skeleton']
+      && pets['Dolphin-Skeleton']
+      && pets['Robot-Skeleton']) {
+        set['achievements.boneToPick'] = true;
+      }
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({ _id: user._id }, { $set: set }).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    // migration: { $ne: MIGRATION_NAME },
+    'auth.timestamps.loggedin': { $gt: new Date('2022-01-01') },
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1]._id,
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2022/20221213_pet_group_achievements.js

@@ -0,0 +1,108 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20221213_pet_group_achievements';
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = {
+    migration: MIGRATION_NAME,
+  };
+
+  if (user && user.items && user.items.pets) {
+    const pets = user.items.pets;
+    if (pets['BearCub-Base']
+      && pets['BearCub-CottonCandyBlue']
+      && pets['BearCub-CottonCandyPink']
+      && pets['BearCub-Desert']
+      && pets['BearCub-Golden']
+      && pets['BearCub-Red']
+      && pets['BearCub-Shade']
+      && pets['BearCub-Skeleton']
+      && pets['BearCub-White']
+      && pets['BearCub-Zombie']
+      && pets['Fox-Base']
+      && pets['Fox-CottonCandyBlue']
+      && pets['Fox-CottonCandyPink']
+      && pets['Fox-Desert']
+      && pets['Fox-Golden']
+      && pets['Fox-Red']
+      && pets['Fox-Shade']
+      && pets['Fox-Skeleton']
+      && pets['Fox-White']
+      && pets['Fox-Zombie']
+      && pets['Penguin-Base']
+      && pets['Penguin-CottonCandyBlue']
+      && pets['Penguin-CottonCandyPink']
+      && pets['Penguin-Desert']
+      && pets['Penguin-Golden']
+      && pets['Penguin-Red']
+      && pets['Penguin-Shade']
+      && pets['Penguin-Skeleton']
+      && pets['Penguin-White']
+      && pets['Penguin-Zombie']
+      && pets['Whale-Base']
+      && pets['Whale-CottonCandyBlue']
+      && pets['Whale-CottonCandyPink']
+      && pets['Whale-Desert']
+      && pets['Whale-Golden']
+      && pets['Whale-Red']
+      && pets['Whale-Shade']
+      && pets['Whale-Skeleton']
+      && pets['Whale-White']
+      && pets['Whale-Zombie']
+      && pets['Wolf-Base']
+      && pets['Wolf-CottonCandyBlue']
+      && pets['Wolf-CottonCandyPink']
+      && pets['Wolf-Desert']
+      && pets['Wolf-Golden']
+      && pets['Wolf-Red']
+      && pets['Wolf-Shade']
+      && pets['Wolf-Skeleton']
+      && pets['Wolf-White']
+      && pets['Wolf-Zombie'] {
+        set['achievements.polarPro'] = true;
+      }
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({ _id: user._id }, { $set: set }).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    // migration: { $ne: MIGRATION_NAME },
+    'auth.timestamps.loggedin': { $gt: new Date('2022-11-01') },
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1]._id,
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2022/20221227_nye.js

@@ -0,0 +1,144 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20221227_nye';
+import { model as User } from '../../../website/server/models/user';
+import { v4 as uuid } from 'uuid';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = { migration: MIGRATION_NAME };
+  let push;
+
+  if (typeof user.items.gear.owned.head_special_nye2021 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2022'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2022',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2020 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2021'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2021',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2019 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2020'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2020',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2018 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2019'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2019',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2017 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2018'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2018',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2016 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2017'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2017',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2015 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2016'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2016',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2014 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2015'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2015',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye !== 'undefined') {
+    set['items.gear.owned.head_special_nye2014'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2014',
+        _id: uuid(),
+      },
+    ];
+  } else {
+    set['items.gear.owned.head_special_nye'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye',
+        _id: uuid(),
+      },
+    ];
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({_id: user._id}, {$set: set, $push: {pinnedItems: {$each: push}}}).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    'auth.timestamps.loggedin': {$gt: new Date('2022-12-01')},
+    migration: {$ne: MIGRATION_NAME},
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2023/20230123_habit_birthday.js

@@ -0,0 +1,88 @@
+/* eslint-disable no-console */
+import { v4 as uuid } from 'uuid';
+import { model as User } from '../../../website/server/models/user';
+
+const MIGRATION_NAME = '20230123_habit_birthday';
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count += 1;
+
+  const inc = { 'balance': 5 };
+  const set = {};
+  const push = {};
+
+  set.migration = MIGRATION_NAME;
+
+  if (typeof user.items.gear.owned.armor_special_birthday2022 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2023'] = true;
+  } else if (typeof user.items.gear.owned.armor_special_birthday2021 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2022'] = true;
+  } else if (typeof user.items.gear.owned.armor_special_birthday2020 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2021'] = true;
+  } else if (typeof user.items.gear.owned.armor_special_birthday2019 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2020'] = true;
+  } else if (typeof user.items.gear.owned.armor_special_birthday2018 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2019'] = true;
+  } else if (typeof user.items.gear.owned.armor_special_birthday2017 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2018'] = true;
+  } else if (typeof user.items.gear.owned.armor_special_birthday2016 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2017'] = true;
+  } else if (typeof user.items.gear.owned.armor_special_birthday2015 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2016'] = true;
+  } else if (typeof user.items.gear.owned.armor_special_birthday !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2015'] = true;
+  } else {
+    set['items.gear.owned.armor_special_birthday'] = true;
+  }
+
+  push.notifications = {
+    type: 'ITEM_RECEIVED',
+    data: {
+      icon: 'notif_head_special_nye',
+      title: 'Birthday Bash Day 1!',
+      text: 'Enjoy your new Birthday Robe and 20 Gems on us!',
+      destination: 'equipment',
+    },
+    seen: false,
+  };
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({_id: user._id}, {$inc: inc, $set: set, $push: push}).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'auth.timestamps.loggedin': {$gt: new Date('2022-12-23')},
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2023/20230127_habit_birthday_day5.js

@@ -0,0 +1,69 @@
+/* eslint-disable no-console */
+import { v4 as uuid } from 'uuid';
+import { model as User } from '../../../website/server/models/user';
+
+const MIGRATION_NAME = '20230127_habit_birthday_day5';
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count += 1;
+
+  const set = {};
+  const push = {};
+
+  set.migration = MIGRATION_NAME;
+
+  set['items.gear.owned.back_special_anniversary'] = true;
+  set['items.gear.owned.body_special_anniversary'] = true;
+  set['items.gear.owned.eyewear_special_anniversary'] = true;
+
+  push.notifications = {
+    type: 'ITEM_RECEIVED',
+    data: {
+      icon: 'notif_head_special_nye',
+      title: 'Birthday Bash Day 5!',
+      text: 'Come celebrate by wearing your new Habitica Hero Cape, Collar, and Mask!',
+      destination: 'equipment',
+    },
+    seen: false,
+  };
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({_id: user._id}, {$set: set, $push: push}).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'auth.timestamps.loggedin': {$gt: new Date('2022-12-23')},
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2023/20230201_habit_birthday_day10.js

@@ -0,0 +1,79 @@
+/* eslint-disable no-console */
+import { v4 as uuid } from 'uuid';
+import { model as User } from '../../../website/server/models/user';
+
+const MIGRATION_NAME = '20230201_habit_birthday_day10';
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count += 1;
+
+  const set = { 
+    migration: MIGRATION_NAME,
+    'purchased.background.birthday_bash': true,
+  };
+  const push = {
+    notifications: {
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'notif_head_special_nye',
+        title: 'Birthday Bash Day 10!',
+        text: 'Join in for the end of our birthday celebrations with 10th Birthday background, Cake, and achievement!',
+        destination: 'backgrounds',
+      },
+      seen: false,
+    },
+  };
+  const inc = {
+    'items.food.Cake_Skeleton': 1,
+    'items.food.Cake_Base': 1,
+    'items.food.Cake_CottonCandyBlue': 1,
+    'items.food.Cake_CottonCandyPink': 1,
+    'items.food.Cake_Shade': 1,
+    'items.food.Cake_White': 1,
+    'items.food.Cake_Golden': 1,
+    'items.food.Cake_Zombie': 1,
+    'items.food.Cake_Desert': 1,
+    'items.food.Cake_Red': 1,
+    'achievements.habitBirthdays': 1,
+  };
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({_id: user._id}, {$set: set, $push: push, $inc: inc }).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'auth.timestamps.loggedin': {$gt: new Date('2022-12-23')},
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2023/20230522_pet_group_achievements.js

@@ -0,0 +1,158 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20230522_pet_group_achievements';
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = {
+    migration: MIGRATION_NAME,
+  };
+
+  if (user && user.items && user.items.pets) {
+    const pets = user.items.pets;
+    if (pets['Parrot-Base']
+      && pets['Parrot-CottonCandyBlue']
+      && pets['Parrot-CottonCandyPink']
+      && pets['Parrot-Desert']
+      && pets['Parrot-Golden']
+      && pets['Parrot-Red']
+      && pets['Parrot-Shade']
+      && pets['Parrot-Skeleton']
+      && pets['Parrot-White']
+      && pets['Parrot-Zombie']
+      && pets['Rooster-Base']
+      && pets['Rooster-CottonCandyBlue']
+      && pets['Rooster-CottonCandyPink']
+      && pets['Rooster-Desert']
+      && pets['Rooster-Golden']
+      && pets['Rooster-Red']
+      && pets['Rooster-Shade']
+      && pets['Rooster-Skeleton']
+      && pets['Rooster-White']
+      && pets['Rooster-Zombie']
+      && pets['Triceratops-Base']
+      && pets['Triceratops-CottonCandyBlue']
+      && pets['Triceratops-CottonCandyPink']
+      && pets['Triceratops-Desert']
+      && pets['Triceratops-Golden']
+      && pets['Triceratops-Red']
+      && pets['Triceratops-Shade']
+      && pets['Triceratops-Skeleton']
+      && pets['Triceratops-White']
+      && pets['Triceratops-Zombie']
+      && pets['TRex-Base']
+      && pets['TRex-CottonCandyBlue']
+      && pets['TRex-CottonCandyPink']
+      && pets['TRex-Desert']
+      && pets['TRex-Golden']
+      && pets['TRex-Red']
+      && pets['TRex-Shade']
+      && pets['TRex-Skeleton']
+      && pets['TRex-White']
+      && pets['TRex-Zombie']
+      && pets['Pterodactyl-Base']
+      && pets['Pterodactyl-CottonCandyBlue']
+      && pets['Pterodactyl-CottonCandyPink']
+      && pets['Pterodactyl-Desert']
+      && pets['Pterodactyl-Golden']
+      && pets['Pterodactyl-Red']
+      && pets['Pterodactyl-Shade']
+      && pets['Pterodactyl-Skeleton']
+      && pets['Pterodactyl-White']
+      && pets['Pterodactyl-Zombie']
+      && pets['Owl-Base']
+      && pets['Owl-CottonCandyBlue']
+      && pets['Owl-CottonCandyPink']
+      && pets['Owl-Desert']
+      && pets['Owl-Golden']
+      && pets['Owl-Red']
+      && pets['Owl-Shade']
+      && pets['Owl-Skeleton']
+      && pets['Owl-White']
+      && pets['Owl-Zombie']
+      && pets['Velociraptor-Base']
+      && pets['Velociraptor-CottonCandyBlue']
+      && pets['Velociraptor-CottonCandyPink']
+      && pets['Velociraptor-Desert']
+      && pets['Velociraptor-Golden']
+      && pets['Velociraptor-Red']
+      && pets['Velociraptor-Shade']
+      && pets['Velociraptor-Skeleton']
+      && pets['Velociraptor-White']
+      && pets['Velociraptor-Zombie']
+      && pets['Penguin-Base']
+      && pets['Penguin-CottonCandyBlue']
+      && pets['Penguin-CottonCandyPink']
+      && pets['Penguin-Desert']
+      && pets['Penguin-Golden']
+      && pets['Penguin-Red']
+      && pets['Penguin-Shade']
+      && pets['Penguin-Skeleton']
+      && pets['Penguin-White']
+      && pets['Penguin-Zombie']
+      && pets['Falcon-Base']
+      && pets['Falcon-CottonCandyBlue']
+      && pets['Falcon-CottonCandyPink']
+      && pets['Falcon-Desert']
+      && pets['Falcon-Golden']
+      && pets['Falcon-Red']
+      && pets['Falcon-Shade']
+      && pets['Falcon-Skeleton']
+      && pets['Falcon-White']
+      && pets['Falcon-Zombie']
+      && pets['Peacock-Base']
+      && pets['Peacock-CottonCandyBlue']
+      && pets['Peacock-CottonCandyPink']
+      && pets['Peacock-Desert']
+      && pets['Peacock-Golden']
+      && pets['Peacock-Red']
+      && pets['Peacock-Shade']
+      && pets['Peacock-Skeleton']
+      && pets['Peacock-White']
+      && pets['Peacock-Zombie']) {
+        set['achievements.dinosaurDynasty'] = true;
+      }
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({ _id: user._id }, { $set: set }).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    // migration: { $ne: MIGRATION_NAME },
+    'auth.timestamps.loggedin': { $gt: new Date('2023-04-15') },
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1]._id,
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2023/20230718_summer_splash_orcas.js

@@ -0,0 +1,79 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20230718_summer_splash_orcas';
+
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = { migration: MIGRATION_NAME };
+  const push = {};
+
+  if (user && user.items && user.items.pets && typeof user.items.pets['Orca-Base'] !== 'undefined') {
+    return;
+  } else if (user && user.items && user.items.mounts && typeof user.items.mounts['Orca-Base'] !== 'undefined') {
+    set['items.pets.Orca-Base'] = 5;
+    push.notifications = {
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'notif_orca_pet',
+        title: 'Orcas for Summer Splash!',
+        text: 'To celebrate Summer Splash, we\'ve given you an Orca Pet!',
+        destination: 'stable',
+      },
+      seen: false,
+    };
+  } else {
+    set['items.mounts.Orca-Base'] = true;
+    push.notifications = {
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'notif_orca_mount',
+        title: 'Orcas for Summer Splash!',
+        text: 'To celebrate Summer Splash, we\'ve given you an Orca Mount!',
+        destination: 'stable',
+      },
+      seen: false,
+    };
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await user.updateOne({ $set: set, $push: push }).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'auth.timestamps.loggedin': {$gt: new Date('2023-06-18')},
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2023/20230731_naming_day.js

@@ -0,0 +1,155 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20230731_naming_day';
+import { v4 as uuid } from 'uuid';
+
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async 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.back_special_namingDay2020 !== 'undefined') {
+    set = { migration: MIGRATION_NAME };
+    push = {
+      notifications: {
+        type: 'ITEM_RECEIVED',
+        data: {
+          icon: 'notif_namingDay_cake',
+          title: 'Happy Naming Day!',
+          text: 'To celebrate the day we became Habitica, we’ve awarded you some cake!',
+          destination: '/inventory/items',
+        },
+        seen: false,
+      },
+    };
+  } else if (user && user.items && user.items.gear && user.items.gear.owned && typeof user.items.gear.owned.body_special_namingDay2018 !== 'undefined') {
+    set = { migration: MIGRATION_NAME, 'items.gear.owned.back_special_namingDay2020': true };
+    push = {
+      notifications: {
+        type: 'ITEM_RECEIVED',
+        data: {
+          icon: 'notif_namingDay_back',
+          title: 'Happy Naming Day!',
+          text: 'To celebrate the day we became Habitica, we’ve awarded you a Royal Purple Gryphon Tail and cake!',
+          destination: '/inventory/equipment',
+        },
+        seen: false,
+      },
+    };
+  } else if (user && user.items && user.items.gear && user.items.gear.owned && typeof user.items.gear.owned.head_special_namingDay2017 !== 'undefined') {
+    set = { migration: MIGRATION_NAME, 'items.gear.owned.body_special_namingDay2018': true };
+    push = {
+      notifications: {
+        type: 'ITEM_RECEIVED',
+        data: {
+          icon: 'notif_namingDay_body',
+          title: 'Happy Naming Day!',
+          text: 'To celebrate the day we became Habitica, we’ve awarded you a Royal Purple Gryphon Cloak and cake!',
+          destination: '/inventory/equipment',
+        },
+        seen: false,
+      },
+    };
+  } else if (user && user.items && user.items.pets && typeof user.items.pets['Gryphon-RoyalPurple'] !== 'undefined') {
+    set = { migration: MIGRATION_NAME, 'items.gear.owned.head_special_namingDay2017': true };
+    push = {
+      notifications: {
+        type: 'ITEM_RECEIVED',
+        data: {
+          icon: 'notif_namingDay_head',
+          title: 'Happy Naming Day!',
+          text: 'To celebrate the day we became Habitica, we’ve awarded you a Royal Purple Gryphon Helm and cake!',
+          destination: '/inventory/equipment',
+        },
+        seen: false,
+      },
+    };
+  } else if (user && user.items && user.items.mounts && typeof user.items.mounts['Gryphon-RoyalPurple'] !== 'undefined') {
+    set = { migration: MIGRATION_NAME, 'items.pets.Gryphon-RoyalPurple': 5 };
+    push = {
+      notifications: {
+        type: 'ITEM_RECEIVED',
+        data: {
+          icon: 'notif_namingDay_pet',
+          title: 'Happy Naming Day!',
+          text: 'To celebrate the day we became Habitica, we’ve awarded you a Royal Purple Gryphon Pet and cake!',
+          destination: '/inventory/stable',
+        },
+        seen: false,
+      },
+    };
+  } else {
+    set = { migration: MIGRATION_NAME, 'items.mounts.Gryphon-RoyalPurple': true };
+    push = {
+      notifications: {
+        type: 'ITEM_RECEIVED',
+        data: {
+          icon: 'notif_namingDay_mount',
+          title: 'Happy Naming Day!',
+          text: 'To celebrate the day we became Habitica, we’ve awarded you a Royal Purple Gryphon Mount and cake!',
+          destination: '/inventory/stable',
+        },
+        seen: false,
+      },
+    };
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  if (push) {
+    return await user.updateOne({ $set: set, $inc: inc, $push: push }).exec();
+  } else {
+    return await user.updateOne({ $set: set, $inc: inc }).exec();
+  }
+}
+
+export default async function processUsers () {
+  let query = {
+    migration: { $ne: MIGRATION_NAME },
+    'auth.timestamps.loggedin': { $gt: new Date('2023-07-01') },
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1]._id,
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2023/20230808_guild_gems.js

@@ -0,0 +1,72 @@
+/* eslint-disable no-console */
+import { model as User } from '../../../website/server/models/user';
+import { model as Group } from '../../../website/server/models/group';
+
+const guildsPerRun = 500;
+const progressCount = 1000;
+const guildsQuery = {
+  type: 'guild',
+};
+
+let count = 0;
+async function updateGroup (guild) {
+  count++;
+  if (count % progressCount === 0) {
+    console.warn(`${count} ${guild._id}`);
+  }
+
+  if (guild.hasActiveGroupPlan()) {
+    return console.warn(`Guild ${guild._id} is active Group Plan`);
+  }
+
+  const leader = await User
+    .findOne({ _id: guild.leader })
+    .select({ _id: true })
+    .exec();
+
+  if (!leader) {
+    return console.warn(`Leader not found for Guild ${guild._id}`);
+  }
+
+  if (guild.balance > 0) {
+    await leader.updateBalance(
+      guild.balance,
+      'create_guild',
+      '',
+      `Guild Bank refund for ${guild.name} (${guild._id})`,
+    );
+  }
+
+  return guild.updateOne({ $set: { balance: 0 } }).exec();
+}
+
+export default async function processGroups () {
+  const guildFields = {
+    _id: 1,
+    balance: 1,
+    leader: 1,
+    name: 1,
+    purchased: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const foundGroups = await Group // eslint-disable-line no-await-in-loop
+      .find(guildsQuery)
+      .limit(guildsPerRun)
+      .sort({ _id: 1 })
+      .select(guildFields)
+      .exec();
+
+    if (foundGroups.length === 0) {
+      console.warn('All appropriate Guilds found and modified.');
+      console.warn(`\n${count} Guilds processed\n`);
+      break;
+    } else {
+      guildsQuery._id = {
+        $gt: foundGroups[foundGroups.length - 1],
+      };
+    }
+
+    await Promise.all(foundGroups.map(guild => updateGroup(guild))); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2023/20230808_guild_gems_fix.js

@@ -0,0 +1,62 @@
+/* eslint-disable no-console */
+import { model as User } from '../../../website/server/models/user';
+import { TransactionModel as Transaction } from '../../../website/server/models/transaction';
+
+const transactionsPerRun = 500;
+const progressCount = 1000;
+const transactionsQuery = {
+  transactionType: 'create_guild',
+  amount: { $gt: 0 },
+};
+
+let count = 0;
+async function updateTransaction (transaction) {
+  count++;
+  if (count % progressCount === 0) {
+    console.warn(`${count} ${transaction._id}`);
+  }
+
+  const leader = await User
+    .findOne({ _id: transaction.userId })
+    .select({ _id: true })
+    .exec();
+
+  if (!leader) {
+    return console.warn(`User not found for transaction ${transaction._id}`);
+  }
+
+  return leader.updateOne(
+    { $inc: { balance: transaction.amount }},
+  ).exec();
+}
+
+export default async function processTransactions () {
+  const transactionFields = {
+    _id: 1,
+    userId: 1,
+    currency: 1,
+    amount: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const foundTransactions = await Transaction // eslint-disable-line no-await-in-loop
+      .find(transactionsQuery)
+      .limit(transactionsPerRun)
+      .sort({ _id: 1 })
+      .select(transactionFields)
+      .lean()
+      .exec();
+
+    if (foundTransactions.length === 0) {
+      console.warn('All appropriate transactions found and modified.');
+      console.warn(`\n${count} transactions processed\n`);
+      break;
+    } else {
+      transactionsQuery._id = {
+        $gt: foundTransactions[foundTransactions.length - 1],
+      };
+    }
+
+    await Promise.all(foundTransactions.map(txn => updateTransaction(txn))); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2023/20230808_veteran_pet_ladder.js

@@ -0,0 +1,144 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20230808_veteran_pet_ladder';
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = {};
+  let push = { notifications: { $each: [] }};
+
+  set.migration = MIGRATION_NAME;
+  if (user.items.pets['Fox-Veteran']) {
+    set['items.pets.Dragon-Veteran'] = 5;
+    push.notifications.$each.push({
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'icon_pet_veteran_dragon',
+        title: 'You’ve received a Veteran Pet!',
+        text: 'To commemorate being here for a new era of Habitica, we’ve awarded you a Veteran Dragon.',
+        destination: '/inventory/stable',
+      },
+      seen: false,
+    });
+  } else if (user.items.pets['Bear-Veteran']) {
+    set['items.pets.Fox-Veteran'] = 5;
+    push.notifications.$each.push({
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'icon_pet_veteran_fox',
+        title: 'You’ve received a Veteran Pet!',
+        text: 'To commemorate being here for a new era of Habitica, we’ve awarded you a Veteran Fox.',
+        destination: '/inventory/stable',
+      },
+      seen: false,
+    });
+  } else if (user.items.pets['Lion-Veteran']) {
+    set['items.pets.Bear-Veteran'] = 5;
+    push.notifications.$each.push({
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'icon_pet_veteran_bear',
+        title: 'You’ve received a Veteran Pet!',
+        text: 'To commemorate being here for a new era of Habitica, we’ve awarded you a Veteran Bear.',
+        destination: '/inventory/stable',
+      },
+      seen: false,
+    });
+  } else if (user.items.pets['Tiger-Veteran']) {
+    set['items.pets.Lion-Veteran'] = 5;
+    push.notifications.$each.push({
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'icon_pet_veteran_lion',
+        title: 'You’ve received a Veteran Pet!',
+        text: 'To commemorate being here for a new era of Habitica, we’ve awarded you a Veteran Lion.',
+        destination: '/inventory/stable',
+      },
+      seen: false,
+    });
+  } else if (user.items.pets['Wolf-Veteran']) {
+    set['items.pets.Tiger-Veteran'] = 5;
+    push.notifications.$each.push({
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'icon_pet_veteran_tiger',
+        title: 'You’ve received a Veteran Pet!',
+        text: 'To commemorate being here for a new era of Habitica, we’ve awarded you a Veteran Tiger.',
+        destination: '/inventory/stable',
+      },
+      seen: false,
+    });
+  } else {
+    set['items.pets.Wolf-Veteran'] = 5;
+    push.notifications.$each.push({
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'icon_pet_veteran_wolf',
+        title: 'You’ve received a Veteran Pet!',
+        text: 'To commemorate being here for a new era of Habitica, we’ve awarded you a Veteran Wolf.',
+        destination: '/inventory/stable',
+      },
+      seen: false,
+    });
+  }
+
+  if (user.contributor.level > 0) {
+    set['items.gear.owned.armor_special_heroicTunic'] = true;
+    set['items.gear.owned.back_special_heroicAureole'] = true;
+    set['items.gear.owned.headAccessory_special_heroicCirclet'] = true;
+    push.notifications.$each.push({
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'heroic_set_icon',
+        title: 'You’ve received the Heroic Set!',
+        text: 'To commemorate your hard work as a contributor, we’ve awarded you the Heroic Circlet, Heroic Aureole, and Heroic Tunic.',
+        destination: '/inventory/equipment',
+      },
+      seen: false,
+    });
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({_id: user._id}, {$set: set, $push: push}).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    // 'auth.timestamps.loggedin': { $gt: new Date('2023-07-08') },
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+    migration: 1,
+    contributor: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2023/20231017_pet_group_achievements.js

@@ -0,0 +1,118 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20231017_pet_group_achievements';
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = {
+    migration: MIGRATION_NAME,
+  };
+
+  if (user && user.items && user.items.pets) {
+    const pets = user.items.pets;
+    if (pets['Armadillo-Base']
+      && pets['Armadillo-CottonCandyBlue']
+      && pets['Armadillo-CottonCandyPink']
+      && pets['Armadillo-Desert']
+      && pets['Armadillo-Golden']
+      && pets['Armadillo-Red']
+      && pets['Armadillo-Shade']
+      && pets['Armadillo-Skeleton']
+      && pets['Armadillo-White']
+      && pets['Armadillo-Zombie']
+      && pets['Cactus-Base']
+      && pets['Cactus-CottonCandyBlue']
+      && pets['Cactus-CottonCandyPink']
+      && pets['Cactus-Desert']
+      && pets['Cactus-Golden']
+      && pets['Cactus-Red']
+      && pets['Cactus-Shade']
+      && pets['Cactus-Skeleton']
+      && pets['Cactus-White']
+      && pets['Cactus-Zombie']
+      && pets['Fox-Base']
+      && pets['Fox-CottonCandyBlue']
+      && pets['Fox-CottonCandyPink']
+      && pets['Fox-Desert']
+      && pets['Fox-Golden']
+      && pets['Fox-Red']
+      && pets['Fox-Shade']
+      && pets['Fox-Skeleton']
+      && pets['Fox-White']
+      && pets['Fox-Zombie']
+      && pets['Frog-Base']
+      && pets['Frog-CottonCandyBlue']
+      && pets['Frog-CottonCandyPink']
+      && pets['Frog-Desert']
+      && pets['Frog-Golden']
+      && pets['Frog-Red']
+      && pets['Frog-Shade']
+      && pets['Frog-Skeleton']
+      && pets['Frog-White']
+      && pets['Frog-Zombie']
+      && pets['Snake-Base']
+      && pets['Snake-CottonCandyBlue']
+      && pets['Snake-CottonCandyPink']
+      && pets['Snake-Desert']
+      && pets['Snake-Golden']
+      && pets['Snake-Red']
+      && pets['Snake-Shade']
+      && pets['Snake-Skeleton']
+      && pets['Snake-White']
+      && pets['Snake-Zombie']
+      && pets['Spider-Base']
+      && pets['Spider-CottonCandyBlue']
+      && pets['Spider-CottonCandyPink']
+      && pets['Spider-Desert']
+      && pets['Spider-Golden']
+      && pets['Spider-Red']
+      && pets['Spider-Shade']
+      && pets['Spider-Skeleton']
+      && pets['Spider-White']
+      && pets['Spider-Zombie']) {
+        set['achievements.duneBuddy'] = true;
+      }
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.updateOne({ _id: user._id }, { $set: set }).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    migration: { $ne: MIGRATION_NAME },
+    'auth.timestamps.loggedin': { $gt: new Date('2023-09-16') },
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1]._id,
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2023/20231114_pet_group_achievements.js

@@ -0,0 +1,124 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20231114_pet_group_achievements';
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  let set = {
+    migration: MIGRATION_NAME,
+  };
+
+  if (user && user.items && user.items.pets) {
+    const pets = user.items.pets;
+    if (pets['Cactus-Zombie'] > 0
+      && pets['Cactus-Skeleton'] > 0
+      && pets['Cactus-Base'] > 0
+      && pets['Cactus-Desert'] > 0
+      && pets['Cactus-Red'] > 0
+      && pets['Cactus-Shade'] > 0
+      && pets['Cactus-White']> 0
+      && pets['Cactus-Golden'] > 0
+      && pets['Cactus-CottonCandyBlue'] > 0
+      && pets['Cactus-CottonCandyPink'] > 0
+      && pets['Hedgehog-Zombie'] > 0
+      && pets['Hedgehog-Skeleton'] > 0
+      && pets['Hedgehog-Base'] > 0
+      && pets['Hedgehog-Desert'] > 0
+      && pets['Hedgehog-Red'] > 0
+      && pets['Hedgehog-Shade'] > 0
+      && pets['Hedgehog-White'] > 0
+      && pets['Hedgehog-Golder'] > 0
+      && pets['Hedgehog-CottonCandyBlue'] > 0
+      && pets['Hedgehog-CottonCandyPink'] > 0
+      && pets['Rock-Zombie'] > 0
+      && pets['Rock-Skeleton'] > 0
+      && pets['Rock-Base'] > 0
+      && pets['Rock-Desert'] > 0
+      && pets['Rock-Red'] > 0
+      && pets['Rock-Shade'] > 0
+      && pets['Rock-White'] > 0
+      && pets['Rock-Golden'] > 0
+      && pets['Rock-CottonCandyBlue'] > 0
+      && pets['Rock-CottonCandyPink'] > 0 ) {
+        set['achievements.roughRider'] = true;
+      }
+  }
+
+  if (user && user.items && user.items.mounts) {
+    const mounts = user.items.mounts;
+    if (mounts['Cactus-Zombie']
+      && mounts['Cactus-Skeleton']
+      && mounts['Cactus-Base']
+      && mounts['Cactus-Desert']
+      && mounts['Cactus-Red']
+      && mounts['Cactus-Shade']
+      && mounts['Cactus-White']
+      && mounts['Cactus-Golden']
+      && mounts['Cactus-CottonCandyPink']
+      && mounts['Cactus-CottonCandyBlue']
+      && mounts['Hedgehog-Zombie']
+      && mounts['Hedgehog-Skeleton']
+      && mounts['Hedgehog-Base']
+      && mounts['Hedgehog-Desert']
+      && mounts['Hedgehog-Red']
+      && mounts['Hedgehog-Shade']
+      && mounts['Hedgehog-White']
+      && mounts['Hedgehog-Golden']
+      && mounts['Hedgehog-CottonCandyPink']
+      && mounts['Hedgehog-CottonCandyBlue']
+      && mounts['Rock-Zombie']
+      && mounts['Rock-Skeleton']
+      && mounts['Rock-Base']
+      && mounts['Rock-Desert']
+      && mounts['Rock-Red']
+      && mounts['Rock-Shade']
+      && mounts['Rock-White']
+      && mounts['Rock-Golden']
+      && mounts['Rock-CottonCandyPink']
+      && mounts['Rock-CottonCandyBlue'] ) {
+        set['achievements.roughRider'] = true;
+      }
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({ _id: user._id }, { $set: set }).exec();
+}
+
+module.exports = async function processUsers () {
+  let query = {
+    migration: { $ne: MIGRATION_NAME },
+    'auth.timestamps.loggedin': { $gt: new Date('2023-02-01') },
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1]._id,
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2023/20231228_nye.js

@@ -0,0 +1,87 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20231228_nye';
+import { model as User } from '../../../website/server/models/user';
+import { v4 as uuid } from 'uuid';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = { migration: MIGRATION_NAME };
+  let push = {};
+
+  if (typeof user.items.gear.owned.head_special_nye2022 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2023'] = true;
+  } else if (typeof user.items.gear.owned.head_special_nye2021 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2022'] = true;
+  } else if (typeof user.items.gear.owned.head_special_nye2020 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2021'] = true;
+  } else if (typeof user.items.gear.owned.head_special_nye2019 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2020'] = true;
+  } else if (typeof user.items.gear.owned.head_special_nye2018 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2019'] = true;
+  } else if (typeof user.items.gear.owned.head_special_nye2017 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2018'] = true;
+  } else if (typeof user.items.gear.owned.head_special_nye2016 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2017'] = true;
+  } else if (typeof user.items.gear.owned.head_special_nye2015 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2016'] = true;
+  } else if (typeof user.items.gear.owned.head_special_nye2014 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2015'] = true;
+  } else if (typeof user.items.gear.owned.head_special_nye !== 'undefined') {
+    set['items.gear.owned.head_special_nye2014'] = true;
+  } else {
+    set['items.gear.owned.head_special_nye'] = true;
+  }
+
+  push.notifications = {
+    type: 'ITEM_RECEIVED',
+    data: {
+      icon: 'notif_head_special_nye',
+      title: 'Happy New Year!',
+      text: 'Check your Equipment for this year\'s party hat!',
+      destination: 'inventory/equipment',
+    },
+    seen: false,
+  };
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.updateOne({_id: user._id}, {$set: set, $push: push}).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    'auth.timestamps.loggedin': { $gt: new Date('2023-12-01') },
+    migration: { $ne: MIGRATION_NAME },
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/tasks/team-tasks-v2.js

@@ -0,0 +1,71 @@
+import filter from 'lodash/filter';
+import find from 'lodash/find';
+import isArray from 'lodash/isArray';
+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';
+
+async function updateTeamTasks (team) {
+  const toSave = [];
+  const teamTasks = await Tasks.Task.find({
+    'group.id': team._id,
+  }).exec();
+
+  const teamBoardTasks = filter(teamTasks, task => !task.userId);
+  const teamUserTasks = filter(teamTasks, task => task.userId);
+
+  for (const boardTask of teamBoardTasks) {
+    if (isArray(boardTask.group.assignedUsers)) {
+      boardTask.group.approval = undefined;
+      boardTask.group.assignedDate = undefined;
+      boardTask.group.assigningUsername = undefined;
+      boardTask.group.sharedCompletion = undefined;
+
+      for (const assignedUserId of boardTask.group.assignedUsers) {
+        const assignedUser = await User.findById(assignedUserId, 'auth'); // eslint-disable-line no-await-in-loop
+        const userTask = find(teamUserTasks, task => task.userId === assignedUserId
+           && task.group.taskId === boardTask._id);
+        if (!boardTask.group.assignedUsersDetail) boardTask.group.assignedUsersDetail = {};
+        if (userTask && assignedUser) {
+          boardTask.group.assignedUsersDetail[assignedUserId] = {
+            assignedDate: userTask.group.assignedDate,
+            assignedUsername: assignedUser.auth.local.username,
+            assigningUsername: userTask.group.assigningUsername,
+            completed: userTask.completed || false,
+            completedDate: userTask.dateCompleted,
+          };
+        } else if (assignedUser) {
+          boardTask.group.assignedUsersDetail[assignedUserId] = {
+            assignedDate: new Date(),
+            assignedUsername: assignedUser.auth.local.username,
+            assigningUsername: null,
+            completed: false,
+            completedDate: null,
+          };
+        } else {
+          const taskIndex = boardTask.group.assignedUsers.indexOf(assignedUserId);
+          boardTask.group.assignedUsers.splice(taskIndex, 1);
+        }
+        if (userTask) toSave.push(Tasks.Task.findByIdAndDelete(userTask._id));
+      }
+      boardTask.markModified('group');
+      toSave.push(boardTask.save());
+    }
+  }
+
+  return Promise.all(toSave);
+}
+
+export default async function processTeams () {
+  const activeTeams = await Group.find({
+    'purchased.plan.customerId': { $exists: true },
+    $or: [
+      { 'purchased.plan.dateTerminated': { $exists: false } },
+      { 'purchased.plan.dateTerminated': null },
+      { 'purchased.plan.dateTerminated': { $gt: new Date() } },
+    ],
+  }).exec();
+
+  const taskPromises = activeTeams.map(updateTeamTasks);
+  return Promise.all(taskPromises);
+}

migrations/users/pi-day.js

@@ -3,7 +3,7 @@ import { v4 as uuid } from 'uuid';
 
 import { model as User } from '../../website/server/models/user';
 
-const MIGRATION_NAME = '20220314_pi_day';
+const MIGRATION_NAME = '20230314_pi_day';
 
 const progressCount = 1000;
 let count = 0;
@@ -54,7 +54,7 @@ async function updateUser (user) {
 export default async function processUsers () {
   const query = {
     migration: { $ne: MIGRATION_NAME },
-    'auth.timestamps.loggedin': { $gt: new Date('2022-02-15') },
+    'auth.timestamps.loggedin': { $gt: new Date('2023-02-15') },
   };
 
   const fields = {

package.json

@@ -1,23 +1,23 @@
 {
   "name": "habitica",
   "description": "A habit tracker app which treats your goals like a Role Playing Game.",
-  "version": "4.233.3",
+  "version": "5.14.0",
   "main": "./website/server/index.js",
   "dependencies": {
-    "@babel/core": "^7.18.5",
-    "@babel/preset-env": "^7.18.2",
-    "@babel/register": "^7.17.7",
-    "@google-cloud/trace-agent": "^5.1.6",
-    "@parse/node-apn": "^5.1.3",
+    "@babel/core": "^7.22.10",
+    "@babel/preset-env": "^7.22.10",
+    "@babel/register": "^7.22.15",
+    "@google-cloud/trace-agent": "^7.1.2",
+    "@parse/node-apn": "^5.2.3",
     "@slack/webhook": "^6.1.0",
     "accepts": "^1.3.8",
     "amazon-payments": "^0.2.9",
     "amplitude": "^6.0.0",
-    "apidoc": "^0.51.1",
-    "apple-auth": "^1.0.7",
-    "bcrypt": "^5.0.1",
-    "body-parser": "^1.20.0",
-    "bootstrap": "^4.6.0",
+    "apidoc": "^0.54.0",
+    "apple-auth": "^1.0.9",
+    "bcrypt": "^5.1.1",
+    "body-parser": "^1.20.2",
+    "bootstrap": "^4.6.2",
     "compression": "^1.7.4",
     "cookie-session": "^2.0.0",
     "coupon-code": "^0.4.5",
@@ -27,56 +27,57 @@
     "eslint": "^6.8.0",
     "eslint-config-habitrpg": "^6.2.0",
     "eslint-plugin-mocha": "^5.0.0",
-    "express": "^4.18.1",
+    "express": "^4.18.2",
     "express-basic-auth": "^1.2.1",
     "express-validator": "^5.2.0",
-    "glob": "^8.0.3",
-    "got": "^11.8.3",
+    "glob": "^8.1.0",
+    "got": "^11.8.6",
     "gulp": "^4.0.0",
     "gulp-babel": "^8.0.0",
     "gulp-imagemin": "^7.1.0",
     "gulp-nodemon": "^2.5.0",
+    "nodemon": "^2.0.20",
     "gulp.spritesmith": "^6.13.0",
     "habitica-markdown": "^3.0.0",
     "helmet": "^4.6.0",
-    "image-size": "^1.0.1",
+    "image-size": "^1.0.2",
     "in-app-purchase": "^1.11.3",
-    "js2xmlparser": "^4.0.2",
-    "jsonwebtoken": "^8.5.1",
-    "jwks-rsa": "^2.1.4",
+    "js2xmlparser": "^5.0.0",
+    "jsonwebtoken": "^9.0.2",
+    "jwks-rsa": "^2.1.5",
     "lodash": "^4.17.21",
     "merge-stream": "^2.0.0",
     "method-override": "^3.0.0",
-    "moment": "^2.29.3",
+    "moment": "^2.29.4",
     "moment-recur": "^1.0.7",
-    "mongoose": "^5.13.7",
+    "mongoose": "^5.13.20",
     "morgan": "^1.10.0",
-    "nconf": "^0.12.0",
+    "nconf": "^0.12.1",
     "node-gcm": "^1.0.5",
     "on-headers": "^1.0.2",
-    "passport": "^0.5.0",
+    "passport": "^0.5.3",
     "passport-facebook": "^3.0.0",
     "passport-google-oauth2": "^0.2.0",
     "passport-google-oauth20": "2.0.0",
     "paypal-rest-sdk": "^1.8.1",
     "pp-ipn": "^1.1.0",
     "ps-tree": "^1.0.0",
-    "rate-limiter-flexible": "^2.3.7",
+    "rate-limiter-flexible": "^2.4.2",
     "redis": "^3.1.2",
-    "regenerator-runtime": "^0.13.9",
+    "regenerator-runtime": "^0.13.11",
     "remove-markdown": "^0.5.0",
     "rimraf": "^3.0.2",
-    "short-uuid": "^4.2.0",
-    "stripe": "^8.222.0",
-    "superagent": "^7.1.6",
+    "short-uuid": "^4.2.2",
+    "stripe": "^12.18.0",
+    "superagent": "^8.1.2",
     "universal-analytics": "^0.5.3",
     "useragent": "^2.1.9",
-    "uuid": "^8.3.2",
-    "validator": "^13.7.0",
+    "uuid": "^9.0.0",
+    "validator": "^13.11.0",
     "vinyl-buffer": "^1.0.1",
-    "winston": "^3.7.2",
-    "winston-loggly-bulk": "^3.2.1",
-    "xml2js": "^0.4.23"
+    "winston": "^3.10.0",
+    "winston-loggly-bulk": "^3.3.0",
+    "xml2js": "^0.6.2"
   },
   "private": true,
   "engines": {
@@ -105,24 +106,24 @@
     "client:unit": "cd website/client && npm run test:unit",
     "start": "gulp nodemon",
     "debug": "gulp nodemon --inspect",
-    "mongo:dev": "run-rs -v 4.2.8 -l ubuntu1804 --keep --dbpath mongodb-data --number 1 --quiet",
+    "mongo:dev": "run-rs -v 4.1.1 -l ubuntu1804 --keep --dbpath mongodb-data --number 1 --quiet",
     "postinstall": "git config --global url.\"https://\".insteadOf git:// && gulp build && cd website/client && npm install",
     "apidoc": "gulp apidoc"
   },
   "devDependencies": {
-    "axios": "^0.27.2",
-    "chai": "^4.3.6",
+    "axios": "^1.4.0",
+    "chai": "^4.3.7",
     "chai-as-promised": "^7.1.1",
     "chai-moment": "^0.1.0",
-    "chalk": "^4.1.2",
+    "chalk": "^5.3.0",
     "cross-spawn": "^7.0.3",
     "expect.js": "^0.3.1",
     "istanbul": "^1.1.0-alpha.1",
     "mocha": "^5.1.1",
     "monk": "^7.3.4",
     "require-again": "^2.0.0",
-    "run-rs": "^0.7.6",
-    "sinon": "^13.0.2",
+    "run-rs": "^0.7.7",
+    "sinon": "^15.2.0",
     "sinon-chai": "^3.7.0",
     "sinon-stub-promise": "^4.0.0"
   },

scripts/team-cron.js

@@ -0,0 +1,105 @@
+import forEach from 'lodash/forEach';
+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 { daysSince, shouldDo } from '../website/common/script/cron';
+
+const TASK_VALUE_CHANGE_FACTOR = 0.9747;
+const MIN_TASK_VALUE = -47.27;
+
+async function updateTeamTasks (team) {
+  const toSave = [];
+  let teamLeader = await User.findOne({ _id: team.leader }, 'preferences').exec();
+
+  if (!teamLeader) { // why would this happen?
+    teamLeader = {
+      preferences: { }, // when options are sanitized this becomes CDS 0 at UTC
+    };
+  }
+
+  if (
+    !team.cron || !team.cron.lastProcessed
+    || daysSince(team.cron.lastProcessed, teamLeader.preferences) > 0
+  ) {
+    const tasks = await Tasks.Task.find({
+      'group.id': team._id,
+      userId: { $exists: false },
+      $or: [
+        { type: 'todo', completed: false },
+        { type: { $in: ['habit', 'daily'] } },
+      ],
+    }).exec();
+
+    const tasksByType = {
+      habits: [], dailys: [], todos: [], rewards: [],
+    };
+    forEach(tasks, task => tasksByType[`${task.type}s`].push(task));
+
+    forEach(tasksByType.habits, habit => {
+      if (!(habit.up && habit.down) && habit.value !== 0) {
+        habit.value *= 0.5;
+        if (Math.abs(habit.value) < 0.1) habit.value = 0;
+        toSave.push(habit.save());
+      }
+    });
+    forEach(tasksByType.todos, todo => {
+      if (!todo.completed) {
+        const delta = TASK_VALUE_CHANGE_FACTOR ** todo.value;
+        todo.value -= delta;
+        if (todo.value < MIN_TASK_VALUE) todo.value = MIN_TASK_VALUE;
+        toSave.push(todo.save());
+      }
+    });
+    forEach(tasksByType.dailys, daily => {
+      let processChecklist = false;
+      let assignments = 0;
+      let completions = 0;
+      for (const assignedUser in daily.group.assignedUsersDetail) {
+        if (Object.prototype.hasOwnProperty.call(daily.group.assignedUsersDetail, assignedUser)) {
+          assignments += 1;
+          if (daily.group.assignedUsersDetail[assignedUser].completed) {
+            completions += 1;
+            daily.group.assignedUsersDetail[assignedUser].completed = false;
+          }
+        }
+      }
+      if (completions > 0) daily.markModified('group.assignedUsersDetail');
+      if (daily.completed) {
+        processChecklist = true;
+        daily.completed = false;
+      } else if (shouldDo(team.cron.lastProcessed, daily, teamLeader.preferences)) {
+        processChecklist = true;
+        const delta = TASK_VALUE_CHANGE_FACTOR ** daily.value;
+        if (assignments > 0) {
+          daily.value -= ((completions / assignments) * delta);
+        }
+        if (daily.value < MIN_TASK_VALUE) daily.value = MIN_TASK_VALUE;
+      }
+      daily.isDue = shouldDo(new Date(), daily, teamLeader.preferences);
+      if (processChecklist && daily.checklist.length > 0) {
+        daily.checklist.forEach(i => { i.completed = false; });
+      }
+      toSave.push(daily.save());
+    });
+
+    if (!team.cron) team.cron = {};
+    team.cron.lastProcessed = new Date();
+    toSave.push(team.save());
+  }
+
+  return Promise.all(toSave);
+}
+
+export default async function processTeamsCron () {
+  const activeTeams = await Group.find({
+    'purchased.plan.customerId': { $exists: true },
+    $or: [
+      { 'purchased.plan.dateTerminated': { $exists: false } },
+      { 'purchased.plan.dateTerminated': null },
+      { 'purchased.plan.dateTerminated': { $gt: new Date() } },
+    ],
+  }).exec();
+
+  const cronPromises = activeTeams.map(updateTeamTasks);
+  return Promise.all(cronPromises);
+}

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

@@ -231,13 +231,16 @@ describe('cron', async () => {
         },
       });
       // user1 has a 1-month recurring subscription starting today
-      user1.purchased.plan.customerId = 'subscribedId';
-      user1.purchased.plan.dateUpdated = moment().toDate();
-      user1.purchased.plan.planId = 'basic';
-      user1.purchased.plan.consecutive.count = 0;
-      user1.purchased.plan.consecutive.offset = 0;
-      user1.purchased.plan.consecutive.trinkets = 0;
-      user1.purchased.plan.consecutive.gemCapExtra = 0;
+      beforeEach(async () => {
+        user1.purchased.plan.customerId = 'subscribedId';
+        user1.purchased.plan.dateUpdated = moment().toDate();
+        user1.purchased.plan.planId = 'basic';
+        user1.purchased.plan.consecutive.count = 0;
+        user1.purchased.plan.perkMonthCount = 0;
+        user1.purchased.plan.consecutive.offset = 0;
+        user1.purchased.plan.consecutive.trinkets = 0;
+        user1.purchased.plan.consecutive.gemCapExtra = 0;
+      });
 
       it('does not increment consecutive benefits after the first month', async () => {
         clock = sinon.useFakeTimers(moment().utcOffset(0).startOf('month').add(1, 'months')
@@ -271,6 +274,24 @@ describe('cron', async () => {
         expect(user1.purchased.plan.consecutive.gemCapExtra).to.equal(0);
       });
 
+      it('increments consecutive benefits after the second month if they also received a 1 month gift subscription', async () => {
+        user1.purchased.plan.perkMonthCount = 1;
+        clock = sinon.useFakeTimers(moment().utcOffset(0).startOf('month').add(2, 'months')
+          .add(2, 'days')
+          .toDate());
+        // Add 1 month to simulate what happens a month after the subscription was created.
+        // Add 2 days so that we're sure we're not affected by any start-of-month effects
+        // e.g., from time zone oddness.
+        await cron({
+          user: user1, tasksByType, daysMissed, analytics,
+        });
+        expect(user1.purchased.plan.perkMonthCount).to.equal(0);
+        expect(user1.purchased.plan.consecutive.count).to.equal(2);
+        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);
+      });
+
       it('increments consecutive benefits after the third month', async () => {
         clock = sinon.useFakeTimers(moment().utcOffset(0).startOf('month').add(3, 'months')
           .add(2, 'days')
@@ -315,6 +336,30 @@ describe('cron', async () => {
         expect(user1.purchased.plan.consecutive.trinkets).to.equal(3);
         expect(user1.purchased.plan.consecutive.gemCapExtra).to.equal(15);
       });
+
+      it('initializes plan.perkMonthCount if necessary', async () => {
+        user.purchased.plan.perkMonthCount = undefined;
+        clock = sinon.useFakeTimers(moment(user.purchased.plan.dateUpdated)
+          .utcOffset(0)
+          .startOf('month')
+          .add(1, 'months')
+          .add(2, 'days')
+          .toDate());
+        await cron({
+          user, tasksByType, daysMissed, analytics,
+        });
+        expect(user.purchased.plan.perkMonthCount).to.equal(1);
+        user.purchased.plan.perkMonthCount = undefined;
+        user.purchased.plan.consecutive.count = 8;
+        clock.restore();
+        clock = sinon.useFakeTimers(moment().utcOffset(0).startOf('month').add(2, 'months')
+          .add(2, 'days')
+          .toDate());
+        await cron({
+          user, tasksByType, daysMissed, analytics,
+        });
+        expect(user.purchased.plan.perkMonthCount).to.equal(2);
+      });
     });
 
     describe('for a 3-month recurring subscription', async () => {
@@ -330,13 +375,16 @@ describe('cron', async () => {
         },
       });
       // user3 has a 3-month recurring subscription starting today
-      user3.purchased.plan.customerId = 'subscribedId';
-      user3.purchased.plan.dateUpdated = moment().toDate();
-      user3.purchased.plan.planId = 'basic_3mo';
-      user3.purchased.plan.consecutive.count = 0;
-      user3.purchased.plan.consecutive.offset = 3;
-      user3.purchased.plan.consecutive.trinkets = 1;
-      user3.purchased.plan.consecutive.gemCapExtra = 5;
+      beforeEach(async () => {
+        user3.purchased.plan.customerId = 'subscribedId';
+        user3.purchased.plan.dateUpdated = moment().toDate();
+        user3.purchased.plan.planId = 'basic_3mo';
+        user3.purchased.plan.perkMonthCount = 0;
+        user3.purchased.plan.consecutive.count = 0;
+        user3.purchased.plan.consecutive.offset = 3;
+        user3.purchased.plan.consecutive.trinkets = 1;
+        user3.purchased.plan.consecutive.gemCapExtra = 5;
+      });
 
       it('does not increment consecutive benefits in the first month of the first paid period that they already have benefits for', async () => {
         clock = sinon.useFakeTimers(moment().utcOffset(0).startOf('month').add(1, 'months')
@@ -390,6 +438,21 @@ describe('cron', async () => {
         expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(10);
       });
 
+      it('keeps existing plan.perkMonthCount intact when incrementing consecutive benefits', async () => {
+        user3.purchased.plan.perkMonthCount = 2;
+        user3.purchased.plan.consecutive.trinkets = 1;
+        user3.purchased.plan.consecutive.gemCapExtra = 5;
+        clock = sinon.useFakeTimers(moment().utcOffset(0).startOf('month').add(4, 'months')
+          .add(2, 'days')
+          .toDate());
+        await cron({
+          user: user3, tasksByType, daysMissed, analytics,
+        });
+        expect(user3.purchased.plan.perkMonthCount).to.equal(2);
+        expect(user3.purchased.plan.consecutive.trinkets).to.equal(2);
+        expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(10);
+      });
+
       it('does not increment consecutive benefits in the second month of the second period that they already have benefits for', async () => {
         clock = sinon.useFakeTimers(moment().utcOffset(0).startOf('month').add(5, 'months')
           .add(2, 'days')
@@ -456,13 +519,16 @@ describe('cron', async () => {
         },
       });
       // user6 has a 6-month recurring subscription starting today
-      user6.purchased.plan.customerId = 'subscribedId';
-      user6.purchased.plan.dateUpdated = moment().toDate();
-      user6.purchased.plan.planId = 'google_6mo';
-      user6.purchased.plan.consecutive.count = 0;
-      user6.purchased.plan.consecutive.offset = 6;
-      user6.purchased.plan.consecutive.trinkets = 2;
-      user6.purchased.plan.consecutive.gemCapExtra = 10;
+      beforeEach(async () => {
+        user6.purchased.plan.customerId = 'subscribedId';
+        user6.purchased.plan.dateUpdated = moment().toDate();
+        user6.purchased.plan.planId = 'google_6mo';
+        user6.purchased.plan.perkMonthCount = 0;
+        user6.purchased.plan.consecutive.count = 0;
+        user6.purchased.plan.consecutive.offset = 6;
+        user6.purchased.plan.consecutive.trinkets = 2;
+        user6.purchased.plan.consecutive.gemCapExtra = 10;
+      });
 
       it('does not increment consecutive benefits in the first month of the first paid period that they already have benefits for', async () => {
         clock = sinon.useFakeTimers(moment().utcOffset(0).startOf('month').add(1, 'months')
@@ -503,6 +569,19 @@ describe('cron', async () => {
         expect(user6.purchased.plan.consecutive.gemCapExtra).to.equal(20);
       });
 
+      it('keeps existing plan.perkMonthCount intact when incrementing consecutive benefits', async () => {
+        user6.purchased.plan.perkMonthCount = 2;
+        clock = sinon.useFakeTimers(moment().utcOffset(0).startOf('month').add(7, 'months')
+          .add(2, 'days')
+          .toDate());
+        await cron({
+          user: user6, tasksByType, daysMissed, analytics,
+        });
+        expect(user6.purchased.plan.perkMonthCount).to.equal(2);
+        expect(user6.purchased.plan.consecutive.trinkets).to.equal(4);
+        expect(user6.purchased.plan.consecutive.gemCapExtra).to.equal(20);
+      });
+
       it('increments consecutive benefits the month after the third paid period has started', async () => {
         clock = sinon.useFakeTimers(moment().utcOffset(0).startOf('month').add(13, 'months')
           .add(2, 'days')

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

@@ -13,11 +13,6 @@ function getUser () {
         username: 'username',
         email: 'email@email',
       },
-      facebook: {
-        emails: [{
-          value: 'email@facebook',
-        }],
-      },
       google: {
         emails: [{
           value: 'email@google',
@@ -62,30 +57,12 @@ describe('emails', () => {
       expect(data).to.have.property('canSend', true);
     });
 
-    it('returns correct user data [facebook users]', () => {
-      const attachEmail = requireAgain(pathToEmailLib);
-      const { getUserInfo } = attachEmail;
-      const user = getUser();
-      delete user.profile.name;
-      delete user.auth.local.email;
-      delete user.auth.google.emails;
-      delete user.auth.apple.emails;
-
-      const data = getUserInfo(user, ['name', 'email', '_id', 'canSend']);
-
-      expect(data).to.have.property('name', user.auth.local.username);
-      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);
-    });
-
     it('returns correct user data [google users]', () => {
       const attachEmail = requireAgain(pathToEmailLib);
       const { getUserInfo } = attachEmail;
       const user = getUser();
       delete user.profile.name;
       delete user.auth.local.email;
-      delete user.auth.facebook.emails;
       delete user.auth.apple.emails;
 
       const data = getUserInfo(user, ['name', 'email', '_id', 'canSend']);
@@ -103,7 +80,6 @@ describe('emails', () => {
       delete user.profile.name;
       delete user.auth.local.email;
       delete user.auth.google.emails;
-      delete user.auth.facebook.emails;
 
       const data = getUserInfo(user, ['name', 'email', '_id', 'canSend']);
 
@@ -118,7 +94,6 @@ describe('emails', () => {
       const { getUserInfo } = attachEmail;
       const user = getUser();
       delete user.auth.local.email;
-      delete user.auth.facebook;
       delete user.auth.google;
       delete user.auth.apple;
 

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

@@ -246,7 +246,7 @@ describe('Password Utilities', () => {
     it('returns false if the user has no local auth', async () => {
       const user = await generateUser({
         auth: {
-          facebook: {},
+          google: {},
         },
       });
       const res = await validatePasswordResetCodeAndFindUser(encrypt(JSON.stringify({

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

@@ -17,7 +17,7 @@ describe('Amazon Payments - Checkout', () => {
   let closeOrderReferenceSpy;
 
   let paymentBuyGemsStub;
-  let paymentCreateSubscritionStub;
+  let paymentCreateSubscriptionStub;
   let amount = gemsBlock.price / 100;
 
   function expectOrderReferenceSpy () {
@@ -85,8 +85,8 @@ describe('Amazon Payments - Checkout', () => {
     paymentBuyGemsStub = sinon.stub(payments, 'buyGems');
     paymentBuyGemsStub.resolves({});
 
-    paymentCreateSubscritionStub = sinon.stub(payments, 'createSubscription');
-    paymentCreateSubscritionStub.resolves({});
+    paymentCreateSubscriptionStub = sinon.stub(payments, 'createSubscription');
+    paymentCreateSubscriptionStub.resolves({});
 
     sinon.stub(common, 'uuid').returns('uuid-generated');
     sandbox.stub(gems, 'validateGiftMessage');
@@ -109,6 +109,7 @@ describe('Amazon Payments - Checkout', () => {
       user,
       paymentMethod,
       headers,
+      sku: undefined,
     };
     if (gift) {
       expectedArgs.gift = gift;
@@ -215,13 +216,14 @@ describe('Amazon Payments - Checkout', () => {
     });
 
     gift.member = receivingUser;
-    expect(paymentCreateSubscritionStub).to.be.calledOnce;
-    expect(paymentCreateSubscritionStub).to.be.calledWith({
+    expect(paymentCreateSubscriptionStub).to.be.calledOnce;
+    expect(paymentCreateSubscriptionStub).to.be.calledWith({
       user,
       paymentMethod: amzLib.constants.PAYMENT_METHOD_GIFT,
       headers,
       gift,
       gemsBlock: undefined,
+      sku: undefined,
     });
     expectAmazonStubs();
   });

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

@@ -12,10 +12,10 @@ const { i18n } = common;
 describe('Apple Payments', () => {
   const subKey = 'basic_3mo';
 
-  describe('verifyGemPurchase', () => {
+  describe('verifyPurchase', () => {
     let sku; let user; let token; let receipt; let
       headers;
-    let iapSetupStub; let iapValidateStub; let iapIsValidatedStub; let paymentBuyGemsStub; let
+    let iapSetupStub; let iapValidateStub; let iapIsValidatedStub; let paymentBuySkuStub; let
       iapGetPurchaseDataStub; let validateGiftMessageStub;
 
     beforeEach(() => {
@@ -29,14 +29,15 @@ describe('Apple Payments', () => {
         .resolves();
       iapValidateStub = sinon.stub(iap, 'validate')
         .resolves({});
-      iapIsValidatedStub = sinon.stub(iap, 'isValidated')
-        .returns(true);
+      iapIsValidatedStub = sinon.stub(iap, 'isValidated').returns(true);
+      sinon.stub(iap, 'isExpired').returns(false);
+      sinon.stub(iap, 'isCanceled').returns(false);
       iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
         .returns([{
           productId: 'com.habitrpg.ios.Habitica.21gems',
           transactionId: token,
         }]);
-      paymentBuyGemsStub = sinon.stub(payments, 'buyGems').resolves({});
+      paymentBuySkuStub = sinon.stub(payments, 'buySkuItem').resolves({});
       validateGiftMessageStub = sinon.stub(gems, 'validateGiftMessage');
     });
 
@@ -44,8 +45,10 @@ describe('Apple Payments', () => {
       iap.setup.restore();
       iap.validate.restore();
       iap.isValidated.restore();
+      iap.isExpired.restore();
+      iap.isCanceled.restore();
       iap.getPurchaseData.restore();
-      payments.buyGems.restore();
+      payments.buySkuItem.restore();
       gems.validateGiftMessage.restore();
     });
 
@@ -54,7 +57,7 @@ describe('Apple Payments', () => {
       iapIsValidatedStub = sinon.stub(iap, 'isValidated')
         .returns(false);
 
-      await expect(applePayments.verifyGemPurchase({ user, receipt, headers }))
+      await expect(applePayments.verifyPurchase({ user, receipt, headers }))
         .to.eventually.be.rejected.and.to.eql({
           httpCode: 401,
           name: 'NotAuthorized',
@@ -66,7 +69,7 @@ describe('Apple Payments', () => {
       iapGetPurchaseDataStub.restore();
       iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData').returns([]);
 
-      await expect(applePayments.verifyGemPurchase({ user, receipt, headers }))
+      await expect(applePayments.verifyPurchase({ user, receipt, headers }))
         .to.eventually.be.rejected.and.to.eql({
           httpCode: 401,
           name: 'NotAuthorized',
@@ -76,7 +79,7 @@ describe('Apple Payments', () => {
 
     it('errors if the user cannot purchase gems', async () => {
       sinon.stub(user, 'canGetGems').resolves(false);
-      await expect(applePayments.verifyGemPurchase({ user, receipt, headers }))
+      await expect(applePayments.verifyPurchase({ user, receipt, headers }))
         .to.eventually.be.rejected.and.to.eql({
           httpCode: 401,
           name: 'NotAuthorized',
@@ -94,14 +97,16 @@ describe('Apple Payments', () => {
           productId: 'badProduct',
           transactionId: token,
         }]);
+      paymentBuySkuStub.restore();
 
-      await expect(applePayments.verifyGemPurchase({ user, receipt, headers }))
+      await expect(applePayments.verifyPurchase({ user, receipt, headers }))
         .to.eventually.be.rejected.and.to.eql({
-          httpCode: 401,
-          name: 'NotAuthorized',
+          httpCode: 400,
+          name: 'BadRequest',
           message: applePayments.constants.RESPONSE_INVALID_ITEM,
         });
 
+      paymentBuySkuStub = sinon.stub(payments, 'buySkuItem').resolves({});
       user.canGetGems.restore();
     });
 
@@ -138,7 +143,7 @@ describe('Apple Payments', () => {
           }]);
 
         sinon.stub(user, 'canGetGems').resolves(true);
-        await applePayments.verifyGemPurchase({ user, receipt, headers });
+        await applePayments.verifyPurchase({ user, receipt, headers });
 
         expect(iapSetupStub).to.be.calledOnce;
         expect(iapValidateStub).to.be.calledOnce;
@@ -148,13 +153,13 @@ describe('Apple Payments', () => {
         expect(iapGetPurchaseDataStub).to.be.calledOnce;
         expect(validateGiftMessageStub).to.not.be.called;
 
-        expect(paymentBuyGemsStub).to.be.calledOnce;
-        expect(paymentBuyGemsStub).to.be.calledWith({
+        expect(paymentBuySkuStub).to.be.calledOnce;
+        expect(paymentBuySkuStub).to.be.calledWith({
           user,
-          paymentMethod: applePayments.constants.PAYMENT_METHOD_APPLE,
-          gemsBlock: common.content.gems[gemTest.gemsBlock],
-          headers,
           gift: undefined,
+          paymentMethod: applePayments.constants.PAYMENT_METHOD_APPLE,
+          sku: gemTest.productId,
+          headers,
         });
         expect(user.canGetGems).to.be.calledOnce;
         user.canGetGems.restore();
@@ -173,7 +178,7 @@ describe('Apple Payments', () => {
         }]);
 
       const gift = { uuid: receivingUser._id };
-      await applePayments.verifyGemPurchase({
+      await applePayments.verifyPurchase({
         user, gift, receipt, headers,
       });
 
@@ -187,18 +192,16 @@ describe('Apple Payments', () => {
       expect(validateGiftMessageStub).to.be.calledOnce;
       expect(validateGiftMessageStub).to.be.calledWith(gift, user);
 
-      expect(paymentBuyGemsStub).to.be.calledOnce;
-      expect(paymentBuyGemsStub).to.be.calledWith({
+      expect(paymentBuySkuStub).to.be.calledOnce;
+      expect(paymentBuySkuStub).to.be.calledWith({
         user,
-        paymentMethod: applePayments.constants.PAYMENT_METHOD_APPLE,
-        headers,
         gift: {
-          type: 'gems',
-          gems: { amount: 4 },
-          member: sinon.match({ _id: receivingUser._id }),
           uuid: receivingUser._id,
+          member: sinon.match({ _id: receivingUser._id }),
         },
-        gemsBlock: common.content.gems['4gems'],
+        paymentMethod: applePayments.constants.PAYMENT_METHOD_APPLE,
+        sku: 'com.habitrpg.ios.Habitica.4gems',
+        headers,
       });
     });
   });
@@ -218,6 +221,7 @@ describe('Apple Payments', () => {
       headers = {};
       receipt = `{"token": "${token}"}`;
       nextPaymentProcessing = moment.utc().add({ days: 2 });
+      user = new User();
 
       iapSetupStub = sinon.stub(iap, 'setup')
         .resolves();
@@ -228,14 +232,17 @@ describe('Apple Payments', () => {
       iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
         .returns([{
           expirationDate: moment.utc().subtract({ day: 1 }).toDate(),
+          purchaseDate: moment.utc().valueOf(),
           productId: sku,
           transactionId: token,
         }, {
           expirationDate: moment.utc().add({ day: 1 }).toDate(),
+          purchaseDate: moment.utc().valueOf(),
           productId: 'wrongsku',
           transactionId: token,
         }, {
           expirationDate: moment.utc().add({ day: 1 }).toDate(),
+          purchaseDate: moment.utc().valueOf(),
           productId: sku,
           transactionId: token,
         }]);
@@ -250,21 +257,12 @@ describe('Apple Payments', () => {
       if (payments.createSubscription.restore) payments.createSubscription.restore();
     });
 
-    it('should throw an error if sku is empty', async () => {
-      await expect(applePayments.subscribe('', user, receipt, headers, nextPaymentProcessing))
-        .to.eventually.be.rejected.and.to.eql({
-          httpCode: 400,
-          name: 'BadRequest',
-          message: i18n.t('missingSubscriptionCode'),
-        });
-    });
-
     it('should throw an error if receipt is invalid', async () => {
       iap.isValidated.restore();
       iapIsValidatedStub = sinon.stub(iap, 'isValidated')
         .returns(false);
 
-      await expect(applePayments.subscribe(sku, user, receipt, headers, nextPaymentProcessing))
+      await expect(applePayments.subscribe(user, receipt, headers, nextPaymentProcessing))
         .to.eventually.be.rejected.and.to.eql({
           httpCode: 401,
           name: 'NotAuthorized',
@@ -295,13 +293,15 @@ describe('Apple Payments', () => {
         iap.getPurchaseData.restore();
         iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
           .returns([{
-            expirationDate: moment.utc().add({ day: 1 }).toDate(),
+            expirationDate: moment.utc().add({ day: 2 }).toDate(),
+            purchaseDate: new Date(),
             productId: option.sku,
             transactionId: token,
+            originalTransactionId: token,
           }]);
         sub = common.content.subscriptionBlocks[option.subKey];
 
-        await applePayments.subscribe(option.sku, user, receipt, headers, nextPaymentProcessing);
+        await applePayments.subscribe(user, receipt, headers, nextPaymentProcessing);
 
         expect(iapSetupStub).to.be.calledOnce;
         expect(iapValidateStub).to.be.calledOnce;
@@ -321,20 +321,253 @@ describe('Apple Payments', () => {
           nextPaymentProcessing,
         });
       });
+      if (option !== subOptions[3]) {
+        const newOption = subOptions[3];
+        it(`upgrades a subscription from ${option.sku} to ${newOption.sku}`, async () => {
+          const oldSub = common.content.subscriptionBlocks[option.subKey];
+          oldSub.logic = 'refundAndRepay';
+          user.profile.name = 'sender';
+          user.purchased.plan.paymentMethod = applePayments.constants.PAYMENT_METHOD_APPLE;
+          user.purchased.plan.customerId = token;
+          user.purchased.plan.planId = option.subKey;
+          user.purchased.plan.additionalData = receipt;
+          iap.getPurchaseData.restore();
+          iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
+            .returns([{
+              expirationDate: moment.utc().add({ day: 2 }).toDate(),
+              purchaseDate: moment.utc().valueOf(),
+              productId: newOption.sku,
+              transactionId: `${token}new`,
+              originalTransactionId: token,
+            }]);
+          sub = common.content.subscriptionBlocks[newOption.subKey];
+
+          await applePayments.subscribe(user,
+            receipt,
+            headers,
+            nextPaymentProcessing);
+
+          expect(iapSetupStub).to.be.calledOnce;
+          expect(iapValidateStub).to.be.calledOnce;
+          expect(iapValidateStub).to.be.calledWith(iap.APPLE, receipt);
+          expect(iapIsValidatedStub).to.be.calledOnce;
+          expect(iapIsValidatedStub).to.be.calledWith({});
+          expect(iapGetPurchaseDataStub).to.be.calledOnce;
+
+          expect(paymentsCreateSubscritionStub).to.be.calledOnce;
+          expect(paymentsCreateSubscritionStub).to.be.calledWith({
+            user,
+            customerId: token,
+            paymentMethod: applePayments.constants.PAYMENT_METHOD_APPLE,
+            sub,
+            headers,
+            additionalData: receipt,
+            nextPaymentProcessing,
+            updatedFrom: oldSub,
+          });
+        });
+      }
+      if (option !== subOptions[0]) {
+        const newOption = subOptions[0];
+        it(`downgrades a subscription from ${option.sku} to ${newOption.sku}`, async () => {
+          const oldSub = common.content.subscriptionBlocks[option.subKey];
+          user.profile.name = 'sender';
+          user.purchased.plan.paymentMethod = applePayments.constants.PAYMENT_METHOD_APPLE;
+          user.purchased.plan.customerId = token;
+          user.purchased.plan.planId = option.subKey;
+          user.purchased.plan.additionalData = receipt;
+          iap.getPurchaseData.restore();
+          iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
+            .returns([{
+              expirationDate: moment.utc().add({ day: 2 }).toDate(),
+              purchaseDate: moment.utc().valueOf(),
+              productId: newOption.sku,
+              transactionId: `${token}new`,
+              originalTransactionId: token,
+            }]);
+          sub = common.content.subscriptionBlocks[newOption.subKey];
+
+          await applePayments.subscribe(user,
+            receipt,
+            headers,
+            nextPaymentProcessing);
+
+          expect(iapSetupStub).to.be.calledOnce;
+          expect(iapValidateStub).to.be.calledOnce;
+          expect(iapValidateStub).to.be.calledWith(iap.APPLE, receipt);
+          expect(iapIsValidatedStub).to.be.calledOnce;
+          expect(iapIsValidatedStub).to.be.calledWith({});
+          expect(iapGetPurchaseDataStub).to.be.calledOnce;
+
+          expect(paymentsCreateSubscritionStub).to.be.calledOnce;
+          expect(paymentsCreateSubscritionStub).to.be.calledWith({
+            user,
+            customerId: token,
+            paymentMethod: applePayments.constants.PAYMENT_METHOD_APPLE,
+            sub,
+            headers,
+            additionalData: receipt,
+            nextPaymentProcessing,
+            updatedFrom: oldSub,
+          });
+        });
+      }
     });
 
-    it('errors when a user is already subscribed', async () => {
-      payments.createSubscription.restore();
-      user = new User();
+    it('uses the most recent subscription data', async () => {
+      iap.getPurchaseData.restore();
+      iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
+        .returns([{
+          expirationDate: moment.utc().add({ day: 4 }).toDate(),
+          purchaseDate: moment.utc().subtract({ day: 5 }).toDate(),
+          productId: 'com.habitrpg.ios.habitica.subscription.3month',
+          transactionId: `${token}oldest`,
+          originalTransactionId: `${token}evenOlder`,
+        }, {
+          expirationDate: moment.utc().add({ day: 2 }).toDate(),
+          purchaseDate: moment.utc().subtract({ day: 1 }).toDate(),
+          productId: 'com.habitrpg.ios.habitica.subscription.12month',
+          transactionId: `${token}newest`,
+          originalTransactionId: `${token}newest`,
+        }, {
+          expirationDate: moment.utc().add({ day: 1 }).toDate(),
+          purchaseDate: moment.utc().subtract({ day: 2 }).toDate(),
+          productId: 'com.habitrpg.ios.habitica.subscription.6month',
+          transactionId: token,
+          originalTransactionId: token,
+        }]);
+      sub = common.content.subscriptionBlocks.basic_12mo;
 
-      await applePayments.subscribe(sku, user, receipt, headers, nextPaymentProcessing);
+      await applePayments.subscribe(user, receipt, headers, nextPaymentProcessing);
 
-      await expect(applePayments.subscribe(sku, user, receipt, headers, nextPaymentProcessing))
-        .to.eventually.be.rejected.and.to.eql({
-          httpCode: 401,
-          name: 'NotAuthorized',
-          message: applePayments.constants.RESPONSE_ALREADY_USED,
-        });
+      expect(paymentsCreateSubscritionStub).to.be.calledOnce;
+      expect(paymentsCreateSubscritionStub).to.be.calledWith({
+        user,
+        customerId: `${token}newest`,
+        paymentMethod: applePayments.constants.PAYMENT_METHOD_APPLE,
+        sub,
+        headers,
+        additionalData: receipt,
+        nextPaymentProcessing,
+      });
+    });
+
+    describe('does not apply multiple times', async () => {
+      it('errors when a user is using the same subscription', async () => {
+        payments.createSubscription.restore();
+        iap.getPurchaseData.restore();
+        iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
+          .returns([{
+            expirationDate: moment.utc().add({ day: 1 }).toDate(),
+            purchaseDate: moment.utc().toDate(),
+            productId: sku,
+            transactionId: token,
+            originalTransactionId: token,
+          }]);
+
+        await applePayments.subscribe(user, receipt, headers, nextPaymentProcessing);
+
+        await expect(applePayments.subscribe(user, receipt, headers, nextPaymentProcessing))
+          .to.eventually.be.rejected.and.to.eql({
+            httpCode: 401,
+            name: 'NotAuthorized',
+            message: applePayments.constants.RESPONSE_ALREADY_USED,
+          });
+      });
+
+      it('errors when a user is using a rebill of the same subscription', async () => {
+        user = new User();
+        await user.save();
+        payments.createSubscription.restore();
+        iap.getPurchaseData.restore();
+        iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
+          .returns([{
+            expirationDate: moment.utc().add({ day: 1 }).toDate(),
+            purchaseDate: moment.utc().toDate(),
+            productId: sku,
+            transactionId: `${token}renew`,
+            originalTransactionId: token,
+          }]);
+
+        await applePayments.subscribe(user, receipt, headers, nextPaymentProcessing);
+
+        await expect(applePayments.subscribe(user, receipt, headers, nextPaymentProcessing))
+          .to.eventually.be.rejected.and.to.eql({
+            httpCode: 401,
+            name: 'NotAuthorized',
+            message: applePayments.constants.RESPONSE_ALREADY_USED,
+          });
+      });
+
+      it('errors when a different user is using the subscription', async () => {
+        user = new User();
+        await user.save();
+        payments.createSubscription.restore();
+        iap.getPurchaseData.restore();
+        iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
+          .returns([{
+            expirationDate: moment.utc().add({ day: 1 }).toDate(),
+            purchaseDate: moment.utc().toDate(),
+            productId: sku,
+            transactionId: token,
+            originalTransactionId: token,
+          }]);
+
+        await applePayments.subscribe(user, receipt, headers, nextPaymentProcessing);
+
+        const secondUser = new User();
+        await secondUser.save();
+        await expect(applePayments.subscribe(
+          secondUser, receipt, headers, nextPaymentProcessing,
+        ))
+          .to.eventually.be.rejected.and.to.eql({
+            httpCode: 401,
+            name: 'NotAuthorized',
+            message: applePayments.constants.RESPONSE_ALREADY_USED,
+          });
+      });
+
+      it('errors when a multiple users exist using the subscription', async () => {
+        user = new User();
+        await user.save();
+        payments.createSubscription.restore();
+        iap.getPurchaseData.restore();
+        iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
+          .returns([{
+            expirationDate: moment.utc().add({ day: 1 }).toDate(),
+            purchaseDate: moment.utc().toDate(),
+            productId: sku,
+            transactionId: token,
+            originalTransactionId: token,
+          }]);
+
+        await applePayments.subscribe(user, receipt, headers, nextPaymentProcessing);
+        const secondUser = new User();
+        secondUser.purchased.plan = user.purchased.plan;
+        secondUser.purchased.plan.dateTerminate = new Date();
+        secondUser.save();
+
+        iap.getPurchaseData.restore();
+        iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
+          .returns([{
+            expirationDate: moment.utc().add({ day: 1 }).toDate(),
+            purchaseDate: moment.utc().toDate(),
+            productId: sku,
+            transactionId: `${token}new`,
+            originalTransactionId: token,
+          }]);
+
+        const thirdUser = new User();
+        await thirdUser.save();
+        await expect(applePayments.subscribe(
+          thirdUser, receipt, headers, nextPaymentProcessing,
+        ))
+          .to.eventually.be.rejected.and.to.eql({
+            httpCode: 401,
+            name: 'NotAuthorized',
+            message: applePayments.constants.RESPONSE_ALREADY_USED,
+          });
+      });
     });
   });
 
@@ -359,9 +592,9 @@ describe('Apple Payments', () => {
         });
       iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
         .returns([{ expirationDate: expirationDate.toDate() }]);
-      iapIsValidatedStub = sinon.stub(iap, 'isValidated')
-        .returns(true);
-
+      iapIsValidatedStub = sinon.stub(iap, 'isValidated').returns(true);
+      sinon.stub(iap, 'isCanceled').returns(false);
+      sinon.stub(iap, 'isExpired').returns(true);
       user = new User();
       user.profile.name = 'sender';
       user.purchased.plan.paymentMethod = applePayments.constants.PAYMENT_METHOD_APPLE;
@@ -376,6 +609,8 @@ describe('Apple Payments', () => {
       iap.setup.restore();
       iap.validate.restore();
       iap.isValidated.restore();
+      iap.isExpired.restore();
+      iap.isCanceled.restore();
       iap.getPurchaseData.restore();
       payments.cancelSubscription.restore();
     });
@@ -395,6 +630,8 @@ describe('Apple Payments', () => {
       iap.getPurchaseData.restore();
       iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
         .returns([{ expirationDate: expirationDate.add({ day: 1 }).toDate() }]);
+      iap.isExpired.restore();
+      sinon.stub(iap, 'isExpired').returns(false);
 
       await expect(applePayments.cancelSubscribe(user, headers))
         .to.eventually.be.rejected.and.to.eql({
@@ -417,7 +654,38 @@ describe('Apple Payments', () => {
         });
     });
 
-    it('should cancel a user subscription', async () => {
+    it('should cancel a cancelled subscription with termination date in the future', async () => {
+      const futureDate = expirationDate.add({ day: 1 });
+      iap.getPurchaseData.restore();
+      iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
+        .returns([{ expirationDate: futureDate }]);
+      iap.isExpired.restore();
+      sinon.stub(iap, 'isExpired').returns(false);
+
+      iap.isCanceled.restore();
+      sinon.stub(iap, 'isCanceled').returns(true);
+
+      await applePayments.cancelSubscribe(user, headers);
+
+      expect(iapSetupStub).to.be.calledOnce;
+      expect(iapValidateStub).to.be.calledOnce;
+      expect(iapValidateStub).to.be.calledWith(iap.APPLE, receipt);
+      expect(iapIsValidatedStub).to.be.calledOnce;
+      expect(iapIsValidatedStub).to.be.calledWith({
+        expirationDate: futureDate,
+      });
+      expect(iapGetPurchaseDataStub).to.be.calledOnce;
+
+      expect(paymentCancelSubscriptionSpy).to.be.calledOnce;
+      expect(paymentCancelSubscriptionSpy).to.be.calledWith({
+        user,
+        paymentMethod: applePayments.constants.PAYMENT_METHOD_APPLE,
+        nextBill: futureDate.toDate(),
+        headers,
+      });
+    });
+
+    it('should cancel an expired subscription', async () => {
       await applePayments.cancelSubscribe(user, headers);
 
       expect(iapSetupStub).to.be.calledOnce;

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

@@ -12,11 +12,11 @@ const { i18n } = common;
 describe('Google Payments', () => {
   const subKey = 'basic_3mo';
 
-  describe('verifyGemPurchase', () => {
+  describe('verifyPurchase', () => {
     let sku; let user; let token; let receipt; let signature; let
-      headers; const gemsBlock = common.content.gems['21gems'];
+      headers;
     let iapSetupStub; let iapValidateStub; let iapIsValidatedStub; let
-      paymentBuyGemsStub; let validateGiftMessageStub;
+      paymentBuySkuStub; let validateGiftMessageStub;
 
     beforeEach(() => {
       sku = 'com.habitrpg.android.habitica.iap.21gems';
@@ -27,11 +27,10 @@ describe('Google Payments', () => {
 
       iapSetupStub = sinon.stub(iap, 'setup')
         .resolves();
-      iapValidateStub = sinon.stub(iap, 'validate')
-        .resolves({});
+      iapValidateStub = sinon.stub(iap, 'validate').resolves({ productId: sku });
       iapIsValidatedStub = sinon.stub(iap, 'isValidated')
         .returns(true);
-      paymentBuyGemsStub = sinon.stub(payments, 'buyGems').resolves({});
+      paymentBuySkuStub = sinon.stub(payments, 'buySkuItem').resolves({});
       validateGiftMessageStub = sinon.stub(gems, 'validateGiftMessage');
     });
 
@@ -39,7 +38,7 @@ describe('Google Payments', () => {
       iap.setup.restore();
       iap.validate.restore();
       iap.isValidated.restore();
-      payments.buyGems.restore();
+      payments.buySkuItem.restore();
       gems.validateGiftMessage.restore();
     });
 
@@ -48,7 +47,7 @@ describe('Google Payments', () => {
       iapIsValidatedStub = sinon.stub(iap, 'isValidated')
         .returns(false);
 
-      await expect(googlePayments.verifyGemPurchase({
+      await expect(googlePayments.verifyPurchase({
         user, receipt, signature, headers,
       }))
         .to.eventually.be.rejected.and.to.eql({
@@ -60,21 +59,25 @@ describe('Google Payments', () => {
 
     it('should throw an error if productId is invalid', async () => {
       receipt = `{"token": "${token}", "productId": "invalid"}`;
+      iapValidateStub.restore();
+      iapValidateStub = sinon.stub(iap, 'validate').resolves({});
 
-      await expect(googlePayments.verifyGemPurchase({
+      paymentBuySkuStub.restore();
+      await expect(googlePayments.verifyPurchase({
         user, receipt, signature, headers,
       }))
         .to.eventually.be.rejected.and.to.eql({
-          httpCode: 401,
-          name: 'NotAuthorized',
+          httpCode: 400,
+          name: 'BadRequest',
           message: googlePayments.constants.RESPONSE_INVALID_ITEM,
         });
+      paymentBuySkuStub = sinon.stub(payments, 'buySkuItem').resolves({});
     });
 
     it('should throw an error if user cannot purchase gems', async () => {
       sinon.stub(user, 'canGetGems').resolves(false);
 
-      await expect(googlePayments.verifyGemPurchase({
+      await expect(googlePayments.verifyPurchase({
         user, receipt, signature, headers,
       }))
         .to.eventually.be.rejected.and.to.eql({
@@ -88,7 +91,7 @@ describe('Google Payments', () => {
 
     it('purchases gems', async () => {
       sinon.stub(user, 'canGetGems').resolves(true);
-      await googlePayments.verifyGemPurchase({
+      await googlePayments.verifyPurchase({
         user, receipt, signature, headers,
       });
 
@@ -101,15 +104,17 @@ describe('Google Payments', () => {
         signature,
       });
       expect(iapIsValidatedStub).to.be.calledOnce;
-      expect(iapIsValidatedStub).to.be.calledWith({});
+      expect(iapIsValidatedStub).to.be.calledWith(
+        { productId: sku },
+      );
 
-      expect(paymentBuyGemsStub).to.be.calledOnce;
-      expect(paymentBuyGemsStub).to.be.calledWith({
+      expect(paymentBuySkuStub).to.be.calledOnce;
+      expect(paymentBuySkuStub).to.be.calledWith({
         user,
-        paymentMethod: googlePayments.constants.PAYMENT_METHOD_GOOGLE,
-        gemsBlock,
-        headers,
         gift: undefined,
+        paymentMethod: googlePayments.constants.PAYMENT_METHOD_GOOGLE,
+        sku,
+        headers,
       });
       expect(user.canGetGems).to.be.calledOnce;
       user.canGetGems.restore();
@@ -120,7 +125,7 @@ describe('Google Payments', () => {
       await receivingUser.save();
 
       const gift = { uuid: receivingUser._id };
-      await googlePayments.verifyGemPurchase({
+      await googlePayments.verifyPurchase({
         user, gift, receipt, signature, headers,
       });
 
@@ -134,20 +139,20 @@ describe('Google Payments', () => {
         signature,
       });
       expect(iapIsValidatedStub).to.be.calledOnce;
-      expect(iapIsValidatedStub).to.be.calledWith({});
+      expect(iapIsValidatedStub).to.be.calledWith(
+        { productId: sku },
+      );
 
-      expect(paymentBuyGemsStub).to.be.calledOnce;
-      expect(paymentBuyGemsStub).to.be.calledWith({
+      expect(paymentBuySkuStub).to.be.calledOnce;
+      expect(paymentBuySkuStub).to.be.calledWith({
         user,
-        paymentMethod: googlePayments.constants.PAYMENT_METHOD_GOOGLE,
-        gemsBlock,
-        headers,
         gift: {
-          type: 'gems',
-          gems: { amount: 21 },
-          member: sinon.match({ _id: receivingUser._id }),
           uuid: receivingUser._id,
+          member: sinon.match({ _id: receivingUser._id }),
         },
+        paymentMethod: googlePayments.constants.PAYMENT_METHOD_GOOGLE,
+        sku,
+        headers,
       });
     });
   });

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

@@ -11,10 +11,13 @@ import {
   generateGroup,
 } from '../../../../helpers/api-unit.helper';
 import * as worldState from '../../../../../website/server/libs/worldState';
+import { TransactionModel } from '../../../../../website/server/models/transaction';
 
 describe('payments/index', () => {
-  let user; let group; let data; let
-    plan;
+  let user;
+  let group;
+  let data;
+  let plan;
 
   beforeEach(async () => {
     user = new User();
@@ -104,6 +107,23 @@ describe('payments/index', () => {
         expect(recipient.purchased.plan.extraMonths).to.eql(3);
       });
 
+      it('add a transaction entry to the recipient', async () => {
+        recipient.purchased.plan = plan;
+
+        expect(recipient.purchased.plan.extraMonths).to.eql(0);
+
+        await api.createSubscription(data);
+
+        expect(recipient.purchased.plan.extraMonths).to.eql(3);
+
+        const transactions = await TransactionModel
+          .find({ userId: recipient._id })
+          .sort({ createdAt: -1 })
+          .exec();
+
+        expect(transactions).to.have.lengthOf(1);
+      });
+
       it('does not set negative extraMonths if plan has past dateTerminated date', async () => {
         const dateTerminated = moment().subtract(2, 'months').toDate();
         recipient.purchased.plan.dateTerminated = dateTerminated;
@@ -183,6 +203,28 @@ describe('payments/index', () => {
         expect(recipient.purchased.plan.dateCreated).to.exist;
       });
 
+      it('sets plan.dateCurrentTypeCreated if it did not previously exist', async () => {
+        expect(recipient.purchased.plan.dateCurrentTypeCreated).to.not.exist;
+
+        await api.createSubscription(data);
+
+        expect(recipient.purchased.plan.dateCurrentTypeCreated).to.exist;
+      });
+
+      it('keeps plan.dateCreated when changing subscription type', async () => {
+        await api.createSubscription(data);
+        const initialDate = recipient.purchased.plan.dateCreated;
+        await api.createSubscription(data);
+        expect(recipient.purchased.plan.dateCreated).to.eql(initialDate);
+      });
+
+      it('sets plan.dateCurrentTypeCreated when changing subscription type', async () => {
+        await api.createSubscription(data);
+        const initialDate = recipient.purchased.plan.dateCurrentTypeCreated;
+        await api.createSubscription(data);
+        expect(recipient.purchased.plan.dateCurrentTypeCreated).to.not.eql(initialDate);
+      });
+
       it('does not change plan.customerId if it already exists', async () => {
         recipient.purchased.plan = plan;
         data.customerId = 'purchaserCustomerId';
@@ -193,6 +235,116 @@ describe('payments/index', () => {
         expect(recipient.purchased.plan.customerId).to.eql('customer-id');
       });
 
+      it('sets plan.perkMonthCount to 1 if user is not subscribed', async () => {
+        recipient.purchased.plan = plan;
+        recipient.purchased.plan.perkMonthCount = 1;
+        recipient.purchased.plan.customerId = undefined;
+        data.sub.key = 'basic_earned';
+        data.gift.subscription.key = 'basic_earned';
+        data.gift.subscription.months = 1;
+
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(1);
+        await api.createSubscription(data);
+
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(1);
+      });
+
+      it('sets plan.perkMonthCount to 1 if field is not initialized', async () => {
+        recipient.purchased.plan = plan;
+        recipient.purchased.plan.perkMonthCount = -1;
+        recipient.purchased.plan.customerId = undefined;
+        data.sub.key = 'basic_earned';
+        data.gift.subscription.key = 'basic_earned';
+        data.gift.subscription.months = 1;
+
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(-1);
+        await api.createSubscription(data);
+
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(1);
+      });
+
+      it('sets plan.perkMonthCount to 1 if user had previous count but lapsed subscription', async () => {
+        recipient.purchased.plan = plan;
+        recipient.purchased.plan.perkMonthCount = 2;
+        recipient.purchased.plan.customerId = undefined;
+        data.sub.key = 'basic_earned';
+        data.gift.subscription.key = 'basic_earned';
+        data.gift.subscription.months = 1;
+
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(2);
+        await api.createSubscription(data);
+
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(1);
+      });
+
+      it('adds to plan.perkMonthCount if user is already subscribed', async () => {
+        recipient.purchased.plan = plan;
+        recipient.purchased.plan.perkMonthCount = 1;
+        data.sub.key = 'basic_earned';
+        data.gift.subscription.key = 'basic_earned';
+        data.gift.subscription.months = 1;
+
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(1);
+        await api.createSubscription(data);
+
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(2);
+      });
+
+      it('awards perks if plan.perkMonthCount reaches 3 with existing subscription', async () => {
+        recipient.purchased.plan = plan;
+        recipient.purchased.plan.perkMonthCount = 2;
+        data.sub.key = 'basic_earned';
+        data.gift.subscription.key = 'basic_earned';
+        data.gift.subscription.months = 1;
+
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(2);
+        expect(recipient.purchased.plan.consecutive.trinkets).to.eql(0);
+        expect(recipient.purchased.plan.consecutive.gemCapExtra).to.eql(0);
+        await api.createSubscription(data);
+
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(0);
+        expect(recipient.purchased.plan.consecutive.trinkets).to.eql(1);
+        expect(recipient.purchased.plan.consecutive.gemCapExtra).to.eql(5);
+      });
+
+      it('awards perks if plan.perkMonthCount reaches 3 without existing subscription', async () => {
+        recipient.purchased.plan.perkMonthCount = 0;
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(0);
+        expect(recipient.purchased.plan.consecutive.trinkets).to.eql(0);
+        expect(recipient.purchased.plan.consecutive.gemCapExtra).to.eql(0);
+        await api.createSubscription(data);
+
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(0);
+        expect(recipient.purchased.plan.consecutive.trinkets).to.eql(1);
+        expect(recipient.purchased.plan.consecutive.gemCapExtra).to.eql(5);
+      });
+
+      it('awards perks if plan.perkMonthCount reaches 3 without initialized field', async () => {
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(-1);
+        expect(recipient.purchased.plan.consecutive.trinkets).to.eql(0);
+        expect(recipient.purchased.plan.consecutive.gemCapExtra).to.eql(0);
+        await api.createSubscription(data);
+
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(0);
+        expect(recipient.purchased.plan.consecutive.trinkets).to.eql(1);
+        expect(recipient.purchased.plan.consecutive.gemCapExtra).to.eql(5);
+      });
+
+      it('awards perks if plan.perkMonthCount goes over 3', async () => {
+        recipient.purchased.plan = plan;
+        recipient.purchased.plan.perkMonthCount = 2;
+        data.sub.key = 'basic_earned';
+
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(2);
+        expect(recipient.purchased.plan.consecutive.trinkets).to.eql(0);
+        expect(recipient.purchased.plan.consecutive.gemCapExtra).to.eql(0);
+        await api.createSubscription(data);
+
+        expect(recipient.purchased.plan.perkMonthCount).to.eql(2);
+        expect(recipient.purchased.plan.consecutive.trinkets).to.eql(1);
+        expect(recipient.purchased.plan.consecutive.gemCapExtra).to.eql(5);
+      });
+
       it('sets plan.customerId to "Gift" if it does not already exist', async () => {
         expect(recipient.purchased.plan.customerId).to.not.exist;
 
@@ -359,6 +511,7 @@ describe('payments/index', () => {
         expect(user.purchased.plan.customerId).to.eql('customer-id');
         expect(user.purchased.plan.dateUpdated).to.exist;
         expect(user.purchased.plan.gemsBought).to.eql(0);
+        expect(user.purchased.plan.perkMonthCount).to.eql(0);
         expect(user.purchased.plan.paymentMethod).to.eql('Payment Method');
         expect(user.purchased.plan.extraMonths).to.eql(0);
         expect(user.purchased.plan.dateTerminated).to.eql(null);
@@ -366,6 +519,63 @@ describe('payments/index', () => {
         expect(user.purchased.plan.dateCreated).to.exist;
       });
 
+      it('sets plan.dateCreated if it did not previously exist', async () => {
+        expect(user.purchased.plan.dateCreated).to.not.exist;
+
+        await api.createSubscription(data);
+
+        expect(user.purchased.plan.dateCreated).to.exist;
+      });
+
+      it('sets plan.dateCurrentTypeCreated if it did not previously exist', async () => {
+        expect(user.purchased.plan.dateCurrentTypeCreated).to.not.exist;
+
+        await api.createSubscription(data);
+
+        expect(user.purchased.plan.dateCurrentTypeCreated).to.exist;
+      });
+
+      it('keeps plan.dateCreated when changing subscription type', async () => {
+        await api.createSubscription(data);
+        const initialDate = user.purchased.plan.dateCreated;
+        await api.createSubscription(data);
+        expect(user.purchased.plan.dateCreated).to.eql(initialDate);
+      });
+
+      it('sets plan.dateCurrentTypeCreated when changing subscription type', async () => {
+        await api.createSubscription(data);
+        const initialDate = user.purchased.plan.dateCurrentTypeCreated;
+        await api.createSubscription(data);
+        expect(user.purchased.plan.dateCurrentTypeCreated).to.not.eql(initialDate);
+      });
+
+      it('keeps plan.perkMonthCount when changing subscription type', async () => {
+        await api.createSubscription(data);
+        user.purchased.plan.perkMonthCount = 2;
+        await api.createSubscription(data);
+        expect(user.purchased.plan.perkMonthCount).to.eql(2);
+      });
+
+      it('sets plan.perkMonthCount to zero when creating new monthly subscription', async () => {
+        user.purchased.plan.perkMonthCount = 2;
+        await api.createSubscription(data);
+        expect(user.purchased.plan.perkMonthCount).to.eql(0);
+      });
+
+      it('sets plan.perkMonthCount to zero when creating new 3 month subscription', async () => {
+        user.purchased.plan.perkMonthCount = 2;
+        await api.createSubscription(data);
+        expect(user.purchased.plan.perkMonthCount).to.eql(0);
+      });
+
+      it('updates plan.consecutive.offset when changing subscription type', async () => {
+        await api.createSubscription(data);
+        expect(user.purchased.plan.consecutive.offset).to.eql(3);
+        data.sub.key = 'basic_6mo';
+        await api.createSubscription(data);
+        expect(user.purchased.plan.consecutive.offset).to.eql(6);
+      });
+
       it('awards the Royal Purple Jackalope pet', async () => {
         await api.createSubscription(data);
 
@@ -445,6 +655,89 @@ describe('payments/index', () => {
           },
         });
       });
+
+      context('Upgrades subscription', () => {
+        it('from basic_earned to basic_6mo', async () => {
+          data.sub.key = 'basic_earned';
+          expect(user.purchased.plan.planId).to.not.exist;
+
+          await api.createSubscription(data);
+
+          expect(user.purchased.plan.planId).to.eql('basic_earned');
+          expect(user.purchased.plan.customerId).to.eql('customer-id');
+          const created = user.purchased.plan.dateCreated;
+          const updated = user.purchased.plan.dateUpdated;
+
+          data.sub.key = 'basic_6mo';
+          data.updatedFrom = { key: 'basic_earned' };
+          await api.createSubscription(data);
+          expect(user.purchased.plan.planId).to.eql('basic_6mo');
+          expect(user.purchased.plan.dateCreated).to.eql(created);
+          expect(user.purchased.plan.dateUpdated).to.not.eql(updated);
+          expect(user.purchased.plan.customerId).to.eql('customer-id');
+        });
+
+        it('from basic_3mo to basic_12mo', async () => {
+          expect(user.purchased.plan.planId).to.not.exist;
+
+          await api.createSubscription(data);
+
+          expect(user.purchased.plan.planId).to.eql('basic_3mo');
+          expect(user.purchased.plan.customerId).to.eql('customer-id');
+          const created = user.purchased.plan.dateCreated;
+          const updated = user.purchased.plan.dateUpdated;
+
+          data.sub.key = 'basic_12mo';
+          data.updatedFrom = { key: 'basic_3mo' };
+          await api.createSubscription(data);
+          expect(user.purchased.plan.planId).to.eql('basic_12mo');
+          expect(user.purchased.plan.dateCreated).to.eql(created);
+          expect(user.purchased.plan.dateUpdated).to.not.eql(updated);
+          expect(user.purchased.plan.customerId).to.eql('customer-id');
+        });
+      });
+
+      context('Downgrades subscription', () => {
+        it('from basic_6mo to basic_earned', async () => {
+          data.sub.key = 'basic_6mo';
+          expect(user.purchased.plan.planId).to.not.exist;
+
+          await api.createSubscription(data);
+
+          expect(user.purchased.plan.planId).to.eql('basic_6mo');
+          expect(user.purchased.plan.customerId).to.eql('customer-id');
+          const created = user.purchased.plan.dateCreated;
+          const updated = user.purchased.plan.dateUpdated;
+
+          data.sub.key = 'basic_earned';
+          data.updatedFrom = { key: 'basic_6mo' };
+          await api.createSubscription(data);
+          expect(user.purchased.plan.planId).to.eql('basic_earned');
+          expect(user.purchased.plan.dateCreated).to.eql(created);
+          expect(user.purchased.plan.dateUpdated).to.not.eql(updated);
+          expect(user.purchased.plan.customerId).to.eql('customer-id');
+        });
+
+        it('from basic_12mo to basic_3mo', async () => {
+          expect(user.purchased.plan.planId).to.not.exist;
+
+          data.sub.key = 'basic_12mo';
+          await api.createSubscription(data);
+
+          expect(user.purchased.plan.planId).to.eql('basic_12mo');
+          expect(user.purchased.plan.customerId).to.eql('customer-id');
+          const created = user.purchased.plan.dateCreated;
+          const updated = user.purchased.plan.dateUpdated;
+
+          data.sub.key = 'basic_3mo';
+          data.updatedFrom = { key: 'basic_12mo' };
+          await api.createSubscription(data);
+          expect(user.purchased.plan.planId).to.eql('basic_3mo');
+          expect(user.purchased.plan.dateCreated).to.eql(created);
+          expect(user.purchased.plan.dateUpdated).to.not.eql(updated);
+          expect(user.purchased.plan.customerId).to.eql('customer-id');
+        });
+      });
     });
 
     context('Block subscription perks', () => {
@@ -455,9 +748,19 @@ describe('payments/index', () => {
       });
 
       it('does not add to plans.consecutive.offset if 1 month subscription', async () => {
+        data.sub.key = 'basic_earned';
         await api.createSubscription(data);
 
-        expect(user.purchased.plan.extraMonths).to.eql(0);
+        expect(user.purchased.plan.consecutive.offset).to.eql(0);
+      });
+
+      it('resets plans.consecutive.offset if 1 month subscription', async () => {
+        user.purchased.plan.consecutive.offset = 1;
+        await user.save();
+        data.sub.key = 'basic_earned';
+        await api.createSubscription(data);
+
+        expect(user.purchased.plan.consecutive.offset).to.eql(0);
       });
 
       it('adds 5 to plan.consecutive.gemCapExtra for 3 month block', async () => {
@@ -468,7 +771,6 @@ describe('payments/index', () => {
 
       it('adds 10 to plan.consecutive.gemCapExtra for 6 month block', async () => {
         data.sub.key = 'basic_6mo';
-
         await api.createSubscription(data);
 
         expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(10);
@@ -476,7 +778,6 @@ describe('payments/index', () => {
 
       it('adds 20 to plan.consecutive.gemCapExtra for 12 month block', async () => {
         data.sub.key = 'basic_12mo';
-
         await api.createSubscription(data);
 
         expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(20);
@@ -512,6 +813,532 @@ describe('payments/index', () => {
 
         expect(user.purchased.plan.consecutive.trinkets).to.eql(4);
       });
+
+      context('Upgrades subscription', () => {
+        context('Using payDifference logic', () => {
+          beforeEach(async () => {
+            data.updatedFrom = { logic: 'payDifference' };
+          });
+          it('Adds 10 to plan.consecutive.gemCapExtra from basic_earned to basic_6mo', async () => {
+            data.sub.key = 'basic_earned';
+            expect(user.purchased.plan.planId).to.not.exist;
+
+            await api.createSubscription(data);
+
+            expect(user.purchased.plan.planId).to.eql('basic_earned');
+            expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(0);
+
+            data.sub.key = 'basic_6mo';
+            data.updatedFrom.key = 'basic_earned';
+            await api.createSubscription(data);
+            expect(user.purchased.plan.planId).to.eql('basic_6mo');
+            expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(10);
+          });
+
+          it('Adds 15 to plan.consecutive.gemCapExtra when upgrading from basic_3mo to basic_12mo', async () => {
+            expect(user.purchased.plan.planId).to.not.exist;
+
+            await api.createSubscription(data);
+
+            expect(user.purchased.plan.planId).to.eql('basic_3mo');
+            expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(5);
+
+            data.sub.key = 'basic_12mo';
+            data.updatedFrom.key = 'basic_3mo';
+            await api.createSubscription(data);
+            expect(user.purchased.plan.planId).to.eql('basic_12mo');
+            expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(20);
+          });
+
+          it('Adds 2 to plan.consecutive.trinkets from basic_earned to basic_6mo', async () => {
+            data.sub.key = 'basic_earned';
+            expect(user.purchased.plan.planId).to.not.exist;
+
+            await api.createSubscription(data);
+
+            expect(user.purchased.plan.planId).to.eql('basic_earned');
+            expect(user.purchased.plan.consecutive.trinkets).to.eql(0);
+
+            data.sub.key = 'basic_6mo';
+            data.updatedFrom.key = 'basic_earned';
+            await api.createSubscription(data);
+            expect(user.purchased.plan.planId).to.eql('basic_6mo');
+            expect(user.purchased.plan.consecutive.trinkets).to.eql(2);
+          });
+
+          it('Adds 2 to plan.consecutive.trinkets when upgrading from basic_6mo to basic_12mo', async () => {
+            data.sub.key = 'basic_6mo';
+            expect(user.purchased.plan.planId).to.not.exist;
+
+            await api.createSubscription(data);
+
+            expect(user.purchased.plan.planId).to.eql('basic_6mo');
+            expect(user.purchased.plan.consecutive.trinkets).to.eql(2);
+
+            data.sub.key = 'basic_12mo';
+            data.updatedFrom.key = 'basic_6mo';
+            await api.createSubscription(data);
+            expect(user.purchased.plan.planId).to.eql('basic_12mo');
+            expect(user.purchased.plan.consecutive.trinkets).to.eql(4);
+          });
+
+          it('Adds 3 to plan.consecutive.trinkets when upgrading from basic_3mo to basic_12mo', async () => {
+            expect(user.purchased.plan.planId).to.not.exist;
+
+            await api.createSubscription(data);
+
+            expect(user.purchased.plan.planId).to.eql('basic_3mo');
+            expect(user.purchased.plan.consecutive.trinkets).to.eql(1);
+
+            data.sub.key = 'basic_12mo';
+            data.updatedFrom.key = 'basic_3mo';
+            await api.createSubscription(data);
+            expect(user.purchased.plan.planId).to.eql('basic_12mo');
+            expect(user.purchased.plan.consecutive.trinkets).to.eql(4);
+          });
+        });
+
+        context('Using payFull logic', () => {
+          beforeEach(async () => {
+            data.updatedFrom = { logic: 'payFull' };
+          });
+          it('Adds 10 to plan.consecutive.gemCapExtra from basic_earned to basic_6mo', async () => {
+            data.sub.key = 'basic_earned';
+            expect(user.purchased.plan.planId).to.not.exist;
+
+            await api.createSubscription(data);
+
+            expect(user.purchased.plan.planId).to.eql('basic_earned');
+            expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(0);
+
+            data.sub.key = 'basic_6mo';
+            data.updatedFrom.key = 'basic_earned';
+            await api.createSubscription(data);
+            expect(user.purchased.plan.planId).to.eql('basic_6mo');
+            expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(10);
+          });
+
+          it('Adds 20 to plan.consecutive.gemCapExtra when upgrading from basic_3mo to basic_12mo', async () => {
+            expect(user.purchased.plan.planId).to.not.exist;
+
+            await api.createSubscription(data);
+
+            expect(user.purchased.plan.planId).to.eql('basic_3mo');
+            expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(5);
+
+            data.sub.key = 'basic_12mo';
+            data.updatedFrom.key = 'basic_3mo';
+            await api.createSubscription(data);
+            expect(user.purchased.plan.planId).to.eql('basic_12mo');
+            expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(25);
+          });
+
+          it('Adds 2 to plan.consecutive.trinkets from basic_earned to basic_6mo', async () => {
+            data.sub.key = 'basic_earned';
+            expect(user.purchased.plan.planId).to.not.exist;
+
+            await api.createSubscription(data);
+
+            expect(user.purchased.plan.planId).to.eql('basic_earned');
+            expect(user.purchased.plan.consecutive.trinkets).to.eql(0);
+
+            data.sub.key = 'basic_6mo';
+            data.updatedFrom.key = 'basic_earned';
+            await api.createSubscription(data);
+            expect(user.purchased.plan.planId).to.eql('basic_6mo');
+            expect(user.purchased.plan.consecutive.trinkets).to.eql(2);
+          });
+
+          it('Adds 4 to plan.consecutive.trinkets when upgrading from basic_6mo to basic_12mo', async () => {
+            data.sub.key = 'basic_6mo';
+            expect(user.purchased.plan.planId).to.not.exist;
+
+            await api.createSubscription(data);
+
+            expect(user.purchased.plan.planId).to.eql('basic_6mo');
+            expect(user.purchased.plan.consecutive.trinkets).to.eql(2);
+
+            data.sub.key = 'basic_12mo';
+            data.updatedFrom.key = 'basic_6mo';
+            await api.createSubscription(data);
+            expect(user.purchased.plan.planId).to.eql('basic_12mo');
+            expect(user.purchased.plan.consecutive.trinkets).to.eql(6);
+          });
+
+          it('Adds 4 to plan.consecutive.trinkets when upgrading from basic_3mo to basic_12mo', async () => {
+            expect(user.purchased.plan.planId).to.not.exist;
+
+            await api.createSubscription(data);
+
+            expect(user.purchased.plan.planId).to.eql('basic_3mo');
+            expect(user.purchased.plan.consecutive.trinkets).to.eql(1);
+
+            data.sub.key = 'basic_12mo';
+            data.updatedFrom.key = 'basic_3mo';
+            await api.createSubscription(data);
+            expect(user.purchased.plan.planId).to.eql('basic_12mo');
+            expect(user.purchased.plan.consecutive.trinkets).to.eql(5);
+          });
+        });
+
+        context('Using refundAndRepay logic', () => {
+          let clock;
+          beforeEach(async () => {
+            clock = sinon.useFakeTimers(new Date('2022-01-01'));
+            data.updatedFrom = { logic: 'refundAndRepay' };
+          });
+          context('Upgrades within first half of subscription', () => {
+            it('Adds 10 to plan.consecutive.gemCapExtra from basic_earned to basic_6mo', async () => {
+              data.sub.key = 'basic_earned';
+              expect(user.purchased.plan.planId).to.not.exist;
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_earned');
+              expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(0);
+
+              data.sub.key = 'basic_6mo';
+              data.updatedFrom.key = 'basic_earned';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2022-01-10'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_6mo');
+              expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(10);
+            });
+
+            it('Adds 15 to plan.consecutive.gemCapExtra when upgrading from basic_3mo to basic_12mo', async () => {
+              expect(user.purchased.plan.planId).to.not.exist;
+
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_3mo');
+              expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(5);
+
+              data.sub.key = 'basic_12mo';
+              data.updatedFrom.key = 'basic_3mo';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2022-02-05'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_12mo');
+              expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(20);
+            });
+
+            it('Adds 2 to plan.consecutive.trinkets from basic_earned to basic_6mo', async () => {
+              data.sub.key = 'basic_earned';
+              expect(user.purchased.plan.planId).to.not.exist;
+
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_earned');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(0);
+
+              data.sub.key = 'basic_6mo';
+              data.updatedFrom.key = 'basic_earned';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2022-01-08'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_6mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(2);
+            });
+
+            it('Adds 3 to plan.consecutive.trinkets when upgrading from basic_3mo to basic_12mo', async () => {
+              expect(user.purchased.plan.planId).to.not.exist;
+
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_3mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(1);
+
+              data.sub.key = 'basic_12mo';
+              data.updatedFrom.key = 'basic_3mo';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2022-01-31'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_12mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(4);
+            });
+
+            it('Adds 2 to plan.consecutive.trinkets when upgrading from basic_6mo to basic_12mo', async () => {
+              data.sub.key = 'basic_6mo';
+              expect(user.purchased.plan.planId).to.not.exist;
+
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_6mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(2);
+
+              data.sub.key = 'basic_12mo';
+              data.updatedFrom.key = 'basic_6mo';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2022-01-28'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_12mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(4);
+            });
+
+            it('Adds 2 to plan.consecutive.trinkets from basic_earned to basic_6mo after initial cycle', async () => {
+              data.sub.key = 'basic_earned';
+              expect(user.purchased.plan.planId).to.not.exist;
+
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_earned');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(0);
+
+              data.sub.key = 'basic_6mo';
+              data.updatedFrom.key = 'basic_earned';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2024-01-08'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_6mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(2);
+            });
+
+            it('Adds 2 to plan.consecutive.trinkets when upgrading from basic_6mo to basic_12mo after initial cycle', async () => {
+              data.sub.key = 'basic_6mo';
+              expect(user.purchased.plan.planId).to.not.exist;
+
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_6mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(2);
+
+              data.sub.key = 'basic_12mo';
+              data.updatedFrom.key = 'basic_6mo';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2022-08-28'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_12mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(4);
+            });
+
+            it('Adds 3 to plan.consecutive.trinkets when upgrading from basic_3mo to basic_12mo after initial cycle', async () => {
+              expect(user.purchased.plan.planId).to.not.exist;
+
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_3mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(1);
+
+              data.sub.key = 'basic_12mo';
+              data.updatedFrom.key = 'basic_3mo';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2022-07-31'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_12mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(4);
+            });
+          });
+          context('Upgrades within second half of subscription', () => {
+            it('Adds 10 to plan.consecutive.gemCapExtra from basic_earned to basic_6mo', async () => {
+              data.sub.key = 'basic_earned';
+              expect(user.purchased.plan.planId).to.not.exist;
+
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_earned');
+              expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(0);
+
+              data.sub.key = 'basic_6mo';
+              data.updatedFrom.key = 'basic_earned';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2022-01-20'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_6mo');
+              expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(10);
+            });
+
+            it('Adds 20 to plan.consecutive.gemCapExtra when upgrading from basic_3mo to basic_12mo', async () => {
+              expect(user.purchased.plan.planId).to.not.exist;
+
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_3mo');
+              expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(5);
+
+              data.sub.key = 'basic_12mo';
+              data.updatedFrom.key = 'basic_3mo';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2022-02-24'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_12mo');
+              expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(25);
+            });
+
+            it('Adds 2 to plan.consecutive.trinkets from basic_earned to basic_6mo', async () => {
+              data.sub.key = 'basic_earned';
+              expect(user.purchased.plan.planId).to.not.exist;
+
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_earned');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(0);
+
+              data.sub.key = 'basic_6mo';
+              data.updatedFrom.key = 'basic_earned';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2022-01-28'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_6mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(2);
+            });
+
+            it('Adds 4 to plan.consecutive.trinkets when upgrading from basic_6mo to basic_12mo', async () => {
+              data.sub.key = 'basic_6mo';
+              expect(user.purchased.plan.planId).to.not.exist;
+
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_6mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(2);
+
+              data.sub.key = 'basic_12mo';
+              data.updatedFrom.key = 'basic_6mo';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2022-05-28'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_12mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(6);
+            });
+
+            it('Adds 4 to plan.consecutive.trinkets when upgrading from basic_3mo to basic_12mo', async () => {
+              expect(user.purchased.plan.planId).to.not.exist;
+
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_3mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(1);
+
+              data.sub.key = 'basic_12mo';
+              data.updatedFrom.key = 'basic_3mo';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2022-03-03'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_12mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(5);
+            });
+
+            it('Adds 2 to plan.consecutive.trinkets from basic_earned to basic_6mo after initial cycle', async () => {
+              data.sub.key = 'basic_earned';
+              expect(user.purchased.plan.planId).to.not.exist;
+
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_earned');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(0);
+
+              data.sub.key = 'basic_6mo';
+              data.updatedFrom.key = 'basic_earned';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2022-05-28'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_6mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(2);
+            });
+
+            it('Adds 4 to plan.consecutive.trinkets when upgrading from basic_6mo to basic_12mo after initial cycle', async () => {
+              data.sub.key = 'basic_6mo';
+              expect(user.purchased.plan.planId).to.not.exist;
+
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_6mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(2);
+
+              data.sub.key = 'basic_12mo';
+              data.updatedFrom.key = 'basic_6mo';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2023-05-28'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_12mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(6);
+            });
+
+            it('Adds 4 to plan.consecutive.trinkets when upgrading from basic_3mo to basic_12mo after initial cycle', async () => {
+              expect(user.purchased.plan.planId).to.not.exist;
+
+              await api.createSubscription(data);
+
+              expect(user.purchased.plan.planId).to.eql('basic_3mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(1);
+
+              data.sub.key = 'basic_12mo';
+              data.updatedFrom.key = 'basic_3mo';
+              clock.restore();
+              clock = sinon.useFakeTimers(new Date('2023-09-03'));
+              await api.createSubscription(data);
+              expect(user.purchased.plan.planId).to.eql('basic_12mo');
+              expect(user.purchased.plan.consecutive.trinkets).to.eql(5);
+            });
+          });
+          afterEach(async () => {
+            if (clock !== null) clock.restore();
+          });
+        });
+      });
+
+      context('Downgrades subscription', () => {
+        it('does not remove from plan.consecutive.gemCapExtra from basic_6mo to basic_earned', async () => {
+          data.sub.key = 'basic_6mo';
+          expect(user.purchased.plan.planId).to.not.exist;
+
+          await api.createSubscription(data);
+
+          expect(user.purchased.plan.planId).to.eql('basic_6mo');
+          expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(10);
+
+          data.sub.key = 'basic_earned';
+          data.updatedFrom = { key: 'basic_6mo' };
+          await api.createSubscription(data);
+          expect(user.purchased.plan.planId).to.eql('basic_earned');
+          expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(10);
+        });
+
+        it('does not remove from plan.consecutive.gemCapExtra from basic_12mo to basic_3mo', async () => {
+          expect(user.purchased.plan.planId).to.not.exist;
+
+          data.sub.key = 'basic_12mo';
+          await api.createSubscription(data);
+
+          expect(user.purchased.plan.planId).to.eql('basic_12mo');
+          expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(20);
+
+          data.sub.key = 'basic_3mo';
+          data.updatedFrom = { key: 'basic_12mo' };
+          await api.createSubscription(data);
+          expect(user.purchased.plan.consecutive.gemCapExtra).to.eql(20);
+        });
+
+        it('does not remove from plan.consecutive.trinkets from basic_6mo to basic_earned', async () => {
+          data.sub.key = 'basic_6mo';
+          expect(user.purchased.plan.planId).to.not.exist;
+
+          await api.createSubscription(data);
+
+          expect(user.purchased.plan.planId).to.eql('basic_6mo');
+          expect(user.purchased.plan.consecutive.trinkets).to.eql(2);
+
+          data.sub.key = 'basic_earned';
+          data.updatedFrom = { key: 'basic_6mo' };
+          await api.createSubscription(data);
+          expect(user.purchased.plan.planId).to.eql('basic_earned');
+          expect(user.purchased.plan.consecutive.trinkets).to.eql(2);
+        });
+
+        it('does not remove from plan.consecutive.trinkets from basic_12mo to basic_3mo', async () => {
+          expect(user.purchased.plan.planId).to.not.exist;
+
+          data.sub.key = 'basic_12mo';
+          await api.createSubscription(data);
+
+          expect(user.purchased.plan.planId).to.eql('basic_12mo');
+          expect(user.purchased.plan.consecutive.trinkets).to.eql(4);
+
+          data.sub.key = 'basic_3mo';
+          data.updatedFrom = { key: 'basic_12mo' };
+          await api.createSubscription(data);
+          expect(user.purchased.plan.consecutive.trinkets).to.eql(4);
+        });
+      });
     });
 
     context('Mystery Items', () => {
@@ -672,10 +1499,12 @@ describe('payments/index', () => {
     context('No Active Promotion', () => {
       beforeEach(() => {
         sinon.stub(worldState, 'getCurrentEvent').returns(null);
+        sinon.stub(worldState, 'getCurrentEventList').returns([]);
       });
 
       afterEach(() => {
         worldState.getCurrentEvent.restore();
+        worldState.getCurrentEventList.restore();
       });
 
       it('does not apply a discount', async () => {
@@ -692,14 +1521,14 @@ describe('payments/index', () => {
 
     context('Active Promotion', () => {
       beforeEach(() => {
-        sinon.stub(worldState, 'getCurrentEvent').returns({
+        sinon.stub(worldState, 'getCurrentEventList').returns([{
           ...common.content.events.fall2020,
           event: 'fall2020',
-        });
+        }]);
       });
 
       afterEach(() => {
-        worldState.getCurrentEvent.restore();
+        worldState.getCurrentEventList.restore();
       });
 
       it('applies a discount', async () => {

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

@@ -0,0 +1,40 @@
+import {
+  canBuySkuItem,
+} from '../../../../../website/server/libs/payments/skuItem';
+import { model as User } from '../../../../../website/server/models/user';
+
+describe('payments/skuItems', () => {
+  let user;
+  let clock;
+
+  beforeEach(() => {
+    user = new User();
+    clock = null;
+  });
+  afterEach(() => {
+    if (clock !== null) clock.restore();
+  });
+
+  describe('#canBuySkuItem', () => {
+    it('returns true for random sku', () => {
+      expect(canBuySkuItem('something', user)).to.be.true;
+    });
+
+    describe('#gryphatrice', () => {
+      const sku = 'Pet-Gryphatrice-Jubilant';
+      it('returns true during birthday week', () => {
+        clock = sinon.useFakeTimers(new Date('2023-01-31'));
+        expect(canBuySkuItem(sku, user)).to.be.true;
+      });
+      it('returns false outside of birthday week', () => {
+        clock = sinon.useFakeTimers(new Date('2023-01-20'));
+        expect(canBuySkuItem(sku, user)).to.be.false;
+      });
+      it('returns false if user already owns it', () => {
+        clock = sinon.useFakeTimers(new Date('2023-02-01'));
+        user.items.pets['Gryphatrice-Jubilant'] = 5;
+        expect(canBuySkuItem(sku, user)).to.be.false;
+      });
+    });
+  });
+});

test/api/unit/middlewares/cronMiddleware.js

@@ -242,7 +242,7 @@ describe('cron middleware', () => {
 
     sandbox.spy(cronLib, 'recoverCron');
 
-    sandbox.stub(User, 'update')
+    sandbox.stub(User, 'updateOne')
       .withArgs({
         _id: user._id,
         $or: [

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

@@ -1359,6 +1359,7 @@ describe('Group Model', () => {
     describe('#sendChat', () => {
       beforeEach(() => {
         sandbox.spy(User, 'update');
+        sandbox.spy(User, 'updateMany');
       });
 
       it('formats message', () => {
@@ -1413,8 +1414,8 @@ describe('Group Model', () => {
       it('updates users about new messages in party', () => {
         party.sendChat({ message: 'message' });
 
-        expect(User.update).to.be.calledOnce;
-        expect(User.update).to.be.calledWithMatch({
+        expect(User.updateMany).to.be.calledOnce;
+        expect(User.updateMany).to.be.calledWithMatch({
           'party._id': party._id,
           _id: { $ne: '' },
         });
@@ -1427,8 +1428,8 @@ describe('Group Model', () => {
 
         group.sendChat({ message: 'message' });
 
-        expect(User.update).to.be.calledOnce;
-        expect(User.update).to.be.calledWithMatch({
+        expect(User.updateMany).to.be.calledOnce;
+        expect(User.updateMany).to.be.calledWithMatch({
           guilds: group._id,
           _id: { $ne: '' },
         });
@@ -1437,8 +1438,8 @@ describe('Group Model', () => {
       it('does not send update to user that sent the message', () => {
         party.sendChat({ message: 'message', user: { _id: 'user-id', profile: { name: 'user' } } });
 
-        expect(User.update).to.be.calledOnce;
-        expect(User.update).to.be.calledWithMatch({
+        expect(User.updateMany).to.be.calledOnce;
+        expect(User.updateMany).to.be.calledWithMatch({
           'party._id': party._id,
           _id: { $ne: 'user-id' },
         });
@@ -1731,7 +1732,7 @@ describe('Group Model', () => {
         });
 
         it('updates participting members (not including user)', async () => {
-          sandbox.spy(User, 'update');
+          sandbox.spy(User, 'updateMany');
 
           await party.startQuest(nonParticipatingMember);
 
@@ -1739,7 +1740,7 @@ describe('Group Model', () => {
             questLeader._id, participatingMember._id, sleepingParticipatingMember._id,
           ];
 
-          expect(User.update).to.be.calledWith(
+          expect(User.updateMany).to.be.calledWith(
             { _id: { $in: members } },
             {
               $set: {
@@ -1752,11 +1753,11 @@ describe('Group Model', () => {
         });
 
         it('updates non-user quest leader and decrements quest scroll', async () => {
-          sandbox.spy(User, 'update');
+          sandbox.spy(User, 'updateOne');
 
           await party.startQuest(participatingMember);
 
-          expect(User.update).to.be.calledWith(
+          expect(User.updateOne).to.be.calledWith(
             { _id: questLeader._id },
             {
               $inc: {
@@ -1818,29 +1819,29 @@ describe('Group Model', () => {
         };
 
         it('doesn\'t retry successful operations', async () => {
-          sandbox.stub(User, 'update').returns(successfulMock);
+          sandbox.stub(User, 'updateOne').returns(successfulMock);
 
           await party.finishQuest(quest);
 
-          expect(User.update).to.be.calledThrice;
+          expect(User.updateOne).to.be.calledThrice;
         });
 
         it('stops retrying when a successful update has occurred', async () => {
-          const updateStub = sandbox.stub(User, 'update');
+          const updateStub = sandbox.stub(User, 'updateOne');
           updateStub.onCall(0).returns(failedMock);
           updateStub.returns(successfulMock);
 
           await party.finishQuest(quest);
 
-          expect(User.update.callCount).to.equal(4);
+          expect(User.updateOne.callCount).to.equal(4);
         });
 
         it('retries failed updates at most five times per user', async () => {
-          sandbox.stub(User, 'update').returns(failedMock);
+          sandbox.stub(User, 'updateOne').returns(failedMock);
 
           await expect(party.finishQuest(quest)).to.eventually.be.rejected;
 
-          expect(User.update.callCount).to.eql(15); // for 3 users
+          expect(User.updateOne.callCount).to.eql(15); // for 3 users
         });
       });
 
@@ -2087,17 +2088,17 @@ describe('Group Model', () => {
 
       context('Party quests', () => {
         it('updates participating members with rewards', async () => {
-          sandbox.spy(User, 'update');
+          sandbox.spy(User, 'updateOne');
           await party.finishQuest(quest);
 
-          expect(User.update).to.be.calledThrice;
-          expect(User.update).to.be.calledWithMatch({
+          expect(User.updateOne).to.be.calledThrice;
+          expect(User.updateOne).to.be.calledWithMatch({
             _id: questLeader._id,
           });
-          expect(User.update).to.be.calledWithMatch({
+          expect(User.updateOne).to.be.calledWithMatch({
             _id: participatingMember._id,
           });
-          expect(User.update).to.be.calledWithMatch({
+          expect(User.updateOne).to.be.calledWithMatch({
             _id: sleepingParticipatingMember._id,
           });
         });
@@ -2172,11 +2173,11 @@ describe('Group Model', () => {
         });
 
         it('updates all users with rewards', async () => {
-          sandbox.spy(User, 'update');
+          sandbox.spy(User, 'updateMany');
           await party.finishQuest(tavernQuest);
 
-          expect(User.update).to.be.calledOnce;
-          expect(User.update).to.be.calledWithMatch({});
+          expect(User.updateMany).to.be.calledOnce;
+          expect(User.updateMany).to.be.calledWithMatch({});
         });
 
         it('sets quest completed to the world quest key', async () => {

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

@@ -1,12 +1,10 @@
-import { each, find, findIndex } from 'lodash';
-import { model as Challenge } from '../../../../website/server/models/challenge';
+import { each, findIndex } from 'lodash';
 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';
 
 describe('Group Task Methods', () => {
-  let guild; let leader; let challenge; let
-    task;
+  let guild; let leader; let task;
   const tasksToTest = {
     habit: {
       text: 'test habit',
@@ -31,10 +29,6 @@ describe('Group Task Methods', () => {
     },
   };
 
-  function findLinkedTask (updatedLeadersTask) {
-    return updatedLeadersTask.group.taskId === task._id;
-  }
-
   beforeEach(async () => {
     guild = new Group({
       name: 'test party',
@@ -47,19 +41,9 @@ describe('Group Task Methods', () => {
 
     guild.leader = leader._id;
 
-    challenge = new Challenge({
-      name: 'Test Challenge',
-      shortName: 'Test',
-      leader: leader._id,
-      group: guild._id,
-    });
-
-    leader.challenges = [challenge._id];
-
     await Promise.all([
       guild.save(),
       leader.save(),
-      challenge.save(),
     ]);
   });
 
@@ -78,7 +62,15 @@ describe('Group Task Methods', () => {
       });
 
       it('syncs an assigned task to a user', async () => {
-        await guild.syncTask(task, leader);
+        await guild.syncTask(task, [leader], leader);
+
+        const updatedTask = await Tasks.Task.findOne({ _id: task._id });
+        expect(updatedTask.group.assignedUsers).to.contain(leader._id);
+        expect(updatedTask.group.assignedUsersDetail[leader._id]).to.exist;
+      });
+
+      it('creates tags for a user when task is synced', async () => {
+        await guild.syncTask(task, [leader], leader);
 
         const updatedLeader = await User.findOne({ _id: leader._id });
         const tagIndex = findIndex(updatedLeader.tags, { id: guild._id });
@@ -88,197 +80,6 @@ describe('Group Task Methods', () => {
         expect(newTag.name).to.equal(guild.name);
         expect(newTag.group).to.equal(guild._id);
       });
-
-      it('create tags for a user when task is synced', async () => {
-        await guild.syncTask(task, leader);
-
-        const updatedLeader = await User.findOne({ _id: leader._id });
-        const updatedLeadersTasks = await Tasks.Task.find({ _id: { $in: updatedLeader.tasksOrder[`${taskType}s`] } });
-        const syncedTask = find(updatedLeadersTasks, findLinkedTask);
-
-        expect(task.group.assignedUsers).to.contain(leader._id);
-        expect(syncedTask).to.exist;
-      });
-
-      it('syncs updated info for assigned task to a user', async () => {
-        await guild.syncTask(task, leader);
-        const updatedTaskName = 'Update Task name';
-        task.text = updatedTaskName;
-        await guild.syncTask(task, leader);
-
-        const updatedLeader = await User.findOne({ _id: leader._id });
-        const updatedLeadersTasks = await Tasks.Task.find({ _id: { $in: updatedLeader.tasksOrder[`${taskType}s`] } });
-        const syncedTask = find(updatedLeadersTasks, findLinkedTask);
-
-        expect(task.group.assignedUsers).to.contain(leader._id);
-        expect(syncedTask).to.exist;
-        expect(syncedTask.text).to.equal(task.text);
-      });
-
-      it('syncs checklist items to an assigned user', async () => {
-        await guild.syncTask(task, leader);
-
-        const updatedLeader = await User.findOne({ _id: leader._id });
-        const updatedLeadersTasks = await Tasks.Task.find({ _id: { $in: updatedLeader.tasksOrder[`${taskType}s`] } });
-        const syncedTask = find(updatedLeadersTasks, findLinkedTask);
-
-        if (task.type !== 'daily' && task.type !== 'todo') return;
-
-        expect(syncedTask.checklist.length).to.equal(task.checklist.length);
-        expect(syncedTask.checklist[0].text).to.equal(task.checklist[0].text);
-      });
-
-      describe('syncs updated info', async () => {
-        let newMember;
-
-        beforeEach(async () => {
-          newMember = new User({
-            guilds: [guild._id],
-          });
-          await newMember.save();
-
-          await guild.syncTask(task, leader);
-          await guild.syncTask(task, newMember);
-        });
-
-        it('syncs updated info for assigned task to all users', async () => {
-          const updatedTaskName = 'Update Task name';
-          task.text = updatedTaskName;
-          task.group.approval.required = true;
-
-          await guild.updateTask(task);
-
-          const updatedLeader = await User.findOne({ _id: leader._id });
-          const updatedLeadersTasks = await Tasks.Task.find({ _id: { $in: updatedLeader.tasksOrder[`${taskType}s`] } });
-          const syncedTask = find(updatedLeadersTasks, findLinkedTask);
-
-          const updatedMember = await User.findOne({ _id: newMember._id });
-          const updatedMemberTasks = await Tasks.Task.find({ _id: { $in: updatedMember.tasksOrder[`${taskType}s`] } });
-          const syncedMemberTask = find(updatedMemberTasks, findLinkedTask);
-
-          expect(task.group.assignedUsers).to.contain(leader._id);
-          expect(syncedTask).to.exist;
-          expect(syncedTask.text).to.equal(task.text);
-          expect(syncedTask.group.approval.required).to.equal(true);
-
-          expect(task.group.assignedUsers).to.contain(newMember._id);
-          expect(syncedMemberTask).to.exist;
-          expect(syncedMemberTask.text).to.equal(task.text);
-          expect(syncedMemberTask.group.approval.required).to.equal(true);
-        });
-
-        it('syncs a new checklist item to all assigned users', async () => {
-          if (task.type !== 'daily' && task.type !== 'todo') return;
-
-          const newCheckListItem = {
-            text: 'Checklist Item 1',
-            completed: false,
-          };
-
-          task.checklist.push(newCheckListItem);
-
-          await guild.updateTask(task, { newCheckListItem });
-
-          const updatedLeader = await User.findOne({ _id: leader._id });
-          const updatedLeadersTasks = await Tasks.Task.find({ _id: { $in: updatedLeader.tasksOrder[`${taskType}s`] } });
-          const syncedTask = find(updatedLeadersTasks, findLinkedTask);
-
-          const updatedMember = await User.findOne({ _id: newMember._id });
-          const updatedMemberTasks = await Tasks.Task.find({ _id: { $in: updatedMember.tasksOrder[`${taskType}s`] } });
-          const syncedMemberTask = find(updatedMemberTasks, findLinkedTask);
-
-          expect(syncedTask.checklist.length).to.equal(task.checklist.length);
-          expect(syncedTask.checklist[1].text).to.equal(task.checklist[1].text);
-          expect(syncedMemberTask.checklist.length).to.equal(task.checklist.length);
-          expect(syncedMemberTask.checklist[1].text).to.equal(task.checklist[1].text);
-        });
-
-        it('syncs updated info for checklist in assigned task to all users when flag is passed', async () => {
-          if (task.type !== 'daily' && task.type !== 'todo') return;
-
-          const updateCheckListText = 'Updated checklist item';
-          if (task.checklist) {
-            task.checklist[0].text = updateCheckListText;
-          }
-
-          await guild.updateTask(task, { updateCheckListItems: [task.checklist[0]] });
-
-          const updatedLeader = await User.findOne({ _id: leader._id });
-          const updatedLeadersTasks = await Tasks.Task.find({ _id: { $in: updatedLeader.tasksOrder[`${taskType}s`] } });
-          const syncedTask = find(updatedLeadersTasks, findLinkedTask);
-
-          const updatedMember = await User.findOne({ _id: newMember._id });
-          const updatedMemberTasks = await Tasks.Task.find({ _id: { $in: updatedMember.tasksOrder[`${taskType}s`] } });
-          const syncedMemberTask = find(updatedMemberTasks, findLinkedTask);
-
-          expect(syncedTask.checklist.length).to.equal(task.checklist.length);
-          expect(syncedTask.checklist[0].text).to.equal(updateCheckListText);
-          expect(syncedMemberTask.checklist.length).to.equal(task.checklist.length);
-          expect(syncedMemberTask.checklist[0].text).to.equal(updateCheckListText);
-        });
-
-        it('removes a checklist item in assigned task to all users when flag is passed with checklist id', async () => {
-          if (task.type !== 'daily' && task.type !== 'todo') return;
-
-          await guild.updateTask(task, { removedCheckListItemId: task.checklist[0].id });
-
-          const updatedLeader = await User.findOne({ _id: leader._id });
-          const updatedLeadersTasks = await Tasks.Task.find({ _id: { $in: updatedLeader.tasksOrder[`${taskType}s`] } });
-          const syncedTask = find(updatedLeadersTasks, findLinkedTask);
-
-          const updatedMember = await User.findOne({ _id: newMember._id });
-          const updatedMemberTasks = await Tasks.Task.find({ _id: { $in: updatedMember.tasksOrder[`${taskType}s`] } });
-          const syncedMemberTask = find(updatedMemberTasks, findLinkedTask);
-
-          expect(syncedTask.checklist.length).to.equal(0);
-          expect(syncedMemberTask.checklist.length).to.equal(0);
-        });
-      });
-
-      it('removes assigned tasks when master task is deleted', async () => {
-        await guild.syncTask(task, leader);
-        await guild.removeTask(task);
-
-        const updatedLeader = await User.findOne({ _id: leader._id });
-        const updatedLeadersTasks = await Tasks.Task.find({ userId: leader._id, type: taskType });
-        const syncedTask = find(updatedLeadersTasks, findLinkedTask);
-
-        expect(updatedLeader.tasksOrder[`${taskType}s`]).to.not.include(task._id);
-        expect(syncedTask).to.not.exist;
-      });
-
-      it('unlinks and deletes group tasks for a user when remove-all is specified', async () => {
-        await guild.syncTask(task, leader);
-        await guild.unlinkTask(task, leader, 'remove-all');
-
-        const updatedLeader = await User.findOne({ _id: leader._id });
-        const updatedLeadersTasks = await Tasks.Task.find({ _id: { $in: updatedLeader.tasksOrder[`${taskType}s`] } });
-        const syncedTask = find(updatedLeadersTasks, findLinkedTask);
-
-        expect(task.group.assignedUsers).to.not.contain(leader._id);
-        expect(syncedTask).to.not.exist;
-      });
-
-      it('unlinks and keeps group tasks for a user when keep-all is specified', async () => {
-        await guild.syncTask(task, leader);
-
-        let updatedLeader = await User.findOne({ _id: leader._id });
-        let updatedLeadersTasks = await Tasks.Task.find({ _id: { $in: updatedLeader.tasksOrder[`${taskType}s`] } });
-        const syncedTask = find(updatedLeadersTasks, findLinkedTask);
-
-        await guild.unlinkTask(task, leader, 'keep-all');
-
-        updatedLeader = await User.findOne({ _id: leader._id });
-        updatedLeadersTasks = await Tasks.Task.find({ _id: { $in: updatedLeader.tasksOrder[`${taskType}s`] } });
-        const updatedSyncedTask = find(
-          updatedLeadersTasks,
-          updatedLeadersTask => updatedLeadersTask._id === syncedTask._id,
-        );
-
-        expect(task.group.assignedUsers).to.not.contain(leader._id);
-        expect(updatedSyncedTask).to.exist;
-        expect(updatedSyncedTask.group._id).to.be.undefined;
-      });
     });
   });
 });

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

@@ -246,13 +246,23 @@ describe('Task Model', () => {
         expect(foundTasks[0].text).to.eql(taskWithAlias.text);
       });
 
-      it('scopes alias lookup to user', async () => {
+      it('scopes alias lookup to user when querying aliases only', async () => {
         await Tasks.Task.findMultipleByIdOrAlias([taskWithAlias.alias], user._id);
 
+        expect(Tasks.Task.find).to.be.calledOnce;
+        expect(Tasks.Task.find).to.be.calledWithMatch({
+          alias: { $in: [taskWithAlias.alias] },
+          userId: user._id,
+        });
+      });
+
+      it('scopes alias lookup to user when querying aliases and IDs', async () => {
+        await Tasks.Task.findMultipleByIdOrAlias([taskWithAlias.alias, secondTask._id], user._id);
+
         expect(Tasks.Task.find).to.be.calledOnce;
         expect(Tasks.Task.find).to.be.calledWithMatch({
           $or: [
-            { _id: { $in: [] } },
+            { _id: { $in: [secondTask._id] } },
             { alias: { $in: [taskWithAlias.alias] } },
           ],
           userId: user._id,
@@ -270,10 +280,7 @@ describe('Task Model', () => {
 
         expect(Tasks.Task.find).to.be.calledOnce;
         expect(Tasks.Task.find).to.be.calledWithMatch({
-          $or: [
-            { _id: { $in: [] } },
-            { alias: { $in: [taskWithAlias.alias] } },
-          ],
+          alias: { $in: [taskWithAlias.alias] },
           userId: user._id,
           foo: 'bar',
         });

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

@@ -16,60 +16,7 @@ describe('GET /challenges/:challengeId', () => {
     });
   });
 
-  context('public guild', () => {
-    let groupLeader;
-    let group;
-    let challenge;
-    let user;
-
-    beforeEach(async () => {
-      user = await generateUser();
-
-      const populatedGroup = await createAndPopulateGroup({
-        groupDetails: { type: 'guild', privacy: 'public' },
-      });
-
-      groupLeader = populatedGroup.groupLeader;
-      group = populatedGroup.group;
-
-      challenge = await generateChallenge(groupLeader, group);
-      await groupLeader.post(`/challenges/${challenge._id}/join`);
-    });
-
-    it('should return challenge data', async () => {
-      await challenge.sync();
-      const chal = await user.get(`/challenges/${challenge._id}`);
-      expect(chal.memberCount).to.equal(challenge.memberCount);
-      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 },
-        auth: {
-          local: {
-            username: groupLeader.auth.local.username,
-          },
-        },
-        flags: {
-          verifiedUsername: true,
-        },
-      });
-      expect(chal.group).to.eql({
-        _id: group._id,
-        categories: [],
-        id: group.id,
-        name: group.name,
-        summary: group.name,
-        type: group.type,
-        privacy: group.privacy,
-        leader: groupLeader.id,
-      });
-    });
-  });
-
-  context('private guild', () => {
+  context('Group Plan', () => {
     let groupLeader;
     let challengeLeader;
     let group;
@@ -84,14 +31,14 @@ describe('GET /challenges/:challengeId', () => {
       const populatedGroup = await createAndPopulateGroup({
         groupDetails: { type: 'guild', privacy: 'private' },
         members: 2,
+        upgradeToGroupPlan: true,
       });
 
       groupLeader = populatedGroup.groupLeader;
       group = populatedGroup.group;
       members = populatedGroup.members;
 
-      challengeLeader = members[0]; // eslint-disable-line prefer-destructuring
-      otherMember = members[1]; // eslint-disable-line prefer-destructuring
+      [challengeLeader, otherMember] = members;
 
       challenge = await generateChallenge(challengeLeader, group);
     });

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

@@ -71,42 +71,18 @@ describe('GET /challenges/:challengeId/members', () => {
     });
   });
 
-  it('works with challenges belonging to public guild', async () => {
-    const leader = await generateUser({ balance: 4 });
-    const group = await generateGroup(leader, { type: 'guild', privacy: 'public', name: generateUUID() });
-    const challenge = await generateChallenge(leader, group);
-    await leader.post(`/challenges/${challenge._id}/join`);
-    const res = await user.get(`/challenges/${challenge._id}/members`);
-    expect(res[0]).to.eql({
-      _id: leader._id,
-      id: leader._id,
-      profile: { name: leader.profile.name },
-      auth: {
-        local: {
-          username: leader.auth.local.username,
-        },
-      },
-      flags: {
-        verifiedUsername: true,
-      },
-    });
-    expect(res[0]).to.have.all.keys(['_id', 'auth', 'flags', 'id', 'profile']);
-    expect(res[0].profile).to.have.all.keys(['name']);
-  });
-
   it('populates only some fields', async () => {
-    const anotherUser = await generateUser({ balance: 3 });
-    const group = await generateGroup(anotherUser, { type: 'guild', privacy: 'public', name: generateUUID() });
-    const challenge = await generateChallenge(anotherUser, group);
-    await anotherUser.post(`/challenges/${challenge._id}/join`);
+    const group = await generateGroup(user, { type: 'party', privacy: 'private', name: generateUUID() });
+    const challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
     const res = await user.get(`/challenges/${challenge._id}/members`);
     expect(res[0]).to.eql({
-      _id: anotherUser._id,
-      id: anotherUser._id,
-      profile: { name: anotherUser.profile.name },
+      _id: user._id,
+      id: user._id,
+      profile: { name: user.profile.name },
       auth: {
         local: {
-          username: anotherUser.auth.local.username,
+          username: user.auth.local.username,
         },
       },
       flags: {

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

@@ -72,20 +72,6 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
     });
   });
 
-  it('works with challenges belonging to a public guild', async () => {
-    const groupLeader = await generateUser({ balance: 4 });
-    const group = await generateGroup(groupLeader, { type: 'guild', privacy: 'public', name: generateUUID() });
-    const challenge = await generateChallenge(groupLeader, group);
-    await groupLeader.post(`/challenges/${challenge._id}/join`);
-    const taskText = 'Test Text';
-    await groupLeader.post(`/tasks/challenge/${challenge._id}`, [{ type: 'habit', text: taskText }]);
-
-    const memberProgress = await user.get(`/challenges/${challenge._id}/members/${groupLeader._id}`);
-    expect(memberProgress).to.have.all.keys(['_id', 'auth', 'flags', 'id', 'profile', 'tasks']);
-    expect(memberProgress.profile).to.have.all.keys(['name']);
-    expect(memberProgress.tasks.length).to.equal(1);
-  });
-
   it('returns the member tasks for the challenges', async () => {
     const group = await generateGroup(user, { type: 'party', name: generateUUID() });
     const challenge = await generateChallenge(user, group);

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

@@ -7,117 +7,7 @@ import {
 import { TAVERN_ID } from '../../../../../website/common/script/constants';
 
 describe('GET challenges/groups/:groupId', () => {
-  context('Public Guild', () => {
-    let publicGuild; let user; let nonMember; let challenge; let
-      challenge2;
-
-    before(async () => {
-      const { group, groupLeader } = await createAndPopulateGroup({
-        groupDetails: {
-          name: 'TestGuild',
-          type: 'guild',
-          privacy: 'public',
-        },
-      });
-
-      publicGuild = group;
-      user = groupLeader;
-
-      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 () => {
-      const challenges = await nonMember.get(`/challenges/groups/${publicGuild._id}`);
-
-      const foundChallenge1 = _.find(challenges, { _id: challenge._id });
-      expect(foundChallenge1).to.exist;
-      expect(foundChallenge1.leader).to.eql({
-        _id: publicGuild.leader._id,
-        id: publicGuild.leader._id,
-        profile: { name: user.profile.name },
-        auth: {
-          local: {
-            username: user.auth.local.username,
-          },
-        },
-        flags: {
-          verifiedUsername: true,
-        },
-      });
-      const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
-      expect(foundChallenge2).to.exist;
-      expect(foundChallenge2.leader).to.eql({
-        _id: publicGuild.leader._id,
-        id: publicGuild.leader._id,
-        profile: { name: user.profile.name },
-        auth: {
-          local: {
-            username: user.auth.local.username,
-          },
-        },
-        flags: {
-          verifiedUsername: true,
-        },
-      });
-    });
-
-    it('should return group challenges for member with populated leader', async () => {
-      const challenges = await user.get(`/challenges/groups/${publicGuild._id}`);
-
-      const foundChallenge1 = _.find(challenges, { _id: challenge._id });
-      expect(foundChallenge1).to.exist;
-      expect(foundChallenge1.leader).to.eql({
-        _id: publicGuild.leader._id,
-        id: publicGuild.leader._id,
-        profile: { name: user.profile.name },
-        auth: {
-          local: {
-            username: user.auth.local.username,
-          },
-        },
-        flags: {
-          verifiedUsername: true,
-        },
-      });
-      const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
-      expect(foundChallenge2).to.exist;
-      expect(foundChallenge2.leader).to.eql({
-        _id: publicGuild.leader._id,
-        id: publicGuild.leader._id,
-        profile: { name: user.profile.name },
-        auth: {
-          local: {
-            username: user.auth.local.username,
-          },
-        },
-        flags: {
-          verifiedUsername: true,
-        },
-      });
-    });
-
-    it('should return newest challenges first', async () => {
-      let challenges = await user.get(`/challenges/groups/${publicGuild._id}`);
-
-      let foundChallengeIndex = _.findIndex(challenges, { _id: challenge2._id });
-      expect(foundChallengeIndex).to.eql(0);
-
-      const newChallenge = await generateChallenge(user, publicGuild);
-      await user.post(`/challenges/${newChallenge._id}/join`);
-
-      challenges = await user.get(`/challenges/groups/${publicGuild._id}`);
-
-      foundChallengeIndex = _.findIndex(challenges, { _id: newChallenge._id });
-      expect(foundChallengeIndex).to.eql(0);
-    });
-  });
-
-  context('Private Guild', () => {
+  context('Group Plan', () => {
     let privateGuild; let user; let nonMember; let challenge; let
       challenge2;
 
@@ -128,6 +18,7 @@ describe('GET challenges/groups/:groupId', () => {
           type: 'guild',
           privacy: 'private',
         },
+        upgradeToGroupPlan: true,
       });
 
       privateGuild = group;
@@ -186,68 +77,6 @@ describe('GET challenges/groups/:groupId', () => {
     });
   });
 
-  context('official challenge is present', () => {
-    let publicGuild; let user; let officialChallenge; let unofficialChallenges;
-
-    before(async () => {
-      const { group, groupLeader } = await createAndPopulateGroup({
-        groupDetails: {
-          name: 'TestGuild',
-          type: 'guild',
-          privacy: 'public',
-        },
-      });
-
-      user = groupLeader;
-      publicGuild = group;
-
-      await user.update({
-        'permissions.challengeAdmin': true,
-      });
-
-      officialChallenge = await generateChallenge(user, group, {
-        categories: [{
-          name: 'habitica_official',
-          slug: 'habitica_official',
-        }],
-      });
-      await user.post(`/challenges/${officialChallenge._id}/join`);
-
-      // We add 10 extra challenges to test whether the official challenge
-      // (the oldest) makes it to the front page.
-      unofficialChallenges = [];
-      for (let i = 0; i < 10; i += 1) {
-        const challenge = await generateChallenge(user, group); // eslint-disable-line
-        await user.post(`/challenges/${challenge._id}/join`); // eslint-disable-line
-        unofficialChallenges.push(challenge);
-      }
-    });
-
-    it('should return official challenges first', async () => {
-      const challenges = await user.get(`/challenges/groups/${publicGuild._id}`);
-
-      const foundChallengeIndex = _.findIndex(challenges, { _id: officialChallenge._id });
-      expect(foundChallengeIndex).to.eql(0);
-    });
-
-    it('should return newest challenges first, after official ones', async () => {
-      let challenges = await user.get(`/challenges/groups/${publicGuild._id}`);
-
-      unofficialChallenges.forEach((chal, index) => {
-        const foundChallengeIndex = _.findIndex(challenges, { _id: chal._id });
-        expect(foundChallengeIndex).to.eql(10 - index);
-      });
-
-      const newChallenge = await generateChallenge(user, publicGuild);
-      await user.post(`/challenges/${newChallenge._id}/join`);
-
-      challenges = await user.get(`/challenges/groups/${publicGuild._id}`);
-
-      const foundChallengeIndex = _.findIndex(challenges, { _id: newChallenge._id });
-      expect(foundChallengeIndex).to.eql(1);
-    });
-  });
-
   context('Party', () => {
     let party; let user; let nonMember; let challenge; let
       challenge2;
@@ -401,7 +230,7 @@ describe('GET challenges/groups/:groupId', () => {
       });
     });
 
-    it('should return tavern challenges using ID "habitrpg', async () => {
+    it('should return tavern challenges using ID "habitrpg"', async () => {
       const challenges = await user.get('/challenges/groups/habitrpg');
 
       const foundChallenge1 = _.find(challenges, { _id: challenge._id });
@@ -435,5 +264,58 @@ describe('GET challenges/groups/:groupId', () => {
         },
       });
     });
+
+    context('official challenge is present', () => {
+      let officialChallenge; let unofficialChallenges;
+
+      before(async () => {
+        await user.update({
+          'permissions.challengeAdmin': true,
+          balance: 3,
+        });
+
+        officialChallenge = await generateChallenge(user, tavern, {
+          categories: [{
+            name: 'habitica_official',
+            slug: 'habitica_official',
+          }],
+          prize: 1,
+        });
+        await user.post(`/challenges/${officialChallenge._id}/join`);
+
+        // We add 10 extra challenges to test whether the official challenge
+        // (the oldest) makes it to the front page.
+        unofficialChallenges = [];
+        for (let i = 0; i < 10; i += 1) {
+          const challenge = await generateChallenge(user, tavern, { prize: 1 }); // eslint-disable-line
+          await user.post(`/challenges/${challenge._id}/join`); // eslint-disable-line
+          unofficialChallenges.push(challenge);
+        }
+      });
+
+      it('should return official challenges first', async () => {
+        const challenges = await user.get('/challenges/groups/habitrpg');
+
+        const foundChallengeIndex = _.findIndex(challenges, { _id: officialChallenge._id });
+        expect(foundChallengeIndex).to.eql(0);
+      });
+
+      it('should return newest challenges first, after official ones', async () => {
+        let challenges = await user.get('/challenges/groups/habitrpg');
+
+        unofficialChallenges.forEach((chal, index) => {
+          const foundChallengeIndex = _.findIndex(challenges, { _id: chal._id });
+          expect(foundChallengeIndex).to.eql(10 - index);
+        });
+
+        const newChallenge = await generateChallenge(user, tavern, { prize: 1 });
+        await user.post(`/challenges/${newChallenge._id}/join`);
+
+        challenges = await user.get('/challenges/groups/habitrpg');
+
+        const foundChallengeIndex = _.findIndex(challenges, { _id: newChallenge._id });
+        expect(foundChallengeIndex).to.eql(1);
+      });
+    });
   });
 });

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

@@ -2,39 +2,44 @@ import {
   generateUser,
   generateChallenge,
   createAndPopulateGroup,
+  resetHabiticaDB,
 } from '../../../../helpers/api-integration/v3';
+import { TAVERN_ID } from '../../../../../website/common/script/constants';
 
 describe('GET challenges/user', () => {
   context('no official challenges', () => {
-    let user; let member; let nonMember; let challenge; let challenge2;
-    let publicGuild; let userData; let groupData;
+    let user; let member; let nonMember; let challenge; let challenge2; let publicChallenge;
+    let groupPlan; let userData; let groupData; let tavern; let tavernData;
 
     before(async () => {
+      await resetHabiticaDB();
+
       const { group, groupLeader, members } = await createAndPopulateGroup({
         groupDetails: {
           name: 'TestGuild',
           type: 'guild',
-          privacy: 'public',
+          privacy: 'private',
         },
         members: 1,
+        upgradeToGroupPlan: true,
       });
 
-      publicGuild = group;
+      groupPlan = group;
       groupData = {
-        _id: publicGuild._id,
+        _id: groupPlan._id,
         categories: [],
-        id: publicGuild._id,
-        type: publicGuild.type,
-        privacy: publicGuild.privacy,
-        name: publicGuild.name,
-        summary: publicGuild.name,
-        leader: publicGuild.leader._id,
+        id: groupPlan._id,
+        type: groupPlan.type,
+        privacy: groupPlan.privacy,
+        name: groupPlan.name,
+        summary: groupPlan.name,
+        leader: groupPlan.leader._id,
       };
 
       user = groupLeader;
       userData = {
-        _id: publicGuild.leader._id,
-        id: publicGuild.leader._id,
+        _id: groupPlan.leader._id,
+        id: groupPlan.leader._id,
         profile: { name: user.profile.name },
         auth: {
           local: {
@@ -46,17 +51,31 @@ describe('GET challenges/user', () => {
         },
       };
 
+      tavern = await user.get(`/groups/${TAVERN_ID}`);
+      tavernData = {
+        _id: TAVERN_ID,
+        categories: [],
+        id: TAVERN_ID,
+        type: tavern.type,
+        privacy: tavern.privacy,
+        name: tavern.name,
+        summary: tavern.name,
+        leader: tavern.leader._id,
+      };
+
       member = members[0]; // eslint-disable-line prefer-destructuring
       nonMember = await generateUser();
 
       challenge = await generateChallenge(user, group);
       challenge2 = await generateChallenge(user, group);
+      await user.update({ balance: 0.25 });
+      publicChallenge = await generateChallenge(user, tavern, { prize: 1 });
 
-      await nonMember.post(`/challenges/${challenge._id}/join`);
+      await member.post(`/challenges/${challenge._id}/join`);
     });
     context('all challenges', () => {
       it('should return challenges user has joined', async () => {
-        const challenges = await nonMember.get('/challenges/user?page=0');
+        const challenges = await member.get('/challenges/user?page=0');
 
         const foundChallenge = _.find(challenges, { _id: challenge._id });
         expect(foundChallenge).to.exist;
@@ -64,11 +83,13 @@ describe('GET challenges/user', () => {
         expect(foundChallenge.group).to.eql(groupData);
       });
 
-      it('should not return challenges a non-member has not joined', async () => {
+      it('should return public challenges', async () => {
         const challenges = await nonMember.get('/challenges/user?page=0');
 
-        const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
-        expect(foundChallenge2).to.not.exist;
+        const foundPublicChallenge = _.find(challenges, { _id: publicChallenge._id });
+        expect(foundPublicChallenge).to.exist;
+        expect(foundPublicChallenge.leader).to.eql(userData);
+        expect(foundPublicChallenge.group).to.eql(tavernData);
       });
 
       it('should return challenges user has created', async () => {
@@ -100,10 +121,10 @@ describe('GET challenges/user', () => {
       it('should return newest challenges first', async () => {
         let challenges = await user.get('/challenges/user?page=0');
 
-        let foundChallengeIndex = _.findIndex(challenges, { _id: challenge2._id });
+        let foundChallengeIndex = _.findIndex(challenges, { _id: publicChallenge._id });
         expect(foundChallengeIndex).to.eql(0);
 
-        const newChallenge = await generateChallenge(user, publicGuild);
+        const newChallenge = await generateChallenge(user, groupPlan);
         await user.post(`/challenges/${newChallenge._id}/join`);
 
         challenges = await user.get('/challenges/user?page=0');
@@ -113,52 +134,23 @@ describe('GET challenges/user', () => {
       });
 
       it('should not return challenges user doesn\'t have access to', async () => {
-        const { group, groupLeader } = await createAndPopulateGroup({
-          groupDetails: {
-            name: 'TestPrivateGuild',
-            summary: 'summary for TestPrivateGuild',
-            type: 'guild',
-            privacy: 'private',
-          },
-        });
-
-        const privateChallenge = await generateChallenge(groupLeader, group);
-        await groupLeader.post(`/challenges/${privateChallenge._id}/join`);
-
         const challenges = await nonMember.get('/challenges/user?page=0');
 
-        const foundChallenge = _.find(challenges, { _id: privateChallenge._id });
+        const foundChallenge = _.find(challenges, { _id: challenge._id });
         expect(foundChallenge).to.not.exist;
       });
 
       it('should not return challenges user doesn\'t have access to, even with query parameters', async () => {
-        const { group, groupLeader } = await createAndPopulateGroup({
-          groupDetails: {
-            name: 'TestPrivateGuild',
-            summary: 'summary for TestPrivateGuild',
-            type: 'guild',
-            privacy: 'private',
-          },
-        });
-
-        const privateChallenge = await generateChallenge(groupLeader, group, {
-          categories: [{
-            name: 'academics',
-            slug: 'academics',
-          }],
-        });
-        await groupLeader.post(`/challenges/${privateChallenge._id}/join`);
-
         const challenges = await nonMember.get('/challenges/user?page=0&categories=academics&owned=not_owned');
 
-        const foundChallenge = _.find(challenges, { _id: privateChallenge._id });
+        const foundChallenge = _.find(challenges, { _id: challenge._id });
         expect(foundChallenge).to.not.exist;
       });
     });
 
     context('my challenges', () => {
       it('should return challenges user has joined', async () => {
-        const challenges = await nonMember.get(`/challenges/user?page=0&member=${true}`);
+        const challenges = await member.get(`/challenges/user?page=0&member=${true}`);
 
         const foundChallenge = _.find(challenges, { _id: challenge._id });
         expect(foundChallenge).to.exist;
@@ -177,6 +169,10 @@ describe('GET challenges/user', () => {
         expect(foundChallenge2).to.exist;
         expect(foundChallenge2.leader).to.eql(userData);
         expect(foundChallenge2.group).to.eql(groupData);
+        const foundPublicChallenge = _.find(challenges, { _id: publicChallenge._id });
+        expect(foundPublicChallenge).to.exist;
+        expect(foundPublicChallenge.leader).to.eql(userData);
+        expect(foundPublicChallenge.group).to.eql(tavernData);
       });
 
       it('should return challenges user has created if filter by owned', async () => {
@@ -190,6 +186,10 @@ describe('GET challenges/user', () => {
         expect(foundChallenge2).to.exist;
         expect(foundChallenge2.leader).to.eql(userData);
         expect(foundChallenge2.group).to.eql(groupData);
+        const foundPublicChallenge = _.find(challenges, { _id: publicChallenge._id });
+        expect(foundPublicChallenge).to.exist;
+        expect(foundPublicChallenge.leader).to.eql(userData);
+        expect(foundPublicChallenge.group).to.eql(tavernData);
       });
 
       it('should not return challenges user has created if filter by not owned', async () => {
@@ -199,36 +199,40 @@ describe('GET challenges/user', () => {
         expect(foundChallenge1).to.not.exist;
         const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
         expect(foundChallenge2).to.not.exist;
+        const foundPublicChallenge = _.find(challenges, { _id: publicChallenge._id });
+        expect(foundPublicChallenge).to.not.exist;
       });
 
       it('should not return challenges in user groups', async () => {
         const challenges = await member.get(`/challenges/user?page=0&member=${true}`);
 
-        const foundChallenge1 = _.find(challenges, { _id: challenge._id });
-        expect(foundChallenge1).to.not.exist;
-
         const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
         expect(foundChallenge2).to.not.exist;
       });
+
+      it('should not return public challenges', async () => {
+        const challenges = await member.get(`/challenges/user?page=0&member=${true}`);
+
+        const foundPublicChallenge = _.find(challenges, { _id: publicChallenge._id });
+        expect(foundPublicChallenge).to.not.exist;
+      });
     });
   });
 
   context('official challenge is present', () => {
     let user; let officialChallenge; let unofficialChallenges; let
-      publicGuild;
+      group;
 
     before(async () => {
-      const { group, groupLeader } = await createAndPopulateGroup({
+      ({ group, groupLeader: user } = await createAndPopulateGroup({
         groupDetails: {
           name: 'TestGuild',
           summary: 'summary for TestGuild',
           type: 'guild',
-          privacy: 'public',
+          privacy: 'private',
         },
-      });
-
-      user = groupLeader;
-      publicGuild = group;
+        upgradeToGroupPlan: true,
+      }));
 
       await user.update({
         'permissions.challengeAdmin': true,
@@ -271,7 +275,7 @@ describe('GET challenges/user', () => {
         }
       });
 
-      const newChallenge = await generateChallenge(user, publicGuild);
+      const newChallenge = await generateChallenge(user, group);
       await user.post(`/challenges/${newChallenge._id}/join`);
 
       challenges = await user.get('/challenges/user?page=0');
@@ -294,9 +298,10 @@ describe('GET challenges/user', () => {
         groupDetails: {
           name: 'TestGuild',
           type: 'guild',
-          privacy: 'public',
+          privacy: 'private',
         },
         members: 1,
+        upgradeToGroupPlan: true,
       });
 
       user = groupLeader;

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

@@ -0,0 +1,62 @@
+import { v4 as generateUUID } from 'uuid';
+import {
+  generateChallenge,
+  createAndPopulateGroup,
+  translate as t,
+} from '../../../../helpers/api-integration/v3';
+
+describe('POST /challenges/:challengeId/flag', () => {
+  let user;
+  let challenge;
+
+  beforeEach(async () => {
+    const { group, groupLeader } = await createAndPopulateGroup({
+      groupDetails: {
+        name: 'TestParty',
+        type: 'party',
+        privacy: 'private',
+      },
+      members: 1,
+    });
+
+    user = groupLeader;
+
+    challenge = await generateChallenge(user, group);
+  });
+
+  it('returns an error when challenge is not found', async () => {
+    await expect(user.post(`/challenges/${generateUUID()}/flag`))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('challengeNotFound'),
+      });
+  });
+
+  it('flags a challenge', async () => {
+    const flagResult = await user.post(`/challenges/${challenge._id}/flag`);
+
+    expect(flagResult.challenge.flags[user._id]).to.equal(true);
+    expect(flagResult.challenge.flagCount).to.equal(1);
+  });
+
+  it('flags a challenge with a higher count when from an admin', async () => {
+    await user.update({ 'contributor.admin': true });
+
+    const flagResult = await user.post(`/challenges/${challenge._id}/flag`);
+
+    expect(flagResult.challenge.flags[user._id]).to.equal(true);
+    expect(flagResult.challenge.flagCount).to.equal(5);
+  });
+
+  it('returns an error when user tries to flag a challenge that is already flagged', async () => {
+    await user.post(`/challenges/${challenge._id}/flag`);
+
+    await expect(user.post(`/challenges/${challenge._id}/flag`))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('messageChallengeFlagAlreadyReported'),
+      });
+  });
+});

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

@@ -0,0 +1,58 @@
+import { v4 as generateUUID } from 'uuid';
+import {
+  generateChallenge,
+  createAndPopulateGroup,
+  translate as t,
+} from '../../../../helpers/api-integration/v3';
+
+describe('POST /challenges/:challengeId/clearflags', () => {
+  let admin;
+  let nonAdmin;
+  let challenge;
+
+  beforeEach(async () => {
+    const { group, groupLeader, members } = await createAndPopulateGroup({
+      groupDetails: {
+        name: 'TestParty',
+        type: 'party',
+        privacy: 'private',
+      },
+      members: 1,
+    });
+
+    admin = groupLeader;
+    [nonAdmin] = members;
+
+    await admin.update({ 'permissions.moderator': true });
+
+    challenge = await generateChallenge(admin, group);
+    await admin.post(`/challenges/${challenge._id}/flag`);
+  });
+
+  it('returns error when non-admin attempts to clear flags', async () => {
+    await expect(nonAdmin.post(`/challenges/${generateUUID()}/clearflags`))
+      .to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('messageGroupChatAdminClearFlagCount'),
+      });
+  });
+
+  it('returns an error when challenge is not found', async () => {
+    await expect(admin.post(`/challenges/${generateUUID()}/clearflags`))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('challengeNotFound'),
+      });
+  });
+
+  it('clears flags and sets mod flag to false', async () => {
+    await nonAdmin.post(`/challenges/${challenge._id}/flag`);
+    const flagResult = await admin.post(`/challenges/${challenge._id}/clearflags`);
+
+    expect(flagResult.challenge.flagCount).to.eql(0);
+    expect(flagResult.challenge.flags).to.have.property(admin._id, false);
+    expect(flagResult.challenge.flags).to.have.property(nonAdmin._id, true);
+  });
+});

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

@@ -4,6 +4,7 @@ import {
   createAndPopulateGroup,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
+import { MAX_SUMMARY_SIZE_FOR_CHALLENGES } from '../../../../../website/common/script/constants';
 
 describe('POST /challenges', () => {
   it('returns error when group is empty', async () => {
@@ -41,26 +42,23 @@ describe('POST /challenges', () => {
     });
   });
 
-  it('returns error when creating a challenge in a public guild and you are not a member of it', async () => {
+  it('returns error when creating a challenge with summary with greater than MAX_SUMMARY_SIZE_FOR_CHALLENGES characters', async () => {
     const user = await generateUser();
-    const { group } = await createAndPopulateGroup({
-      groupDetails: {
-        type: 'guild',
-        privacy: 'public',
-      },
+    const summary = 'A'.repeat(MAX_SUMMARY_SIZE_FOR_CHALLENGES + 1);
+    const group = createAndPopulateGroup({
+      members: 1,
     });
-
     await expect(user.post('/challenges', {
       group: group._id,
-      prize: 4,
+      summary,
     })).to.eventually.be.rejected.and.eql({
-      code: 401,
-      error: 'NotAuthorized',
-      message: t('mustBeGroupMember'),
+      code: 400,
+      error: 'BadRequest',
+      message: t('invalidReqParams'),
     });
   });
 
-  context('Creating a challenge for a valid group', () => {
+  context('creating a Challenge for a Group Plan', () => {
     let groupLeader;
     let group;
     let groupMember;
@@ -77,9 +75,11 @@ describe('POST /challenges', () => {
             challenges: true,
           },
         },
+        upgradeToGroupPlan: true,
       });
 
       groupLeader = await populatedGroup.groupLeader.sync();
+      await groupLeader.update({ permissions: {} });
       group = populatedGroup.group;
       groupMember = populatedGroup.members[0]; // eslint-disable-line prefer-destructuring
     });

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

@@ -4,6 +4,7 @@ import {
   createAndPopulateGroup,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
+import { MAX_SUMMARY_SIZE_FOR_CHALLENGES } from '../../../../../website/common/script/constants';
 
 describe('PUT /challenges/:challengeId', () => {
   let privateGuild; let user; let nonMember; let challenge; let
@@ -17,6 +18,7 @@ describe('PUT /challenges/:challengeId', () => {
         privacy: 'private',
       },
       members: 1,
+      upgradeToGroupPlan: true,
     });
 
     privateGuild = group;
@@ -91,4 +93,15 @@ describe('PUT /challenges/:challengeId', () => {
     expect(res.name).to.equal('New Challenge Name');
     expect(res.description).to.equal('New challenge description.');
   });
+
+  it('return error when challenge summary is greater than MAX_SUMMARY_SIZE_FOR_CHALLENGES characters', async () => {
+    const summary = 'A'.repeat(MAX_SUMMARY_SIZE_FOR_CHALLENGES + 1);
+    await expect(user.put(`/challenges/${challenge._id}`, {
+      summary,
+    })).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('invalidReqParams'),
+    });
+  });
 });

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

@@ -1,7 +1,6 @@
 import { v4 as generateUUID } from 'uuid';
 import {
   createAndPopulateGroup,
-  generateUser,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
 
@@ -10,23 +9,30 @@ describe('DELETE /groups/:groupId/chat/:chatId', () => {
     admin;
 
   before(async () => {
-    const { group, groupLeader } = await createAndPopulateGroup({
+    const { group, groupLeader, members } = await createAndPopulateGroup({
       groupDetails: {
         type: 'guild',
-        privacy: 'public',
+        privacy: 'private',
       },
+      leaderDetails: {
+        'auth.timestamps.created': new Date('2022-01-01'),
+        balance: 10,
+      },
+      members: 2,
+      upgradeToGroupPlan: true,
     });
 
     groupWithChat = group;
     user = groupLeader;
     message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some message' });
     message = message.message;
-    userThatDidNotCreateChat = await generateUser();
-    admin = await generateUser({ 'permissions.moderator': true });
+    userThatDidNotCreateChat = members[0]; // eslint-disable-line prefer-destructuring
+    admin = members[1]; // eslint-disable-line prefer-destructuring
+    await admin.update({ permissions: { moderator: true } });
   });
 
   context('Chat errors', () => {
-    it('returns an error is message does not exist', async () => {
+    it('returns an error if message does not exist', async () => {
       const fakeChatId = generateUUID();
       await expect(user.del(`/groups/${groupWithChat._id}/chat/${fakeChatId}`)).to.eventually.be.rejected.and.eql({
         code: 404,
@@ -52,7 +58,7 @@ describe('DELETE /groups/:groupId/chat/:chatId', () => {
       nextMessage = nextMessage.message;
     });
 
-    it('allows creator to delete a their message', async () => {
+    it('allows creator to delete their message', async () => {
       await user.del(`/groups/${groupWithChat._id}/chat/${nextMessage.id}`);
 
       const returnedMessages = await user.get(`/groups/${groupWithChat._id}/chat/`);

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

@@ -1,6 +1,6 @@
 import {
   generateUser,
-  generateGroup,
+  createAndPopulateGroup,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
 
@@ -11,48 +11,22 @@ describe('GET /groups/:groupId/chat', () => {
     user = await generateUser();
   });
 
-  context('public Guild', () => {
-    let group;
-
-    before(async () => {
-      const leader = await generateUser({ balance: 2 });
-
-      group = await generateGroup(leader, {
-        name: 'test group',
-        type: 'guild',
-        privacy: 'public',
-      }, {
-        chat: [
-          { text: 'Hello', flags: {}, id: 1 },
-          { text: 'Welcome to the Guild', flags: {}, id: 2 },
-        ],
-      });
-    });
-
-    it('returns Guild chat', async () => {
-      const chat = await user.get(`/groups/${group._id}/chat`);
-
-      expect(chat[0].id).to.eql(group.chat[0].id);
-      expect(chat[1].id).to.eql(group.chat[1].id);
-    });
-  });
-
   context('private Guild', () => {
     let group;
-
     before(async () => {
-      const leader = await generateUser({ balance: 2 });
-
-      group = await generateGroup(leader, {
-        name: 'test group',
-        type: 'guild',
-        privacy: 'private',
-      }, {
+      ({ group } = await createAndPopulateGroup({
+        groupDetails: {
+          name: 'test group',
+          type: 'guild',
+          privacy: 'private',
+        },
+        members: 1,
+        upgradeToGroupPlan: true,
         chat: [
           'Hello',
           'Welcome to the Guild',
         ],
-      });
+      }));
     });
 
     it('returns error if user is not member of requested private group', async () => {

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

@@ -1,32 +1,42 @@
-import { find } from 'lodash';
+import find from 'lodash/find';
 import moment from 'moment';
-import nconf from 'nconf';
 import { IncomingWebhook } from '@slack/webhook';
 import {
-  generateUser,
+  createAndPopulateGroup,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
 
-const BASE_URL = nconf.get('BASE_URL');
-
 describe('POST /chat/:chatId/flag', () => {
   let user; let admin; let anotherUser; let newUser; let
-    group;
+    group; let members; let userToDelete;
   const TEST_MESSAGE = 'Test Message';
   const USER_AGE_FOR_FLAGGING = 3;
 
   beforeEach(async () => {
-    user = await generateUser({ balance: 1, 'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate() });
-    admin = await generateUser({ balance: 1, 'permissions.moderator': true });
-    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').returns(Promise.resolve());
+    ({ group, groupLeader: user, members } = await createAndPopulateGroup({
+      groupDetails: {
+        name: 'Test Guild',
+        type: 'guild',
+        privacy: 'private',
+      },
+      leaderDetails: {
+        'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate(),
+      },
+      members: 4,
+      upgradeToGroupPlan: true,
+    }));
 
-    group = await user.post('/groups', {
-      name: 'Test Guild',
-      type: 'guild',
-      privacy: 'public',
+    [admin, anotherUser, newUser, userToDelete] = members;
+    await user.update({ permissions: {} });
+    await admin.update({ permissions: { moderator: true } });
+    await anotherUser.update({ 'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate() });
+    await newUser.update({ 'auth.timestamps.created': moment().subtract(1, 'days').toDate() });
+    await userToDelete.update({
+      'auth.timestamps.created': moment().subtract(1, 'days').toDate(),
+      'purchased.plan.dateTerminated': moment().subtract(1, 'minutes').toDate(),
     });
+
+    sandbox.stub(IncomingWebhook.prototype, 'send').returns(Promise.resolve());
   });
 
   afterEach(() => {
@@ -69,8 +79,8 @@ describe('POST /chat/:chatId/flag', () => {
         fallback: 'Flag Message',
         color: 'danger',
         author_name: `@${anotherUser.auth.local.username} ${anotherUser.profile.name} (${anotherUser.auth.local.email}; ${anotherUser._id})\n${timestamp}`,
-        title: 'Flag in Test Guild',
-        title_link: `${BASE_URL}/groups/guild/${group._id}`,
+        title: 'Flag in Test Guild - (private guild)',
+        title_link: undefined,
         text: TEST_MESSAGE,
         footer: `<https://habitrpg.github.io/flag-o-rama/?groupId=${group._id}&chatId=${message.id}|Flag this message.>`,
         mrkdwn_in: [
@@ -78,7 +88,7 @@ describe('POST /chat/:chatId/flag', () => {
         ],
       }],
     });
-    /* eslint-ensable camelcase */
+    /* eslint-enable camelcase */
   });
 
   it('Does not increment message flag count and sends different message to moderator Slack when user is new', async () => {
@@ -104,8 +114,8 @@ describe('POST /chat/:chatId/flag', () => {
         fallback: 'Flag Message',
         color: 'danger',
         author_name: `@${newUser.auth.local.username} ${newUser.profile.name} (${newUser.auth.local.email}; ${newUser._id})\n${timestamp}`,
-        title: 'Flag in Test Guild',
-        title_link: `${BASE_URL}/groups/guild/${group._id}`,
+        title: 'Flag in Test Guild - (private guild)',
+        title_link: undefined,
         text: TEST_MESSAGE,
         footer: `<https://habitrpg.github.io/flag-o-rama/?groupId=${group._id}&chatId=${message.id}|Flag this message.> ${automatedComment}`,
         mrkdwn_in: [
@@ -113,13 +123,12 @@ describe('POST /chat/:chatId/flag', () => {
         ],
       }],
     });
-    /* eslint-ensable camelcase */
+    /* eslint-enable camelcase */
   });
 
   it('Flags a chat when the author\'s account was deleted', async () => {
-    const deletedUser = await generateUser();
-    const { message } = await deletedUser.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
-    await deletedUser.del('/user', {
+    const { message } = await userToDelete.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
+    await userToDelete.del('/user', {
       password: 'password',
     });
 

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

@@ -6,23 +6,28 @@ import {
 
 describe('POST /chat/:chatId/like', () => {
   let user;
-  let groupWithChat;
-  const testMessage = 'Test Message';
   let anotherUser;
+  let groupWithChat;
+  let members;
+  const testMessage = 'Test Message';
 
   before(async () => {
-    const { group, groupLeader, members } = await createAndPopulateGroup({
+    ({ group: groupWithChat, groupLeader: user, members } = await createAndPopulateGroup({
       groupDetails: {
         name: 'Test Guild',
         type: 'guild',
-        privacy: 'public',
+        privacy: 'private',
       },
       members: 1,
-    });
+      leaderDetails: {
+        'auth.timestamps.created': new Date('2022-01-01'),
+        balance: 10,
+      },
+      upgradeToGroupPlan: true,
+    }));
 
-    user = groupLeader;
-    groupWithChat = group;
-    anotherUser = members[0]; // eslint-disable-line prefer-destructuring
+    [anotherUser] = members;
+    await anotherUser.update({ 'auth.timestamps.created': new Date('2022-01-01') });
   });
 
   it('Returns an error when chat message is not found', async () => {

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

@@ -1,47 +1,43 @@
 import { IncomingWebhook } from '@slack/webhook';
-import nconf from 'nconf';
 import { v4 as generateUUID } from 'uuid';
 import {
   createAndPopulateGroup,
-  generateUser,
   translate as t,
   sleep,
   server,
 } from '../../../../helpers/api-integration/v3';
 import {
-  SPAM_MESSAGE_LIMIT,
   SPAM_MIN_EXEMPT_CONTRIB_LEVEL,
-  TAVERN_ID,
 } from '../../../../../website/server/models/group';
-import { CHAT_FLAG_FROM_SHADOW_MUTE, MAX_MESSAGE_LENGTH } from '../../../../../website/common/script/constants';
+import { MAX_MESSAGE_LENGTH } from '../../../../../website/common/script/constants';
 import * as email from '../../../../../website/server/libs/email';
 
-const BASE_URL = nconf.get('BASE_URL');
-
 describe('POST /chat', () => {
   let user; let groupWithChat; let member; let
     additionalMember;
   const testMessage = 'Test Message';
   const testBannedWordMessage = 'TESTPLACEHOLDERSWEARWORDHERE';
-  const testBannedWordMessage1 = 'TESTPLACEHOLDERSWEARWORDHERE1';
   const testSlurMessage = 'message with TESTPLACEHOLDERSLURWORDHERE';
-  const testSlurMessage1 = 'TESTPLACEHOLDERSLURWORDHERE1';
-  const bannedWordErrorMessage = t('bannedWordUsed', { swearWordsUsed: testBannedWordMessage });
 
   before(async () => {
     const { group, groupLeader, members } = await createAndPopulateGroup({
       groupDetails: {
         name: 'Test Guild',
         type: 'guild',
-        privacy: 'public',
+        privacy: 'private',
       },
       members: 2,
+      upgradeToGroupPlan: true,
     });
     user = groupLeader;
-    await user.update({ 'contributor.level': SPAM_MIN_EXEMPT_CONTRIB_LEVEL }); // prevent tests accidentally throwing messageGroupChatSpam
+    await user.update({
+      'contributor.level': SPAM_MIN_EXEMPT_CONTRIB_LEVEL,
+      'auth.timestamps.created': new Date('2022-01-01'),
+    }); // prevent tests accidentally throwing messageGroupChatSpam
     groupWithChat = group;
-    member = members[0]; // eslint-disable-line prefer-destructuring
-    additionalMember = members[1]; // eslint-disable-line prefer-destructuring
+    [member, additionalMember] = members;
+    await member.update({ 'auth.timestamps.created': new Date('2022-01-01') });
+    await additionalMember.update({ 'auth.timestamps.created': new Date('2022-01-01') });
   });
 
   it('Returns an error when no message is provided', async () => {
@@ -84,29 +80,12 @@ describe('POST /chat', () => {
       member.update({ 'flags.chatRevoked': false });
     });
 
-    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'),
-      });
-    });
-
     it('does not error when chat privileges are revoked when sending a message to a private guild', async () => {
-      const { group, members } = await createAndPopulateGroup({
-        groupDetails: {
-          name: 'Private Guild',
-          type: 'guild',
-          privacy: 'private',
-        },
-        members: 1,
+      await member.update({
+        'flags.chatRevoked': true,
       });
 
-      const privateGuildMemberWithChatsRevoked = members[0];
-      await privateGuildMemberWithChatsRevoked.update({ 'flags.chatRevoked': true });
-
-      const message = await privateGuildMemberWithChatsRevoked.post(`/groups/${group._id}/chat`, { message: testMessage });
+      const message = await member.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
 
       expect(message.message.id).to.exist;
     });
@@ -122,7 +101,10 @@ describe('POST /chat', () => {
       });
 
       const privatePartyMemberWithChatsRevoked = members[0];
-      await privatePartyMemberWithChatsRevoked.update({ 'flags.chatRevoked': true });
+      await privatePartyMemberWithChatsRevoked.update({
+        'flags.chatRevoked': true,
+        'auth.timestamps.created': new Date('2022-01-01'),
+      });
 
       const message = await privatePartyMemberWithChatsRevoked.post(`/groups/${group._id}/chat`, { message: testMessage });
 
@@ -141,51 +123,12 @@ describe('POST /chat', () => {
       member.update({ 'flags.chatShadowMuted': false });
     });
 
-    it('creates a chat with flagCount already set and notifies mods when sending a message to a public guild', async () => {
-      const userWithChatShadowMuted = await member.update({ 'flags.chatShadowMuted': true });
-      const message = await userWithChatShadowMuted.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
-      expect(message.message.id).to.exist;
-      expect(message.message.flagCount).to.eql(CHAT_FLAG_FROM_SHADOW_MUTE);
-
-      // Email sent to mods
-      await sleep(0.5);
-      expect(email.sendTxn).to.be.calledOnce;
-      expect(email.sendTxn.args[0][1]).to.eql('shadow-muted-post-report-to-mods');
-
-      // Slack message to mods
-      expect(IncomingWebhook.prototype.send).to.be.calledOnce;
-      /* eslint-disable camelcase */
-      expect(IncomingWebhook.prototype.send).to.be.calledWith({
-        text: `@${member.auth.local.username} / ${member.profile.name} posted while shadow-muted`,
-        attachments: [{
-          fallback: 'Shadow-Muted Message',
-          color: 'danger',
-          author_name: `@${member.auth.local.username} ${member.profile.name} (${member.auth.local.email}; ${member._id})`,
-          title: 'Shadow-Muted Post in Test Guild',
-          title_link: `${BASE_URL}/groups/guild/${groupWithChat.id}`,
-          text: testMessage,
-          mrkdwn_in: [
-            'text',
-          ],
-        }],
-      });
-      /* eslint-enable camelcase */
-    });
-
     it('creates a chat with zero flagCount when sending a message to a private guild', async () => {
-      const { group, members } = await createAndPopulateGroup({
-        groupDetails: {
-          name: 'Private Guild',
-          type: 'guild',
-          privacy: 'private',
-        },
-        members: 1,
+      await member.update({
+        'flags.chatShadowMuted': true,
       });
 
-      const userWithChatShadowMuted = members[0];
-      await userWithChatShadowMuted.update({ 'flags.chatShadowMuted': true });
-
-      const message = await userWithChatShadowMuted.post(`/groups/${group._id}/chat`, { message: testMessage });
+      const message = await member.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
 
       expect(message.message.id).to.exist;
       expect(message.message.flagCount).to.eql(0);
@@ -202,107 +145,19 @@ describe('POST /chat', () => {
       });
 
       const userWithChatShadowMuted = members[0];
-      await userWithChatShadowMuted.update({ 'flags.chatShadowMuted': true });
+      await userWithChatShadowMuted.update({
+        'flags.chatShadowMuted': true,
+        'auth.timestamps.created': new Date('2022-01-01'),
+      });
 
       const message = await userWithChatShadowMuted.post(`/groups/${group._id}/chat`, { message: testMessage });
 
       expect(message.message.id).to.exist;
       expect(message.message.flagCount).to.eql(0);
     });
-
-    it('creates a chat with zero flagCount when non-shadow-muted user sends a message to a public guild', async () => {
-      const message = await member.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
-      expect(message.message.id).to.exist;
-      expect(message.message.flagCount).to.eql(0);
-    });
   });
 
   context('banned word', () => {
-    it('returns an error when chat message contains a banned word in tavern', async () => {
-      await expect(user.post('/groups/habitrpg/chat', { message: testBannedWordMessage }))
-        .to.eventually.be.rejected.and.eql({
-          code: 400,
-          error: 'BadRequest',
-          message: bannedWordErrorMessage,
-        });
-    });
-
-    it('returns an error when chat message contains a banned word in a public guild', async () => {
-      const { group, members } = await createAndPopulateGroup({
-        groupDetails: {
-          name: 'public guild',
-          type: 'guild',
-          privacy: 'public',
-        },
-        members: 1,
-      });
-
-      await expect(members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage }))
-        .to.eventually.be.rejected.and.eql({
-          code: 400,
-          error: 'BadRequest',
-          message: bannedWordErrorMessage,
-        });
-    });
-
-    it('errors when word is part of a phrase', async () => {
-      const wordInPhrase = `phrase ${testBannedWordMessage} end`;
-      await expect(user.post('/groups/habitrpg/chat', { message: wordInPhrase }))
-        .to.eventually.be.rejected.and.eql({
-          code: 400,
-          error: 'BadRequest',
-          message: bannedWordErrorMessage,
-        });
-    });
-
-    it('errors when word is surrounded by non alphabet characters', async () => {
-      const wordInPhrase = `_!${testBannedWordMessage}@_`;
-      await expect(user.post('/groups/habitrpg/chat', { message: wordInPhrase }))
-        .to.eventually.be.rejected.and.eql({
-          code: 400,
-          error: 'BadRequest',
-          message: bannedWordErrorMessage,
-        });
-    });
-
-    it('errors when word is typed in mixed case', async () => {
-      const substrLength = Math.floor(testBannedWordMessage.length / 2);
-      const chatMessage = testBannedWordMessage.substring(0, substrLength).toLowerCase()
-        + testBannedWordMessage.substring(substrLength).toUpperCase();
-      await expect(user.post('/groups/habitrpg/chat', { message: chatMessage }))
-        .to.eventually.be.rejected.and.eql({
-          code: 400,
-          error: 'BadRequest',
-          message: t('bannedWordUsed', { swearWordsUsed: chatMessage }),
-        });
-    });
-
-    it('checks error message has all the banned words used, regardless of case', async () => {
-      const testBannedWords = [
-        testBannedWordMessage.toUpperCase(),
-        testBannedWordMessage1.toLowerCase(),
-      ];
-      const chatMessage = `Mixing ${testBannedWords[0]} and ${testBannedWords[1]} is bad for you.`;
-      await expect(user.post('/groups/habitrpg/chat', { message: chatMessage }))
-        .to.eventually.be.rejected
-        .and.have.property('message')
-        .that.includes(testBannedWords.join(', '));
-    });
-
-    it('does not error when bad word is suffix of a word', async () => {
-      const wordAsSuffix = `prefix${testBannedWordMessage}`;
-      const message = await user.post('/groups/habitrpg/chat', { message: wordAsSuffix });
-
-      expect(message.message.id).to.exist;
-    });
-
-    it('does not error when bad word is prefix of a word', async () => {
-      const wordAsPrefix = `${testBannedWordMessage}suffix`;
-      const message = await user.post('/groups/habitrpg/chat', { message: wordAsPrefix });
-
-      expect(message.message.id).to.exist;
-    });
-
     it('does not error when sending a chat message containing a banned word to a party', async () => {
       const { group, members } = await createAndPopulateGroup({
         groupDetails: {
@@ -312,24 +167,7 @@ describe('POST /chat', () => {
         },
         members: 1,
       });
-
-      const message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage });
-
-      expect(message.message.id).to.exist;
-    });
-
-    it('does not error when sending a chat message containing a banned word to a public guild in which banned words are allowed', async () => {
-      const { group, members } = await createAndPopulateGroup({
-        groupDetails: {
-          name: 'public guild',
-          type: 'guild',
-          privacy: 'public',
-        },
-        members: 1,
-      });
-
-      // Update the bannedWordsAllowed property for the group
-      group.update({ bannedWordsAllowed: true });
+      await members[0].update({ 'auth.timestamps.created': new Date('2022-01-01') });
 
       const message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage });
 
@@ -337,16 +175,7 @@ describe('POST /chat', () => {
     });
 
     it('does not error when sending a chat message containing a banned word to a private guild', async () => {
-      const { group, members } = await createAndPopulateGroup({
-        groupDetails: {
-          name: 'private guild',
-          type: 'guild',
-          privacy: 'private',
-        },
-        members: 1,
-      });
-
-      const message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage });
+      const message = await member.post(`/groups/${groupWithChat._id}/chat`, { message: testBannedWordMessage });
 
       expect(message.message.id).to.exist;
     });
@@ -363,45 +192,6 @@ describe('POST /chat', () => {
       user.update({ 'flags.chatRevoked': false });
     });
 
-    it('errors and revokes privileges when chat message contains a banned slur', async () => {
-      await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: testSlurMessage })).to.eventually.be.rejected.and.eql({
-        code: 400,
-        error: 'BadRequest',
-        message: t('bannedSlurUsed'),
-      });
-
-      // Email sent to mods
-      await sleep(0.5);
-      expect(email.sendTxn).to.be.calledOnce;
-      expect(email.sendTxn.args[0][1]).to.eql('slur-report-to-mods');
-
-      // Slack message to mods
-      expect(IncomingWebhook.prototype.send).to.be.calledOnce;
-      /* eslint-disable camelcase */
-      expect(IncomingWebhook.prototype.send).to.be.calledWith({
-        text: `${user.profile.name} (${user.id}) tried to post a slur`,
-        attachments: [{
-          fallback: 'Slur Message',
-          color: 'danger',
-          author_name: `@${user.auth.local.username} ${user.profile.name} (${user.auth.local.email}; ${user._id})`,
-          title: 'Slur in Test Guild',
-          title_link: `${BASE_URL}/groups/guild/${groupWithChat.id}`,
-          text: testSlurMessage,
-          mrkdwn_in: [
-            'text',
-          ],
-        }],
-      });
-      /* eslint-enable camelcase */
-
-      // Chat privileges are revoked
-      await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage })).to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('chatPrivilegesRevoked'),
-      });
-    });
-
     it('allows slurs in private groups', async () => {
       const { group, members } = await createAndPopulateGroup({
         groupDetails: {
@@ -411,23 +201,23 @@ describe('POST /chat', () => {
         },
         members: 1,
       });
+      await members[0].update({ 'auth.timestamps.created': new Date('2022-01-01') });
 
       const message = await members[0].post(`/groups/${group._id}/chat`, { message: testSlurMessage });
 
       expect(message.message.id).to.exist;
     });
+  });
 
-    it('errors when slur is typed in mixed case', async () => {
-      const substrLength = Math.floor(testSlurMessage1.length / 2);
-      const chatMessage = testSlurMessage1.substring(0, substrLength).toLowerCase()
-        + testSlurMessage1.substring(substrLength).toUpperCase();
-      await expect(user.post('/groups/habitrpg/chat', { message: chatMessage }))
-        .to.eventually.be.rejected.and.eql({
-          code: 400,
-          error: 'BadRequest',
-          message: t('bannedSlurUsed'),
-        });
-    });
+  it('errors when user account is too young', async () => {
+    await user.update({ 'auth.timestamps.created': new Date() });
+    await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: 'hi im new' }))
+      .to.eventually.be.rejected.and.eql({
+        code: 400,
+        error: 'BadRequest',
+        message: t('chatTemporarilyUnavailable'),
+      });
+    await user.update({ 'auth.timestamps.created': new Date('2022-01-01') });
   });
 
   it('creates a chat', async () => {
@@ -488,25 +278,43 @@ describe('POST /chat', () => {
     const mount = 'test-mount';
     const pet = 'test-pet';
     const style = 'test-style';
-    const userWithStyle = await generateUser({
+    await user.update({
       'items.currentMount': mount,
       'items.currentPet': pet,
       'preferences.style': style,
     });
-    await userWithStyle.sync();
 
-    const message = await userWithStyle.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
+    const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
 
     expect(message.message.id).to.exist;
-    expect(message.message.userStyles.items.currentMount).to.eql(userWithStyle.items.currentMount);
-    expect(message.message.userStyles.items.currentPet).to.eql(userWithStyle.items.currentPet);
-    expect(message.message.userStyles.preferences.style).to.eql(userWithStyle.preferences.style);
-    expect(message.message.userStyles.preferences.hair).to.eql(userWithStyle.preferences.hair);
-    expect(message.message.userStyles.preferences.skin).to.eql(userWithStyle.preferences.skin);
-    expect(message.message.userStyles.preferences.shirt).to.eql(userWithStyle.preferences.shirt);
-    expect(message.message.userStyles.preferences.chair).to.eql(userWithStyle.preferences.chair);
+    expect(message.message.userStyles.items.currentMount).to.eql(user.items.currentMount);
+    expect(message.message.userStyles.items.currentPet).to.eql(user.items.currentPet);
+    expect(message.message.userStyles.preferences.style).to.eql(user.preferences.style);
+    expect(message.message.userStyles.preferences.hair).to.eql(user.preferences.hair);
+    expect(message.message.userStyles.preferences.skin).to.eql(user.preferences.skin);
+    expect(message.message.userStyles.preferences.shirt).to.eql(user.preferences.shirt);
+    expect(message.message.userStyles.preferences.chair).to.eql(user.preferences.chair);
     expect(message.message.userStyles.preferences.background)
-      .to.eql(userWithStyle.preferences.background);
+      .to.eql(user.preferences.background);
+  });
+
+  it('creates equipped to user styles', async () => {
+    const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
+
+    expect(message.message.id).to.exist;
+    expect(message.message.userStyles.items.gear.equipped)
+      .to.eql(user.items.gear.equipped);
+    expect(message.message.userStyles.items.gear.costume).to.not.exist;
+  });
+
+  it('creates costume to user styles', async () => {
+    await user.update({ 'preferences.costume': true });
+
+    const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
+
+    expect(message.message.id).to.exist;
+    expect(message.message.userStyles.items.gear.costume).to.eql(user.items.gear.costume);
+    expect(message.message.userStyles.items.gear.equipped).to.not.exist;
   });
 
   it('adds backer info to chat', async () => {
@@ -515,11 +323,11 @@ describe('POST /chat', () => {
       tier: 800,
       tokensApplied: true,
     };
-    const backer = await generateUser({
+    await user.update({
       backer: backerInfo,
     });
 
-    const message = await backer.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
+    const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
     const messageBackerInfo = message.message.backer;
 
     expect(messageBackerInfo.npc).to.equal(backerInfo.npc);
@@ -587,6 +395,9 @@ describe('POST /chat', () => {
           privacy: 'private',
         },
         members: 1,
+        leaderDetails: {
+          'auth.timestamps.created': new Date('2022-01-01'),
+        },
       });
 
       const message = await groupLeader.post(`/groups/${group._id}/chat`, { message: testMessage });
@@ -596,43 +407,5 @@ describe('POST /chat', () => {
       expect(memberWithNotification.newMessages[`${group._id}`]).to.exist;
       expect(memberWithNotification.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === group._id)).to.exist;
     });
-
-    it('does not notify other users of a new message that is already hidden from shadow-muting', async () => {
-      await user.update({ 'flags.chatShadowMuted': true });
-      const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
-      const memberWithNotification = await member.get('/user');
-
-      await user.update({ 'flags.chatShadowMuted': false });
-
-      expect(message.message.id).to.exist;
-      expect(memberWithNotification.newMessages[`${groupWithChat._id}`]).to.not.exist;
-      expect(memberWithNotification.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupWithChat._id)).to.not.exist;
-    });
-  });
-
-  context('Spam prevention', () => {
-    it('Returns an error when the user has been posting too many messages', async () => {
-      // Post as many messages are needed to reach the spam limit
-      for (let i = 0; i < SPAM_MESSAGE_LIMIT; i += 1) {
-        const result = await additionalMember.post(`/groups/${TAVERN_ID}/chat`, { message: testMessage }); // eslint-disable-line no-await-in-loop
-        expect(result.message.id).to.exist;
-      }
-
-      await expect(additionalMember.post(`/groups/${TAVERN_ID}/chat`, { message: testMessage })).to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('messageGroupChatSpam'),
-      });
-    });
-
-    it('contributor should not receive spam alert', async () => {
-      const userSocialite = await member.update({ 'contributor.level': SPAM_MIN_EXEMPT_CONTRIB_LEVEL });
-
-      // Post 1 more message than the spam limit to ensure they do not reach the limit
-      for (let i = 0; i < SPAM_MESSAGE_LIMIT + 1; i += 1) {
-        const result = await userSocialite.post(`/groups/${TAVERN_ID}/chat`, { message: testMessage }); // eslint-disable-line no-await-in-loop
-        expect(result.message.id).to.exist;
-      }
-    });
   });
 });

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

@@ -12,14 +12,19 @@ describe('POST /groups/:id/chat/seen', () => {
       const { group, groupLeader, members } = await createAndPopulateGroup({
         groupDetails: {
           type: 'guild',
-          privacy: 'public',
+          privacy: 'private',
         },
         members: 1,
+        leaderDetails: {
+          'auth.timestamps.created': new Date('2022-01-01'),
+          balance: 10,
+        },
+        upgradeToGroupPlan: true,
       });
 
       guild = group;
       guildLeader = groupLeader;
-      guildMember = members[0]; // eslint-disable-line prefer-destructuring
+      [guildMember] = members;
 
       guildMessage = await guildLeader.post(`/groups/${guild._id}/chat`, { message: 'Some guild message' });
       guildMessage = guildMessage.message;
@@ -51,6 +56,9 @@ describe('POST /groups/:id/chat/seen', () => {
           privacy: 'private',
         },
         members: 1,
+        leaderDetails: {
+          'auth.timestamps.created': new Date('2022-01-01'),
+        },
       });
 
       party = group;

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

@@ -2,7 +2,6 @@ import moment from 'moment';
 import { v4 as generateUUID } from 'uuid';
 import {
   createAndPopulateGroup,
-  generateUser,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
 import config from '../../../../../config.json';
@@ -13,17 +12,24 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
     admin;
 
   before(async () => {
-    const { group, groupLeader } = await createAndPopulateGroup({
+    const { group, groupLeader, members } = await createAndPopulateGroup({
       groupDetails: {
         type: 'guild',
-        privacy: 'public',
+        privacy: 'private',
       },
+      leaderDetails: {
+        'auth.timestamps.created': new Date('2022-01-01'),
+        balance: 10,
+      },
+      upgradeToGroupPlan: true,
+      members: 2,
     });
 
     groupWithChat = group;
     author = groupLeader;
-    nonAdmin = await generateUser({ 'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate() });
-    admin = await generateUser({ 'permissions.moderator': true });
+    [nonAdmin, admin] = members;
+    await nonAdmin.update({ 'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate() });
+    await admin.update({ 'permissions.moderator': true });
 
     message = await author.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some message' });
     message = message.message;
@@ -62,21 +68,27 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
           type: 'party',
           privacy: 'private',
         },
-        members: 1,
+        members: 2,
       });
 
+      await members[0].update({ 'auth.timestamps.created': new Date('2022-01-01') });
       let privateMessage = await members[0].post(`/groups/${group._id}/chat`, { message: 'Some message' });
       privateMessage = privateMessage.message;
 
       await admin.post(`/groups/${group._id}/chat/${privateMessage.id}/flag`);
 
       // first test that the flag was actually successful
+      // author always sees own message; flag count is hidden from non-admins
       let messages = await members[0].get(`/groups/${group._id}/chat`);
-      expect(messages[0].flagCount).to.eql(5);
+      expect(messages[0].flagCount).to.eql(0);
+      messages = await members[1].get(`/groups/${group._id}/chat`);
+      expect(messages.length).to.eql(0);
 
+      // admin cannot directly request private group chat, but after unflag,
+      // message should be revealed again and still have flagCount of 0
       await admin.post(`/groups/${group._id}/chat/${privateMessage.id}/clearflags`);
-
-      messages = await members[0].get(`/groups/${group._id}/chat`);
+      messages = await members[1].get(`/groups/${group._id}/chat`);
+      expect(messages.length).to.eql(1);
       expect(messages[0].flagCount).to.eql(0);
     });
 

test/api/v3/integration/groups/GET-group-plans.test.js

@@ -1,6 +1,5 @@
 import {
-  generateUser,
-  generateGroup,
+  createAndPopulateGroup,
 } from '../../../../helpers/api-integration/v3';
 
 describe('GET /group-plans', () => {
@@ -8,20 +7,15 @@ describe('GET /group-plans', () => {
   let groupPlan;
 
   before(async () => {
-    user = await generateUser({ balance: 4 });
-    groupPlan = await generateGroup(user,
-      {
-        name: 'public guild - is member',
+    ({ group: groupPlan, groupLeader: user } = await createAndPopulateGroup({
+      groupDetails: {
+        name: 'group plan - is member',
         type: 'guild',
-        privacy: 'public',
+        privacy: 'private',
       },
-      {
-        purchased: {
-          plan: {
-            customerId: 'existings',
-          },
-        },
-      });
+      upgradeToGroupPlan: true,
+      leaderDetails: { balance: 4 },
+    }));
   });
 
   it('returns group plans for the user', async () => {

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

@@ -1,70 +1,63 @@
 import {
-  generateUser,
+  createAndPopulateGroup,
   resetHabiticaDB,
   generateGroup,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
-import {
-  TAVERN_ID,
-} from '../../../../../website/server/models/group';
-import apiError from '../../../../../website/server/libs/apiError';
 
 describe('GET /groups', () => {
-  let user;
-  let userInGuild;
-  const NUMBER_OF_PUBLIC_GUILDS = 2;
-  const NUMBER_OF_PUBLIC_GUILDS_USER_IS_LEADER = 2;
-  const NUMBER_OF_PUBLIC_GUILDS_USER_IS_MEMBER = 1;
-  const NUMBER_OF_USERS_PRIVATE_GUILDS = 1;
-  const NUMBER_OF_GROUPS_USER_CAN_VIEW = 5;
-  const GUILD_PER_PAGE = 30;
+  let user; let leader; let members;
+  let secondGroup; let secondLeader;
+  const NUMBER_OF_USERS_PRIVATE_GUILDS = 2;
+  const NUMBER_OF_GROUPS_USER_CAN_VIEW = 3;
   const categories = [{
     slug: 'newCat',
     name: 'New Category',
   }];
-  let publicGuildNotMember;
   let privateGuildUserIsMemberOf;
 
   before(async () => {
     await resetHabiticaDB();
 
-    const leader = await generateUser({ balance: 10 });
-    user = await generateUser({ balance: 4 });
+    ({
+      group: privateGuildUserIsMemberOf,
+      groupLeader: leader,
+      members,
+    } = await createAndPopulateGroup({
+      groupDetails: {
+        name: 'private guild - is member',
+        type: 'guild',
+        privacy: 'private',
+        categories,
+      },
+      leaderDetails: {
+        balance: 10,
+      },
+      members: 1,
+      upgradeToGroupPlan: true,
+    }));
+    [user] = members;
+    await user.update({ balance: 4 });
 
-    const publicGuildUserIsMemberOf = await generateGroup(leader, {
-      name: 'public guild - is member',
-      type: 'guild',
-      privacy: 'public',
-      summary: 'ohayou kombonwa',
-      description: 'oyasumi',
-    });
-    await leader.post(`/groups/${publicGuildUserIsMemberOf._id}/invite`, { uuids: [user._id] });
-    await user.post(`/groups/${publicGuildUserIsMemberOf._id}/join`);
+    ({ group: secondGroup, groupLeader: secondLeader } = await createAndPopulateGroup({
+      groupDetails: {
+        name: 'c++ coders',
+        type: 'guild',
+        privacy: 'private',
+      },
+      upgradeToGroupPlan: true,
+    }));
 
-    userInGuild = await generateUser({ guilds: [publicGuildUserIsMemberOf._id] });
+    await secondLeader.post(`/groups/${secondGroup._id}/invite`, { uuids: [user._id] });
+    await user.post(`/groups/${secondGroup._id}/join`);
 
-    publicGuildNotMember = await generateGroup(leader, {
-      name: 'public guild - is not member',
-      type: 'guild',
-      privacy: 'public',
-      summary: 'Natsume Soseki',
-      description: 'Kinnosuke no Hondana',
-      categories,
-    });
-
-    privateGuildUserIsMemberOf = await generateGroup(leader, {
-      name: 'private guild - is member',
-      type: 'guild',
-      privacy: 'private',
-      categories,
-    });
-    await leader.post(`/groups/${privateGuildUserIsMemberOf._id}/invite`, { uuids: [user._id] });
-    await user.post(`/groups/${privateGuildUserIsMemberOf._id}/join`);
-
-    await generateGroup(leader, {
-      name: 'private guild - is not member',
-      type: 'guild',
-      privacy: 'private',
+    await createAndPopulateGroup({
+      groupDetails: {
+        name: 'private guild - is not member',
+        type: 'guild',
+        privacy: 'private',
+      },
+      upgradeToGroupPlan: true,
     });
 
     await generateGroup(leader, {
@@ -98,172 +91,16 @@ describe('GET /groups', () => {
       });
   });
 
-  it('returns only the tavern when tavern passed in as query', async () => {
-    await expect(user.get('/groups?type=tavern'))
-      .to.eventually.have.a.lengthOf(1)
-      .and.to.have.nested.property('[0]')
-      .and.to.have.property('_id', TAVERN_ID);
-  });
-
   it('returns only the user\'s party when party passed in as query', async () => {
     await expect(user.get('/groups?type=party'))
       .to.eventually.have.a.lengthOf(1)
       .and.to.have.nested.property('[0]');
   });
 
-  it('returns all public guilds when publicGuilds passed in as query', async () => {
-    await expect(user.get('/groups?type=publicGuilds'))
-      .to.eventually.have.a.lengthOf(NUMBER_OF_PUBLIC_GUILDS);
-  });
-
-  describe('filters', () => {
-    it('returns public guilds filtered by category', async () => {
-      const guilds = await user.get(`/groups?type=publicGuilds&categories=${categories[0].slug}`);
-
-      expect(guilds[0]._id).to.equal(publicGuildNotMember._id);
-    });
-
-    it('returns private guilds filtered by category', async () => {
-      const guilds = await user.get(`/groups?type=privateGuilds&categories=${categories[0].slug}`);
-
-      expect(guilds[0]._id).to.equal(privateGuildUserIsMemberOf._id);
-    });
-
-    it('filters public guilds by size', async () => {
-      await generateGroup(user, {
-        name: 'guild1',
-        type: 'guild',
-        privacy: 'public',
-        memberCount: 1,
-      });
-
-      // @TODO: anyway to set higher memberCount in tests right now?
-
-      const guilds = await user.get('/groups?type=publicGuilds&minMemberCount=3');
-
-      expect(guilds.length).to.equal(0);
-    });
-
-    it('filters private guilds by size', async () => {
-      await generateGroup(user, {
-        name: 'guild1',
-        type: 'guild',
-        privacy: 'private',
-        memberCount: 1,
-      });
-
-      // @TODO: anyway to set higher memberCount in tests right now?
-
-      const guilds = await user.get('/groups?type=privateGuilds&minMemberCount=3');
-
-      expect(guilds.length).to.equal(0);
-    });
-
-    it('filters public guilds by leader role', async () => {
-      const guilds = await user.get('/groups?type=publicGuilds&leader=true');
-      expect(guilds.length).to.equal(NUMBER_OF_PUBLIC_GUILDS_USER_IS_LEADER);
-    });
-
-    it('filters public guilds by member role', async () => {
-      const guilds = await userInGuild.get('/groups?type=publicGuilds&member=true');
-      expect(guilds.length).to.equal(1);
-      expect(guilds[0].name).to.have.string('is member');
-    });
-
-    it('filters public guilds by single-word search term', async () => {
-      const guilds = await user.get('/groups?type=publicGuilds&search=kom');
-      expect(guilds.length).to.equal(1);
-      expect(guilds[0].summary).to.have.string('ohayou kombonwa');
-    });
-
-    it('filters public guilds by single-word search term left and right-padded by spaces', async () => {
-      const guilds = await user.get('/groups?type=publicGuilds&search=++++ohayou+kombonwa+++++');
-      expect(guilds.length).to.equal(1);
-      expect(guilds[0].summary).to.have.string('ohayou kombonwa');
-    });
-
-    it('filters public guilds by two-words search term separated by multiple spaces', async () => {
-      const guilds = await user.get('/groups?type=publicGuilds&search=kinnosuke+++++hon');
-      expect(guilds.length).to.equal(1);
-      expect(guilds[0].description).to.have.string('Kinnosuke');
-    });
-  });
-
-  describe('public guilds pagination', () => {
-    it('req.query.paginate must be a boolean string', async () => {
-      await expect(user.get('/groups?paginate=aString&type=publicGuilds'))
-        .to.eventually.be.rejected.and.eql({
-          code: 400,
-          error: 'BadRequest',
-          message: 'Invalid request parameters.',
-        });
-    });
-
-    it('req.query.paginate can only be true when req.query.type includes publicGuilds', async () => {
-      await expect(user.get('/groups?paginate=true&type=notPublicGuilds'))
-        .to.eventually.be.rejected.and.eql({
-          code: 400,
-          error: 'BadRequest',
-          message: apiError('guildsOnlyPaginate'),
-        });
-    });
-
-    it('req.query.page can\'t be negative', async () => {
-      await expect(user.get('/groups?paginate=true&page=-1&type=publicGuilds'))
-        .to.eventually.be.rejected.and.eql({
-          code: 400,
-          error: 'BadRequest',
-          message: 'Invalid request parameters.',
-        });
-    });
-
-    it('returns 30 guilds per page ordered by number of members', async () => {
-      await user.update({ balance: 9000 });
-      const delay = () => new Promise(resolve => setTimeout(resolve, 40));
-      const promises = [];
-
-      for (let i = 0; i < 60; i += 1) {
-        promises.push(generateGroup(user, {
-          name: `public guild ${i} - is member`,
-          type: 'guild',
-          privacy: 'public',
-        }));
-        await delay(); // eslint-disable-line no-await-in-loop
-      }
-
-      const groups = await Promise.all(promises);
-
-      // update group number 32 and not the first to make sure sorting works
-      await groups[32].update({ name: 'guild with most members', memberCount: 199 });
-      await groups[33].update({ name: 'guild with less members', memberCount: -100 });
-
-      const page0 = await expect(user.get('/groups?type=publicGuilds&paginate=true'))
-        .to.eventually.have.a.lengthOf(GUILD_PER_PAGE);
-      expect(page0[0].name).to.equal('guild with most members');
-
-      await expect(user.get('/groups?type=publicGuilds&paginate=true&page=1'))
-        .to.eventually.have.a.lengthOf(GUILD_PER_PAGE);
-      const page2 = await expect(user.get('/groups?type=publicGuilds&paginate=true&page=2'))
-        // 1 created now, 4 by other tests, -1 for no more tavern.
-        .to.eventually.have.a.lengthOf(1 + 4 - 1);
-      expect(page2[3].name).to.equal('guild with less members');
-    }).timeout(10000);
-  });
-
-  it('makes sure that the tavern doesn\'t show up when guilds is passed as a query', async () => {
-    const guilds = await user.get('/groups?type=guilds');
-    expect(guilds.find(g => g.id === TAVERN_ID)).to.be.undefined;
-  });
-
-  it('makes sure that the tavern doesn\'t show up when publicGuilds is passed as a query', async () => {
-    const guilds = await user.get('/groups?type=publicGuilds');
-    expect(guilds.find(g => g.id === TAVERN_ID)).to.be.undefined;
-  });
-
   it('returns all the user\'s guilds when guilds passed in as query', async () => {
     await expect(user.get('/groups?type=guilds'))
       .to.eventually.have.a
-      .lengthOf(NUMBER_OF_PUBLIC_GUILDS_USER_IS_MEMBER + NUMBER_OF_USERS_PRIVATE_GUILDS);
+      .lengthOf(NUMBER_OF_USERS_PRIVATE_GUILDS);
   });
 
   it('returns all private guilds user is a part of when privateGuilds passed in as query', async () => {
@@ -272,21 +109,21 @@ describe('GET /groups', () => {
   });
 
   it('returns a list of groups user has access to', async () => {
-    await expect(user.get('/groups?type=privateGuilds,publicGuilds,party,tavern'))
-      .to.eventually.have.lengthOf(NUMBER_OF_GROUPS_USER_CAN_VIEW - 1); // -1 for no Tavern.
+    await expect(user.get('/groups?type=privateGuilds,party'))
+      .to.eventually.have.lengthOf(NUMBER_OF_GROUPS_USER_CAN_VIEW);
   });
 
-  it('returns a list of groups user has access to', async () => {
-    const group = await generateGroup(user, {
-      name: 'c++ coders',
-      type: 'guild',
-      privacy: 'public',
+  describe('filters', () => {
+    it('returns private guilds filtered by category', async () => {
+      const guilds = await user.get(`/groups?type=privateGuilds&categories=${categories[0].slug}`);
+
+      expect(guilds[0]._id).to.equal(privateGuildUserIsMemberOf._id);
     });
 
-    // search for 'c++ coders'
-    await expect(user.get('/groups?type=publicGuilds&paginate=true&page=0&search=c%2B%2B+coders'))
-      .to.eventually.have.lengthOf(1)
-      .and.to.have.nested.property('[0]')
-      .and.to.have.property('_id', group._id);
+    it('filters private guilds by size', async () => {
+      const guilds = await user.get('/groups?type=privateGuilds&minMemberCount=3');
+
+      expect(guilds.length).to.equal(0);
+    });
   });
 });

test/api/v3/integration/groups/GET-groups_groupId_invites.test.js

@@ -3,6 +3,7 @@ import {
   generateUser,
   generateGroup,
   translate as t,
+  createAndPopulateGroup,
 } from '../../../../helpers/api-integration/v3';
 
 describe('GET /groups/:groupId/invites', () => {
@@ -71,15 +72,16 @@ describe('GET /groups/:groupId/invites', () => {
   });
 
   it('returns only first 30 invites by default (req.query.limit not specified)', async () => {
-    const leader = await generateUser({ balance: 4 });
-    const group = await generateGroup(leader, { type: 'guild', privacy: 'public', name: generateUUID() });
-
-    const invitesToGenerate = [];
-    for (let i = 0; i < 31; i += 1) {
-      invitesToGenerate.push(generateUser());
-    }
-    const generatedInvites = await Promise.all(invitesToGenerate);
-    await leader.post(`/groups/${group._id}/invite`, { uuids: generatedInvites.map(invite => invite._id) });
+    const { group, groupLeader: leader } = await createAndPopulateGroup({
+      groupDetails: {
+        type: 'guild',
+        privacy: 'private',
+        name: generateUUID(),
+      },
+      leaderDetails: { balance: 4 },
+      invites: 31,
+      upgradeToGroupPlan: true,
+    });
 
     const res = await leader.get(`/groups/${group._id}/invites`);
     expect(res.length).to.equal(30);
@@ -90,8 +92,16 @@ describe('GET /groups/:groupId/invites', () => {
   }).timeout(10000);
 
   it('returns an error if req.query.limit is over 60', async () => {
-    const leader = await generateUser({ balance: 4 });
-    const group = await generateGroup(leader, { type: 'guild', privacy: 'public', name: generateUUID() });
+    const { group, groupLeader: leader } = await createAndPopulateGroup({
+      groupDetails: {
+        type: 'guild',
+        privacy: 'private',
+        name: generateUUID(),
+      },
+      leaderDetails: { balance: 4 },
+      invites: 1,
+      upgradeToGroupPlan: true,
+    });
 
     await expect(leader.get(`/groups/${group._id}/invites?limit=61`)).to.eventually.be.rejected.and.eql({
       code: 400,
@@ -101,8 +111,16 @@ describe('GET /groups/:groupId/invites', () => {
   });
 
   it('returns an error if req.query.limit is under 1', async () => {
-    const leader = await generateUser({ balance: 4 });
-    const group = await generateGroup(leader, { type: 'guild', privacy: 'public', name: generateUUID() });
+    const { group, groupLeader: leader } = await createAndPopulateGroup({
+      groupDetails: {
+        type: 'guild',
+        privacy: 'private',
+        name: generateUUID(),
+      },
+      leaderDetails: { balance: 4 },
+      invites: 1,
+      upgradeToGroupPlan: true,
+    });
 
     await expect(leader.get(`/groups/${group._id}/invites?limit=-1`)).to.eventually.be.rejected.and.eql({
       code: 400,
@@ -112,8 +130,16 @@ describe('GET /groups/:groupId/invites', () => {
   });
 
   it('returns an error if req.query.limit is not an integer', async () => {
-    const leader = await generateUser({ balance: 4 });
-    const group = await generateGroup(leader, { type: 'guild', privacy: 'public', name: generateUUID() });
+    const { group, groupLeader: leader } = await createAndPopulateGroup({
+      groupDetails: {
+        type: 'guild',
+        privacy: 'private',
+        name: generateUUID(),
+      },
+      leaderDetails: { balance: 4 },
+      invites: 1,
+      upgradeToGroupPlan: true,
+    });
 
     await expect(leader.get(`/groups/${group._id}/invites?limit=1.3`)).to.eventually.be.rejected.and.eql({
       code: 400,
@@ -123,15 +149,16 @@ describe('GET /groups/:groupId/invites', () => {
   });
 
   it('returns up to 60 invites when req.query.limit is specified', async () => {
-    const leader = await generateUser({ balance: 4 });
-    const group = await generateGroup(leader, { type: 'guild', privacy: 'public', name: generateUUID() });
-
-    const invitesToGenerate = [];
-    for (let i = 0; i < 31; i += 1) {
-      invitesToGenerate.push(generateUser());
-    }
-    const generatedInvites = await Promise.all(invitesToGenerate);
-    await leader.post(`/groups/${group._id}/invite`, { uuids: generatedInvites.map(invite => invite._id) });
+    const { group, groupLeader: leader } = await createAndPopulateGroup({
+      groupDetails: {
+        type: 'guild',
+        privacy: 'private',
+        name: generateUUID(),
+      },
+      leaderDetails: { balance: 4 },
+      invites: 31,
+      upgradeToGroupPlan: true,
+    });
 
     let res = await leader.get(`/groups/${group._id}/invites?limit=14`);
     expect(res.length).to.equal(14);
@@ -149,17 +176,20 @@ describe('GET /groups/:groupId/invites', () => {
   }).timeout(30000);
 
   it('supports using req.query.lastId to get more invites', async function test () {
+    let group; let invitees;
     this.timeout(30000); // @TODO: times out after 8 seconds
-    const leader = await generateUser({ balance: 4 });
-    const group = await generateGroup(leader, { type: 'guild', privacy: 'public', name: generateUUID() });
+    ({ group, groupLeader: user, invitees } = await createAndPopulateGroup({
+      groupDetails: {
+        type: 'guild',
+        privacy: 'private',
+        name: generateUUID(),
+      },
+      leaderDetails: { balance: 4 },
+      invites: 32,
+      upgradeToGroupPlan: true,
+    }));
 
-    const invitesToGenerate = [];
-    for (let i = 0; i < 32; i += 1) {
-      invitesToGenerate.push(generateUser());
-    }
-    const generatedInvites = await Promise.all(invitesToGenerate); // Group has 32 invites
-    const expectedIds = generatedInvites.map(generatedInvite => generatedInvite._id);
-    await user.post(`/groups/${group._id}/invite`, { uuids: expectedIds });
+    const expectedIds = invitees.map(generatedInvite => generatedInvite._id);
 
     const res = await user.get(`/groups/${group._id}/invites`);
     expect(res.length).to.equal(30);

test/api/v3/integration/groups/GET-groups_groupId_members.test.js

@@ -1,5 +1,6 @@
 import { v4 as generateUUID } from 'uuid';
 import {
+  createAndPopulateGroup,
   generateUser,
   generateGroup,
   translate as t,
@@ -75,7 +76,15 @@ describe('GET /groups/:groupId/members', () => {
   });
 
   it('req.query.includeAllPublicFields === true works with guilds', async () => {
-    const group = await generateGroup(user, { type: 'guild', name: generateUUID() });
+    let group;
+    ({ group, groupLeader: user } = await createAndPopulateGroup({
+      type: 'guild',
+      privacy: 'private',
+      name: generateUUID(),
+      upgradeToGroupPlan: true,
+      members: 1,
+    }));
+
     const [memberRes] = await user.get(`/groups/${group._id}/members?includeAllPublicFields=true`);
 
     expect(memberRes).to.have.all.keys([ // works as: object has all and only these keys
@@ -206,20 +215,20 @@ describe('GET /groups/:groupId/members', () => {
 
   it('supports using req.query.lastId to get more members', async function test () {
     this.timeout(30000); // @TODO: times out after 8 seconds
-    const leader = await generateUser({ balance: 4 });
-    const group = await generateGroup(leader, { type: 'guild', privacy: 'public', name: generateUUID() });
+    const { group, groupLeader: leader, members: generatedUsers } = await createAndPopulateGroup({
+      type: 'guild',
+      privacy: 'private',
+      name: generateUUID(),
+      upgradeToGroupPlan: true,
+      leaderDetails: { balance: 4 },
+      members: 57,
+    });
 
-    const usersToGenerate = [];
-    for (let i = 0; i < 57; i += 1) {
-      usersToGenerate.push(generateUser({ guilds: [group._id] }));
-    }
-    // Group has 59 members (1 is the leader)
-    const generatedUsers = await Promise.all(usersToGenerate);
     const expectedIds = [leader._id].concat(generatedUsers.map(generatedUser => generatedUser._id));
 
-    const res = await user.get(`/groups/${group._id}/members`);
+    const res = await leader.get(`/groups/${group._id}/members`);
     expect(res.length).to.equal(30);
-    const res2 = await user.get(`/groups/${group._id}/members?lastId=${res[res.length - 1]._id}`);
+    const res2 = await leader.get(`/groups/${group._id}/members?lastId=${res[res.length - 1]._id}`);
     expect(res2.length).to.equal(28);
 
     const resIds = res.concat(res2).map(member => member._id);

test/api/v3/integration/groups/GET-groups_id.test.js

@@ -11,7 +11,6 @@ import {
 
 describe('GET /groups/:id', () => {
   const typesOfGroups = {};
-  typesOfGroups['public guild'] = { type: 'guild', privacy: 'public' };
   typesOfGroups['private guild'] = { type: 'guild', privacy: 'private' };
   typesOfGroups.party = { type: 'party', privacy: 'private' };
 
@@ -24,10 +23,11 @@ describe('GET /groups/:id', () => {
         const groupData = await createAndPopulateGroup({
           members: 30,
           groupDetails,
+          upgradeToGroupPlan: groupDetails.type === 'guild',
         });
 
         leader = groupData.groupLeader;
-        member = groupData.members[0]; // eslint-disable-line prefer-destructuring
+        [member] = groupData.members;
         createdGroup = groupData.group;
       });
 
@@ -49,34 +49,6 @@ describe('GET /groups/:id', () => {
     });
   });
 
-  context('Non-member of a public guild', () => {
-    let nonMember; let
-      createdGroup;
-
-    before(async () => {
-      const groupData = await createAndPopulateGroup({
-        members: 1,
-        groupDetails: {
-          name: 'test guild',
-          type: 'guild',
-          privacy: 'public',
-        },
-      });
-
-      createdGroup = groupData.group;
-      nonMember = await generateUser();
-    });
-
-    it('returns the group object for a non-member', async () => {
-      const group = await nonMember.get(`/groups/${createdGroup._id}`);
-
-      expect(group._id).to.eql(createdGroup._id);
-      expect(group.name).to.eql(createdGroup.name);
-      expect(group.type).to.eql(createdGroup.type);
-      expect(group.privacy).to.eql(createdGroup.privacy);
-    });
-  });
-
   context('Non-member of a private guild', () => {
     let nonMember; let
       createdGroup;
@@ -89,6 +61,7 @@ describe('GET /groups/:id', () => {
           type: 'guild',
           privacy: 'private',
         },
+        upgradeToGroupPlan: true,
       });
 
       createdGroup = groupData.group;
@@ -218,7 +191,7 @@ describe('GET /groups/:id', () => {
   });
 
   context('Flagged messages', () => {
-    let group;
+    let group; let members;
 
     const chat1 = {
       id: 'chat1',
@@ -268,7 +241,7 @@ describe('GET /groups/:id', () => {
         groupDetails: {
           name: 'test guild',
           type: 'guild',
-          privacy: 'public',
+          privacy: 'private',
           chat: [
             chat1,
             chat2,
@@ -277,9 +250,11 @@ describe('GET /groups/:id', () => {
             chat5,
           ],
         },
+        members: 1,
+        upgradeToGroupPlan: true,
       });
 
-      group = groupData.group;
+      ({ group, members } = groupData);
 
       await group.addChat([chat1, chat2, chat3, chat4, chat5]);
     });
@@ -287,8 +262,8 @@ describe('GET /groups/:id', () => {
     context('non-admin', () => {
       let nonAdmin;
 
-      beforeEach(async () => {
-        nonAdmin = await generateUser();
+      beforeEach(() => {
+        [nonAdmin] = members;
       });
 
       it('does not include messages with a flag count of 2 or greater', async () => {
@@ -314,9 +289,8 @@ describe('GET /groups/:id', () => {
       let admin;
 
       beforeEach(async () => {
-        admin = await generateUser({
-          'permissions.moderator': true,
-        });
+        [admin] = members;
+        await admin.update({ permissions: { moderator: true } });
       });
 
       it('includes all messages', async () => {

test/api/v3/integration/groups/POST-group_remove_manager.test.js

@@ -1,4 +1,3 @@
-import { find } from 'lodash';
 import {
   createAndPopulateGroup,
   translate as t,
@@ -11,10 +10,6 @@ describe('POST /group/:groupId/remove-manager', () => {
   const groupType = 'guild';
   let nonManager;
 
-  function findAssignedTask (memberTask) {
-    return memberTask.group.id === groupToUpdate._id;
-  }
-
   beforeEach(async () => {
     const { group, groupLeader, members } = await createAndPopulateGroup({
       groupDetails: {
@@ -63,28 +58,4 @@ describe('POST /group/:groupId/remove-manager', () => {
 
     expect(updatedGroup.managers[nonLeader._id]).to.not.exist;
   });
-
-  it('removes group approval notifications from a manager that is removed', async () => {
-    await leader.post(`/groups/${groupToUpdate._id}/add-manager`, {
-      managerId: nonLeader._id,
-    });
-    const task = await leader.post(`/tasks/group/${groupToUpdate._id}`, {
-      text: 'test todo',
-      type: 'todo',
-      requiresApproval: true,
-    });
-    await nonLeader.post(`/tasks/${task._id}/assign/${nonManager._id}`);
-    const memberTasks = await nonManager.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-    await nonManager.post(`/tasks/${syncedTask._id}/score/up`);
-
-    const updatedGroup = await leader.post(`/groups/${groupToUpdate._id}/remove-manager`, {
-      managerId: nonLeader._id,
-    });
-
-    await nonLeader.sync();
-
-    expect(nonLeader.notifications.length).to.equal(1); // user gets mystery items
-    expect(updatedGroup.managers[nonLeader._id]).to.not.exist;
-  });
 });

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

@@ -2,7 +2,7 @@ import {
   generateUser,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
-import { model as Group } from '../../../../../website/server/models/group';
+import { MAX_SUMMARY_SIZE_FOR_GUILDS } from '../../../../../website/common/script/constants';
 
 describe('POST /group', () => {
   let user;
@@ -34,8 +34,8 @@ describe('POST /group', () => {
 
     it('sets the group leader to the user who created the group', async () => {
       const group = await user.post('/groups', {
-        name: 'Test Public Guild',
-        type: 'guild',
+        name: 'Test Party',
+        type: 'party',
       });
 
       expect(group.leader).to.eql({
@@ -50,7 +50,7 @@ describe('POST /group', () => {
       const name = 'Test Group';
       const group = await user.post('/groups', {
         name,
-        type: 'guild',
+        type: 'party',
       });
 
       const updatedGroup = await user.get(`/groups/${group._id}`);
@@ -63,7 +63,7 @@ describe('POST /group', () => {
       const summary = 'Test Summary';
       const group = await user.post('/groups', {
         name,
-        type: 'guild',
+        type: 'party',
         summary,
       });
 
@@ -71,155 +71,18 @@ describe('POST /group', () => {
 
       expect(updatedGroup.summary).to.eql(summary);
     });
-  });
 
-  context('Guilds', () => {
-    it('returns an error when a user with insufficient funds attempts to create a guild', async () => {
-      await user.update({ balance: 0 });
-
-      await expect(
-        user.post('/groups', {
-          name: 'Test Public Guild',
-          type: 'guild',
-        }),
-      ).to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('messageInsufficientGems'),
-      });
-    });
-
-    it('adds guild to user\'s list of guilds', async () => {
-      const guild = await user.post('/groups', {
-        name: 'some guild',
-        type: 'guild',
-        privacy: 'public',
-      });
-
-      const updatedUser = await user.get('/user');
-
-      expect(updatedUser.guilds).to.include(guild._id);
-    });
-
-    it('awards the Joined Guild achievement', async () => {
-      await user.post('/groups', {
-        name: 'some guild',
-        type: 'guild',
-        privacy: 'public',
-      });
-
-      const updatedUser = await user.get('/user');
-
-      expect(updatedUser.achievements.joinedGuild).to.eql(true);
-    });
-
-    context('public guild', () => {
-      it('creates a group', async () => {
-        const groupName = 'Test Public Guild';
-        const groupType = 'guild';
-        const groupPrivacy = 'public';
-
-        const publicGuild = await user.post('/groups', {
-          name: groupName,
-          type: groupType,
-          privacy: groupPrivacy,
-        });
-
-        expect(publicGuild._id).to.exist;
-        expect(publicGuild.name).to.equal(groupName);
-        expect(publicGuild.type).to.equal(groupType);
-        expect(publicGuild.memberCount).to.equal(1);
-        expect(publicGuild.privacy).to.equal(groupPrivacy);
-        expect(publicGuild.leader).to.eql({
-          _id: user._id,
-          profile: {
-            name: user.profile.name,
-          },
-        });
-      });
-
-      it('returns an error when a user with no chat privileges attempts to create a public guild', async () => {
-        await user.update({ 'flags.chatRevoked': true });
-
-        await expect(
-          user.post('/groups', {
-            name: 'Test Public Guild',
-            type: 'guild',
-            privacy: 'public',
-          }),
-        ).to.eventually.be.rejected.and.eql({
-          code: 401,
-          error: 'NotAuthorized',
-          message: t('chatPrivilegesRevoked'),
-        });
-      });
-    });
-
-    context('private guild', () => {
-      const groupName = 'Test Private Guild';
-      const groupType = 'guild';
-      const groupPrivacy = 'private';
-
-      it('creates a group', async () => {
-        const privateGuild = await user.post('/groups', {
-          name: groupName,
-          type: groupType,
-          privacy: groupPrivacy,
-        });
-
-        expect(privateGuild._id).to.exist;
-        expect(privateGuild.name).to.equal(groupName);
-        expect(privateGuild.type).to.equal(groupType);
-        expect(privateGuild.memberCount).to.equal(1);
-        expect(privateGuild.privacy).to.equal(groupPrivacy);
-        expect(privateGuild.leader).to.eql({
-          _id: user._id,
-          profile: {
-            name: user.profile.name,
-          },
-        });
-      });
-
-      it('creates a private guild when the user has no chat privileges', async () => {
-        await user.update({ 'flags.chatRevoked': true });
-        const privateGuild = await user.post('/groups', {
-          name: groupName,
-          type: groupType,
-          privacy: groupPrivacy,
-        });
-
-        expect(privateGuild._id).to.exist;
-      });
-
-      it('deducts gems from user and adds them to guild bank', async () => {
-        const privateGuild = await user.post('/groups', {
-          name: groupName,
-          type: groupType,
-          privacy: groupPrivacy,
-        });
-
-        expect(privateGuild.balance).to.eql(1);
-
-        const updatedUser = await user.get('/user');
-
-        expect(updatedUser.balance).to.eql(user.balance - 1);
-      });
-
-      it('does not deduct the gems from user when guild creation fails', async () => {
-        const stub = sinon.stub(Group.prototype, 'save').rejects();
-        const promise = user.post('/groups', {
-          name: groupName,
-          type: groupType,
-          privacy: groupPrivacy,
-        });
-
-        await expect(promise).to.eventually.be.rejected;
-
-        const updatedUser = await user.get('/user');
-
-        expect(updatedUser.balance).to.eql(user.balance);
-
-        stub.restore();
+    it('returns error when summary is longer than MAX_SUMMARY_SIZE_FOR_GUILDS characters', async () => {
+      const name = 'Test Group';
+      const summary = 'A'.repeat(MAX_SUMMARY_SIZE_FOR_GUILDS + 1);
+      await expect(user.post('/groups', {
+        name,
+        type: 'party',
+        summary,
+      })).to.eventually.be.rejected.and.eql({
+        code: 400,
+        error: 'BadRequest',
+        message: t('invalidReqParams'),
       });
     });
   });

test/api/v3/integration/groups/POST-groups_groupId_join.test.js

@@ -2,7 +2,6 @@ import { v4 as generateUUID } from 'uuid';
 import {
   generateUser,
   createAndPopulateGroup,
-  checkExistence,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
 
@@ -19,81 +18,24 @@ describe('POST /group/:groupId/join', () => {
     });
   });
 
-  context('Joining a public guild', () => {
-    let user; let joiningUser; let
-      publicGuild;
-
-    beforeEach(async () => {
-      const { group, groupLeader } = await createAndPopulateGroup({
-        groupDetails: {
-          name: 'Test Guild',
-          type: 'guild',
-          privacy: 'public',
-        },
-      });
-
-      publicGuild = group;
-      user = groupLeader;
-      joiningUser = await generateUser();
-    });
-
-    it('allows non-invited users to join public guilds', async () => {
-      const res = await joiningUser.post(`/groups/${publicGuild._id}/join`);
-
-      await expect(joiningUser.get('/user')).to.eventually.have.property('guilds').to.include(publicGuild._id);
-      expect(res.leader._id).to.eql(user._id);
-      expect(res.leader.profile.name).to.eql(user.profile.name);
-    });
-
-    it('returns an error if user was already a member', async () => {
-      await joiningUser.post(`/groups/${publicGuild._id}/join`);
-      await expect(joiningUser.post(`/groups/${publicGuild._id}/join`)).to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('youAreAlreadyInGroup'),
-      });
-    });
-
-    it('promotes joining member in a public empty guild to leader', async () => {
-      await user.post(`/groups/${publicGuild._id}/leave`);
-
-      await joiningUser.post(`/groups/${publicGuild._id}/join`);
-
-      await expect(joiningUser.get(`/groups/${publicGuild._id}`)).to.eventually.have.nested.property('leader._id', joiningUser._id);
-    });
-
-    it('increments memberCount when joining guilds', async () => {
-      const oldMemberCount = publicGuild.memberCount;
-
-      await joiningUser.post(`/groups/${publicGuild._id}/join`);
-
-      await expect(joiningUser.get(`/groups/${publicGuild._id}`)).to.eventually.have.property('memberCount', oldMemberCount + 1);
-    });
-
-    it('awards Joined Guild achievement', async () => {
-      await joiningUser.post(`/groups/${publicGuild._id}/join`);
-
-      await expect(joiningUser.get('/user')).to.eventually.have.nested.property('achievements.joinedGuild', true);
-    });
-  });
-
   context('Joining a private guild', () => {
-    let user; let invitedUser; let
-      guild;
+    let user;
+    let invitedUser;
+    let guild;
+    let invitees;
 
     beforeEach(async () => {
-      const { group, groupLeader, invitees } = await createAndPopulateGroup({
+      ({ group: guild, groupLeader: user, invitees } = await createAndPopulateGroup({
         groupDetails: {
           name: 'Test Guild',
           type: 'guild',
           privacy: 'private',
         },
         invites: 1,
-      });
+        upgradeToGroupPlan: true,
+      }));
 
-      guild = group;
-      user = groupLeader;
-      invitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
+      [invitedUser] = invitees;
     });
 
     it('returns error when user is not invited to private guild', async () => {
@@ -183,7 +125,7 @@ describe('POST /group/:groupId/join', () => {
 
       party = group;
       user = groupLeader;
-      invitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
+      [invitedUser] = invitees;
     });
 
     it('returns error when user is not invited to party', async () => {
@@ -258,47 +200,6 @@ describe('POST /group/:groupId/join', () => {
         await expect(user.get('/user')).to.eventually.have.nested.property('items.quests.basilist', 2);
       });
 
-      it('deletes previous party where the user was the only member', async () => {
-        const userToInvite = await generateUser();
-        const oldParty = await userToInvite.post('/groups', { // add user to a party
-          name: 'Another Test Party',
-          type: 'party',
-        });
-
-        await expect(checkExistence('groups', oldParty._id)).to.eventually.equal(true);
-        await user.post(`/groups/${party._id}/invite`, {
-          uuids: [userToInvite._id],
-        });
-        await userToInvite.post(`/groups/${party._id}/join`);
-
-        await expect(user.get('/user')).to.eventually.have.nested.property('party._id', party._id);
-        await expect(checkExistence('groups', oldParty._id)).to.eventually.equal(false);
-      });
-
-      it('does not allow user to leave a party if a quest was active and they were the only member', async () => {
-        const userToInvite = await generateUser();
-        const oldParty = await userToInvite.post('/groups', { // add user to a party
-          name: 'Another Test Party',
-          type: 'party',
-        });
-
-        await userToInvite.update({
-          [`items.quests.${PET_QUEST}`]: 1,
-        });
-        await userToInvite.post(`/groups/${oldParty._id}/quests/invite/${PET_QUEST}`);
-
-        await expect(checkExistence('groups', oldParty._id)).to.eventually.equal(true);
-        await user.post(`/groups/${party._id}/invite`, {
-          uuids: [userToInvite._id],
-        });
-
-        await expect(userToInvite.post(`/groups/${party._id}/join`)).to.eventually.be.rejected.and.eql({
-          code: 401,
-          error: 'NotAuthorized',
-          message: t('messageCannotLeaveWhileQuesting'),
-        });
-      });
-
       it('invites joining member to active quest', async () => {
         await user.update({
           [`items.quests.${PET_QUEST}`]: 1,

test/api/v3/integration/groups/POST-groups_groupId_leave.test.js

@@ -5,7 +5,6 @@ import {
   generateChallenge,
   checkExistence,
   createAndPopulateGroup,
-  sleep,
   generateUser,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
@@ -14,248 +13,187 @@ import payments from '../../../../../website/server/libs/payments/payments';
 import calculateSubscriptionTerminationDate from '../../../../../website/server/libs/payments/calculateSubscriptionTerminationDate';
 
 describe('POST /groups/:groupId/leave', () => {
-  const typesOfGroups = {
-    'public guild': { type: 'guild', privacy: 'public' },
-    'private guild': { type: 'guild', privacy: 'private' },
-    party: { type: 'party', privacy: 'private' },
-  };
+  let groupToLeave;
+  let leader;
+  let member;
+  let members;
+  let memberCount;
 
-  each(typesOfGroups, (groupDetails, groupType) => {
-    context(`Leaving a ${groupType}`, () => {
-      let groupToLeave;
-      let leader;
-      let member;
-      let memberCount;
+  context('Leaving a Group Plan', () => {
+    beforeEach(async () => {
+      ({ group: groupToLeave, groupLeader: leader, members } = await createAndPopulateGroup({
+        type: 'guild',
+        privacy: 'private',
+        members: 1,
+        upgradeToGroupPlan: true,
+      }));
+
+      [member] = members;
+      memberCount = groupToLeave.memberCount;
+      await leader.update({ 'auth.timestamps.created': new Date('2022-01-01') });
+    });
+
+    it('prevents non members from leaving', async () => {
+      const user = await generateUser();
+      await expect(user.post(`/groups/${groupToLeave._id}/leave`)).to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('groupNotFound'),
+      });
+    });
+
+    it('lets user leave', async () => {
+      await member.post(`/groups/${groupToLeave._id}/leave`);
+
+      const userThatLeftGroup = await member.get('/user');
+
+      expect(userThatLeftGroup.guilds).to.be.empty;
+      expect(userThatLeftGroup.party._id).to.not.exist;
+      await groupToLeave.sync();
+      expect(groupToLeave.memberCount).to.equal(memberCount - 1);
+    });
+
+    it('removes new messages for that group from user', async () => {
+      await leader.post(`/groups/${groupToLeave._id}/chat`, { message: 'Some message' });
+      await member.sync();
+
+      expect(member.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupToLeave._id)).to.exist;
+      expect(member.newMessages[groupToLeave._id]).to.not.be.empty;
+
+      await member.post(`/groups/${groupToLeave._id}/leave`);
+      await member.sync();
+
+      expect(member.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupToLeave._id)).to.not.exist;
+      expect(member.newMessages[groupToLeave._id]).to.be.undefined;
+    });
+
+    context('with challenges', () => {
+      let challenge;
 
       beforeEach(async () => {
-        const { group, groupLeader, members } = await createAndPopulateGroup({
-          groupDetails,
-          members: 1,
-        });
+        challenge = await generateChallenge(leader, groupToLeave);
+        await member.post(`/challenges/${challenge._id}/join`);
 
-        groupToLeave = group;
-        leader = groupLeader;
-        member = members[0]; // eslint-disable-line prefer-destructuring
-        memberCount = group.memberCount;
-      });
-
-      it('prevents non members from leaving', async () => {
-        const user = await generateUser();
-        await expect(user.post(`/groups/${groupToLeave._id}/leave`)).to.eventually.be.rejected.and.eql({
-          code: 404,
-          error: 'NotFound',
-          message: t('groupNotFound'),
+        await leader.post(`/tasks/challenge/${challenge._id}`, {
+          text: 'test habit',
+          type: 'habit',
         });
       });
 
-      it(`lets user leave a ${groupType}`, async () => {
+      it('removes all challenge tasks when keep parameter is set to remove', async () => {
+        await member.post(`/groups/${groupToLeave._id}/leave?keep=remove-all`);
+
+        const userWithoutChallengeTasks = await member.get('/user');
+
+        expect(userWithoutChallengeTasks.challenges).to.not.include(challenge._id);
+        expect(userWithoutChallengeTasks.tasksOrder.habits).to.be.empty;
+      });
+
+      it('keeps all challenge tasks when keep parameter is not set', async () => {
         await member.post(`/groups/${groupToLeave._id}/leave`);
 
-        const userThatLeftGroup = await member.get('/user');
+        const userWithChallengeTasks = await member.get('/user');
 
-        expect(userThatLeftGroup.guilds).to.be.empty;
-        expect(userThatLeftGroup.party._id).to.not.exist;
-        await groupToLeave.sync();
-        expect(groupToLeave.memberCount).to.equal(memberCount - 1);
+        expect(userWithChallengeTasks.tasksOrder.habits).to.not.be.empty;
       });
 
-      it(`sets a new group leader when leader leaves a ${groupType}`, async () => {
-        await leader.post(`/groups/${groupToLeave._id}/leave`);
+      it('keeps the user in the challenge when the keepChallenges parameter is set to remain-in-challenges', async () => {
+        await member.post(`/groups/${groupToLeave._id}/leave`, { keepChallenges: 'remain-in-challenges' });
 
-        await groupToLeave.sync();
-        expect(groupToLeave.memberCount).to.equal(memberCount - 1);
-        expect(groupToLeave.leader).to.equal(member._id);
+        const userWithChallengeTasks = await member.get('/user');
+
+        expect(userWithChallengeTasks.challenges).to.include(challenge._id);
       });
 
-      it('removes new messages for that group from user', async () => {
-        await member.post(`/groups/${groupToLeave._id}/chat`, { message: 'Some message' });
+      it('drops the user in the challenge when the keepChallenges parameter isn\'t set', async () => {
+        await member.post(`/groups/${groupToLeave._id}/leave`);
 
-        await sleep(0.5);
+        const userWithChallengeTasks = await member.get('/user');
 
-        await leader.sync();
-
-        expect(leader.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupToLeave._id)).to.exist;
-        expect(leader.newMessages[groupToLeave._id]).to.not.be.empty;
-
-        await leader.post(`/groups/${groupToLeave._id}/leave`);
-        await leader.sync();
-
-        expect(leader.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupToLeave._id)).to.not.exist;
-        expect(leader.newMessages[groupToLeave._id]).to.be.undefined;
+        expect(userWithChallengeTasks.challenges).to.not.include(challenge._id);
       });
-
-      context('with challenges', () => {
-        let challenge;
-
-        beforeEach(async () => {
-          challenge = await generateChallenge(leader, groupToLeave);
-          await leader.post(`/challenges/${challenge._id}/join`);
-
-          await leader.post(`/tasks/challenge/${challenge._id}`, {
-            text: 'test habit',
-            type: 'habit',
-          });
-
-          await sleep(0.5);
-        });
-
-        it('removes all challenge tasks when keep parameter is set to remove', async () => {
-          await leader.post(`/groups/${groupToLeave._id}/leave?keep=remove-all`);
-
-          const userWithoutChallengeTasks = await leader.get('/user');
-
-          expect(userWithoutChallengeTasks.challenges).to.not.include(challenge._id);
-          expect(userWithoutChallengeTasks.tasksOrder.habits).to.be.empty;
-        });
-
-        it('keeps all challenge tasks when keep parameter is not set', async () => {
-          await leader.post(`/groups/${groupToLeave._id}/leave`);
-
-          const userWithChallengeTasks = await leader.get('/user');
-
-          // @TODO find elegant way to assert against the task existing
-          expect(userWithChallengeTasks.tasksOrder.habits).to.not.be.empty;
-        });
-
-        it('keeps the user in the challenge when the keepChallenges parameter is set to remain-in-challenges', async () => {
-          await leader.post(`/groups/${groupToLeave._id}/leave`, { keepChallenges: 'remain-in-challenges' });
-
-          const userWithChallengeTasks = await leader.get('/user');
-
-          expect(userWithChallengeTasks.challenges).to.include(challenge._id);
-        });
-
-        it('drops the user in the challenge when the keepChallenges parameter isn\'t set', async () => {
-          await leader.post(`/groups/${groupToLeave._id}/leave`);
-
-          const userWithChallengeTasks = await leader.get('/user');
-
-          expect(userWithChallengeTasks.challenges).to.not.include(challenge._id);
-        });
-      });
-
-      it('prevents quest leader from leaving a groupToLeave');
-      it('prevents a user from leaving during an active quest');
     });
   });
 
-  context('Leaving a group as the last member', () => {
-    context('private guild', () => {
-      let privateGuild;
-      let leader;
-      let invitedUser;
+  context('Leaving a Party', () => {
+    let invitees;
+    let invitedUser;
 
-      beforeEach(async () => {
-        const { group, groupLeader, invitees } = await createAndPopulateGroup({
-          groupDetails: {
-            name: 'Test Private Guild',
-            type: 'guild',
-          },
-          invites: 1,
-        });
+    beforeEach(async () => {
+      ({
+        group: groupToLeave,
+        groupLeader: leader,
+        members,
+        invitees,
+      } = await createAndPopulateGroup({
+        type: 'party',
+        privacy: 'private',
+        members: 1,
+        invites: 1,
+      }));
 
-        privateGuild = group;
-        leader = groupLeader;
-        invitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
+      [member] = members;
+      [invitedUser] = invitees;
+      memberCount = groupToLeave.memberCount;
+      await leader.update({ 'auth.timestamps.created': new Date('2022-01-01') });
+    });
 
-        await leader.post(`/groups/${group._id}/chat`, { message: 'Some message' });
-      });
-
-      it('removes a group when the last member leaves', async () => {
-        await leader.post(`/groups/${privateGuild._id}/leave`);
-
-        await expect(checkExistence('groups', privateGuild._id)).to.eventually.equal(false);
-      });
-
-      it('removes invitations when the last member leaves', async () => {
-        await leader.post(`/groups/${privateGuild._id}/leave`);
-
-        const userWithoutInvitation = await invitedUser.get('/user');
-
-        expect(userWithoutInvitation.invitations.guilds).to.be.empty;
+    it('prevents non members from leaving', async () => {
+      const user = await generateUser();
+      await expect(user.post(`/groups/${groupToLeave._id}/leave`)).to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('groupNotFound'),
       });
     });
 
-    context('public guild', () => {
-      let publicGuild;
-      let leader;
-      let invitedUser;
+    it('lets user leave', async () => {
+      await member.post(`/groups/${groupToLeave._id}/leave`);
 
-      beforeEach(async () => {
-        const { group, groupLeader, invitees } = await createAndPopulateGroup({
-          groupDetails: {
-            name: 'Test Public Guild',
-            type: 'guild',
-            privacy: 'public',
-          },
-          invites: 1,
-        });
+      const userThatLeftGroup = await member.get('/user');
 
-        publicGuild = group;
-        leader = groupLeader;
-        invitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
-      });
-
-      it('keeps the group when the last member leaves', async () => {
-        await leader.post(`/groups/${publicGuild._id}/leave`);
-
-        await expect(checkExistence('groups', publicGuild._id)).to.eventually.equal(true);
-      });
-
-      it('keeps the invitations when the last member leaves a public guild', async () => {
-        await leader.post(`/groups/${publicGuild._id}/leave`);
-
-        const userWithoutInvitation = await invitedUser.get('/user');
-
-        expect(userWithoutInvitation.invitations.guilds).to.not.be.empty;
-      });
-
-      it('deletes non existent guild from user when user tries to leave', async () => {
-        const nonExistentGuildId = generateUUID();
-        const userWithNonExistentGuild = await generateUser({ guilds: [nonExistentGuildId] });
-        expect(userWithNonExistentGuild.guilds).to.contain(nonExistentGuildId);
-
-        await expect(userWithNonExistentGuild.post(`/groups/${nonExistentGuildId}/leave`))
-          .to.eventually.be.rejected;
-
-        await userWithNonExistentGuild.sync();
-
-        expect(userWithNonExistentGuild.guilds).to.not.contain(nonExistentGuildId);
-      });
+      expect(userThatLeftGroup.guilds).to.be.empty;
+      expect(userThatLeftGroup.party._id).to.not.exist;
+      await groupToLeave.sync();
+      expect(groupToLeave.memberCount).to.equal(memberCount - 1);
     });
 
-    context('party', () => {
-      let party;
-      let leader;
-      let invitedUser;
+    it('sets a new group leader when leader leaves', async () => {
+      await leader.post(`/groups/${groupToLeave._id}/leave`);
 
-      beforeEach(async () => {
-        const { group, groupLeader, invitees } = await createAndPopulateGroup({
-          groupDetails: {
-            name: 'Test Party',
-            type: 'party',
-          },
-          invites: 1,
-        });
+      await groupToLeave.sync();
+      expect(groupToLeave.memberCount).to.equal(memberCount - 1);
+      expect(groupToLeave.leader).to.equal(member._id);
+    });
 
-        party = group;
-        leader = groupLeader;
-        invitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
-      });
+    it('removes new messages for that group from user', async () => {
+      await leader.post(`/groups/${groupToLeave._id}/chat`, { message: 'Some message' });
+      await member.sync();
 
-      it('removes a group when the last member leaves a party', async () => {
-        await leader.post(`/groups/${party._id}/leave`);
+      expect(member.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupToLeave._id)).to.exist;
+      expect(member.newMessages[groupToLeave._id]).to.not.be.empty;
 
-        await expect(checkExistence('party', party._id)).to.eventually.equal(false);
-      });
+      await member.post(`/groups/${groupToLeave._id}/leave`);
+      await member.sync();
 
-      it('removes invitations when the last member leaves a party', async () => {
-        await leader.post(`/groups/${party._id}/leave`);
+      expect(member.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupToLeave._id)).to.not.exist;
+      expect(member.newMessages[groupToLeave._id]).to.be.undefined;
+    });
 
-        const userWithoutInvitation = await invitedUser.get('/user');
+    it('removes a party when the last member leaves', async () => {
+      await member.post(`/groups/${groupToLeave._id}/leave`);
+      await leader.post(`/groups/${groupToLeave._id}/leave`);
 
-        expect(userWithoutInvitation.invitations.parties[0]).to.be.undefined;
-      });
+      await expect(checkExistence('party', groupToLeave._id)).to.eventually.equal(false);
+    });
+
+    it('removes invitations when the last member leaves a party', async () => {
+      await member.post(`/groups/${groupToLeave._id}/leave`);
+      await leader.post(`/groups/${groupToLeave._id}/leave`);
+
+      const userWithoutInvitation = await invitedUser.get('/user');
+
+      expect(userWithoutInvitation.invitations.parties[0]).to.be.undefined;
     });
 
     it('deletes non existent party from user when user tries to leave', async () => {
@@ -270,23 +208,71 @@ describe('POST /groups/:groupId/leave', () => {
 
       expect(userWithNonExistentParty.party).to.eql({});
     });
+
+    context('with challenges', () => {
+      let challenge;
+
+      beforeEach(async () => {
+        challenge = await generateChallenge(leader, groupToLeave);
+        await member.post(`/challenges/${challenge._id}/join`);
+
+        await leader.post(`/tasks/challenge/${challenge._id}`, {
+          text: 'test habit',
+          type: 'habit',
+        });
+      });
+
+      it('removes all challenge tasks when keep parameter is set to remove', async () => {
+        await member.post(`/groups/${groupToLeave._id}/leave?keep=remove-all`);
+
+        const userWithoutChallengeTasks = await member.get('/user');
+
+        expect(userWithoutChallengeTasks.challenges).to.not.include(challenge._id);
+        expect(userWithoutChallengeTasks.tasksOrder.habits).to.be.empty;
+      });
+
+      it('keeps all challenge tasks when keep parameter is not set', async () => {
+        await member.post(`/groups/${groupToLeave._id}/leave`);
+
+        const userWithChallengeTasks = await member.get('/user');
+
+        expect(userWithChallengeTasks.tasksOrder.habits).to.not.be.empty;
+      });
+
+      it('keeps the user in the challenge when the keepChallenges parameter is set to remain-in-challenges', async () => {
+        await member.post(`/groups/${groupToLeave._id}/leave`, { keepChallenges: 'remain-in-challenges' });
+
+        const userWithChallengeTasks = await member.get('/user');
+
+        expect(userWithChallengeTasks.challenges).to.include(challenge._id);
+      });
+
+      it('drops the user in the challenge when the keepChallenges parameter isn\'t set', async () => {
+        await member.post(`/groups/${groupToLeave._id}/leave`);
+
+        const userWithChallengeTasks = await member.get('/user');
+
+        expect(userWithChallengeTasks.challenges).to.not.include(challenge._id);
+      });
+    });
   });
 
+  const typesOfGroups = {
+    'private guild': { type: 'guild', privacy: 'private' },
+    party: { type: 'party', privacy: 'private' },
+  };
+
   each(typesOfGroups, (groupDetails, groupType) => {
     context(`Leaving a group plan when the group is a ${groupType}`, () => {
-      if (groupDetails.privacy === 'public') return; // public guilds cannot be group plans
       let groupWithPlan;
-      let leader;
-      let member;
 
       beforeEach(async () => {
-        const { group, groupLeader, members } = await createAndPopulateGroup({
+        ({ group: groupWithPlan, groupLeader: leader, members } = await createAndPopulateGroup({
           groupDetails,
           members: 1,
-        });
-        leader = groupLeader;
-        member = members[0]; // eslint-disable-line prefer-destructuring
-        groupWithPlan = group;
+          upgradeToGroupPlan: true,
+        }));
+        [member] = members;
         const userWithFreePlan = await User.findById(leader._id).exec();
 
         // Create subscription
@@ -316,45 +302,21 @@ describe('POST /groups/:groupId/leave', () => {
         await member.sync();
         expect(member.purchased.plan.dateTerminated).to.exist;
       });
-
-      it('preserves the free subscription when leaving a any other group without a plan', async () => {
-        // Joining a guild without a group plan
-        const { group: groupWithNoPlan } = await createAndPopulateGroup({
-          groupDetails: {
-            name: 'Group Without Plan',
-            type: 'guild',
-            privacy: 'public',
-          },
-        });
-
-        await member.post(`/groups/${groupWithNoPlan._id}/join`);
-        await member.sync();
-        expect(member.purchased.plan.planId).to.equal('group_plan_auto');
-        expect(member.purchased.plan.dateTerminated).to.not.exist;
-
-        // Leaving the guild without a group plan
-        await member.post(`/groups/${groupWithNoPlan._id}/leave`);
-        await member.sync();
-        expect(member.purchased.plan.dateTerminated).to.not.exist;
-      });
     });
   });
 
   each(typesOfGroups, (groupDetails, groupType) => {
     context(`Leaving a group with extraMonths left plan when the group is a ${groupType}`, () => {
-      if (groupDetails.privacy === 'public') return; // public guilds cannot be group plans
       const extraMonths = 12;
       let groupWithPlan;
-      let member;
 
       beforeEach(async () => {
-        const { group, members } = await createAndPopulateGroup({
+        ({ group: groupWithPlan, members } = await createAndPopulateGroup({
           groupDetails,
           members: 1,
           upgradeToGroupPlan: true,
-        });
+        }));
         [member] = members;
-        groupWithPlan = group;
         await member.update({
           'purchased.plan.extraMonths': extraMonths,
         });

test/api/v3/integration/groups/POST-groups_groupId_reject.test.js

@@ -5,43 +5,6 @@ import {
 } from '../../../../helpers/api-integration/v3';
 
 describe('POST /group/:groupId/reject-invite', () => {
-  context('Rejecting a public guild invite', () => {
-    let publicGuild; let
-      invitedUser;
-
-    beforeEach(async () => {
-      const { group, invitees } = await createAndPopulateGroup({
-        groupDetails: {
-          name: 'Test Guild',
-          type: 'guild',
-          privacy: 'public',
-        },
-        invites: 1,
-      });
-
-      publicGuild = group;
-      invitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
-    });
-
-    it('returns error when user is not invited', async () => {
-      const userWithoutInvite = await generateUser();
-
-      await expect(userWithoutInvite.post(`/groups/${publicGuild._id}/reject-invite`)).to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('messageGroupRequiresInvite'),
-      });
-    });
-
-    it('clears invitation from user', async () => {
-      await invitedUser.post(`/groups/${publicGuild._id}/reject-invite`);
-
-      await expect(invitedUser.get('/user'))
-        .to.eventually.have.nested.property('invitations.guilds')
-        .to.not.include({ id: publicGuild._id });
-    });
-  });
-
   context('Rejecting a private guild invite', () => {
     let invitedUser; let
       guild;
@@ -54,6 +17,7 @@ describe('POST /group/:groupId/reject-invite', () => {
           privacy: 'private',
         },
         invites: 1,
+        upgradeToGroupPlan: true,
       });
 
       guild = group;

test/api/v3/integration/groups/POST-groups_id_removeMember.test.js

@@ -25,6 +25,7 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
       },
       invites: 1,
       members: 2,
+      upgradeToGroupPlan: true,
     });
 
     guild = group;
@@ -129,9 +130,11 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
     it('sends email to removed user', async () => {
       await leader.post(`/groups/${guild._id}/removeMember/${member._id}`);
 
-      expect(email.sendTxn).to.be.calledOnce;
+      expect(email.sendTxn).to.be.calledTwice;
       expect(email.sendTxn.args[0][0]._id).to.eql(member._id);
       expect(email.sendTxn.args[0][1]).to.eql('kicked-from-guild');
+      expect(email.sendTxn.args[1][0]._id).to.eql(member._id);
+      expect(email.sendTxn.args[1][1]).to.eql('group-member-removed');
     });
   });
 
@@ -153,6 +156,7 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
         },
         invites: 1,
         members: 2,
+        leaderDetails: { 'auth.timestamps.created': new Date('2022-01-01') },
       });
 
       party = group;

test/api/v3/integration/groups/POST-groups_invite.test.js

@@ -1,25 +1,25 @@
 import { v4 as generateUUID } from 'uuid';
 import nconf from 'nconf';
 import {
+  createAndPopulateGroup,
   generateUser,
-  generateGroup,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
 
 const INVITES_LIMIT = 100;
-const PARTY_LIMIT_MEMBERS = 29;
+const PARTY_LIMIT_MEMBERS = 30;
 const MAX_EMAIL_INVITES_BY_USER = 200;
 
 describe('Post /groups/:groupId/invite', () => {
   let inviter;
   let group;
-  const groupName = 'Test Public Guild';
+  const groupName = 'Test Party';
 
   beforeEach(async () => {
     inviter = await generateUser({ balance: 4 });
     group = await inviter.post('/groups', {
       name: groupName,
-      type: 'guild',
+      type: 'party',
     });
   });
 
@@ -48,48 +48,60 @@ describe('Post /groups/:groupId/invite', () => {
         });
     });
 
+    it('returns error when recipient has blocked the senders', async () => {
+      const inviterNoBlocks = await inviter.update({ 'inbox.blocks': [] });
+      const userWithBlockedInviter = await generateUser({ 'inbox.blocks': [inviter._id] });
+      await expect(inviterNoBlocks.post(`/groups/${group._id}/invite`, {
+        usernames: [userWithBlockedInviter.auth.local.lowerCaseUsername],
+      }))
+        .to.eventually.be.rejected.and.eql({
+          code: 401,
+          error: 'NotAuthorized',
+          message: t('notAuthorizedToSendMessageToThisUser'),
+        });
+    });
+
     it('invites a user to a group by username', async () => {
       const userToInvite = await generateUser();
 
-      await expect(inviter.post(`/groups/${group._id}/invite`, {
+      const response = await inviter.post(`/groups/${group._id}/invite`, {
         usernames: [userToInvite.auth.local.lowerCaseUsername],
-      })).to.eventually.deep.equal([{
-        id: group._id,
-        name: groupName,
-        inviter: inviter._id,
-        publicGuild: false,
-      }]);
+      });
+      expect(response).to.be.an('Array');
+      expect(response[0]).to.have.all.keys(['_id', 'id', 'name', 'inviter']);
+      expect(response[0]._id).to.be.a('String');
+      expect(response[0].id).to.eql(group._id);
+      expect(response[0].name).to.eql(groupName);
+      expect(response[0].inviter).to.eql(inviter._id);
 
       await expect(userToInvite.get('/user'))
-        .to.eventually.have.nested.property('invitations.guilds[0].id', group._id);
+        .to.eventually.have.nested.property('invitations.parties[0].id', group._id);
     });
 
     it('invites multiple users to a group by uuid', async () => {
       const userToInvite = await generateUser();
       const userToInvite2 = await generateUser();
 
-      await expect(inviter.post(`/groups/${group._id}/invite`, {
+      const response = await (inviter.post(`/groups/${group._id}/invite`, {
         usernames: [
           userToInvite.auth.local.lowerCaseUsername,
           userToInvite2.auth.local.lowerCaseUsername,
         ],
-      })).to.eventually.deep.equal([
-        {
-          id: group._id,
-          name: groupName,
-          inviter: inviter._id,
-          publicGuild: false,
-        },
-        {
-          id: group._id,
-          name: groupName,
-          inviter: inviter._id,
-          publicGuild: false,
-        },
-      ]);
+      }));
+      expect(response).to.be.an('Array');
+      expect(response[0]).to.have.all.keys(['_id', 'id', 'name', 'inviter']);
+      expect(response[0]._id).to.be.a('String');
+      expect(response[0].id).to.eql(group._id);
+      expect(response[0].name).to.eql(groupName);
+      expect(response[0].inviter).to.eql(inviter._id);
+      expect(response[1]).to.have.all.keys(['_id', 'id', 'name', 'inviter']);
+      expect(response[1]._id).to.be.a('String');
+      expect(response[1].id).to.eql(group._id);
+      expect(response[1].name).to.eql(groupName);
+      expect(response[1].inviter).to.eql(inviter._id);
 
-      await expect(userToInvite.get('/user')).to.eventually.have.nested.property('invitations.guilds[0].id', group._id);
-      await expect(userToInvite2.get('/user')).to.eventually.have.nested.property('invitations.guilds[0].id', group._id);
+      await expect(userToInvite.get('/user')).to.eventually.have.nested.property('invitations.parties[0].id', group._id);
+      await expect(userToInvite2.get('/user')).to.eventually.have.nested.property('invitations.parties[0].id', group._id);
     });
   });
 
@@ -200,42 +212,42 @@ describe('Post /groups/:groupId/invite', () => {
     it('invites a user to a group by uuid', async () => {
       const userToInvite = await generateUser();
 
-      await expect(inviter.post(`/groups/${group._id}/invite`, {
+      const response = await inviter.post(`/groups/${group._id}/invite`, {
         uuids: [userToInvite._id],
-      })).to.eventually.deep.equal([{
-        id: group._id,
-        name: groupName,
-        inviter: inviter._id,
-        publicGuild: false,
-      }]);
+      });
+      expect(response).to.be.an('Array');
+      expect(response[0]).to.have.all.keys(['_id', 'id', 'name', 'inviter']);
+      expect(response[0]._id).to.be.a('String');
+      expect(response[0].id).to.eql(group._id);
+      expect(response[0].name).to.eql(groupName);
+      expect(response[0].inviter).to.eql(inviter._id);
 
       await expect(userToInvite.get('/user'))
-        .to.eventually.have.nested.property('invitations.guilds[0].id', group._id);
+        .to.eventually.have.nested.property('invitations.parties[0].id', group._id);
     });
 
     it('invites multiple users to a group by uuid', async () => {
       const userToInvite = await generateUser();
       const userToInvite2 = await generateUser();
 
-      await expect(inviter.post(`/groups/${group._id}/invite`, {
+      const response = await inviter.post(`/groups/${group._id}/invite`, {
         uuids: [userToInvite._id, userToInvite2._id],
-      })).to.eventually.deep.equal([
-        {
-          id: group._id,
-          name: groupName,
-          inviter: inviter._id,
-          publicGuild: false,
-        },
-        {
-          id: group._id,
-          name: groupName,
-          inviter: inviter._id,
-          publicGuild: false,
-        },
-      ]);
+      });
 
-      await expect(userToInvite.get('/user')).to.eventually.have.nested.property('invitations.guilds[0].id', group._id);
-      await expect(userToInvite2.get('/user')).to.eventually.have.nested.property('invitations.guilds[0].id', group._id);
+      expect(response).to.be.an('Array');
+      expect(response[0]).to.have.all.keys(['_id', 'id', 'name', 'inviter']);
+      expect(response[0]._id).to.be.a('String');
+      expect(response[0].id).to.eql(group._id);
+      expect(response[0].name).to.eql(groupName);
+      expect(response[0].inviter).to.eql(inviter._id);
+      expect(response[1]).to.have.all.keys(['_id', 'id', 'name', 'inviter']);
+      expect(response[1]._id).to.be.a('String');
+      expect(response[1].id).to.eql(group._id);
+      expect(response[1].name).to.eql(groupName);
+      expect(response[1].inviter).to.eql(inviter._id);
+
+      await expect(userToInvite.get('/user')).to.eventually.have.nested.property('invitations.parties[0].id', group._id);
+      await expect(userToInvite2.get('/user')).to.eventually.have.nested.property('invitations.parties[0].id', group._id);
     });
 
     it('returns an error when inviting multiple users and a user is not found', async () => {
@@ -324,12 +336,8 @@ describe('Post /groups/:groupId/invite', () => {
         invitesSent: MAX_EMAIL_INVITES_BY_USER,
         balance: 4,
       });
-      const tmpGroup = await inviterWithMax.post('/groups', {
-        name: groupName,
-        type: 'guild',
-      });
 
-      await expect(inviterWithMax.post(`/groups/${tmpGroup._id}/invite`, {
+      await expect(inviterWithMax.post(`/groups/${group._id}/invite`, {
         emails: [testInvite],
         inviter: 'inviter name',
       }))
@@ -405,15 +413,15 @@ describe('Post /groups/:groupId/invite', () => {
       });
       const invitedUser = await newUser.get('/user');
 
-      expect(invitedUser.invitations.guilds[0].id).to.equal(group._id);
+      expect(invitedUser.invitations.parties[0].id).to.equal(group._id);
       expect(invite).to.exist;
     });
 
-    it('invites marks invite with cancelled plan', async () => {
-      const cancelledPlanGroup = await generateGroup(inviter, {
-        type: 'guild',
-        name: generateUUID(),
-      });
+    it('invites user to group with cancelled plan', async () => {
+      let cancelledPlanGroup;
+      ({ group: cancelledPlanGroup, groupLeader: inviter } = await createAndPopulateGroup({
+        upgradeToGroupPlan: true,
+      }));
       await cancelledPlanGroup.createCancelledSubscription();
 
       const newUser = await generateUser();
@@ -423,13 +431,13 @@ describe('Post /groups/:groupId/invite', () => {
       });
       const invitedUser = await newUser.get('/user');
 
-      expect(invitedUser.invitations.guilds[0].id).to.equal(cancelledPlanGroup._id);
-      expect(invitedUser.invitations.guilds[0].cancelledPlan).to.be.true;
+      expect(invitedUser.invitations.parties[0].id).to.equal(cancelledPlanGroup._id);
+      expect(invitedUser.invitations.parties[0].cancelledPlan).to.be.true;
       expect(invite).to.exist;
     });
   });
 
-  describe('guild invites', () => {
+  describe('party invites', () => {
     it('returns an error when inviter has no chat privileges', async () => {
       const inviterMuted = await inviter.update({ 'flags.chatRevoked': true });
       const userToInvite = await generateUser();
@@ -443,103 +451,13 @@ describe('Post /groups/:groupId/invite', () => {
         });
     });
 
-    it('returns an error when invited user is already invited to the group', async () => {
-      const userToInvite = await generateUser();
-      await inviter.post(`/groups/${group._id}/invite`, {
-        uuids: [userToInvite._id],
-      });
-
-      await expect(inviter.post(`/groups/${group._id}/invite`, {
-        uuids: [userToInvite._id],
-      }))
-        .to.eventually.be.rejected.and.eql({
-          code: 401,
-          error: 'NotAuthorized',
-          message: t('userAlreadyInvitedToGroup', { userId: userToInvite._id, username: userToInvite.profile.name }),
-        });
-    });
-
-    it('returns an error when invited user is already in the group', async () => {
-      const userToInvite = await generateUser();
-      await inviter.post(`/groups/${group._id}/invite`, {
-        uuids: [userToInvite._id],
-      });
-      await userToInvite.post(`/groups/${group._id}/join`);
-
-      await expect(inviter.post(`/groups/${group._id}/invite`, {
-        uuids: [userToInvite._id],
-      }))
-        .to.eventually.be.rejected.and.eql({
-          code: 401,
-          error: 'NotAuthorized',
-          message: t('userAlreadyInGroup', { userId: userToInvite._id, username: userToInvite.profile.name }),
-        });
-    });
-
-    it('allows 30+ members in a guild', async () => {
-      const invitesToGenerate = [];
-      // Generate 30 users to invite (30 + leader = 31 members)
-      for (let i = 0; i < PARTY_LIMIT_MEMBERS; i += 1) {
-        invitesToGenerate.push(generateUser());
-      }
-      const generatedInvites = await Promise.all(invitesToGenerate);
-      // Invite users
-      expect(await inviter.post(`/groups/${group._id}/invite`, {
-        uuids: generatedInvites.map(invite => invite._id),
-      })).to.be.an('array');
-    }).timeout(10000);
-
-    // @TODO: Add this after we are able to mock the group plan route
-    xit('returns an error when a non-leader invites to a group plan', async () => {
-      const userToInvite = await generateUser();
-
-      const nonGroupLeader = await generateUser();
-      await inviter.post(`/groups/${group._id}/invite`, {
-        uuids: [nonGroupLeader._id],
-      });
-      await nonGroupLeader.post(`/groups/${group._id}/join`);
-
-      await expect(nonGroupLeader.post(`/groups/${group._id}/invite`, {
-        uuids: [userToInvite._id],
-      }))
-        .to.eventually.be.rejected.and.eql({
-          code: 401,
-          error: 'NotAuthorized',
-          message: t('onlyGroupLeaderCanInviteToGroupPlan'),
-        });
-    });
-  });
-
-  describe('party invites', () => {
-    let party;
-
-    beforeEach(async () => {
-      party = await inviter.post('/groups', {
-        name: 'Test Party',
-        type: 'party',
-      });
-    });
-
-    it('returns an error when inviter has no chat privileges', async () => {
-      const inviterMuted = await inviter.update({ 'flags.chatRevoked': true });
-      const userToInvite = await generateUser();
-      await expect(inviterMuted.post(`/groups/${party._id}/invite`, {
-        uuids: [userToInvite._id],
-      }))
-        .to.eventually.be.rejected.and.eql({
-          code: 401,
-          error: 'NotAuthorized',
-          message: t('chatPrivilegesRevoked'),
-        });
-    });
-
     it('returns an error when invited user has a pending invitation to the party', async () => {
       const userToInvite = await generateUser();
-      await inviter.post(`/groups/${party._id}/invite`, {
+      await inviter.post(`/groups/${group._id}/invite`, {
         uuids: [userToInvite._id],
       });
 
-      await expect(inviter.post(`/groups/${party._id}/invite`, {
+      await expect(inviter.post(`/groups/${group._id}/invite`, {
         uuids: [userToInvite._id],
       }))
         .to.eventually.be.rejected.and.eql({
@@ -552,13 +470,13 @@ describe('Post /groups/:groupId/invite', () => {
     it('returns an error when invited user is already in a party of more than 1 member', async () => {
       const userToInvite = await generateUser();
       const userToInvite2 = await generateUser();
-      await inviter.post(`/groups/${party._id}/invite`, {
+      await inviter.post(`/groups/${group._id}/invite`, {
         uuids: [userToInvite._id, userToInvite2._id],
       });
-      await userToInvite.post(`/groups/${party._id}/join`);
-      await userToInvite2.post(`/groups/${party._id}/join`);
+      await userToInvite.post(`/groups/${group._id}/join`);
+      await userToInvite2.post(`/groups/${group._id}/join`);
 
-      await expect(inviter.post(`/groups/${party._id}/invite`, {
+      await expect(inviter.post(`/groups/${group._id}/invite`, {
         uuids: [userToInvite._id],
       }))
         .to.eventually.be.rejected.and.eql({
@@ -568,20 +486,7 @@ describe('Post /groups/:groupId/invite', () => {
         });
     });
 
-    it('allow inviting a user to a party if they are partying solo', async () => {
-      const userToInvite = await generateUser();
-      await userToInvite.post('/groups', { // add user to a party
-        name: 'Another Test Party',
-        type: 'party',
-      });
-
-      await inviter.post(`/groups/${party._id}/invite`, {
-        uuids: [userToInvite._id],
-      });
-      expect((await userToInvite.get('/user')).invitations.parties[0].id).to.equal(party._id);
-    });
-
-    it('allow inviting a user to 2 different parties', async () => {
+    it('allows inviting a user to 2 different parties', async () => {
       // Create another inviter
       const inviter2 = await generateUser();
 
@@ -595,7 +500,7 @@ describe('Post /groups/:groupId/invite', () => {
       });
 
       // Invite to first party
-      await inviter.post(`/groups/${party._id}/invite`, {
+      await inviter.post(`/groups/${group._id}/invite`, {
         uuids: [userToInvite._id],
       });
 
@@ -608,49 +513,65 @@ describe('Post /groups/:groupId/invite', () => {
       const invitedUser = await userToInvite.get('/user');
 
       expect(invitedUser.invitations.parties.length).to.equal(2);
-      expect(invitedUser.invitations.parties[0].id).to.equal(party._id);
+      expect(invitedUser.invitations.parties[0].id).to.equal(group._id);
       expect(invitedUser.invitations.parties[1].id).to.equal(party2._id);
     });
 
-    it('allow inviting a user if party id is not associated with a real party', async () => {
+    it('allows inviting a user if party id is not associated with a real party', async () => {
       const userToInvite = await generateUser({
         party: { _id: generateUUID() },
       });
 
-      await inviter.post(`/groups/${party._id}/invite`, {
+      await inviter.post(`/groups/${group._id}/invite`, {
         uuids: [userToInvite._id],
       });
-      expect((await userToInvite.get('/user')).invitations.parties[0].id).to.equal(party._id);
+      expect((await userToInvite.get('/user')).invitations.parties[0].id).to.equal(group._id);
+    });
+  });
+
+  describe('party size limits', () => {
+    let partyLeader;
+
+    beforeEach(async () => {
+      ({ group, groupLeader: partyLeader } = await createAndPopulateGroup({
+        groupDetails: {
+          name: 'Test Party',
+          type: 'party',
+          privacy: 'private',
+        },
+        // Generate party with 20 members
+        members: PARTY_LIMIT_MEMBERS - 10,
+      }));
     });
 
     it('allows 30 members in a party', async () => {
       const invitesToGenerate = [];
-      // Generate 29 users to invite (29 + leader = 30 members)
-      for (let i = 0; i < PARTY_LIMIT_MEMBERS - 1; i += 1) {
+      // Generate 10 new invites
+      for (let i = 1; i < 10; i += 1) {
         invitesToGenerate.push(generateUser());
       }
       const generatedInvites = await Promise.all(invitesToGenerate);
       // Invite users
-      expect(await inviter.post(`/groups/${party._id}/invite`, {
+      expect(await partyLeader.post(`/groups/${group._id}/invite`, {
         uuids: generatedInvites.map(invite => invite._id),
       })).to.be.an('array');
     }).timeout(10000);
 
-    it('does not allow 30+ members in a party', async () => {
+    it('does not allow >30 members in a party', async () => {
       const invitesToGenerate = [];
-      // Generate 30 users to invite (30 + leader = 31 members)
-      for (let i = 0; i < PARTY_LIMIT_MEMBERS; i += 1) {
+      // Generate 11 invites
+      for (let i = 1; i < 11; i += 1) {
         invitesToGenerate.push(generateUser());
       }
       const generatedInvites = await Promise.all(invitesToGenerate);
       // Invite users
-      await expect(inviter.post(`/groups/${party._id}/invite`, {
+      await expect(partyLeader.post(`/groups/${group._id}/invite`, {
         uuids: generatedInvites.map(invite => invite._id),
       }))
         .to.eventually.be.rejected.and.eql({
           code: 400,
           error: 'BadRequest',
-          message: t('partyExceedsMembersLimit', { maxMembersParty: PARTY_LIMIT_MEMBERS + 1 }),
+          message: t('partyExceedsMembersLimit', { maxMembersParty: PARTY_LIMIT_MEMBERS }),
         });
     }).timeout(10000);
   });

test/api/v3/integration/groups/POST-groups_manager.test.js

@@ -17,9 +17,10 @@ describe('POST /group/:groupId/add-manager', () => {
         groupDetails: {
           name: groupName,
           type: groupType,
-          privacy: 'public',
+          privacy: 'private',
         },
         members: 1,
+        upgradeToGroupPlan: true,
       });
 
       groupToUpdate = group;

test/api/v3/integration/groups/PUT-groups.test.js

@@ -3,6 +3,7 @@ import {
   generateUser,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
+import { MAX_SUMMARY_SIZE_FOR_GUILDS } from '../../../../../website/common/script/constants';
 
 describe('PUT /group', () => {
   let leader; let nonLeader; let groupToUpdate; let
@@ -10,15 +11,23 @@ describe('PUT /group', () => {
   const groupName = 'Test Public Guild';
   const groupType = 'guild';
   const groupUpdatedName = 'Test Public Guild Updated';
+  const groupCategories = [
+    {
+      slug: 'initialCat',
+      name: 'Initial Category',
+    },
+  ];
 
   beforeEach(async () => {
     const { group, groupLeader, members } = await createAndPopulateGroup({
       groupDetails: {
         name: groupName,
         type: groupType,
-        privacy: 'public',
+        privacy: 'private',
+        categories: groupCategories,
       },
       members: 1,
+      upgradeToGroupPlan: true,
     });
     adminUser = await generateUser({ 'permissions.moderator': true });
     groupToUpdate = group;
@@ -60,6 +69,35 @@ describe('PUT /group', () => {
     expect(updatedGroup.categories[0].name).to.eql(categories[0].name);
   });
 
+  it('removes the initial group category', async () => {
+    const categories = [];
+
+    const updatedGroup = await leader.put(`/groups/${groupToUpdate._id}`, {
+      categories,
+    });
+
+    expect(updatedGroup.categories.length).to.equal(0);
+  });
+
+  it('removes duplicate group categories', async () => {
+    const categories = [
+      {
+        slug: 'newCat',
+        name: 'New Category',
+      },
+      {
+        slug: 'newCat',
+        name: 'New Category',
+      },
+    ];
+
+    const updatedGroup = await leader.put(`/groups/${groupToUpdate._id}`, {
+      categories,
+    });
+
+    expect(updatedGroup.categories.length).to.equal(1);
+  });
+
   it('allows an admin to update a guild', async () => {
     const updatedGroup = await adminUser.put(`/groups/${groupToUpdate._id}`, {
       name: groupUpdatedName,
@@ -69,14 +107,28 @@ describe('PUT /group', () => {
     expect(updatedGroup.name).to.equal(groupUpdatedName);
   });
 
-  it('allows a leader to change leaders', async () => {
-    const updatedGroup = await leader.put(`/groups/${groupToUpdate._id}`, {
+  it('does not allow a leader to change leader of active group plan', async () => {
+    await expect(leader.put(`/groups/${groupToUpdate._id}`, {
       name: groupUpdatedName,
       leader: nonLeader._id,
+    })).to.eventually.be.rejected.and.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('cannotChangeLeaderWithActiveGroupPlan'),
+    });
+  });
+
+  it('allows a leader of a party to change leaders', async () => {
+    const { group: party, groupLeader: partyLeader, members } = await createAndPopulateGroup({
+      members: 1,
+    });
+    const updatedGroup = await partyLeader.put(`/groups/${party._id}`, {
+      name: groupUpdatedName,
+      leader: members[0]._id,
     });
 
-    expect(updatedGroup.leader._id).to.eql(nonLeader._id);
-    expect(updatedGroup.leader.profile.name).to.eql(nonLeader.profile.name);
+    expect(updatedGroup.leader._id).to.eql(members[0]._id);
+    expect(updatedGroup.leader.profile.name).to.eql(members[0].profile.name);
     expect(updatedGroup.name).to.equal(groupUpdatedName);
   });
 
@@ -85,15 +137,16 @@ describe('PUT /group', () => {
       groupDetails: {
         name: 'public guild',
         type: 'guild',
-        privacy: 'public',
+        privacy: 'private',
       },
+      upgradeToGroupPlan: true,
     });
 
     const updateGroupDetails = {
       id: group._id,
       name: 'public guild',
       type: 'guild',
-      privacy: 'public',
+      privacy: 'private',
       bannedWordsAllowed: true,
     };
 
@@ -113,9 +166,11 @@ describe('PUT /group', () => {
       groupDetails: {
         name: 'public guild',
         type: 'guild',
-        privacy: 'public',
+        privacy: 'private',
       },
+      upgradeToGroupPlan: true,
     });
+    await groupLeader.update({ permissions: {} });
 
     const updateGroupDetails = {
       id: group._id,
@@ -130,4 +185,15 @@ describe('PUT /group', () => {
 
     expect(response.bannedWordsAllowed).to.eql(undefined);
   });
+
+  it('returns error when summary is longer than MAX_SUMMARY_SIZE_FOR_GUILDS characters', async () => {
+    const summary = 'A'.repeat(MAX_SUMMARY_SIZE_FOR_GUILDS + 1);
+    await expect(leader.put(`/groups/${groupToUpdate._id}`, {
+      summary,
+    })).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('invalidReqParams'),
+    });
+  });
 });

test/api/v3/integration/members/POST-members_memberId_clear-flags.js

@@ -0,0 +1,64 @@
+import { v4 as generateUUID } from 'uuid';
+import {
+  generateUser,
+  translate as t,
+} from '../../../../helpers/api-integration/v3';
+
+describe('POST /members/:memberId/clear-flags', () => {
+  let reporter;
+  let admin;
+  let moderator;
+
+  beforeEach(async () => {
+    reporter = await generateUser();
+    admin = await generateUser({ permissions: { userSupport: true } });
+    moderator = await generateUser({ permissions: { moderator: true } });
+    await reporter.post(`/members/${admin._id}/flag`);
+  });
+
+  context('error cases', () => {
+    it('returns error when memberId is not a UUID', async () => {
+      await expect(moderator.post('/members/gribbly/clear-flags'))
+        .to.eventually.be.rejected.and.eql({
+          code: 400,
+          error: 'BadRequest',
+          message: t('invalidReqParams'),
+        });
+    });
+
+    it('returns error when member with UUID is not found', async () => {
+      const randomId = generateUUID();
+
+      await expect(moderator.post(`/members/${randomId}/clear-flags`))
+        .to.eventually.be.rejected.and.eql({
+          code: 404,
+          error: 'NotFound',
+          message: t('userWithIDNotFound', { userId: randomId }),
+        });
+    });
+
+    it('returns error when requesting user is not a moderator', async () => {
+      await expect(reporter.post(`/members/${admin._id}/clear-flags`))
+        .to.eventually.be.rejected.and.eql({
+          code: 400,
+          error: 'BadRequest',
+          message: 'Only a moderator may clear reports from a profile.',
+        });
+    });
+  });
+
+  context('valid request', () => {
+    it('removes a single flag from user', async () => {
+      await expect(moderator.post(`/members/${admin._id}/clear-flags`)).to.eventually.be.ok;
+      const updatedTarget = await admin.get(`/hall/heroes/${admin._id}`);
+      expect(updatedTarget.profile.flags).to.eql({});
+    });
+
+    it('removes multiple flags from user', async () => {
+      await moderator.post(`/members/${admin._id}/flag`);
+      await expect(moderator.post(`/members/${admin._id}/clear-flags`)).to.eventually.be.ok;
+      const updatedTarget = await admin.get(`/hall/heroes/${admin._id}`);
+      expect(updatedTarget.profile.flags).to.eql({});
+    });
+  });
+});

test/api/v3/integration/members/POST-members_memberId_flag.js

@@ -0,0 +1,151 @@
+import { v4 as generateUUID } from 'uuid';
+import moment from 'moment';
+import nconf from 'nconf';
+import { IncomingWebhook } from '@slack/webhook';
+import {
+  generateUser,
+  translate as t,
+} from '../../../../helpers/api-integration/v3';
+
+describe('POST /members/:memberId/flag', () => {
+  let reporter;
+  let target;
+
+  beforeEach(async () => {
+    reporter = await generateUser();
+    target = await generateUser({
+      'profile.blurb': 'Naughty Text',
+      'profile.imageUrl': 'https://evil.com/',
+    });
+  });
+
+  context('error cases', () => {
+    it('returns error when memberId is not a UUID', async () => {
+      await expect(reporter.post('/members/gribbly/flag'))
+        .to.eventually.be.rejected.and.eql({
+          code: 400,
+          error: 'BadRequest',
+          message: t('invalidReqParams'),
+        });
+    });
+
+    it('returns error when member with UUID is not found', async () => {
+      const randomId = generateUUID();
+
+      await expect(reporter.post(`/members/${randomId}/flag`))
+        .to.eventually.be.rejected.and.eql({
+          code: 404,
+          error: 'NotFound',
+          message: t('userWithIDNotFound', { userId: randomId }),
+        });
+    });
+
+    it('returns error when non-admin flags same profile twice', async () => {
+      await reporter.post(`/members/${target._id}/flag`);
+      await expect(reporter.post(`/members/${target._id}/flag`))
+        .to.eventually.be.rejected.and.eql({
+          code: 400,
+          error: 'BadRequest',
+          message: 'A profile can not be flagged more than once by the same user.',
+        });
+    });
+  });
+
+  context('valid request', () => {
+    let admin;
+    const comment = 'this profile is bad';
+    const source = 'Third Party Script';
+
+    beforeEach(async () => {
+      admin = await generateUser({ 'permissions.userSupport': true });
+      sandbox.stub(IncomingWebhook.prototype, 'send').returns(Promise.resolve());
+    });
+
+    afterEach(() => {
+      sandbox.restore();
+    });
+
+    it('adds flags object to target user', async () => {
+      await reporter.post(`/members/${target._id}/flag`);
+      const updatedTarget = await admin.get(`/hall/heroes/${target._id}`);
+      expect(updatedTarget.profile.flags[reporter._id]).to.have.all.keys([
+        'comment',
+        'source',
+        'timestamp',
+      ]);
+      expect(moment(updatedTarget.profile.flags[reporter._id].timestamp).toDate()).to.be.a('date');
+    });
+
+    it('allows addition of a comment and source', async () => {
+      await reporter.post(`/members/${target._id}/flag`, {
+        comment,
+        source,
+      });
+      const updatedTarget = await admin.get(`/hall/heroes/${target._id}`);
+      expect(updatedTarget.profile.flags[reporter._id].comment).to.eql(comment);
+      expect(updatedTarget.profile.flags[reporter._id].source).to.eql(source);
+    });
+
+    it('allows moderator to flag twice', async () => {
+      const moderator = await generateUser({ 'permissions.moderator': true });
+      await moderator.post(`/members/${target._id}/flag`);
+      await expect(moderator.post(`/members/${target._id}/flag`)).to.eventually.be.ok;
+    });
+
+    it('allows multiple non-moderators to flag individually', async () => {
+      await admin.post(`/members/${target._id}/flag`);
+      await reporter.post(`/members/${target._id}/flag`);
+      const updatedTarget = await admin.get(`/hall/heroes/${target._id}`);
+      expect(updatedTarget.profile.flags[admin._id]).to.exist;
+      expect(updatedTarget.profile.flags[reporter._id]).to.exist;
+    });
+
+    it('sends a flag report to moderation Slack', async () => {
+      const BASE_URL = nconf.get('BASE_URL');
+      await reporter.post(`/members/${target._id}/flag`, {
+        comment,
+        source,
+      });
+
+      /* eslint-disable camelcase */
+      expect(IncomingWebhook.prototype.send).to.be.calledWith({
+        text: `@${reporter.auth.local.username} (${reporter._id}; language: ${reporter.preferences.language}) flagged @${target.auth.local.username}'s profile from ${source} and commented: ${comment}`,
+        attachments: [{
+          fallback: 'Flag Profile',
+          color: 'danger',
+          title: 'User Profile Report',
+          title_link: `${BASE_URL}/profile/${target._id}`,
+          text: `Display Name: ${target.profile.name}\n\nImage URL: ${target.profile.imageUrl}\n\nAbout: ${target.profile.blurb}`,
+          mrkdwn_in: [
+            'text',
+          ],
+        }],
+      });
+      /* eslint-enable camelcase */
+    });
+
+    it('excludes empty fields when sending Slack message', async () => {
+      const BASE_URL = nconf.get('BASE_URL');
+      await reporter.post(`/members/${admin._id}/flag`, {
+        comment,
+        source,
+      });
+
+      /* eslint-disable camelcase */
+      expect(IncomingWebhook.prototype.send).to.be.calledWith({
+        text: `@${reporter.auth.local.username} (${reporter._id}; language: ${reporter.preferences.language}) flagged @${admin.auth.local.username}'s profile from ${source} and commented: ${comment}`,
+        attachments: [{
+          fallback: 'Flag Profile',
+          color: 'danger',
+          title: 'User Profile Report',
+          title_link: `${BASE_URL}/profile/${admin._id}`,
+          text: `Display Name: ${admin.profile.name}`,
+          mrkdwn_in: [
+            'text',
+          ],
+        }],
+      });
+      /* eslint-enable camelcase */
+    });
+  });
+});

test/api/v3/integration/notifications/prevent-multiple-notification.js

@@ -25,6 +25,7 @@ describe('Prevent multiple notifications', () => {
 
     for (let i = 0; i < 4; i += 1) {
       for (let memberIndex = 0; memberIndex < partyMembers.length; memberIndex += 1) {
+        await partyMembers[memberIndex].update({ 'auth.timestamps.created': new Date('2022-01-01') }); // eslint-disable-line no-await-in-loop
         multipleChatMessages.push(
           partyMembers[memberIndex].post(`/groups/${party._id}/chat`, { message: `Message ${i}_${memberIndex}` }),
         );

test/api/v3/integration/payments/amazon/GET-payments_amazon_subscribe_cancel.test.js

@@ -1,6 +1,6 @@
 import {
+  createAndPopulateGroup,
   generateUser,
-  generateGroup,
   translate as t,
 } from '../../../../../helpers/api-integration/v3';
 import amzLib from '../../../../../../website/server/libs/payments/amazon';
@@ -50,22 +50,21 @@ describe('payments : amazon #subscribeCancel', () => {
     });
 
     it('cancels a group subscription', async () => {
-      user = await generateUser({
-        'profile.name': 'sender',
-        'purchased.plan.customerId': 'customer-id',
-        'purchased.plan.planId': 'basic_3mo',
-        'purchased.plan.lastBillingDate': new Date(),
-        balance: 2,
-      });
-
-      group = await generateGroup(user, {
-        name: 'test group',
-        type: 'guild',
-        privacy: 'public',
-        'purchased.plan.customerId': 'customer-id',
-        'purchased.plan.planId': 'basic_3mo',
-        'purchased.plan.lastBillingDate': new Date(),
-      });
+      ({ group, groupLeader: user } = await createAndPopulateGroup({
+        groupDetails: {
+          name: 'test group',
+          type: 'guild',
+          privacy: 'private',
+        },
+        leaderDetails: {
+          'profile.name': 'sender',
+          'purchased.plan.customerId': 'customer-id',
+          'purchased.plan.planId': 'basic_3mo',
+          'purchased.plan.lastBillingDate': new Date(),
+          balance: 2,
+        },
+        upgradeToGroupPlan: true,
+      }));
 
       await user.get(`${endpoint}&groupId=${group._id}`);
 

test/api/v3/integration/payments/amazon/POST-payments_amazon_subscribe.test.js

@@ -70,8 +70,8 @@ describe('payments - amazon - #subscribe', () => {
 
       group = await generateGroup(user, {
         name: 'test group',
-        type: 'guild',
-        privacy: 'public',
+        type: 'party',
+        privacy: 'private',
         'purchased.plan.customerId': 'customer-id',
         'purchased.plan.planId': 'basic_3mo',
         'purchased.plan.lastBillingDate': new Date(),

test/api/v3/integration/payments/apple/POST-payments_apple_subscribe.test.js

@@ -45,11 +45,10 @@ describe('payments : apple #subscribe', () => {
       });
 
       expect(subscribeStub).to.be.calledOnce;
-      expect(subscribeStub.args[0][0]).to.eql(sku);
-      expect(subscribeStub.args[0][1]._id).to.eql(user._id);
-      expect(subscribeStub.args[0][2]).to.eql('receipt');
-      expect(subscribeStub.args[0][3]['x-api-key']).to.eql(user.apiToken);
-      expect(subscribeStub.args[0][3]['x-api-user']).to.eql(user._id);
+      expect(subscribeStub.args[0][0]._id).to.eql(user._id);
+      expect(subscribeStub.args[0][1]).to.eql('receipt');
+      expect(subscribeStub.args[0][2]['x-api-key']).to.eql(user.apiToken);
+      expect(subscribeStub.args[0][2]['x-api-user']).to.eql(user._id);
     });
   });
 });

test/api/v3/integration/payments/apple/POST-payments_apple_verifyiap.js

@@ -21,11 +21,11 @@ describe('payments : apple #verify', () => {
     let verifyStub;
 
     beforeEach(async () => {
-      verifyStub = sinon.stub(applePayments, 'verifyGemPurchase').resolves({});
+      verifyStub = sinon.stub(applePayments, 'verifyPurchase').resolves({});
     });
 
     afterEach(() => {
-      applePayments.verifyGemPurchase.restore();
+      applePayments.verifyPurchase.restore();
     });
 
     it('makes a purchase', async () => {

test/api/v3/integration/payments/google/POST-payments_google_verifyiap.js

@@ -21,11 +21,11 @@ describe('payments : google #verify', () => {
     let verifyStub;
 
     beforeEach(async () => {
-      verifyStub = sinon.stub(googlePayments, 'verifyGemPurchase').resolves({});
+      verifyStub = sinon.stub(googlePayments, 'verifyPurchase').resolves({});
     });
 
     afterEach(() => {
-      googlePayments.verifyGemPurchase.restore();
+      googlePayments.verifyPurchase.restore();
     });
 
     it('makes a purchase', async () => {

test/api/v3/integration/payments/stripe/GET-payments_stripe_subscribe_cancel.test.js

@@ -1,7 +1,7 @@
 import {
   generateUser,
-  generateGroup,
   translate as t,
+  createAndPopulateGroup,
 } from '../../../../../helpers/api-integration/v3';
 import stripePayments from '../../../../../../website/server/libs/payments/stripe';
 
@@ -48,22 +48,21 @@ describe('payments - stripe - #subscribeCancel', () => {
     });
 
     it('cancels a group subscription', async () => {
-      user = await generateUser({
-        'profile.name': 'sender',
-        'purchased.plan.customerId': 'customer-id',
-        'purchased.plan.planId': 'basic_3mo',
-        'purchased.plan.lastBillingDate': new Date(),
-        balance: 2,
-      });
-
-      group = await generateGroup(user, {
-        name: 'test group',
-        type: 'guild',
-        privacy: 'public',
-        'purchased.plan.customerId': 'customer-id',
-        'purchased.plan.planId': 'basic_3mo',
-        'purchased.plan.lastBillingDate': new Date(),
-      });
+      ({ group, groupLeader: user } = await createAndPopulateGroup({
+        groupDetails: {
+          name: 'test group',
+          type: 'guild',
+          privacy: 'private',
+        },
+        leaderDetails: {
+          'profile.name': 'sender',
+          'purchased.plan.customerId': 'customer-id',
+          'purchased.plan.planId': 'basic_3mo',
+          'purchased.plan.lastBillingDate': new Date(),
+          balance: 2,
+        },
+        upgradeToGroupPlan: true,
+      }));
 
       await user.get(`${endpoint}&groupId=${group._id}`);
 

test/api/v3/integration/quests/POST-groups_groupId_quests_accept.test.js

@@ -53,6 +53,7 @@ describe('POST /groups/:groupId/quests/accept', () => {
     it('does not accept quest for a guild', async () => {
       const { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
         groupDetails: { type: 'guild', privacy: 'private' },
+        upgradeToGroupPlan: true,
       });
 
       await expect(guildLeader.post(`/groups/${guild._id}/quests/accept`))

test/api/v3/integration/quests/POST-groups_groupId_quests_force-start.test.js

@@ -43,6 +43,7 @@ describe('POST /groups/:groupId/quests/force-start', () => {
     it('does not force start quest for a guild', async () => {
       const { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
         groupDetails: { type: 'guild', privacy: 'private' },
+        upgradeToGroupPlan: true,
       });
 
       await expect(guildLeader.post(`/groups/${guild._id}/quests/force-start`))

test/api/v3/integration/quests/POST-groups_groupId_quests_invite.test.js

@@ -51,14 +51,13 @@ describe('POST /groups/:groupId/quests/invite/:questKey', () => {
     });
 
     it('does not issue invites for Guilds', async () => {
-      const { group } = await createAndPopulateGroup({
-        groupDetails: { type: 'guild', privacy: 'public' },
+      const { group, groupLeader } = await createAndPopulateGroup({
+        groupDetails: { type: 'guild', privacy: 'private' },
         members: 1,
+        upgradeToGroupPlan: true,
       });
 
-      const alternateGroup = group;
-
-      await expect(leader.post(`/groups/${alternateGroup._id}/quests/invite/${PET_QUEST}`)).to.eventually.be.rejected.and.eql({
+      await expect(groupLeader.post(`/groups/${group._id}/quests/invite/${PET_QUEST}`)).to.eventually.be.rejected.and.eql({
         code: 401,
         error: 'NotAuthorized',
         message: t('guildQuestsNotSupported'),

test/api/v3/integration/quests/POST-groups_groupid_quests_abort.test.js

@@ -52,6 +52,7 @@ describe('POST /groups/:groupId/quests/abort', () => {
     it('returns an error when group is a guild', async () => {
       const { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
         groupDetails: { type: 'guild', privacy: 'private' },
+        upgradeToGroupPlan: true,
       });
 
       await expect(guildLeader.post(`/groups/${guild._id}/quests/abort`))

test/api/v3/integration/quests/POST-groups_groupid_quests_cancel.test.js

@@ -52,6 +52,7 @@ describe('POST /groups/:groupId/quests/cancel', () => {
     it('returns an error when group is a guild', async () => {
       const { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
         groupDetails: { type: 'guild', privacy: 'private' },
+        upgradeToGroupPlan: true,
       });
 
       await expect(guildLeader.post(`/groups/${guild._id}/quests/cancel`))

test/api/v3/integration/quests/POST-groups_groupid_quests_leave.test.js

@@ -51,6 +51,7 @@ describe('POST /groups/:groupId/quests/leave', () => {
     it('returns an error when group is a guild', async () => {
       const { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
         groupDetails: { type: 'guild', privacy: 'private' },
+        upgradeToGroupPlan: true,
       });
 
       await expect(guildLeader.post(`/groups/${guild._id}/quests/leave`))

test/api/v3/integration/quests/POST-groups_groupid_quests_reject.test.js

@@ -53,6 +53,7 @@ describe('POST /groups/:groupId/quests/reject', () => {
     it('returns an error when group is a guild', async () => {
       const { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
         groupDetails: { type: 'guild', privacy: 'private' },
+        upgradeToGroupPlan: true,
       });
 
       await expect(guildLeader.post(`/groups/${guild._id}/quests/reject`))

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

@@ -13,6 +13,9 @@ describe('POST /tasks/clearCompletedTodos', () => {
       { 'purchased.plan.customerId': 'group-unlimited' },
     );
     const challenge = await generateChallenge(user, guild);
+    await user.put('/user', {
+      'preferences.tasks.mirrorGroupTasks': [guild._id],
+    });
     await user.post(`/challenges/${challenge._id}/join`);
 
     const initialTodoCount = user.tasksOrder.todos.length;
@@ -33,7 +36,7 @@ describe('POST /tasks/clearCompletedTodos', () => {
       text: 'todo 7',
       type: 'todo',
     });
-    await user.post(`/tasks/${groupTask._id}/assign/${user._id}`);
+    await user.post(`/tasks/${groupTask._id}/assign`, [user._id]);
 
     const tasks = await user.get('/tasks/user?type=todos');
     expect(tasks.length).to.equal(initialTodoCount + 7);

test/api/v3/integration/tasks/POST-tasks_unlink-one_taskId.test.js

@@ -90,7 +90,9 @@ describe('POST /tasks/unlink-one/:taskId', () => {
       });
   });
 
-  it('unlinks a task from a challenge and saves it on keep=keep', async () => {
+  // These tests are causing trouble. Race condition?
+
+  xit('unlinks a task from a challenge and saves it on keep=keep', async () => {
     await user.post(`/tasks/challenge/${challenge._id}`, tasksToTest.daily);
     let [daily] = await user.get('/tasks/user');
     await user.del(`/challenges/${challenge._id}`);
@@ -99,7 +101,7 @@ describe('POST /tasks/unlink-one/:taskId', () => {
     expect(daily.challenge).to.eql({});
   });
 
-  it('unlinks a task from a challenge and deletes it on keep=remove', async () => {
+  xit('unlinks a task from a challenge and deletes it on keep=remove', async () => {
     await user.post(`/tasks/challenge/${challenge._id}`, tasksToTest.daily);
     const [daily] = await user.get('/tasks/user');
     await user.del(`/challenges/${challenge._id}`);

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

@@ -30,7 +30,7 @@ describe('POST /tasks/:taskId/checklist/:itemId/score', () => {
     expect(savedTask.checklist[0].completed).to.equal(true);
   });
 
-  it('can use a alias to score a checklist item', async () => {
+  it('can use an alias to score a checklist item', async () => {
     const task = await user.post('/tasks/user', {
       type: 'daily',
       text: 'Daily with checklist',

test/api/v3/integration/tasks/groups/DELETE-group_tasks_id.test.js

@@ -1,4 +1,3 @@
-import { find } from 'lodash';
 import {
   translate as t,
   createAndPopulateGroup,
@@ -8,10 +7,6 @@ describe('Groups DELETE /tasks/:id', () => {
   let user; let guild; let member; let member2; let
     task;
 
-  function findAssignedTask (memberTask) {
-    return memberTask.group.id === guild._id;
-  }
-
   beforeEach(async () => {
     const { group, members, groupLeader } = await createAndPopulateGroup({
       groupDetails: {
@@ -35,8 +30,7 @@ describe('Groups DELETE /tasks/:id', () => {
       notes: 1976,
     });
 
-    await user.post(`/tasks/${task._id}/assign/${member._id}`);
-    await user.post(`/tasks/${task._id}/assign/${member2._id}`);
+    await user.post(`/tasks/${task._id}/assign`, [member._id, member2._id]);
   });
 
   it('deletes a group task', async () => {
@@ -64,81 +58,4 @@ describe('Groups DELETE /tasks/:id', () => {
         message: t('messageTaskNotFound'),
       });
   });
-
-  it('removes deleted taskʾs approval pending notifications from managers', async () => {
-    await user.post(`/groups/${guild._id}/add-manager`, {
-      managerId: member2._id,
-    });
-    await user.put(`/tasks/${task._id}/`, {
-      requiresApproval: true,
-    });
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-
-    await user.sync();
-    await member2.sync();
-    expect(user.notifications.length).to.equal(3); // mystery items
-    expect(user.notifications[2].type).to.equal('GROUP_TASK_APPROVAL');
-    expect(member2.notifications.length).to.equal(3);
-    expect(member2.notifications[2].type).to.equal('GROUP_TASK_APPROVAL');
-
-    await member2.del(`/tasks/${task._id}`);
-
-    await user.sync();
-    await member2.sync();
-
-    expect(user.notifications.length).to.equal(2);
-    expect(member2.notifications.length).to.equal(2);
-  });
-
-  it('deletes task from assigned user', async () => {
-    await user.del(`/tasks/${task._id}`);
-
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-
-    expect(syncedTask).to.not.exist;
-  });
-
-  it('deletes task from all assigned users', async () => {
-    await user.del(`/tasks/${task._id}`);
-
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-
-    const member2Tasks = await member2.get('/tasks/user');
-    const member2SyncedTask = find(member2Tasks, findAssignedTask);
-
-    expect(syncedTask).to.not.exist;
-    expect(member2SyncedTask).to.not.exist;
-  });
-
-  it('prevents a user from deleting a task they are assigned to', async () => {
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-
-    await expect(member.del(`/tasks/${syncedTask._id}`))
-      .to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('cantDeleteAssignedGroupTasks'),
-      });
-  });
-
-  it('allows a user to delete a task after leaving a group', async () => {
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-
-    await member.post(`/groups/${guild._id}/leave`);
-
-    await member.del(`/tasks/${syncedTask._id}`);
-
-    await expect(member.get(`/tasks/${syncedTask._id}`))
-      .to.eventually.be.rejected.and.eql({
-        code: 404,
-        error: 'NotFound',
-        message: 'Task not found.',
-      });
-  });
 });

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

@@ -1,78 +0,0 @@
-import { find } from 'lodash';
-import {
-  createAndPopulateGroup,
-} from '../../../../../helpers/api-integration/v3';
-
-describe('GET /approvals/group/:groupId', () => {
-  let user; let guild; let member; let addlMember; let task; let syncedTask; let
-    addlSyncedTask;
-
-  function findAssignedTask (memberTask) {
-    return memberTask.group.id === guild._id;
-  }
-
-  beforeEach(async () => {
-    const { group, members, groupLeader } = await createAndPopulateGroup({
-      groupDetails: {
-        name: 'Test Guild',
-        type: 'guild',
-      },
-      members: 2,
-      upgradeToGroupPlan: true,
-    });
-
-    guild = group;
-    user = groupLeader;
-    member = members[0]; // eslint-disable-line prefer-destructuring
-    addlMember = members[1]; // eslint-disable-line prefer-destructuring
-
-    task = await user.post(`/tasks/group/${guild._id}`, {
-      text: 'test todo',
-      type: 'todo',
-      requiresApproval: true,
-    });
-
-    await user.post(`/tasks/${task._id}/assign/${member._id}`);
-    await user.post(`/tasks/${task._id}/assign/${addlMember._id}`);
-
-    const memberTasks = await member.get('/tasks/user');
-    syncedTask = find(memberTasks, findAssignedTask);
-
-    const addlMemberTasks = await addlMember.get('/tasks/user');
-    addlSyncedTask = find(addlMemberTasks, findAssignedTask);
-
-    try {
-      await member.post(`/tasks/${syncedTask._id}/score/up`);
-    } catch (e) {
-      // eslint-disable-next-line no-empty
-    }
-
-    try {
-      await addlMember.post(`/tasks/${addlSyncedTask._id}/score/up`);
-    } catch (e) {
-      // eslint-disable-next-line no-empty
-    }
-  });
-
-  it('provides only user\'s own tasks when user is not the group leader', async () => {
-    const approvals = await member.get(`/approvals/group/${guild._id}`);
-    expect(approvals[0]._id).to.equal(syncedTask._id);
-    expect(approvals[1]).to.not.exist;
-  });
-
-  it('allows group leaders to get a list of tasks that need approval', async () => {
-    const approvals = await user.get(`/approvals/group/${guild._id}`);
-    expect(approvals[0]._id).to.equal(syncedTask._id);
-    expect(approvals[1]._id).to.equal(addlSyncedTask._id);
-  });
-
-  it('allows managers to get a list of tasks that need approval', async () => {
-    await user.post(`/groups/${guild._id}/add-manager`, {
-      managerId: member._id,
-    });
-
-    const approvals = await member.get(`/approvals/group/${guild._id}`);
-    expect(approvals[0]._id).to.equal(syncedTask._id);
-    expect(approvals[1]._id).to.equal(addlSyncedTask._id);
-  });
-});

test/api/v3/integration/tasks/groups/POST-group_tasks_id_approve_userId.test.js

@@ -1,261 +0,0 @@
-import { find } from 'lodash';
-import {
-  createAndPopulateGroup,
-  translate as t,
-} from '../../../../../helpers/api-integration/v3';
-
-describe('POST /tasks/:id/approve/:userId', () => {
-  let user; let guild; let member; let member2; let
-    task;
-
-  function findAssignedTask (memberTask) {
-    return memberTask.group.id === guild._id;
-  }
-
-  beforeEach(async () => {
-    const { group, members, groupLeader } = await createAndPopulateGroup({
-      groupDetails: {
-        name: 'Test Guild',
-        type: 'guild',
-      },
-      members: 2,
-      upgradeToGroupPlan: true,
-    });
-
-    guild = group;
-    user = groupLeader;
-    member = members[0]; // eslint-disable-line prefer-destructuring
-    member2 = members[1]; // eslint-disable-line prefer-destructuring
-
-    task = await user.post(`/tasks/group/${guild._id}`, {
-      text: 'test todo',
-      type: 'todo',
-      requiresApproval: true,
-    });
-  });
-
-  it('errors when user is not assigned', async () => {
-    await expect(user.post(`/tasks/${task._id}/approve/${member._id}`))
-      .to.eventually.be.rejected.and.to.eql({
-        code: 404,
-        error: 'NotFound',
-        message: t('messageTaskNotFound'),
-      });
-  });
-
-  it('errors when user is not the group leader', async () => {
-    await user.post(`/tasks/${task._id}/assign/${member._id}`);
-    await expect(member.post(`/tasks/${task._id}/approve/${member._id}`))
-      .to.eventually.be.rejected.and.to.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('onlyGroupLeaderCanEditTasks'),
-      });
-  });
-
-  it('approves an assigned user', async () => {
-    await user.post(`/tasks/${task._id}/assign/${member._id}`);
-
-    let memberTasks = await member.get('/tasks/user');
-    let syncedTask = find(memberTasks, findAssignedTask);
-
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-    await user.post(`/tasks/${task._id}/approve/${member._id}`);
-
-    await member.sync();
-
-    expect(member.notifications.length).to.equal(3);
-    expect(member.notifications[2].type).to.equal('GROUP_TASK_APPROVED');
-    expect(member.notifications[2].data.message).to.equal(t('yourTaskHasBeenApproved', { taskText: task.text }));
-
-    memberTasks = await member.get('/tasks/user');
-    syncedTask = find(memberTasks, findAssignedTask);
-
-    expect(syncedTask.group.approval.approved).to.be.true;
-    expect(syncedTask.group.approval.approvingUser).to.equal(user._id);
-    expect(syncedTask.group.approval.dateApproved).to.be.a('string'); // date gets converted to a string as json doesn't have a Date type
-  });
-
-  it('allows a manager to approve an assigned user', async () => {
-    await user.post(`/groups/${guild._id}/add-manager`, {
-      managerId: member2._id,
-    });
-
-    await member2.post(`/tasks/${task._id}/assign/${member._id}`);
-
-    let memberTasks = await member.get('/tasks/user');
-    let syncedTask = find(memberTasks, findAssignedTask);
-
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-    await member2.post(`/tasks/${task._id}/approve/${member._id}`);
-    await member.sync();
-
-    expect(member.notifications.length).to.equal(3);
-    expect(member.notifications[2].type).to.equal('GROUP_TASK_APPROVED');
-    expect(member.notifications[2].data.message).to.equal(t('yourTaskHasBeenApproved', { taskText: task.text }));
-
-    memberTasks = await member.get('/tasks/user');
-    syncedTask = find(memberTasks, findAssignedTask);
-
-    expect(syncedTask.group.approval.approved).to.be.true;
-    expect(syncedTask.group.approval.approvingUser).to.equal(member2._id);
-    expect(syncedTask.group.approval.dateApproved).to.be.a('string'); // date gets converted to a string as json doesn't have a Date type
-  });
-
-  it('removes approval pending notifications from managers', async () => {
-    await user.post(`/groups/${guild._id}/add-manager`, {
-      managerId: member2._id,
-    });
-
-    await member2.post(`/tasks/${task._id}/assign/${member._id}`);
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-
-    await user.sync();
-    await member2.sync();
-    expect(user.notifications.length).to.equal(3);
-    expect(user.notifications[2].type).to.equal('GROUP_TASK_APPROVAL');
-    expect(member2.notifications.length).to.equal(2);
-    expect(member2.notifications[1].type).to.equal('GROUP_TASK_APPROVAL');
-
-    await member2.post(`/tasks/${task._id}/approve/${member._id}`);
-
-    await user.sync();
-    await member2.sync();
-
-    expect(user.notifications.length).to.equal(2);
-    expect(member2.notifications.length).to.equal(1);
-  });
-
-  it('prevents double approval on a task', async () => {
-    await user.post(`/groups/${guild._id}/add-manager`, {
-      managerId: member2._id,
-    });
-
-    await member2.post(`/tasks/${task._id}/assign/${member._id}`);
-
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-    await member2.post(`/tasks/${task._id}/approve/${member._id}`);
-
-    await expect(user.post(`/tasks/${task._id}/approve/${member._id}`))
-      .to.eventually.be.rejected.and.to.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('canOnlyApproveTaskOnce'),
-      });
-  });
-
-  it('prevents approving a task if it is not waiting for approval', async () => {
-    await user.post(`/tasks/${task._id}/assign/${member._id}`);
-
-    await expect(user.post(`/tasks/${task._id}/approve/${member._id}`))
-      .to.eventually.be.rejected.and.to.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('taskApprovalWasNotRequested'),
-      });
-  });
-
-  it('completes master task when single-completion task is approved', async () => {
-    const sharedCompletionTask = await user.post(`/tasks/group/${guild._id}`, {
-      text: 'shared completion todo',
-      type: 'todo',
-      requiresApproval: true,
-      sharedCompletion: 'singleCompletion',
-    });
-
-    await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member._id}`);
-    await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member2._id}`);
-
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-    await user.post(`/tasks/${sharedCompletionTask._id}/approve/${member._id}`);
-
-    const groupTasks = await user.get(`/tasks/group/${guild._id}?type=completedTodos`);
-
-    const masterTask = find(groupTasks, groupTask => groupTask._id === sharedCompletionTask._id);
-
-    expect(masterTask.completed).to.equal(true);
-  });
-
-  it('deletes other assigned user tasks when single-completion task is approved', async () => {
-    const sharedCompletionTask = await user.post(`/tasks/group/${guild._id}`, {
-      text: 'shared completion todo',
-      type: 'todo',
-      requiresApproval: true,
-      sharedCompletion: 'singleCompletion',
-    });
-
-    await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member._id}`);
-    await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member2._id}`);
-
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-    await user.post(`/tasks/${sharedCompletionTask._id}/approve/${member._id}`);
-
-    const member2Tasks = await member2.get('/tasks/user');
-
-    const syncedTask2 = find(
-      member2Tasks,
-      memberTask => memberTask.group.taskId === sharedCompletionTask._id,
-    );
-
-    expect(syncedTask2).to.equal(undefined);
-  });
-
-  it('does not complete master task when not all user tasks are approved if all assigned must complete', async () => {
-    const sharedCompletionTask = await user.post(`/tasks/group/${guild._id}`, {
-      text: 'shared completion todo',
-      type: 'todo',
-      requiresApproval: true,
-      sharedCompletion: 'allAssignedCompletion',
-    });
-
-    await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member._id}`);
-    await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member2._id}`);
-
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-    await user.post(`/tasks/${sharedCompletionTask._id}/approve/${member._id}`);
-
-    const groupTasks = await user.get(`/tasks/group/${guild._id}`);
-
-    const masterTask = find(groupTasks, groupTask => groupTask._id === sharedCompletionTask._id);
-
-    expect(masterTask.completed).to.equal(false);
-  });
-
-  it('completes master task when all user tasks are approved if all assigned must complete', async () => {
-    const sharedCompletionTask = await user.post(`/tasks/group/${guild._id}`, {
-      text: 'shared completion todo',
-      type: 'todo',
-      requiresApproval: true,
-      sharedCompletion: 'allAssignedCompletion',
-    });
-
-    await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member._id}`);
-    await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member2._id}`);
-
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-    const member2Tasks = await member2.get('/tasks/user');
-    const member2SyncedTask = find(member2Tasks, findAssignedTask);
-    await member2.post(`/tasks/${member2SyncedTask._id}/score/up`);
-
-    await user.post(`/tasks/${sharedCompletionTask._id}/approve/${member._id}`);
-    await user.post(`/tasks/${sharedCompletionTask._id}/approve/${member2._id}`);
-
-    const groupTasks = await user.get(`/tasks/group/${guild._id}?type=completedTodos`);
-
-    const masterTask = find(groupTasks, groupTask => groupTask._id === sharedCompletionTask._id);
-
-    expect(masterTask.completed).to.equal(true);
-  });
-});

test/api/v3/integration/tasks/groups/POST-group_tasks_id_needs-work_userId.test.js

@@ -1,4 +1,3 @@
-import { find } from 'lodash';
 import {
   createAndPopulateGroup,
   translate as t,
@@ -8,10 +7,6 @@ describe('POST /tasks/:id/needs-work/:userId', () => {
   let user; let guild; let member; let member2; let
     task;
 
-  function findAssignedTask (memberTask) {
-    return memberTask.group.id === guild._id;
-  }
-
   beforeEach(async () => {
     const { group, members, groupLeader } = await createAndPopulateGroup({
       groupDetails: {
@@ -37,14 +32,15 @@ describe('POST /tasks/:id/needs-work/:userId', () => {
   it('errors when user is not assigned', async () => {
     await expect(user.post(`/tasks/${task._id}/needs-work/${member._id}`))
       .to.eventually.be.rejected.and.to.eql({
-        code: 404,
-        error: 'NotFound',
-        message: t('messageTaskNotFound'),
+        code: 400,
+        error: 'BadRequest',
+        message: 'Task not completed by this user.',
       });
   });
 
   it('errors when user is not the group leader', async () => {
-    await user.post(`/tasks/${task._id}/assign/${member._id}`);
+    await user.post(`/tasks/${task._id}/assign`, [member._id]);
+    await member.post(`/tasks/${task._id}/score/up`);
     await expect(member.post(`/tasks/${task._id}/needs-work/${member._id}`))
       .to.eventually.be.rejected.and.to.eql({
         code: 401,
@@ -54,132 +50,64 @@ describe('POST /tasks/:id/needs-work/:userId', () => {
   });
 
   it('marks a task as needing more work', async () => {
+    await member.sync();
     const initialNotifications = member.notifications.length;
-
-    await user.post(`/tasks/${task._id}/assign/${member._id}`);
-
-    let memberTasks = await member.get('/tasks/user');
-    let syncedTask = find(memberTasks, findAssignedTask);
+    await user.post(`/tasks/${task._id}/assign`, [member._id]);
 
     // score task to require approval
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
+    await member.post(`/tasks/${task._id}/score/up`);
     await user.post(`/tasks/${task._id}/needs-work/${member._id}`);
 
-    [memberTasks] = await Promise.all([member.get('/tasks/user'), member.sync()]);
-    syncedTask = find(memberTasks, findAssignedTask);
-
-    // Check that the notification approval request has been removed
-    expect(syncedTask.group.approval.requested).to.equal(false);
-    expect(syncedTask.group.approval.requestedDate).to.equal(undefined);
-
     // Check that the notification is correct
+    await member.sync();
     expect(member.notifications.length).to.equal(initialNotifications + 3);
     const notification = member.notifications[member.notifications.length - 1];
     expect(notification.type).to.equal('GROUP_TASK_NEEDS_WORK');
 
-    const taskText = syncedTask.text;
-    const managerName = user.profile.name;
+    const taskText = task.text;
+    const managerName = user.auth.local.username;
 
     expect(notification.data.message).to.equal(t('taskNeedsWork', { taskText, managerName }));
 
-    expect(notification.data.task.id).to.equal(syncedTask._id);
+    expect(notification.data.task.id).to.equal(task._id);
     expect(notification.data.task.text).to.equal(taskText);
 
-    expect(notification.data.group.id).to.equal(syncedTask.group.id);
+    expect(notification.data.group.id).to.equal(task.group.id);
     expect(notification.data.group.name).to.equal(guild.name);
 
     expect(notification.data.manager.id).to.equal(user._id);
     expect(notification.data.manager.name).to.equal(managerName);
-
-    // Check that the managers' GROUP_TASK_APPROVAL notifications have been removed
-    await user.sync();
-
-    expect(user.notifications.find(n => { // eslint-disable-line arrow-body-style
-      return n.data.taskId === syncedTask._id && n.type === 'GROUP_TASK_APPROVAL';
-    })).to.equal(undefined);
   });
 
   it('allows a manager to mark a task as needing work', async () => {
+    await member.sync();
+    const initialNotifications = member.notifications.length;
     await user.post(`/groups/${guild._id}/add-manager`, {
       managerId: member2._id,
     });
-    await member2.post(`/tasks/${task._id}/assign/${member._id}`);
-
-    let memberTasks = await member.get('/tasks/user');
-    let syncedTask = find(memberTasks, findAssignedTask);
+    await member2.post(`/tasks/${task._id}/assign`, [member._id]);
 
     // score task to require approval
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-
-    const initialNotifications = member.notifications.length;
-
+    await member.post(`/tasks/${task._id}/score/up`);
     await member2.post(`/tasks/${task._id}/needs-work/${member._id}`);
 
-    [memberTasks] = await Promise.all([member.get('/tasks/user'), member.sync()]);
-    syncedTask = find(memberTasks, findAssignedTask);
-
-    // Check that the notification approval request has been removed
-    expect(syncedTask.group.approval.requested).to.equal(false);
-    expect(syncedTask.group.approval.requestedDate).to.equal(undefined);
-
+    await member.sync();
     expect(member.notifications.length).to.equal(initialNotifications + 3);
     const notification = member.notifications[member.notifications.length - 1];
     expect(notification.type).to.equal('GROUP_TASK_NEEDS_WORK');
 
-    const taskText = syncedTask.text;
-    const managerName = member2.profile.name;
+    const taskText = task.text;
+    const managerName = member2.auth.local.username;
 
     expect(notification.data.message).to.equal(t('taskNeedsWork', { taskText, managerName }));
 
-    expect(notification.data.task.id).to.equal(syncedTask._id);
+    expect(notification.data.task.id).to.equal(task._id);
     expect(notification.data.task.text).to.equal(taskText);
 
-    expect(notification.data.group.id).to.equal(syncedTask.group.id);
+    expect(notification.data.group.id).to.equal(task.group.id);
     expect(notification.data.group.name).to.equal(guild.name);
 
     expect(notification.data.manager.id).to.equal(member2._id);
     expect(notification.data.manager.name).to.equal(managerName);
-
-    // Check that the managers' GROUP_TASK_APPROVAL notifications have been removed
-    await Promise.all([user.sync(), member2.sync()]);
-
-    expect(user.notifications.find(n => { // eslint-disable-line arrow-body-style
-      return n.data.taskId === syncedTask._id && n.type === 'GROUP_TASK_APPROVAL';
-    })).to.equal(undefined);
-
-    expect(member2.notifications.find(n => { // eslint-disable-line arrow-body-style
-      return n.data.taskId === syncedTask._id && n.type === 'GROUP_TASK_APPROVAL';
-    })).to.equal(undefined);
-  });
-
-  it('prevents marking a task as needing work if it was already approved', async () => {
-    await user.post(`/groups/${guild._id}/add-manager`, {
-      managerId: member2._id,
-    });
-
-    await member2.post(`/tasks/${task._id}/assign/${member._id}`);
-
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-    await member2.post(`/tasks/${task._id}/approve/${member._id}`);
-    await expect(user.post(`/tasks/${task._id}/needs-work/${member._id}`))
-      .to.eventually.be.rejected.and.to.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('canOnlyApproveTaskOnce'),
-      });
-  });
-
-  it('prevents marking a task as needing work if it is not waiting for approval', async () => {
-    await user.post(`/tasks/${task._id}/assign/${member._id}`);
-
-    await expect(user.post(`/tasks/${task._id}/needs-work/${member._id}`))
-      .to.eventually.be.rejected.and.to.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('taskApprovalWasNotRequested'),
-      });
   });
 });

test/api/v3/integration/tasks/groups/POST-group_tasks_id_score_direction.test.js

@@ -8,10 +8,6 @@ describe('POST /tasks/:id/score/:direction', () => {
   let user; let guild; let member; let member2; let
     task;
 
-  function findAssignedTask (memberTask) {
-    return memberTask.group.id === guild._id;
-  }
-
   beforeEach(async () => {
     const { group, members, groupLeader } = await createAndPopulateGroup({
       groupDetails: {
@@ -30,209 +26,50 @@ describe('POST /tasks/:id/score/:direction', () => {
     task = await user.post(`/tasks/group/${guild._id}`, {
       text: 'test todo',
       type: 'todo',
-      requiresApproval: true,
     });
 
-    await user.post(`/tasks/${task._id}/assign/${member._id}`);
+    await user.post(`/tasks/${task._id}/assign`, [member._id]);
   });
 
-  it('prevents user from scoring a task that needs to be approved', async () => {
-    await user.update({
-      'preferences.language': 'cs',
-    });
-
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-    const direction = 'up';
-
-    const response = await member.post(`/tasks/${syncedTask._id}/score/${direction}`);
-
-    expect(response.data.requiresApproval).to.equal(true);
-    expect(response.message).to.equal(t('taskApprovalHasBeenRequested'));
-
-    const updatedTask = await member.get(`/tasks/${syncedTask._id}`);
-
-    await user.sync();
-
-    expect(user.notifications.length).to.equal(3);
-    expect(user.notifications[2].type).to.equal('GROUP_TASK_APPROVAL');
-    expect(user.notifications[2].data.message).to.equal(t('userHasRequestedTaskApproval', {
-      user: member.auth.local.username,
-      taskName: updatedTask.text,
-      taskId: updatedTask._id,
-      direction,
-    }, 'cs')); // This test only works if we have the notification translated
-    expect(user.notifications[2].data.groupId).to.equal(guild._id);
-
-    expect(updatedTask.group.approval.requested).to.equal(true);
-    expect(updatedTask.group.approval.requestedDate).to.be.a('string'); // date gets converted to a string as json doesn't have a Date type
-  });
-
-  it('sends notifications to all managers', async () => {
-    await user.post(`/groups/${guild._id}/add-manager`, {
-      managerId: member2._id,
-    });
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-    const direction = 'up';
-
-    await member.post(`/tasks/${syncedTask._id}/score/${direction}`);
-    const updatedTask = await member.get(`/tasks/${syncedTask._id}`);
-    await user.sync();
-    await member2.sync();
-
-    expect(user.notifications.length).to.equal(3);
-    expect(user.notifications[2].type).to.equal('GROUP_TASK_APPROVAL');
-    expect(user.notifications[2].data.message).to.equal(t('userHasRequestedTaskApproval', {
-      user: member.auth.local.username,
-      taskName: updatedTask.text,
-      taskId: updatedTask._id,
-      direction,
-    }));
-    expect(user.notifications[2].data.groupId).to.equal(guild._id);
-
-    expect(member2.notifications.length).to.equal(2);
-    expect(member2.notifications[1].type).to.equal('GROUP_TASK_APPROVAL');
-    expect(member2.notifications[1].data.message).to.equal(t('userHasRequestedTaskApproval', {
-      user: member.auth.local.username,
-      taskName: updatedTask.text,
-      taskId: updatedTask._id,
-      direction,
-    }));
-    expect(member2.notifications[1].data.groupId).to.equal(guild._id);
-  });
-
-  it('errors when approval has already been requested', async () => {
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-
-    const response = await member.post(`/tasks/${syncedTask._id}/score/up`);
-    expect(response.data.requiresApproval).to.equal(true);
-    expect(response.message).to.equal(t('taskRequiresApproval'));
-  });
-
-  it('allows a user to score an approved task', async () => {
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-
-    await user.post(`/tasks/${task._id}/approve/${member._id}`);
-
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-    const updatedTask = await member.get(`/tasks/${syncedTask._id}`);
-
-    expect(updatedTask.completed).to.equal(true);
-    expect(updatedTask.dateCompleted).to.be.a('string'); // date gets converted to a string as json doesn't have a Date type
-  });
-
-  it('completes master task when single-completion task is completed', async () => {
-    const sharedCompletionTask = await user.post(`/tasks/group/${guild._id}`, {
-      text: 'shared completion todo',
-      type: 'todo',
-      requiresApproval: false,
-      sharedCompletion: 'singleCompletion',
-    });
-
-    await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member._id}`);
-    const memberTasks = await member.get('/tasks/user');
-
-    const syncedTask = find(
-      memberTasks,
-      memberTask => memberTask.group.taskId === sharedCompletionTask._id,
-    );
-
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
+  it('completes single-assigned task', async () => {
+    await member.post(`/tasks/${task._id}/score/up`);
 
     const groupTasks = await user.get(`/tasks/group/${guild._id}?type=completedTodos`);
-    const masterTask = find(groupTasks, groupTask => groupTask._id === sharedCompletionTask._id);
+    const sourceTask = find(groupTasks, groupTask => groupTask._id === task._id);
 
-    expect(masterTask.completed).to.equal(true);
+    expect(sourceTask.completed).to.equal(true);
   });
 
-  it('deletes other assigned user tasks when single-completion task is completed', async () => {
-    const sharedCompletionTask = await user.post(`/tasks/group/${guild._id}`, {
-      text: 'shared completion todo',
-      type: 'todo',
-      requiresApproval: false,
-      sharedCompletion: 'singleCompletion',
+  it('errors when task has already been completed', async () => {
+    await member.post(`/tasks/${task._id}/score/up`);
+
+    await expect(member.post(`/tasks/${task._id}/score/up`)).to.be.rejected.and.to.eventually.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('sessionOutdated'),
     });
-
-    await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member._id}`);
-    await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member2._id}`);
-    const memberTasks = await member.get('/tasks/user');
-
-    const syncedTask = find(
-      memberTasks,
-      memberTask => memberTask.group.taskId === sharedCompletionTask._id,
-    );
-
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-
-    const member2Tasks = await member2.get('/tasks/user');
-
-    const syncedTask2 = find(
-      member2Tasks,
-      memberTask => memberTask.group.taskId === sharedCompletionTask._id,
-    );
-
-    expect(syncedTask2).to.equal(undefined);
   });
 
-  it('does not complete master task when not all user tasks are completed if all assigned must complete', async () => {
-    const sharedCompletionTask = await user.post(`/tasks/group/${guild._id}`, {
-      text: 'shared completion todo',
-      type: 'todo',
-      requiresApproval: false,
-      sharedCompletion: 'allAssignedCompletion',
-    });
+  it('does not complete multi-assigned task when not all assignees have completed', async () => {
+    await user.post(`/tasks/${task._id}/assign`, [member2._id]);
 
-    await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member._id}`);
-    await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member2._id}`);
-    const memberTasks = await member.get('/tasks/user');
-
-    const syncedTask = find(
-      memberTasks,
-      memberTask => memberTask.group.taskId === sharedCompletionTask._id,
-    );
-
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
+    await member.post(`/tasks/${task._id}/score/up`);
 
     const groupTasks = await user.get(`/tasks/group/${guild._id}`);
-    const masterTask = find(groupTasks, groupTask => groupTask._id === sharedCompletionTask._id);
+    const sourceTask = find(groupTasks, groupTask => groupTask._id === task._id);
 
-    expect(masterTask.completed).to.equal(false);
+    expect(sourceTask.completed).to.equal(false);
   });
 
-  it('completes master task when all user tasks are completed if all assigned must complete', async () => {
-    const sharedCompletionTask = await user.post(`/tasks/group/${guild._id}`, {
-      text: 'shared completion todo',
-      type: 'todo',
-      requiresApproval: false,
-      sharedCompletion: 'allAssignedCompletion',
-    });
+  it('completes multi-assigned task when all assignees have completed', async () => {
+    await user.post(`/tasks/${task._id}/assign`, [member2._id]);
 
-    await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member._id}`);
-    await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member2._id}`);
-    const memberTasks = await member.get('/tasks/user');
-    const member2Tasks = await member2.get('/tasks/user');
-    const syncedTask = find(
-      memberTasks,
-      memberTask => memberTask.group.taskId === sharedCompletionTask._id,
-    );
-    const syncedTask2 = find(
-      member2Tasks,
-      memberTask => memberTask.group.taskId === sharedCompletionTask._id,
-    );
-
-    await member.post(`/tasks/${syncedTask._id}/score/up`);
-    await member2.post(`/tasks/${syncedTask2._id}/score/up`);
+    await member.post(`/tasks/${task._id}/score/up`);
+    await member2.post(`/tasks/${task._id}/score/up`);
 
     const groupTasks = await user.get(`/tasks/group/${guild._id}?type=completedTodos`);
-    const masterTask = find(groupTasks, groupTask => groupTask._id === sharedCompletionTask._id);
+    const sourceTask = find(groupTasks, groupTask => groupTask._id === task._id);
 
-    expect(masterTask.completed).to.equal(true);
+    expect(sourceTask.completed).to.equal(true);
   });
 });

test/api/v3/integration/tasks/groups/POST-tasks_group_id_assign_user_id.test.js

@@ -39,7 +39,7 @@ describe('POST /tasks/:taskId/assign/:memberId', () => {
   });
 
   it('returns error when task is not found', async () => {
-    await expect(user.post(`/tasks/${generateUUID()}/assign/${member._id}`))
+    await expect(user.post(`/tasks/${generateUUID()}/assign`, [member._id]))
       .to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
@@ -56,7 +56,7 @@ describe('POST /tasks/:taskId/assign/:memberId', () => {
       notes: 1976,
     });
 
-    await expect(user.post(`/tasks/${nonGroupTask._id}/assign/${member._id}`))
+    await expect(user.post(`/tasks/${nonGroupTask._id}/assign`, [member._id]))
       .to.eventually.be.rejected.and.eql({
         code: 401,
         error: 'NotAuthorized',
@@ -67,7 +67,7 @@ describe('POST /tasks/:taskId/assign/:memberId', () => {
   it('returns error when user is not a member of the group', async () => {
     const nonUser = await generateUser();
 
-    await expect(nonUser.post(`/tasks/${task._id}/assign/${member._id}`))
+    await expect(nonUser.post(`/tasks/${task._id}/assign`, [member._id]))
       .to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
@@ -76,7 +76,7 @@ describe('POST /tasks/:taskId/assign/:memberId', () => {
   });
 
   it('returns error when non leader tries to create a task', async () => {
-    await expect(member2.post(`/tasks/${task._id}/assign/${member._id}`))
+    await expect(member2.post(`/tasks/${task._id}/assign`, [member._id]))
       .to.eventually.be.rejected.and.eql({
         code: 401,
         error: 'NotAuthorized',
@@ -84,49 +84,23 @@ describe('POST /tasks/:taskId/assign/:memberId', () => {
       });
   });
 
-  it('allows user to assign themselves (claim)', async () => {
-    await member.post(`/tasks/${task._id}/assign/${member._id}`);
-
-    const groupTask = await user.get(`/tasks/group/${guild._id}`);
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-
-    expect(groupTask[0].group.assignedUsers).to.contain(member._id);
-    expect(syncedTask).to.exist;
-  });
-
-  it('sends notifications to group leader and managers when a task is claimed', async () => {
-    await user.post(`/groups/${guild._id}/add-manager`, {
-      managerId: member2._id,
-    });
-    await member.post(`/tasks/${task._id}/assign/${member._id}`);
-    await user.sync();
-    await member2.sync();
-    const groupTask = await user.get(`/tasks/group/${guild._id}`);
-
-    expect(user.notifications.length).to.equal(3); // includes Guild Joined achievement
-    expect(user.notifications[2].type).to.equal('GROUP_TASK_CLAIMED');
-    expect(user.notifications[2].data.taskId).to.equal(groupTask[0]._id);
-    expect(user.notifications[2].data.groupId).to.equal(guild._id);
-    expect(member2.notifications.length).to.equal(2);
-    expect(member2.notifications[1].type).to.equal('GROUP_TASK_CLAIMED');
-    expect(member2.notifications[1].data.taskId).to.equal(groupTask[0]._id);
-    expect(member2.notifications[1].data.groupId).to.equal(guild._id);
-  });
-
   it('assigns a task to a user', async () => {
-    await user.post(`/tasks/${task._id}/assign/${member._id}`);
+    await user.post(`/tasks/${task._id}/assign`, [member._id]);
 
     const groupTask = await user.get(`/tasks/group/${guild._id}`);
+    await member.put('/user', {
+      'preferences.tasks.mirrorGroupTasks': [guild._id],
+    });
     const memberTasks = await member.get('/tasks/user');
     const syncedTask = find(memberTasks, findAssignedTask);
 
     expect(groupTask[0].group.assignedUsers).to.contain(member._id);
+    expect(groupTask[0].group.assignedUsersDetail[member._id]).to.exist;
     expect(syncedTask).to.exist;
   });
 
   it('sends a notification to assigned user', async () => {
-    await user.post(`/tasks/${task._id}/assign/${member._id}`);
+    await user.post(`/tasks/${task._id}/assign`, [member._id]);
     await member.sync();
 
     const groupTask = await user.get(`/tasks/group/${guild._id}`);
@@ -137,20 +111,27 @@ describe('POST /tasks/:taskId/assign/:memberId', () => {
   });
 
   it('assigns a task to multiple users', async () => {
-    await user.post(`/tasks/${task._id}/assign/${member._id}`);
-    await user.post(`/tasks/${task._id}/assign/${member2._id}`);
+    await user.post(`/tasks/${task._id}/assign`, [member._id, member2._id]);
 
     const groupTask = await user.get(`/tasks/group/${guild._id}`);
 
+    await member.put('/user', {
+      'preferences.tasks.mirrorGroupTasks': [guild._id],
+    });
     const memberTasks = await member.get('/tasks/user');
     const member1SyncedTask = find(memberTasks, findAssignedTask);
 
+    await member2.put('/user', {
+      'preferences.tasks.mirrorGroupTasks': [guild._id],
+    });
     const member2Tasks = await member2.get('/tasks/user');
     const member2SyncedTask = find(member2Tasks, findAssignedTask);
 
     expect(groupTask[0].group.assignedUsers).to.contain(member._id);
-    expect(groupTask[0].group.assignedUsers).to.contain(member2._id);
+    expect(groupTask[0].group.assignedUsersDetail[member._id]).to.exist;
     expect(member1SyncedTask).to.exist;
+    expect(groupTask[0].group.assignedUsers).to.contain(member2._id);
+    expect(groupTask[0].group.assignedUsersDetail[member2._id]).to.exist;
     expect(member2SyncedTask).to.exist;
   });
 
@@ -159,13 +140,17 @@ describe('POST /tasks/:taskId/assign/:memberId', () => {
       managerId: member2._id,
     });
 
-    await member2.post(`/tasks/${task._id}/assign/${member._id}`);
+    await member2.post(`/tasks/${task._id}/assign`, [member._id]);
 
     const groupTask = await member2.get(`/tasks/group/${guild._id}`);
+    await member.put('/user', {
+      'preferences.tasks.mirrorGroupTasks': [guild._id],
+    });
     const memberTasks = await member.get('/tasks/user');
     const syncedTask = find(memberTasks, findAssignedTask);
 
     expect(groupTask[0].group.assignedUsers).to.contain(member._id);
+    expect(groupTask[0].group.assignedUsersDetail[member._id]).to.exist;
     expect(syncedTask).to.exist;
   });
 });

test/api/v3/integration/tasks/groups/POST-tasks_move_taskId_to_position.test.js

@@ -1,6 +1,5 @@
 import {
-  generateUser,
-  generateGroup,
+  createAndPopulateGroup,
 } from '../../../../../helpers/api-integration/v3';
 
 describe('POST group-tasks/:taskId/move/to/:position', () => {
@@ -8,8 +7,12 @@ describe('POST group-tasks/:taskId/move/to/:position', () => {
     guild;
 
   beforeEach(async () => {
-    user = await generateUser({ balance: 1 });
-    guild = await generateGroup(user, { type: 'guild' }, { 'purchased.plan.customerId': 'group-unlimited' });
+    const { group, groupLeader } = await createAndPopulateGroup({
+      groupDetails: { type: 'guild', privacy: 'private' },
+      upgradeToGroupPlan: true,
+    });
+    guild = group;
+    user = groupLeader;
   });
 
   it('can move task to new position', async () => {

test/api/v3/integration/tasks/groups/POST-tasks_task_id_unassign.test.js

@@ -37,7 +37,7 @@ describe('POST /tasks/:taskId/unassign/:memberId', () => {
       notes: 1976,
     });
 
-    await user.post(`/tasks/${task._id}/assign/${member._id}`);
+    await user.post(`/tasks/${task._id}/assign`, [member._id]);
   });
 
   it('returns error when task is not found', async () => {
@@ -96,7 +96,7 @@ describe('POST /tasks/:taskId/unassign/:memberId', () => {
   });
 
   it('unassigns a user and only that user from a task', async () => {
-    await user.post(`/tasks/${task._id}/assign/${member2._id}`);
+    await user.post(`/tasks/${task._id}/assign`, [member2._id]);
 
     await user.post(`/tasks/${task._id}/unassign/${member._id}`);
 
@@ -105,6 +105,9 @@ describe('POST /tasks/:taskId/unassign/:memberId', () => {
     const memberTasks = await member.get('/tasks/user');
     const member1SyncedTask = find(memberTasks, findAssignedTask);
 
+    await member2.put('/user', {
+      'preferences.tasks.mirrorGroupTasks': [guild._id],
+    });
     const member2Tasks = await member2.get('/tasks/user');
     const member2SyncedTask = find(member2Tasks, findAssignedTask);
 
@@ -130,20 +133,7 @@ describe('POST /tasks/:taskId/unassign/:memberId', () => {
     expect(syncedTask).to.not.exist;
   });
 
-  it('allows a user to unassign themselves', async () => {
-    await member.post(`/tasks/${task._id}/unassign/${member._id}`);
-
-    const groupTask = await user.get(`/tasks/group/${guild._id}`);
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-
-    expect(groupTask[0].group.assignedUsers).to.not.contain(member._id);
-    expect(syncedTask).to.not.exist;
-  });
-
-  // @TODO: Which do we want? The user to unassign themselves or not. This test was in
-  // here, but then we had a request to allow to unaissgn.
-  xit('returns error when non leader tries to unassign their a task', async () => {
+  it('returns error when non leader tries to unassign a task', async () => {
     await expect(member.post(`/tasks/${task._id}/unassign/${member._id}`))
       .to.eventually.be.rejected.and.eql({
         code: 401,

test/api/v3/integration/tasks/groups/PUT-group_task_id.test.js

@@ -1,4 +1,3 @@
-import { find } from 'lodash';
 import {
   createAndPopulateGroup, translate as t,
 } from '../../../../../helpers/api-integration/v3';
@@ -11,10 +10,6 @@ describe('PUT /tasks/:id', () => {
   let habit;
   let todo;
 
-  function findAssignedTask (memberTask) {
-    return memberTask.group.id === guild._id;
-  }
-
   beforeEach(async () => {
     const { group, members, groupLeader } = await createAndPopulateGroup({
       groupDetails: {
@@ -44,8 +39,7 @@ describe('PUT /tasks/:id', () => {
       notes: 1976,
     });
 
-    await user.post(`/tasks/${habit._id}/assign/${member._id}`);
-    await user.post(`/tasks/${habit._id}/assign/${member2._id}`);
+    await user.post(`/tasks/${habit._id}/assign`, [member._id, member2._id]);
   });
 
   it('updates a group task', async () => {
@@ -56,28 +50,6 @@ describe('PUT /tasks/:id', () => {
     expect(savedHabit.notes).to.eql('some new notes');
   });
 
-  it('updates a group task - approval is required', async () => {
-    // allow to manage
-    await user.post(`/groups/${guild._id}/add-manager`, {
-      managerId: member._id,
-    });
-
-    // change the habit
-    habit = await member.put(`/tasks/${habit._id}`, {
-      text: 'new text!',
-      requiresApproval: true,
-    });
-
-    const memberTasks = await member2.get('/tasks/user');
-    const syncedTask = find(memberTasks, memberTask => memberTask.group.taskId === habit._id);
-
-    // score up to trigger approval
-    const response = await member2.post(`/tasks/${syncedTask._id}/score/up`);
-
-    expect(response.data.requiresApproval).to.equal(true);
-    expect(response.message).to.equal(t('taskApprovalHasBeenRequested'));
-  });
-
   it('member updates a group task value - not allowed', async () => {
     // change the todo
     await expect(member.put(`/tasks/${habit._id}`, {
@@ -120,7 +92,7 @@ describe('PUT /tasks/:id', () => {
       ],
     });
 
-    await user.post(`/tasks/${habit._id}/assign/${member._id}`);
+    await user.post(`/tasks/${habit._id}/assign`, [member._id]);
 
     // change the checklist text
     habit = await user.put(`/tasks/${habit._id}`, {
@@ -137,63 +109,4 @@ describe('PUT /tasks/:id', () => {
 
     expect(habit.checklist.length).to.eql(2);
   });
-
-  it('updates the linked tasks', async () => {
-    await user.put(`/tasks/${habit._id}`, {
-      text: 'some new text',
-      up: false,
-      down: false,
-      notes: 'some new notes',
-    });
-
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-
-    expect(syncedTask.text).to.eql('some new text');
-    expect(syncedTask.up).to.eql(false);
-    expect(syncedTask.down).to.eql(false);
-  });
-
-  it('updates the linked tasks for all assigned users', async () => {
-    await user.put(`/tasks/${habit._id}`, {
-      text: 'some new text',
-      up: false,
-      down: false,
-      notes: 'some new notes',
-    });
-
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-
-    const member2Tasks = await member2.get('/tasks/user');
-    const member2SyncedTask = find(member2Tasks, findAssignedTask);
-
-    expect(syncedTask.text).to.eql('some new text');
-    expect(syncedTask.up).to.eql(false);
-    expect(syncedTask.down).to.eql(false);
-
-    expect(member2SyncedTask.text).to.eql('some new text');
-    expect(member2SyncedTask.up).to.eql(false);
-    expect(member2SyncedTask.down).to.eql(false);
-  });
-
-  it('updates the linked tasks', async () => {
-    await user.post(`/groups/${guild._id}/add-manager`, {
-      managerId: member2._id,
-    });
-
-    await member2.put(`/tasks/${habit._id}`, {
-      text: 'some new text',
-      up: false,
-      down: false,
-      notes: 'some new notes',
-    });
-
-    const memberTasks = await member.get('/tasks/user');
-    const syncedTask = find(memberTasks, findAssignedTask);
-
-    expect(syncedTask.text).to.eql('some new text');
-    expect(syncedTask.up).to.eql(false);
-    expect(syncedTask.down).to.eql(false);
-  });
 });

test/api/v3/integration/user/DELETE-user.test.js

@@ -1,5 +1,4 @@
 import {
-  find,
   each,
   map,
 } from 'lodash';
@@ -198,134 +197,6 @@ describe('DELETE /user', () => {
         await expect(checkExistence('party', party._id)).to.eventually.eql(false);
       });
     });
-
-    context('last member of a private guild', () => {
-      let privateGuild;
-
-      beforeEach(async () => {
-        privateGuild = await generateGroup(user, {
-          type: 'guild',
-          privacy: 'private',
-        });
-      });
-
-      it('deletes guild when user is the only member', async () => {
-        await user.del('/user', {
-          password,
-        });
-        await expect(checkExistence('groups', privateGuild._id)).to.eventually.eql(false);
-      });
-    });
-
-    context('groups user is leader of', () => {
-      let guild; let oldLeader; let
-        newLeader;
-
-      beforeEach(async () => {
-        const { group, groupLeader, members } = await createAndPopulateGroup({
-          groupDetails: {
-            type: 'guild',
-            privacy: 'public',
-          },
-          members: 1,
-        });
-
-        guild = group;
-        newLeader = members[0]; // eslint-disable-line prefer-destructuring
-        oldLeader = groupLeader;
-      });
-
-      it('chooses new group leader for any group user was the leader of', async () => {
-        await oldLeader.del('/user', {
-          password,
-        });
-
-        const updatedGuild = await newLeader.get(`/groups/${guild._id}`);
-
-        expect(updatedGuild.leader).to.exist;
-        expect(updatedGuild.leader._id).to.not.eql(oldLeader._id);
-      });
-    });
-
-    context('groups user is a part of', () => {
-      let group1; let group2; let userToDelete; let
-        otherUser;
-
-      beforeEach(async () => {
-        userToDelete = await generateUser({ balance: 10 });
-
-        group1 = await generateGroup(userToDelete, {
-          type: 'guild',
-          privacy: 'public',
-        });
-
-        const { group, members } = await createAndPopulateGroup({
-          groupDetails: {
-            type: 'guild',
-            privacy: 'public',
-          },
-          members: 3,
-        });
-
-        group2 = group;
-        otherUser = members[0]; // eslint-disable-line prefer-destructuring
-
-        await userToDelete.post(`/groups/${group2._id}/join`);
-      });
-
-      it('removes user from all groups user was a part of', async () => {
-        await userToDelete.del('/user', {
-          password,
-        });
-
-        const updatedGroup1Members = await otherUser.get(`/groups/${group1._id}/members`);
-        const updatedGroup2Members = await otherUser.get(`/groups/${group2._id}/members`);
-        const userInGroup = find(updatedGroup2Members, member => member._id === userToDelete._id);
-
-        expect(updatedGroup1Members).to.be.empty;
-        expect(updatedGroup2Members).to.not.be.empty;
-        expect(userInGroup).to.not.exist;
-      });
-    });
-  });
-
-  context('user with Facebook auth', async () => {
-    beforeEach(async () => {
-      user = await generateUser({
-        auth: {
-          facebook: {
-            id: 'facebook-id',
-          },
-        },
-      });
-    });
-
-    it('returns an error if confirmation phrase is wrong', async () => {
-      await expect(user.del('/user', {
-        password: 'just-do-it',
-      })).to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('incorrectDeletePhrase', { magicWord: 'DELETE' }),
-      });
-    });
-
-    it('returns an error if confirmation phrase is not supplied', async () => {
-      await expect(user.del('/user', {
-        password: '',
-      })).to.eventually.be.rejected.and.eql({
-        code: 400,
-        error: 'BadRequest',
-        message: t('missingPassword'),
-      });
-    });
-
-    it('deletes a Facebook user', async () => {
-      await user.del('/user', {
-        password: DELETE_CONFIRMATION,
-      });
-      await expect(checkExistence('users', user._id)).to.eventually.eql(false);
-    });
   });
 
   context('user with Google auth', async () => {