5.18.0

commit 44b1c8c7ba8b45cb682973fb89b70445d0f5c478
Merge: 489c15b7fd 4dadb64af0
Author: Sabe Jones <sabe@habitica.com>
Date:   Thu Feb 8 14:49:05 2024 -0600

    Merge branch 'release' into phillip/panel_profile

commit 489c15b7fd
Author: Phillip Thelen <phillip@habitica.com>
Date:   Wed Dec 14 13:29:32 2022 +0100

    allow profiles to be edited in admin panel

commit 1afaaf4089
Author: Phillip Thelen <phillip@habitica.com>
Date:   Wed Dec 14 12:50:47 2022 +0100

    include month for next hourglass date in admin panel

.eslintrc.js

@@ -1,6 +1,10 @@
+/* eslint-disable import/no-commonjs */
 module.exports = {
   root: true,
   extends: [
-    'habitrpg/lib/node'
+    'habitrpg/lib/node',
   ],
-}
+  rules: {
+    'import/no-extraneous-dependencies': 'off',
+  },
+};

.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

.gitignore

@@ -40,6 +40,7 @@ yarn.lock
 !.elasticbeanstalk/*.global.yml
 
 /.vscode
+habitica.code-workspace
 
 # webstorm fake webpack for path intellisense
 webpack.webstorm.config

Dockerfile

@@ -1,30 +0,0 @@
-FROM node:14
-
-ENV ADMIN_EMAIL admin@habitica.com
-ENV EMAILS_COMMUNITY_MANAGER_EMAIL admin@habitica.com
-ENV AMAZON_PAYMENTS_CLIENT_ID amzn1.application-oa2-client.68ed9e6904ef438fbc1bf86bf494056e
-ENV AMAZON_PAYMENTS_SELLER_ID AMQ3SB4SG5E91
-ENV AMPLITUDE_KEY e8d4c24b3d6ef3ee73eeba715023dd43
-ENV BASE_URL https://habitica.com
-ENV FACEBOOK_KEY 128307497299777
-ENV GA_ID UA-33510635-1
-ENV GOOGLE_CLIENT_ID 1035232791481-32vtplgnjnd1aufv3mcu1lthf31795fq.apps.googleusercontent.com
-ENV LOGGLY_CLIENT_TOKEN ab5663bf-241f-4d14-8783-7d80db77089a
-ENV NODE_ENV production
-ENV STRIPE_PUB_KEY pk_85fQ0yMECHNfHTSsZoxZXlPSwSNfA
-ENV APPLE_AUTH_CLIENT_ID 9Q9SMRMCNN.com.habitrpg.ios.Habitica
-
-# Install global packages
-RUN npm install -g gulp-cli mocha
-
-# Clone Habitica repo and install dependencies
-RUN mkdir -p /usr/src/habitrpg
-WORKDIR /usr/src/habitrpg
-RUN git clone --branch release --depth 1 https://github.com/HabitRPG/habitica.git /usr/src/habitrpg
-RUN git config --global url."https://".insteadOf git://
-RUN npm set unsafe-perm true
-RUN npm install
-
-# Start Habitica
-EXPOSE 80 8080 36612
-CMD ["node", "./website/transpiled-babel/index.js"]

config.json.example

@@ -87,5 +87,5 @@
   "REDIS_HOST": "aaabbbcccdddeeefff",
   "REDIS_PORT": "1234",
   "REDIS_PASSWORD": "12345678",
-  "TRUSTED_DOMAINS": "https://localhost,https://habitica.com"
+  "TRUSTED_DOMAINS": "localhost,habitica.com"
 }

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();

gulp/gulp-console.js

@@ -2,7 +2,6 @@ import mongoose from 'mongoose';
 import nconf from 'nconf';
 import repl from 'repl';
 import gulp from 'gulp';
-import logger from '../website/server/libs/logger';
 import {
   getDevelopmentConnectionUrl,
   getDefaultConnectionOptions,
@@ -39,10 +38,6 @@ const improveRepl = context => {
   mongoose.connect(
     connectionUrl,
     mongooseOptions,
-    err => {
-      if (err) throw err;
-      logger.info('Connected with Mongoose');
-    },
   );
 };
 

gulp/gulp-tests.js

@@ -59,13 +59,15 @@ gulp.task('test:prepare:mongo', cb => {
   const mongooseOptions = getDefaultConnectionOptions();
   const connectionUrl = getDevelopmentConnectionUrl(TEST_DB_URI);
 
-  mongoose.connect(connectionUrl, mongooseOptions, err => {
-    if (err) return cb(`Unable to connect to mongo database. Are you sure it's running? \n\n${err}`);
-    return mongoose.connection.dropDatabase(err2 => {
-      if (err2) return cb(err2);
-      return mongoose.connection.close(cb);
+  mongoose.connect(connectionUrl, mongooseOptions)
+    .then(() => mongoose.connection.dropDatabase())
+    .then(() => mongoose.connection.close()).then(() => {
+      cb();
+    })
+    .catch(err => {
+      if (err) return cb(`Unable to connect to mongo database. Are you sure it's running? \n\n${err}`);
+      throw err;
     });
-  });
 });
 
 gulp.task('test:prepare:server', gulp.series('test:prepare:mongo', done => {
@@ -116,8 +118,10 @@ gulp.task('test:common:safe', gulp.series('test:prepare:build', cb => {
   pipe(runner);
 }));
 
-gulp.task('test:content', gulp.series('test:prepare:build',
-  runInChildProcess(CONTENT_TEST_COMMAND, LIMIT_MAX_BUFFER_OPTIONS)));
+gulp.task('test:content', gulp.series(
+  'test:prepare:build',
+  runInChildProcess(CONTENT_TEST_COMMAND, LIMIT_MAX_BUFFER_OPTIONS),
+));
 
 gulp.task('test:content:clean', cb => {
   pipe(exec(testBin(CONTENT_TEST_COMMAND), LIMIT_MAX_BUFFER_OPTIONS, () => cb()));
@@ -142,16 +146,20 @@ gulp.task('test:content:safe', gulp.series('test:prepare:build', cb => {
   pipe(runner);
 }));
 
-gulp.task('test:api:unit:run',
-  runInChildProcess(integrationTestCommand('test/api/unit', 'coverage/api-unit')));
+gulp.task(
+  'test:api:unit:run',
+  runInChildProcess(integrationTestCommand('test/api/unit', 'coverage/api-unit')),
+);
 
 gulp.task('test:api:unit:watch', () => gulp.watch(['website/server/libs/*', 'test/api/unit/**/*', 'website/server/controllers/**/*'], gulp.series('test:api:unit:run', done => done())));
 
-gulp.task('test:api-v3:integration', gulp.series('test:prepare:mongo',
+gulp.task('test:api-v3:integration', gulp.series(
+  'test:prepare:mongo',
   runInChildProcess(
     integrationTestCommand('test/api/v3/integration', 'coverage/api-v3-integration'),
     LIMIT_MAX_BUFFER_OPTIONS,
-  )));
+  ),
+));
 
 gulp.task('test:api-v3:integration:watch', () => gulp.watch([
   'website/server/controllers/api-v3/**/*', 'common/script/ops/*', 'website/server/libs/*.js',
@@ -164,11 +172,13 @@ gulp.task('test:api-v3:integration:separate-server', runInChildProcess(
   'LOAD_SERVER=0',
 ));
 
-gulp.task('test:api-v4:integration', gulp.series('test:prepare:mongo',
+gulp.task('test:api-v4:integration', gulp.series(
+  'test:prepare:mongo',
   runInChildProcess(
     integrationTestCommand('test/api/v4', 'api-v4-integration'),
     LIMIT_MAX_BUFFER_OPTIONS,
-  )));
+  ),
+));
 
 gulp.task('test:api-v4:integration:separate-server', runInChildProcess(
   'mocha test/api/v4 --recursive --require ./test/helpers/start-server',

migrations/.eslintrc.js

@@ -3,6 +3,6 @@ module.exports = {
   root: false,
   rules: {
     'no-console': 0,
-    'no-use-before-define': ['error', { functions: false }]
-  }
-}
+    'no-use-before-define': ['error', { functions: false }],
+  },
+};

migrations/archive/2017/achievement-restore.js

@@ -51,7 +51,8 @@ function getAchievementUpdate (newUser, oldUser) {
   // Rebirth level
   if (achievementsUpdate.rebirthLevel) {
     achievementsUpdate.rebirthLevel = Math.max(
-      achievementsUpdate.rebirthLevel, oldAchievements.rebirthLevel,
+      achievementsUpdate.rebirthLevel,
+      oldAchievements.rebirthLevel,
     );
   } else if (oldAchievements.rebirthLevel) {
     achievementsUpdate.rebirthLevel = oldAchievements.rebirthLevel;

migrations/archive/2021/20210129_habit_birthday.js

@@ -61,7 +61,7 @@ async function updateUser (user) {
 
 export default async function processUsers () {
   let query = {
-    // migration: {$ne: MIGRATION_NAME},
+    migration: {$ne: MIGRATION_NAME},
     'auth.timestamps.loggedin': {$gt: new Date('2021-01-01')},
   };
 

migrations/archive/2021/20210824_pet_group_achievements.js

@@ -105,7 +105,7 @@ async function updateUser (user) {
 
 export default async function processUsers () {
   let query = {
-    // migration: { $ne: MIGRATION_NAME },
+    migration: { $ne: MIGRATION_NAME },
     'auth.timestamps.loggedin': { $gt: new Date('2021-08-01') },
   };
 

migrations/archive/2022/20220201_pet_group_achievements.js

@@ -145,7 +145,7 @@ async function updateUser (user) {
 
 export default async function processUsers () {
   let query = {
-    // migration: { $ne: MIGRATION_NAME },
+    migration: { $ne: MIGRATION_NAME },
     'auth.timestamps.loggedin': { $gt: new Date('2021-08-01') },
   };
 

migrations/archive/2022/20220309_pet_group_achievements.js

@@ -105,7 +105,7 @@ async function updateUser (user) {
 
 export default async function processUsers () {
   let query = {
-    // migration: { $ne: MIGRATION_NAME },
+    migration: { $ne: MIGRATION_NAME },
     'auth.timestamps.loggedin': { $gt: new Date('2021-08-01') },
   };
 

migrations/archive/2022/20220524_pet_group_achievements.js

@@ -95,7 +95,7 @@ async function updateUser (user) {
 
 export default async function processUsers () {
   let query = {
-    // migration: { $ne: MIGRATION_NAME },
+    migration: { $ne: MIGRATION_NAME },
     'auth.timestamps.loggedin': { $gt: new Date('2022-01-01') },
   };
 

migrations/archive/2022/20221031_pet_set_group_achievements.js

@@ -86,7 +86,7 @@ async function updateUser (user) {
 
 export default async function processUsers () {
   let query = {
-    // migration: { $ne: MIGRATION_NAME },
+    migration: { $ne: MIGRATION_NAME },
     'auth.timestamps.loggedin': { $gt: new Date('2022-01-01') },
   };
 

migrations/archive/2022/20221213_pet_group_achievements.js

@@ -63,7 +63,7 @@ async function updateUser (user) {
       && pets['Wolf-Shade']
       && pets['Wolf-Skeleton']
       && pets['Wolf-White']
-      && pets['Wolf-Zombie'] {
+      && pets['Wolf-Zombie']) {
         set['achievements.polarPro'] = true;
       }
   }
@@ -75,7 +75,7 @@ async function updateUser (user) {
 
 export default async function processUsers () {
   let query = {
-    // migration: { $ne: MIGRATION_NAME },
+    migration: { $ne: MIGRATION_NAME },
     'auth.timestamps.loggedin': { $gt: new Date('2022-11-01') },
   };
 

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/archive/2024/20240131_habit_birthday.js

@@ -0,0 +1,102 @@
+/* eslint-disable no-console */
+import { v4 as uuid } from 'uuid';
+import { model as User } from '../../../website/server/models/user';
+
+const MIGRATION_NAME = '20240131_habit_birthday';
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count += 1;
+
+   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,
+  };
+  const set = {};
+  const push = {
+    notifications: {
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'notif_namingDay_cake',
+        title: 'Happy Habit Birthday!',
+        text: 'Habitica turns 11 today! Enjoy free party robes and cake!',
+        destination: 'inventory/equipment',
+      },
+      seen: false,
+    },
+  };
+
+  set.migration = MIGRATION_NAME;
+
+  if (typeof user.items.gear.owned.armor_special_birthday2023 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2024'] = true;
+  } else 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;
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.updateOne({_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('2023-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/takeThis.js

@@ -1,118 +0,0 @@
-let migrationName = '20180904_takeThis.js'; // Update per month
-let authorName = 'Sabe'; // in case script author needs to know when their ...
-let authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
-
-/*
- * Award Take This ladder items to participants in this month's challenge
- */
-
-import monk from 'monk';
-import nconf from 'nconf';
-const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING'); // FOR TEST DATABASE
-let dbUsers = monk(CONNECTION_STRING).get('users', { castIds: false });
-
-function processUsers (lastId) {
-  // specify a query to limit the affected users (empty for all users):
-  let query = {
-    migration: {$ne: migrationName},
-    challenges: {$in: ['1044ec0c-4a85-48c5-9f36-d51c0c62c7d3']}, // Update per month
-  };
-
-  if (lastId) {
-    query._id = {
-      $gt: lastId,
-    };
-  }
-
-  dbUsers.find(query, {
-    sort: {_id: 1},
-    limit: 250,
-    fields: [
-      'items.gear.owned',
-    ], // specify fields we are interested in to limit retrieved data (empty if we're not reading data):
-  })
-    .then(updateUsers)
-    .catch((err) => {
-      console.log(err);
-      return exiting(1, `ERROR! ${  err}`);
-    });
-}
-
-let progressCount = 1000;
-let count = 0;
-
-function updateUsers (users) {
-  if (!users || users.length === 0) {
-    console.warn('All appropriate users found and modified.');
-    displayData();
-    return;
-  }
-
-  let userPromises = users.map(updateUser);
-  let lastUser = users[users.length - 1];
-
-  return Promise.all(userPromises)
-    .then(() => {
-      processUsers(lastUser._id);
-    });
-}
-
-function updateUser (user) {
-  count++;
-
-  let set = {};
-  let push;
-
-  if (typeof user.items.gear.owned.back_special_takeThis !== 'undefined') {
-    set = {migration: migrationName};
-  } else if (typeof user.items.gear.owned.body_special_takeThis !== 'undefined') {
-    set = {migration: migrationName, 'items.gear.owned.back_special_takeThis': false};
-    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.back_special_takeThis', _id: monk.id()}};
-  } else if (typeof user.items.gear.owned.head_special_takeThis !== 'undefined') {
-    set = {migration: migrationName, 'items.gear.owned.body_special_takeThis': false};
-    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.body_special_takeThis', _id: monk.id()}};
-  } else if (typeof user.items.gear.owned.armor_special_takeThis !== 'undefined') {
-    set = {migration: migrationName, 'items.gear.owned.head_special_takeThis': false};
-    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.head_special_takeThis', _id: monk.id()}};
-  } else if (typeof user.items.gear.owned.weapon_special_takeThis !== 'undefined') {
-    set = {migration: migrationName, 'items.gear.owned.armor_special_takeThis': false};
-    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_takeThis', _id: monk.id()}};
-  } else if (typeof user.items.gear.owned.shield_special_takeThis !== 'undefined') {
-    set = {migration: migrationName, 'items.gear.owned.weapon_special_takeThis': false};
-    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.weapon_special_takeThis', _id: monk.id()}};
-  } else {
-    set = {migration: migrationName, 'items.gear.owned.shield_special_takeThis': false};
-    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.shield_special_takeThis', _id: monk.id()}};
-  }
-
-  if (push) {
-    dbUsers.update({_id: user._id}, {$set: set, $push: push});
-  } else {
-    dbUsers.update({_id: user._id}, {$set: set});
-  }
-
-  if (count % progressCount === 0) console.warn(`${count  } ${  user._id}`);
-  if (user._id === authorUuid) console.warn(`${authorName  } processed`);
-}
-
-function displayData () {
-  console.warn(`\n${  count  } users processed\n`);
-  return exiting(0);
-}
-
-function exiting (code, msg) {
-  code = code || 0; // 0 = success
-  if (code && !msg) {
-    msg = 'ERROR!';
-  }
-  if (msg) {
-    if (code) {
-      console.error(msg);
-    } else      {
-      console.log(msg);
-    }
-  }
-  process.exit(code);
-}
-
-module.exports = processUsers;

migrations/csvexport.py

@@ -1,10 +0,0 @@
-import csv
-
-with open(r"/home/slappybag/Documents/SurveyScrape.csv") as f:
-     reader = csv.reader(f, delimiter=',', quotechar='"')
-     column = []
-     for row in reader:
-        if row:
-            column.append(row[4])
-
-print column

migrations/groups/habitrpg-jackalopes.js

@@ -21,12 +21,14 @@ async function handOutJackalopes () {
     if (user.party._id) groupList.push(user.party._id);
     groupList = groupList.concat(user.guilds);
 
-    const subscribedGroup = await Group.findOne({
-      _id: { $in: groupList },
-      'purchased.plan.planId': 'group_monthly',
-      'purchased.plan.dateTerminated': null,
-    },
-    { _id: 1 });
+    const subscribedGroup = await Group.findOne(
+      {
+        _id: { $in: groupList },
+        'purchased.plan.planId': 'group_monthly',
+        'purchased.plan.dateTerminated': null,
+      },
+      { _id: 1 },
+    );
 
     if (subscribedGroup) {
       User.update({ _id: user._id }, { $set: { 'items.mounts.Jackalope-RoyalPurple': true } }).exec();

migrations/users/bulk-email.js

@@ -16,6 +16,7 @@ async function updateUser (user) {
 
   if (count % progressCount === 0) {
     console.warn(`${count} ${user._id}`);
+    // eslint-disable-next-line no-promise-executor-return
     await new Promise(resolve => setTimeout(resolve, 5000));
   }
 

package.json

@@ -1,37 +1,37 @@
 {
   "name": "habitica",
   "description": "A habit tracker app which treats your goals like a Role Playing Game.",
-  "version": "4.267.3",
+  "version": "5.18.0",
   "main": "./website/server/index.js",
   "dependencies": {
-    "@babel/core": "^7.20.12",
-    "@babel/preset-env": "^7.20.2",
-    "@babel/register": "^7.18.9",
+    "@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.1.3",
+    "@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.54.0",
-    "apple-auth": "^1.0.7",
-    "bcrypt": "^5.1.0",
-    "body-parser": "^1.20.1",
-    "bootstrap": "^4.6.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",
     "csv-stringify": "^5.6.5",
     "cwait": "^1.1.1",
     "domain-middleware": "~0.1.0",
-    "eslint": "^6.8.0",
-    "eslint-config-habitrpg": "^6.2.0",
+    "eslint": "^8.55.0",
+    "eslint-config-habitrpg": "^6.2.3",
     "eslint-plugin-mocha": "^5.0.0",
     "express": "^4.18.2",
     "express-basic-auth": "^1.2.1",
     "express-validator": "^5.2.0",
     "glob": "^8.1.0",
-    "got": "^11.8.3",
+    "got": "^11.8.6",
     "gulp": "^4.0.0",
     "gulp-babel": "^8.0.0",
     "gulp-imagemin": "^7.1.0",
@@ -39,44 +39,42 @@
     "gulp.spritesmith": "^6.13.0",
     "habitica-markdown": "^3.0.0",
     "helmet": "^4.6.0",
-    "image-size": "^1.0.2",
     "in-app-purchase": "^1.11.3",
     "js2xmlparser": "^5.0.0",
-    "jsonwebtoken": "^8.5.1",
+    "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.4",
     "moment-recur": "^1.0.7",
-    "mongoose": "^5.13.7",
+    "mongoose": "^7.6.3",
     "morgan": "^1.10.0",
-    "nconf": "^0.12.0",
+    "nconf": "^0.12.1",
     "node-gcm": "^1.0.5",
+    "nodemon": "^2.0.20",
     "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.4.0",
+    "rate-limiter-flexible": "^2.4.2",
     "redis": "^3.1.2",
-    "regenerator-runtime": "^0.13.11",
     "remove-markdown": "^0.5.0",
     "rimraf": "^3.0.2",
     "short-uuid": "^4.2.2",
-    "stripe": "^11.10.0",
-    "superagent": "^8.0.6",
+    "stripe": "^12.18.0",
+    "superagent": "^8.1.2",
     "universal-analytics": "^0.5.3",
     "useragent": "^2.1.9",
     "uuid": "^9.0.0",
-    "validator": "^13.9.0",
-    "vinyl-buffer": "^1.0.1",
-    "winston": "^3.8.2",
-    "winston-loggly-bulk": "^3.2.1",
-    "xml2js": "^0.4.23"
+    "validator": "^13.11.0",
+    "winston": "^3.10.0",
+    "winston-loggly-bulk": "^3.3.0",
+    "xml2js": "^0.6.2"
   },
   "private": true,
   "engines": {
@@ -105,16 +103,16 @@
     "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 5.0.23 -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": "^1.2.2",
+    "axios": "^1.4.0",
     "chai": "^4.3.7",
     "chai-as-promised": "^7.1.1",
     "chai-moment": "^0.1.0",
-    "chalk": "^5.2.0",
+    "chalk": "^5.3.0",
     "cross-spawn": "^7.0.3",
     "expect.js": "^0.3.1",
     "istanbul": "^1.1.0-alpha.1",
@@ -122,7 +120,7 @@
     "monk": "^7.3.4",
     "require-again": "^2.0.0",
     "run-rs": "^0.7.7",
-    "sinon": "^15.0.1",
+    "sinon": "^15.2.0",
     "sinon-chai": "^3.7.0",
     "sinon-stub-promise": "^4.0.0"
   },

scripts/gdpr-delete-users.js

@@ -44,6 +44,7 @@ async function deleteHabiticaData (user, email) {
     { _id: user._id },
     { $set: set },
   );
+  // eslint-disable-next-line no-promise-executor-return
   await new Promise(resolve => setTimeout(resolve, 1000));
   const response = await axios.delete(
     `${BASE_URL}/api/v3/user`,
@@ -96,6 +97,7 @@ async function processEmailAddress (email) {
     return console.log(`No users found with email address ${email}`);
   }
 
+  // eslint-disable-next-line no-promise-executor-return
   await new Promise(resolve => setTimeout(resolve, 1000));
   return Promise.all(users.map(user => (async () => {
     await deleteAmplitudeData(user._id, email); // eslint-disable-line no-await-in-loop

test/.eslintrc.js

@@ -1,3 +1,5 @@
+/* eslint-disable import/no-commonjs */
+
 module.exports = {
   extends: [
     'habitrpg/lib/mocha',
@@ -7,6 +9,9 @@ module.exports = {
     chai: true,
     expect: true,
     sinon: true,
-    sandbox: true
+    sandbox: true,
   },
-}
+  rules: {
+    'import/no-extraneous-dependencies': 'off',
+  },
+};

test/api/unit/libs/bug-report.test.js

@@ -26,9 +26,7 @@ describe('bug-report', () => {
       _id: userId,
     });
 
-    const result = await bugReportLogic(
-      user, userMail, userMessage, userAgent,
-    );
+    const result = await bugReportLogic(user, userMail, userMessage, userAgent);
 
     expect(emailLib.sendTxn).to.be.called;
     expect(result).to.deep.equal({

test/api/unit/libs/mongodb.js

@@ -44,7 +44,7 @@ describe('mongodb', () => {
       const mongoLibOverride = requireAgain(pathToMongoLib);
 
       const options = mongoLibOverride.getDefaultConnectionOptions();
-      expect(options).to.have.all.keys(['useNewUrlParser', 'useUnifiedTopology', 'keepAlive', 'keepAliveInitialDelay']);
+      expect(options).to.have.all.keys(['useNewUrlParser', 'useUnifiedTopology']);
     });
   });
 });

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

@@ -227,7 +227,7 @@ describe('Password Utilities', () => {
         expiresAt: moment().subtract({ minutes: 1 }),
       }));
 
-      await user.update({
+      await user.updateOne({
         'auth.local.passwordResetCode': code,
       });
 
@@ -264,7 +264,7 @@ describe('Password Utilities', () => {
         expiresAt: moment().add({ days: 1 }),
       }));
 
-      await user.update({
+      await user.updateOne({
         'auth.local.passwordResetCode': 'invalid',
       });
 
@@ -280,7 +280,7 @@ describe('Password Utilities', () => {
         expiresAt: moment().add({ days: 1 }),
       }));
 
-      await user.update({
+      await user.updateOne({
         'auth.local.passwordResetCode': code,
       });
 

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

@@ -342,10 +342,12 @@ describe('Apple Payments', () => {
             }]);
           sub = common.content.subscriptionBlocks[newOption.subKey];
 
-          await applePayments.subscribe(user,
+          await applePayments.subscribe(
+            user,
             receipt,
             headers,
-            nextPaymentProcessing);
+            nextPaymentProcessing,
+          );
 
           expect(iapSetupStub).to.be.calledOnce;
           expect(iapValidateStub).to.be.calledOnce;
@@ -387,10 +389,12 @@ describe('Apple Payments', () => {
             }]);
           sub = common.content.subscriptionBlocks[newOption.subKey];
 
-          await applePayments.subscribe(user,
+          await applePayments.subscribe(
+            user,
             receipt,
             headers,
-            nextPaymentProcessing);
+            nextPaymentProcessing,
+          );
 
           expect(iapSetupStub).to.be.calledOnce;
           expect(iapValidateStub).to.be.calledOnce;
@@ -517,9 +521,7 @@ describe('Apple Payments', () => {
 
         const secondUser = new User();
         await secondUser.save();
-        await expect(applePayments.subscribe(
-          secondUser, receipt, headers, nextPaymentProcessing,
-        ))
+        await expect(applePayments.subscribe(secondUser, receipt, headers, nextPaymentProcessing))
           .to.eventually.be.rejected.and.to.eql({
             httpCode: 401,
             name: 'NotAuthorized',
@@ -559,9 +561,7 @@ describe('Apple Payments', () => {
 
         const thirdUser = new User();
         await thirdUser.save();
-        await expect(applePayments.subscribe(
-          thirdUser, receipt, headers, nextPaymentProcessing,
-        ))
+        await expect(applePayments.subscribe(thirdUser, receipt, headers, nextPaymentProcessing))
           .to.eventually.be.rejected.and.to.eql({
             httpCode: 401,
             name: 'NotAuthorized',

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

@@ -748,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 () => {
@@ -1372,18 +1382,6 @@ describe('payments/index', () => {
         expect(user.purchased.plan.mysteryItems).to.have.a.lengthOf(1);
         expect(user.purchased.plan.mysteryItems).to.include('head_mystery_201605');
       });
-
-      it('does not award mystery item when user already has the item in the mystery box', async () => {
-        user.purchased.plan.mysteryItems = [mayMysteryItem];
-
-        sandbox.spy(user.purchased.plan.mysteryItems, 'push');
-
-        data = { paymentMethod: 'PaymentMethod', user, sub: { key: 'basic_3mo' } };
-        await api.createSubscription(data);
-
-        expect(user.purchased.plan.mysteryItems.push).to.be.calledOnce;
-        expect(user.purchased.plan.mysteryItems.push).to.be.calledWith('head_mystery_201605');
-      });
     });
   });
 
@@ -1589,10 +1587,10 @@ describe('payments/index', () => {
       it('sends gem donation message in each participant\'s language', async () => {
         // TODO using english for both users because other languages are not loaded
         // for api.buyGems
-        await recipient.update({
+        await recipient.updateOne({
           'preferences.language': 'en',
         });
-        await user.update({
+        await user.updateOne({
           'preferences.language': 'en',
         });
         await api.buyGems(data);

test/api/unit/middlewares/cronMiddleware.js

@@ -53,11 +53,9 @@ describe('cron middleware', () => {
       cronMiddleware(req, res, err => {
         if (err) return reject(err);
 
-        Tasks.Task.findOne({ _id: task }, (secondErr, taskFound) => {
-          if (secondErr) return reject(err);
-          expect(secondErr).to.not.exist;
-          expect(taskFound).to.not.exist;
-          return resolve();
+        Tasks.Task.findOne({ _id: task }).then(foundTask => {
+          expect(foundTask).to.not.exist;
+          resolve();
         });
 
         return null;
@@ -78,10 +76,8 @@ describe('cron middleware', () => {
     await new Promise((resolve, reject) => {
       cronMiddleware(req, res, err => {
         if (err) return reject(err);
-        Tasks.Task.findOne({ _id: task }, (secondErr, taskFound) => {
-          if (secondErr) return reject(secondErr);
-          expect(secondErr).to.not.exist;
-          expect(taskFound).to.exist;
+        Tasks.Task.findOne({ _id: task }).then(foundTask => {
+          expect(foundTask).to.exist;
           return resolve();
         });
         return null;
@@ -103,10 +99,8 @@ describe('cron middleware', () => {
     await new Promise((resolve, reject) => {
       cronMiddleware(req, res, err => {
         if (err) return reject(err);
-        Tasks.Task.findOne({ _id: task }, (secondErr, taskFound) => {
-          if (secondErr) return reject(secondErr);
-          expect(secondErr).to.not.exist;
-          expect(taskFound).to.not.exist;
+        Tasks.Task.findOne({ _id: task }).then(foundTask => {
+          expect(foundTask).to.not.exist;
           return resolve();
         });
         return null;
@@ -170,8 +164,7 @@ describe('cron middleware', () => {
     await new Promise((resolve, reject) => {
       cronMiddleware(req, res, err => {
         if (err) return reject(err);
-        return User.findOne({ _id: user._id }, (secondErr, updatedUser) => {
-          if (secondErr) return reject(secondErr);
+        return User.findOne({ _id: user._id }).then(updatedUser => {
           expect(updatedUser.stats.hp).to.be.lessThan(hpBefore);
           return resolve();
         });
@@ -188,8 +181,7 @@ describe('cron middleware', () => {
     await new Promise((resolve, reject) => {
       cronMiddleware(req, res, err => {
         if (err) return reject(err);
-        return Tasks.Task.findOne({ _id: todo._id }, (secondErr, todoFound) => {
-          if (secondErr) return reject(secondErr);
+        return Tasks.Task.findOne({ _id: todo._id }).then(todoFound => {
           expect(todoFound.value).to.be.lessThan(todoValueBefore);
           return resolve();
         });
@@ -224,8 +216,7 @@ describe('cron middleware', () => {
     await new Promise((resolve, reject) => {
       cronMiddleware(req, res, err => {
         if (err) return reject(err);
-        return User.findOne({ _id: user._id }, (secondErr, updatedUser) => {
-          if (secondErr) return reject(secondErr);
+        return User.findOne({ _id: user._id }).then(updatedUser => {
           expect(updatedUser.stats.hp).to.be.lessThan(hpBefore);
           return resolve();
         });
@@ -238,11 +229,11 @@ describe('cron middleware', () => {
     await user.save();
 
     const updatedUser = user.toObject();
-    updatedUser.nMatched = 0;
+    updatedUser.matchedCount = 0;
 
     sandbox.spy(cronLib, 'recoverCron');
 
-    sandbox.stub(User, 'update')
+    sandbox.stub(User, 'updateOne')
       .withArgs({
         _id: user._id,
         $or: [
@@ -269,7 +260,7 @@ describe('cron middleware', () => {
   it('cronSignature less than an hour ago should error', async () => {
     user.lastCron = moment(new Date()).subtract({ days: 2 });
     const now = new Date();
-    await User.update({
+    await User.updateOne({
       _id: user._id,
     }, {
       $set: {
@@ -291,7 +282,7 @@ describe('cron middleware', () => {
   it('cronSignature longer than an hour ago should allow cron', async () => {
     user.lastCron = moment(new Date()).subtract({ days: 2 });
     const now = new Date();
-    await User.update({
+    await User.updateOne({
       _id: user._id,
     }, {
       $set: {

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

@@ -1358,7 +1358,7 @@ describe('Group Model', () => {
 
     describe('#sendChat', () => {
       beforeEach(() => {
-        sandbox.spy(User, 'update');
+        sandbox.spy(User, 'updateOne');
         sandbox.spy(User, 'updateMany');
       });
 
@@ -1450,7 +1450,7 @@ describe('Group Model', () => {
 
         party.sendChat({ message: 'message' });
 
-        expect(User.update).to.not.be.called;
+        expect(User.updateMany).to.not.be.called;
       });
 
       it('skips sending messages to the tavern', () => {
@@ -1458,7 +1458,7 @@ describe('Group Model', () => {
 
         party.sendChat({ message: 'message' });
 
-        expect(User.update).to.not.be.called;
+        expect(User.updateMany).to.not.be.called;
       });
     });
 
@@ -1732,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);
 
@@ -1740,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: {
@@ -1753,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: {
@@ -1819,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
         });
       });
 
@@ -2088,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,
           });
         });
@@ -2173,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/newsPost.js

@@ -103,7 +103,7 @@ describe('NewsPost Model', () => {
 
     beforeEach(async () => {
       // Delete all existing posts from the database
-      await NewsPost.remove();
+      await NewsPost.deleteMany();
     });
 
     afterEach(() => {
@@ -116,7 +116,7 @@ describe('NewsPost Model', () => {
         _id: v4(), publishDate: new Date(), published: true,
       };
       NewsPost.updateLastNewsPost(previousPost);
-      intervalId = refreshNewsPost(50); // refreshes every 50ms
+      intervalId = refreshNewsPost(100); // refreshes every 100ms
 
       await sleep(0.1); // wait 100ms to make sure the new post has a more recent publishDate
       const newPost = await NewsPost.create({

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

@@ -221,7 +221,8 @@ describe('Task Model', () => {
 
       it('returns task by alias', async () => {
         const foundTasks = await Tasks.Task.findMultipleByIdOrAlias(
-          [taskWithAlias.alias], user._id,
+          [taskWithAlias.alias],
+          user._id,
         );
 
         expect(foundTasks[0].text).to.eql(taskWithAlias.text);
@@ -229,7 +230,8 @@ describe('Task Model', () => {
 
       it('returns multiple tasks', async () => {
         const foundTasks = await Tasks.Task.findMultipleByIdOrAlias(
-          [taskWithAlias.alias, secondTask._id], user._id,
+          [taskWithAlias.alias, secondTask._id],
+          user._id,
         );
 
         expect(foundTasks.length).to.eql(2);
@@ -239,7 +241,8 @@ describe('Task Model', () => {
 
       it('returns a task only once if searched by both id and alias', async () => {
         const foundTasks = await Tasks.Task.findMultipleByIdOrAlias(
-          [taskWithAlias.alias, taskWithAlias._id], user._id,
+          [taskWithAlias.alias, taskWithAlias._id],
+          user._id,
         );
 
         expect(foundTasks.length).to.eql(1);

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

@@ -188,7 +188,7 @@ describe('User Model', () => {
     it('removes invalid tags when loading the user', async () => {
       let user = new User();
       await user.save();
-      await user.update({
+      await user.updateOne({
         $set: {
           tags: [
             null, // invalid, not an object
@@ -212,7 +212,7 @@ describe('User Model', () => {
     it('removes invalid push devices when loading the user', async () => {
       let user = new User();
       await user.save();
-      await user.update({
+      await user.updateOne({
         $set: {
           pushDevices: [
             null, // invalid, not an object
@@ -236,7 +236,7 @@ describe('User Model', () => {
     it('removes duplicate push devices when loading the user', async () => {
       let user = new User();
       await user.save();
-      await user.update({
+      await user.updateOne({
         $set: {
           pushDevices: [
             { type: 'android', regId: '1234' },
@@ -258,7 +258,7 @@ describe('User Model', () => {
     it('removes invalid notifications when loading the user', async () => {
       let user = new User();
       await user.save();
-      await user.update({
+      await user.updateOne({
         $set: {
           notifications: [
             null, // invalid, not an object
@@ -284,7 +284,7 @@ describe('User Model', () => {
     it('removes multiple NEW_CHAT_MESSAGE for the same group', async () => {
       let user = new User();
       await user.save();
-      await user.update({
+      await user.updateOne({
         $set: {
           notifications: [
             {

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

@@ -87,7 +87,7 @@ describe('DELETE /challenges/:challengeId', () => {
       const testTask = _.find(tasks, task => task.text === taskText);
 
       expect(testTask.challenge.broken).to.eql('CHALLENGE_DELETED');
-      expect(testTask.challenge.winner).to.be.null;
+      expect(testTask.challenge.winner).to.be.undefined;
     });
   });
 });

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_export_csv.test.js

@@ -74,7 +74,7 @@ describe('GET /challenges/:challengeId/export/csv', () => {
   });
 
   it('should successfully return when it contains erroneous residue user data', async () => {
-    await members[0].update({ challenges: [] });
+    await members[0].updateOne({ challenges: [] });
     const res = await members[1].get(`/challenges/${challenge._id}/export/csv`);
     const sortedMembers = _.sortBy([members[1], members[2], groupLeader], '_id');
     const splitRes = res.split('\n');

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;
@@ -357,7 +186,7 @@ describe('GET challenges/groups/:groupId', () => {
 
     before(async () => {
       user = await generateUser();
-      await user.update({ balance: 0.5 });
+      await user.updateOne({ balance: 0.5 });
       tavern = await user.get(`/groups/${TAVERN_ID}`);
 
       challenge = await generateChallenge(user, tavern, { prize: 1 });
@@ -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.updateOne({
+          '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.updateOne({ 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,38 +199,42 @@ 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',
         },
-      });
+        upgradeToGroupPlan: true,
+      }));
 
-      user = groupLeader;
-      publicGuild = group;
-
-      await user.update({
+      await user.updateOne({
         '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,16 +298,17 @@ describe('GET challenges/user', () => {
         groupDetails: {
           name: 'TestGuild',
           type: 'guild',
-          privacy: 'public',
+          privacy: 'private',
         },
         members: 1,
+        upgradeToGroupPlan: true,
       });
 
       user = groupLeader;
       guild = group;
       member = members[0]; // eslint-disable-line prefer-destructuring
 
-      await user.update({ balance: 20 });
+      await user.updateOne({ balance: 20 });
 
       for (let i = 0; i < 11; i += 1) {
         let challenge = await generateChallenge(user, group); // eslint-disable-line

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.updateOne({ '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.updateOne({ '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

@@ -42,26 +42,7 @@ describe('POST /challenges', () => {
     });
   });
 
-  it('returns error when creating a challenge in a public guild and you are not a member of it', async () => {
-    const user = await generateUser();
-    const { group } = await createAndPopulateGroup({
-      groupDetails: {
-        type: 'guild',
-        privacy: 'public',
-      },
-    });
-
-    await expect(user.post('/challenges', {
-      group: group._id,
-      prize: 4,
-    })).to.eventually.be.rejected.and.eql({
-      code: 401,
-      error: 'NotAuthorized',
-      message: t('mustBeGroupMember'),
-    });
-  });
-
-  it('return error when creating a challenge with summary with greater than MAX_SUMMARY_SIZE_FOR_CHALLENGES characters', 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 summary = 'A'.repeat(MAX_SUMMARY_SIZE_FOR_CHALLENGES + 1);
     const group = createAndPopulateGroup({
@@ -77,7 +58,7 @@ describe('POST /challenges', () => {
     });
   });
 
-  context('Creating a challenge for a valid group', () => {
+  context('creating a Challenge for a Group Plan', () => {
     let groupLeader;
     let group;
     let groupMember;
@@ -94,9 +75,11 @@ describe('POST /challenges', () => {
             challenges: true,
           },
         },
+        upgradeToGroupPlan: true,
       });
 
       groupLeader = await populatedGroup.groupLeader.sync();
+      await groupLeader.updateOne({ permissions: {} });
       group = populatedGroup.group;
       groupMember = populatedGroup.members[0]; // eslint-disable-line prefer-destructuring
     });
@@ -194,7 +177,7 @@ describe('POST /challenges', () => {
       const oldUserBalance = groupLeader.balance;
       const prize = 8;
 
-      await group.update({ balance: 0 });
+      await group.updateOne({ balance: 0 });
       await groupLeader.post('/challenges', {
         group: group._id,
         name: 'Test Challenge',
@@ -219,7 +202,7 @@ describe('POST /challenges', () => {
     });
 
     it('sets challenge as official if created by admin and official flag is set', async () => {
-      await groupLeader.update({
+      await groupLeader.updateOne({
         permissions: {
           challengeAdmin: true,
         },

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

@@ -128,10 +128,10 @@ describe('POST /challenges/:challengeId/winner/:winnerId', () => {
       const oldBalance = winningUser.balance;
       const oldLeaderBalance = (await groupLeader.sync()).balance;
 
-      await winningUser.update({
+      await winningUser.updateOne({
         'purchased.plan.customerId': 'group-plan',
       });
-      await group.update({
+      await group.updateOne({
         'leaderOnly.getGems': true,
         'purchased.plan.customerId': 123,
       });

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

@@ -18,6 +18,7 @@ describe('PUT /challenges/:challengeId', () => {
         privacy: 'private',
       },
       members: 1,
+      upgradeToGroupPlan: true,
     });
 
     privateGuild = group;

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,27 +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.updateOne({ 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,
@@ -56,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.updateOne({ permissions: {} });
+    await admin.updateOne({ permissions: { moderator: true } });
+    await anotherUser.updateOne({ 'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate() });
+    await newUser.updateOne({ 'auth.timestamps.created': moment().subtract(1, 'days').toDate() });
+    await userToDelete.updateOne({
+      '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,15 +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({
-      'auth.timestamps.created': new Date('2022-01-01'),
-    });
-    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,28 +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
-    await anotherUser.update({ 'auth.timestamps.created': new Date('2022-01-01') });
+    [anotherUser] = members;
+    await anotherUser.updateOne({ 'auth.timestamps.created': new Date('2022-01-01') });
   });
 
   it('Returns an error when chat message is not found', async () => {
@@ -39,17 +39,6 @@ describe('POST /chat/:chatId/like', () => {
       });
   });
 
-  it('Returns an error when user tries to like their own message', async () => {
-    const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
-
-    await expect(user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`))
-      .to.eventually.be.rejected.and.eql({
-        code: 404,
-        error: 'NotFound',
-        message: t('messageGroupChatLikeOwnMessage'),
-      });
-  });
-
   it('Likes a chat', async () => {
     const message = await anotherUser.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
 
@@ -63,6 +52,19 @@ describe('POST /chat/:chatId/like', () => {
     expect(messageToCheck.likes[user._id]).to.equal(true);
   });
 
+  it('Allows to likes their own chat message', async () => {
+    const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
+
+    const likeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
+
+    expect(likeResult.likes[user._id]).to.equal(true);
+
+    const groupWithChatLikes = await user.get(`/groups/${groupWithChat._id}`);
+
+    const messageToCheck = find(groupWithChatLikes.chat, { id: message.message.id });
+    expect(messageToCheck.likes[user._id]).to.equal(true);
+  });
+
   it('Unlikes a chat', async () => {
     const message = await anotherUser.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
 

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

@@ -1,52 +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({
+    await user.updateOne({
       '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
-    await member.update({ 'auth.timestamps.created': new Date('2022-01-01') });
-    await additionalMember.update({ 'auth.timestamps.created': new Date('2022-01-01') });
+    [member, additionalMember] = members;
+    await member.updateOne({ 'auth.timestamps.created': new Date('2022-01-01') });
+    await additionalMember.updateOne({ 'auth.timestamps.created': new Date('2022-01-01') });
   });
 
   it('Returns an error when no message is provided', async () => {
@@ -86,35 +77,15 @@ describe('POST /chat', () => {
 
   describe('mute user', () => {
     afterEach(() => {
-      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'),
-      });
+      member.updateOne({ 'flags.chatRevoked': false });
     });
 
     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,
-      });
-
-      const privateGuildMemberWithChatsRevoked = members[0];
-      await privateGuildMemberWithChatsRevoked.update({
+      await member.updateOne({
         'flags.chatRevoked': true,
-        'auth.timestamps.created': new Date('2022-01-01'),
       });
 
-      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;
     });
@@ -130,7 +101,7 @@ describe('POST /chat', () => {
       });
 
       const privatePartyMemberWithChatsRevoked = members[0];
-      await privatePartyMemberWithChatsRevoked.update({
+      await privatePartyMemberWithChatsRevoked.updateOne({
         'flags.chatRevoked': true,
         'auth.timestamps.created': new Date('2022-01-01'),
       });
@@ -149,57 +120,15 @@ describe('POST /chat', () => {
 
     afterEach(() => {
       sandbox.restore();
-      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 */
+      member.updateOne({ 'flags.chatShadowMuted': false });
     });
 
     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,
-      });
-
-      const userWithChatShadowMuted = members[0];
-      await userWithChatShadowMuted.update({
+      await member.updateOne({
         'flags.chatShadowMuted': true,
-        'auth.timestamps.created': new Date('2022-01-01'),
       });
 
-      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);
@@ -216,7 +145,7 @@ describe('POST /chat', () => {
       });
 
       const userWithChatShadowMuted = members[0];
-      await userWithChatShadowMuted.update({
+      await userWithChatShadowMuted.updateOne({
         'flags.chatShadowMuted': true,
         'auth.timestamps.created': new Date('2022-01-01'),
       });
@@ -226,100 +155,9 @@ describe('POST /chat', () => {
       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: {
@@ -329,26 +167,7 @@ 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: 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') });
+      await members[0].updateOne({ 'auth.timestamps.created': new Date('2022-01-01') });
 
       const message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage });
 
@@ -356,17 +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,
-      });
-      await members[0].update({ 'auth.timestamps.created': new Date('2022-01-01') });
-
-      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;
     });
@@ -380,46 +189,7 @@ describe('POST /chat', () => {
 
     afterEach(() => {
       sandbox.restore();
-      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'),
-      });
+      user.updateOne({ 'flags.chatRevoked': false });
     });
 
     it('allows slurs in private groups', async () => {
@@ -431,34 +201,23 @@ describe('POST /chat', () => {
         },
         members: 1,
       });
-      await members[0].update({ 'auth.timestamps.created': new Date('2022-01-01') });
+      await members[0].updateOne({ '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 () => {
-    const brandNewUser = await generateUser();
-    await expect(brandNewUser.post('/groups/habitrpg/chat', { message: 'hi im new' }))
+    await user.updateOne({ '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.updateOne({ 'auth.timestamps.created': new Date('2022-01-01') });
   });
 
   it('creates a chat', async () => {
@@ -499,7 +258,7 @@ describe('POST /chat', () => {
 
   it('chat message with mentions - mention link should not count towards 3000 chars limit', async () => {
     const memberUsername = 'memberUsername';
-    await member.update({ 'auth.local.username': memberUsername });
+    await member.updateOne({ 'auth.local.username': memberUsername });
 
     const messageWithMentions = `hi @${memberUsername} 123456789
      123456789 123456789 123456789 123456789 123456789 123456789 89 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 12345678 END.`;
@@ -519,54 +278,42 @@ describe('POST /chat', () => {
     const mount = 'test-mount';
     const pet = 'test-pet';
     const style = 'test-style';
-    const userWithStyle = await generateUser({
+    await user.updateOne({
       'items.currentMount': mount,
       'items.currentPet': pet,
       'preferences.style': style,
-      'auth.timestamps.created': new Date('2022-01-01'),
     });
-    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 userWithStyle = await generateUser({
-      'preferences.costume': false,
-      'auth.timestamps.created': new Date('2022-01-01'),
-    });
-    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.gear.equipped)
-      .to.eql(userWithStyle.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 () => {
-    const userWithStyle = await generateUser({
-      'preferences.costume': true,
-      'auth.timestamps.created': new Date('2022-01-01'),
-    });
-    await userWithStyle.sync();
+    await user.updateOne({ 'preferences.costume': true });
 
-    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.gear.costume).to.eql(userWithStyle.items.gear.costume);
+    expect(message.message.userStyles.items.gear.costume).to.eql(user.items.gear.costume);
     expect(message.message.userStyles.items.gear.equipped).to.not.exist;
   });
 
@@ -576,12 +323,11 @@ describe('POST /chat', () => {
       tier: 800,
       tokensApplied: true,
     };
-    const backer = await generateUser({
+    await user.updateOne({
       backer: backerInfo,
-      'auth.timestamps.created': new Date('2022-01-01'),
     });
 
-    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);
@@ -629,7 +375,7 @@ describe('POST /chat', () => {
 
   context('chat notifications', () => {
     beforeEach(() => {
-      member.update({ newMessages: {}, notifications: [] });
+      member.updateOne({ newMessages: {}, notifications: [] });
     });
 
     it('notifies other users of new messages for a guild', async () => {
@@ -661,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,18 +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;

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,21 +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.updateOne({ 'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate() });
+    await admin.updateOne({ 'permissions.moderator': true });
 
     message = await author.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some message' });
     message = message.message;
@@ -69,7 +71,7 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
         members: 2,
       });
 
-      await members[0].update({ 'auth.timestamps.created': new Date('2022-01-01') });
+      await members[0].updateOne({ 'auth.timestamps.created': new Date('2022-01-01') });
       let privateMessage = await members[0].post(`/groups/${group._id}/chat`, { message: 'Some message' });
       privateMessage = privateMessage.message;
 
@@ -102,7 +104,7 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
       const member = members[0];
 
       // make member that can use skills
-      await member.update({
+      await member.updateOne({
         'stats.lvl': 100,
         'stats.mp': 400,
         'stats.class': 'wizard',

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

@@ -24,7 +24,7 @@ describe('GET /coupons/', () => {
   });
 
   it('should return the coupons in CSV format ordered by creation date', async () => {
-    await user.update({
+    await user.updateOne({
       'permissions.coupons': true,
     });
 

test/api/v3/integration/coupons/POST-coupons_generate_event.test.js

@@ -19,7 +19,7 @@ describe('POST /coupons/generate/:event', () => {
   });
 
   it('returns an error if user has no coupons permission', async () => {
-    await user.update({
+    await user.updateOne({
       'permissions.coupons': false,
     });
 
@@ -47,7 +47,7 @@ describe('POST /coupons/generate/:event', () => {
   });
 
   it('should generate coupons', async () => {
-    await user.update({
+    await user.updateOne({
       'permissions.coupons': true,
     });
 

test/api/v3/integration/debug/POST-debug_quest-progress.test.js

@@ -24,7 +24,7 @@ describe('POST /debug/quest-progress', () => {
   });
 
   it('increases boss quest progress by 1000', async () => {
-    await user.update({
+    await user.updateOne({
       'party.quest.key': 'whale',
     });
 
@@ -36,7 +36,7 @@ describe('POST /debug/quest-progress', () => {
   });
 
   it('increases collection quest progress by 300 items', async () => {
-    await user.update({
+    await user.updateOne({
       'party.quest.key': 'evilsanta2',
     });
 

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.updateOne({ 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;
@@ -180,7 +153,7 @@ describe('GET /groups/:id', () => {
     it('removes non-existent guild from user\'s guild list', async () => {
       const guildId = generateUUID();
 
-      await user.update({
+      await user.updateOne({
         guilds: [guildId, generateUUID()],
       });
 
@@ -200,7 +173,7 @@ describe('GET /groups/:id', () => {
     it('removes non-existent party from user\'s party object', async () => {
       const partyId = generateUUID();
 
-      await user.update({
+      await user.updateOne({
         party: { _id: partyId },
       });
 
@@ -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.updateOne({ permissions: { moderator: true } });
       });
 
       it('includes all messages', async () => {

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

@@ -2,7 +2,6 @@ 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', () => {
@@ -35,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({
@@ -51,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}`);
@@ -64,7 +63,7 @@ describe('POST /group', () => {
       const summary = 'Test Summary';
       const group = await user.post('/groups', {
         name,
-        type: 'guild',
+        type: 'party',
         summary,
       });
 
@@ -78,7 +77,7 @@ describe('POST /group', () => {
       const summary = 'A'.repeat(MAX_SUMMARY_SIZE_FOR_GUILDS + 1);
       await expect(user.post('/groups', {
         name,
-        type: 'guild',
+        type: 'party',
         summary,
       })).to.eventually.be.rejected.and.eql({
         code: 400,
@@ -88,157 +87,6 @@ describe('POST /group', () => {
     });
   });
 
-  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();
-      });
-    });
-  });
-
   context('Parties', () => {
     const partyName = 'Test Party';
     const partyType = 'party';
@@ -262,7 +110,7 @@ describe('POST /group', () => {
     });
 
     it('creates a party when the user has no chat privileges', async () => {
-      await user.update({ 'flags.chatRevoked': true });
+      await user.updateOne({ 'flags.chatRevoked': true });
       const party = await user.post('/groups', {
         name: partyName,
         type: partyType,
@@ -272,7 +120,7 @@ describe('POST /group', () => {
     });
 
     it('does not require gems to create a party', async () => {
-      await user.update({ balance: 0 });
+      await user.updateOne({ balance: 0 });
 
       const party = await user.post('/groups', {
         name: partyName,

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 () => {
@@ -136,7 +78,7 @@ describe('POST /group/:groupId/join', () => {
       });
 
       it('does not increment basilist quest count to inviter with basilist when joining a guild', async () => {
-        await user.update({ 'items.quests.basilist': 1 });
+        await user.updateOne({ 'items.quests.basilist': 1 });
 
         await invitedUser.post(`/groups/${guild._id}/join`);
 
@@ -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 () => {
@@ -204,7 +146,7 @@ describe('POST /group/:groupId/join', () => {
       });
 
       it('Issue #12291: accepting a redundant party invite will let the user stay in the party', async () => {
-        await invitedUser.update({
+        await invitedUser.updateOne({
           'party._id': party._id,
         });
         await expect(invitedUser.get('/user')).to.eventually.have.nested.property('party._id', party._id);
@@ -251,56 +193,15 @@ describe('POST /group/:groupId/join', () => {
       });
 
       it('increments basilist quest item count to inviter when joining a party', async () => {
-        await user.update({ 'items.quests.basilist': 1 });
+        await user.updateOne({ 'items.quests.basilist': 1 });
 
         await invitedUser.post(`/groups/${party._id}/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({
+        await user.updateOne({
           [`items.quests.${PET_QUEST}`]: 1,
         });
         await user.post(`/groups/${party._id}/quests/invite/${PET_QUEST}`);

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,253 +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.updateOne({ '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;
-        await members[0].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'),
+        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,
-          leaderDetails: {
-            'auth.timestamps.created': new Date('2022-01-01'),
-            balance: 10,
-          },
-        });
+    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.updateOne({ '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 () => {
@@ -275,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
@@ -321,46 +302,22 @@ 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({
+        await member.updateOne({
           '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');
     });
   });
 
@@ -209,7 +212,7 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
 
     it('removes user from quest when removing user from party after quest starts', async () => {
       const petQuest = 'whale';
-      await partyLeader.update({
+      await partyLeader.updateOne({
         [`items.quests.${petQuest}`]: 1,
       });
 
@@ -231,7 +234,7 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
 
     it('removes user from quest when removing user from party before quest starts', async () => {
       const petQuest = 'whale';
-      await partyLeader.update({
+      await partyLeader.updateOne({
         [`items.quests.${petQuest}`]: 1,
       });
       await partyInvitedUser.post(`/groups/${party._id}/join`);
@@ -254,7 +257,7 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
 
     it('prevents user from being removed if they are the quest owner', async () => {
       const petQuest = 'whale';
-      await partyMember.update({
+      await partyMember.updateOne({
         [`items.quests.${petQuest}`]: 1,
       });
 

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',
     });
   });
 
@@ -49,7 +49,7 @@ describe('Post /groups/:groupId/invite', () => {
     });
 
     it('returns error when recipient has blocked the senders', async () => {
-      const inviterNoBlocks = await inviter.update({ 'inbox.blocks': [] });
+      const inviterNoBlocks = await inviter.updateOne({ 'inbox.blocks': [] });
       const userWithBlockedInviter = await generateUser({ 'inbox.blocks': [inviter._id] });
       await expect(inviterNoBlocks.post(`/groups/${group._id}/invite`, {
         usernames: [userWithBlockedInviter.auth.local.lowerCaseUsername],
@@ -64,51 +64,50 @@ describe('Post /groups/:groupId/invite', () => {
     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);
     });
   });
 
   describe('user id invites', () => {
     it('returns an error when inviter has no chat privileges', async () => {
-      const inviterMuted = await inviter.update({ 'flags.chatRevoked': true });
+      const inviterMuted = await inviter.updateOne({ 'flags.chatRevoked': true });
       const userToInvite = await generateUser();
       await expect(inviterMuted.post(`/groups/${group._id}/invite`, {
         uuids: [userToInvite._id],
@@ -198,7 +197,7 @@ describe('Post /groups/:groupId/invite', () => {
     });
 
     it('returns error when recipient has blocked the senders', async () => {
-      const inviterNoBlocks = await inviter.update({ 'inbox.blocks': [] });
+      const inviterNoBlocks = await inviter.updateOne({ 'inbox.blocks': [] });
       const userWithBlockedInviter = await generateUser({ 'inbox.blocks': [inviter._id] });
       await expect(inviterNoBlocks.post(`/groups/${group._id}/invite`, {
         uuids: [userWithBlockedInviter._id],
@@ -213,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 () => {
@@ -270,7 +269,7 @@ describe('Post /groups/:groupId/invite', () => {
     const testInvite = { name: 'test', email: 'test@habitica.com' };
 
     it('returns an error when inviter has no chat privileges', async () => {
-      const inviterMuted = await inviter.update({ 'flags.chatRevoked': true });
+      const inviterMuted = await inviter.updateOne({ 'flags.chatRevoked': true });
       await expect(inviterMuted.post(`/groups/${group._id}/invite`, {
         emails: [testInvite],
         inviter: 'inviter name',
@@ -337,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',
       }))
@@ -418,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();
@@ -436,15 +431,15 @@ 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 inviterMuted = await inviter.updateOne({ 'flags.chatRevoked': true });
       const userToInvite = await generateUser();
       await expect(inviterMuted.post(`/groups/${group._id}/invite`, {
         uuids: [userToInvite._id],
@@ -456,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({
@@ -565,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({
@@ -581,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();
 
@@ -608,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],
       });
 
@@ -621,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

@@ -23,10 +23,11 @@ describe('PUT /group', () => {
       groupDetails: {
         name: groupName,
         type: groupType,
-        privacy: 'public',
+        privacy: 'private',
         categories: groupCategories,
       },
       members: 1,
+      upgradeToGroupPlan: true,
     });
     adminUser = await generateUser({ 'permissions.moderator': true });
     groupToUpdate = group;
@@ -106,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);
   });
 
@@ -122,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,
     };
 
@@ -150,9 +166,11 @@ describe('PUT /group', () => {
       groupDetails: {
         name: 'public guild',
         type: 'guild',
-        privacy: 'public',
+        privacy: 'private',
       },
+      upgradeToGroupPlan: true,
     });
+    await groupLeader.updateOne({ permissions: {} });
 
     const updateGroupDetails = {
       id: group._id,

test/api/v3/integration/hall/GET-hall_heroes_heroId.test.js

@@ -9,7 +9,7 @@ describe('GET /heroes/:heroId', () => {
 
   const heroFields = [
     '_id', 'id', 'auth', 'balance', 'contributor', 'flags', 'items',
-    'lastCron', 'party', 'preferences', 'profile', 'purchased', 'secret',
+    'lastCron', 'party', 'preferences', 'profile', 'purchased', 'secret', 'achievements',
   ];
 
   before(async () => {

test/api/v3/integration/hall/PUT-hall_heores_heroId.test.js

@@ -10,7 +10,7 @@ describe('PUT /heroes/:heroId', () => {
 
   const heroFields = [
     '_id', 'auth', 'balance', 'contributor', 'flags', 'items', 'lastCron',
-    'party', 'preferences', 'profile', 'purchased', 'secret', 'permissions',
+    'party', 'preferences', 'profile', 'purchased', 'secret', 'permissions', 'achievements',
   ];
 
   before(async () => {
@@ -251,4 +251,159 @@ describe('PUT /heroes/:heroId', () => {
     expect(updatedHero.apiToken).to.not.equal(originalToken);
     expect(updatedHero.apiTokenObscured).to.not.exist;
   });
+
+  it('updates purchased hair customization', async () => {
+    const hero = await generateUser();
+    const heroRes = await user.put(`/hall/heroes/${hero._id}`, {
+      purchasedPath: 'purchased.hair.bangs.1',
+      purchasedVal: true,
+    });
+
+    // test response
+    expect(heroRes).to.have.all.keys(heroFields);
+    expect(heroRes.auth.local).not.to.have.keys(['salt', 'hashed_password']);
+    expect(heroRes.profile).to.have.all.keys(['name']);
+
+    // test response values
+    expect(heroRes.purchased.hair.bangs['1']).to.equal(true);
+    // test hero values
+    await hero.sync();
+    expect(hero.purchased.hair.bangs['1']).to.equal(true);
+  });
+
+  it('updates purchased customization', async () => {
+    const hero = await generateUser();
+    const heroRes = await user.put(`/hall/heroes/${hero._id}`, {
+      purchasedPath: 'purchased.background.beach',
+      purchasedVal: true,
+    });
+
+    // test response
+    expect(heroRes).to.have.all.keys(heroFields);
+    expect(heroRes.auth.local).not.to.have.keys(['salt', 'hashed_password']);
+    expect(heroRes.profile).to.have.all.keys(['name']);
+
+    // test response values
+    expect(heroRes.purchased.background.beach).to.equal(true);
+    // test hero values
+    await hero.sync();
+    expect(hero.purchased.background.beach).to.equal(true);
+  });
+
+  it('updates giving nested achievement', async () => {
+    const hero = await generateUser();
+    const heroRes = await user.put(`/hall/heroes/${hero._id}`, {
+      achievementPath: 'achievements.quests.dilatory',
+      achievementVal: 2,
+    });
+
+    // test response
+    expect(heroRes).to.have.all.keys(heroFields);
+    expect(heroRes.auth.local).not.to.have.keys(['salt', 'hashed_password']);
+    expect(heroRes.profile).to.have.all.keys(['name']);
+
+    // test response values
+    expect(heroRes.achievements.quests.dilatory).to.equal(2);
+    // test hero values
+    await hero.sync();
+    expect(hero.achievements.quests.dilatory).to.equal(2);
+  });
+
+  it('updates taking away nested achievement', async () => {
+    const hero = await generateUser({ 'achievements.quests.dilatory': 3 });
+    expect(hero.achievements.quests.dilatory).to.equal(3);
+    const heroRes = await user.put(`/hall/heroes/${hero._id}`, {
+      achievementPath: 'achievements.quests.dilatory',
+      achievementVal: 0,
+    });
+
+    // test response
+    expect(heroRes).to.have.all.keys(heroFields);
+    expect(heroRes.auth.local).not.to.have.keys(['salt', 'hashed_password']);
+    expect(heroRes.profile).to.have.all.keys(['name']);
+
+    // test response values
+    expect(heroRes.achievements.quests.dilatory).to.equal(0);
+    // test hero values
+    await hero.sync();
+    expect(hero.achievements.quests.dilatory).to.equal(0);
+  });
+
+  it('updates giving achievement', async () => {
+    const hero = await generateUser();
+    const heroRes = await user.put(`/hall/heroes/${hero._id}`, {
+      achievementPath: 'achievements.partyOn',
+      achievementVal: true,
+    });
+
+    // test response
+    expect(heroRes).to.have.all.keys(heroFields);
+    expect(heroRes.auth.local).not.to.have.keys(['salt', 'hashed_password']);
+    expect(heroRes.profile).to.have.all.keys(['name']);
+
+    // test response values
+    expect(heroRes.achievements.partyOn).to.equal(true);
+    // test hero values
+    await hero.sync();
+    expect(hero.achievements.partyOn).to.equal(true);
+  });
+
+  it('updates taking away achievement', async () => {
+    const hero = await generateUser({ 'achievements.partyUp': true });
+    expect(hero.achievements.partyUp).to.equal(true);
+    const heroRes = await user.put(`/hall/heroes/${hero._id}`, {
+      achievementPath: 'achievements.partyUp',
+      achievementVal: false,
+    });
+
+    // test response
+    expect(heroRes).to.have.all.keys(heroFields);
+    expect(heroRes.auth.local).not.to.have.keys(['salt', 'hashed_password']);
+    expect(heroRes.profile).to.have.all.keys(['name']);
+
+    // test response values
+    expect(heroRes.achievements.partyUp).to.equal(false);
+    // test hero values
+    await hero.sync();
+    expect(hero.achievements.partyUp).to.equal(false);
+  });
+
+  it('updates giving numbered achievement', async () => {
+    const hero = await generateUser();
+    const heroRes = await user.put(`/hall/heroes/${hero._id}`, {
+      achievementPath: 'achievements.streak',
+      achievementVal: 42,
+    });
+
+    // test response
+    expect(heroRes).to.have.all.keys(heroFields);
+    expect(heroRes.auth.local).not.to.have.keys(['salt', 'hashed_password']);
+    expect(heroRes.profile).to.have.all.keys(['name']);
+
+    // test response values
+    expect(heroRes.achievements.streak).to.equal(42);
+    // test hero values
+    await hero.sync();
+    expect(hero.achievements.streak).to.equal(42);
+  });
+
+  it('updates setting numbered achievement to 0', async () => {
+    const hero = await generateUser({ 'achievements.streak': 42 });
+    expect(hero.achievements.streak).to.equal(42);
+    const heroRes = await user.put(`/hall/heroes/${hero._id}`, {
+      achievementPath: 'achievements.streak',
+      achievementVal: 0,
+    });
+
+    // test response
+    expect(heroRes).to.have.all.keys(heroFields);
+    expect(heroRes.auth.local).not.to.have.keys(['salt', 'hashed_password']);
+    expect(heroRes.profile).to.have.all.keys(['name']);
+
+    // test response values
+    expect(heroRes.achievements.streak).to.equal(0);
+    // test hero values
+    await hero.sync();
+    expect(hero.achievements.streak).to.equal(0);
+  });
 });

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,149 @@
+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([
+        '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 */
+    });
+  });
+});