4.229.1

Bumps [stripe](https://github.com/stripe/stripe-node) from 8.217.0 to 8.219.0.
- [Release notes](https://github.com/stripe/stripe-node/releases)
- [Changelog](https://github.com/stripe/stripe-node/blob/master/CHANGELOG.md)
- [Commits](https://github.com/stripe/stripe-node/compare/v8.217.0...v8.219.0)

---
updated-dependencies:
- dependency-name: stripe
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.eslintignore

@@ -8,10 +8,10 @@ website/client/
 website/common/transpiled-babel/
 dist/
 dist-client/
-apidoc_build/
+apidoc/html/
 content_cache/
 i18n_cache/
 node_modules/
 
 # Old migrations, disabled
-migrations/archive/*
+migrations/archive/*

.github/CONTRIBUTING.md

@@ -4,7 +4,7 @@
 
 # Pull Request
 
-[Please see these instructions for adding a pull request](http://habitica.fandom.com/wiki/Using_Your_Local_Install_to_Modify_Habitica%27s_Website_and_API)
+[Please see these instructions for adding a pull request](https://habitica.fandom.com/wiki/Using_Your_Local_Install_to_Modify_Habitica's_Website_and_API)
 
 # Requesting a feature
 
@@ -12,4 +12,4 @@ Habitica uses [this Google form](https://docs.google.com/forms/d/e/1FAIpQLScPhrw
 
 # Contributing Code
 
-See [Contributing to Habitica](http://habitica.fandom.com/wiki/Contributing_to_Habitica#Coders_.28Web_.26_Mobile.29)
+See [Contributing to Habitica](https://habitica.fandom.com/wiki/Contributing_to_Habitica#Coders_.28Web_.26_Mobile.29)

.github/ISSUE_TEMPLATE.md

@@ -1,20 +1,19 @@
-[//]: # (Before logging this issue, please post to the Report a Bug guild from the Habitica website's Help menu. Most bugs can be handled quickly there. If a GitHub issue is needed, you will be advised of that by a moderator or staff member -- a player with a dark blue or purple name. It is recommended that you don't create a new issue unless advised to.)
+[//]: # (Before logging this issue, please contact site administrators from "Report a Bug" in the Habitica website's Help menu. If a GitHub issue is needed, staff will let you know and will most likely log one on your behalf. It is recommended that you don't create a new issue unless advised to.)
 
-[//]: # (Bugs in the mobile apps can also be reported there.)
+[//]: # (Bugs in the mobile apps can be reported via Menu > About > Support.)
 
-[//]: # (If you have a feature request, use "Help > Request a Feature", not GitHub or the Report a Bug guild.)
+[//]: # (If you have a feature request, use "Help > Request a Feature", not GitHub.)
 
 [//]: # (For more guidelines see https://github.com/HabitRPG/habitica/issues/2760)
 
-[//]: # (Fill out relevant information - UUID is found from the Habitia website at User Icon > Settings > API)
+[//]: # (Fill out relevant information - UUID is found from the Habitica website at User Icon > Settings > API)
 ### General Info
-  * UUID: 
-  * Browser: 
-  * OS: 
+  * UUID:
+  * Browser:
+  * OS:
 
 ### Description
 [//]: # (Describe bug in detail here. Include screenshots if helpful.)
 
 #### Console Errors
 [//]: # (Include any JavaScript console errors here.)
-

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,4 +1,4 @@
-[//]: # (Note: See http://habitica.fandom.com/wiki/Using_Your_Local_Install_to_Modify_Habitica%27s_Website_and_API for more info)
+[//]: # (Note: See https://habitica.fandom.com/wiki/Using_Your_Local_Install_to_Modify_Habitica%27s_Website_and_API for more info)
 
 [//]: # (Put Issue # here, if applicable. This will automatically close the issue if your PR is merged in)
 Fixes put_#_and_issue_number_here
@@ -11,4 +11,4 @@ Fixes put_#_and_issue_number_here
 [//]: # (Put User ID in here - found on the Habitica website at User Icon > Settings > API)
 
 ----
-UUID: 
+UUID:

.github/workflows/test.yml

@@ -219,4 +219,25 @@ jobs:
         CI: true
         NODE_ENV: test
     - run: npm run test:unit
-      working-directory: ./website/client
+      working-directory: ./website/client
+
+  production-build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [14.x]
+    steps:
+    - uses: actions/checkout@v1
+      with:
+        fetch-depth: 1
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: cp config.json.example config.json
+    - name: npm install
+      run: |
+        npm install
+      env:
+        CI: true
+        NODE_ENV: production

.gitignore

@@ -5,7 +5,7 @@ website/common/transpiled-babel/
 node_modules
 content_cache
 i18n_cache
-apidoc_build
+apidoc/html
 *.swp
 .idea*
 config.json

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "habitica-images"]
+	path = habitica-images
+	url = https://github.com/HabitRPG/habitica-images

.slugignore

@@ -0,0 +1,7 @@
+# Files not included in deployments to Heroku, to save on file size.
+
+/habitica-images
+/test
+/migrations
+/scripts
+/database_reports

README.md

@@ -4,11 +4,11 @@ Habitica ![Build Status](https://github.com/HabitRPG/habitica/workflows/Test/bad
 [Habitica](https://habitica.com) is an open source habit building program which treats your life like a Role Playing Game. Level up as you succeed, lose HP as you fail, earn money to buy weapons and armor.
 
 **We need more programmers!** Your assistance will be greatly appreciated. The wiki pages below and the additional pages they link to will tell you how to get started on contributing code and where you can go to seek further help or ask questions:
-* [Guidance for Blacksmiths](http://habitica.fandom.com/wiki/Guidance_for_Blacksmiths) - an introduction to the technologies used and how the software is organized.
-* [Setting up Habitica Locally](http://habitica.fandom.com/wiki/Setting_up_Habitica_Locally) - how to set up a local install of Habitica for development and testing on various platforms.
+* [Guidance for Blacksmiths](https://habitica.fandom.com/wiki/Guidance_for_Blacksmiths) - an introduction to the technologies used and how the software is organized.
+* [Setting up Habitica Locally](https://habitica.fandom.com/wiki/Setting_up_Habitica_Locally) - how to set up a local install of Habitica for development and testing on various platforms.
 
 Habitica's code is licensed as described at https://github.com/HabitRPG/habitica/blob/develop/LICENSE
 
-**Found a bug?** Please report it in the [Report a Bug guild](https://habitica.com/groups/guild/a29da26b-37de-4a71-b0c6-48e72a900dac) rather than creating an issue (an admin will advise you if a new issue is necessary; usually it is not).
+**Found a bug?** Please report it to [admin email](mailto:admin@habitica.com) rather than creating an issue (an admin will advise you if a new issue is necessary; usually it is not).
 
 **Have any questions about Habitica or its community?** See the links in the [habitica.com](https://habitica.com) website's Help menu or drop in to [Guilds > Tavern Chat](https://habitica.com/groups/tavern) to ask questions or chat socially!

apidoc/apidoc.json

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

apidoc/header.md

@@ -3,6 +3,3 @@
 This webpage includes the documentation for version 3 of the [Habitica](https://habitica.com) API.
 
 If you're developing a 3rd party tool that uses the Habitica API you should read the [Guidance for Comrades](https://habitica.fandom.com/wiki/Guidance_for_Comrades) and in particular the section called [Rules for Third-Party Tools](https://habitica.fandom.com/wiki/Guidance_for_Comrades#Rules_for_Third-Party_Tools) which includes suggestions on how to best use the API and the rules to follow when interacting with it.
-
-# Attention: Sample forms are non-functional
-The sample forms were enabled [due to a change in the apidoc package](https://github.com/apidoc/apidoc/pull/915) and do not function, they will be disabled in a future release.

gulp/gulp-apidoc.js

@@ -2,8 +2,9 @@ import gulp from 'gulp';
 import clean from 'rimraf';
 import apidoc from 'apidoc';
 
-const APIDOC_DEST_PATH = './apidoc_build';
+const APIDOC_DEST_PATH = './apidoc/html';
 const APIDOC_SRC_PATH = './website/server';
+const APIDOC_CONFIG_PATH = './apidoc/apidoc.json';
 gulp.task('apidoc:clean', done => {
   clean(APIDOC_DEST_PATH, done);
 });
@@ -12,6 +13,7 @@ gulp.task('apidoc', gulp.series('apidoc:clean', done => {
   const result = apidoc.createDoc({
     src: APIDOC_SRC_PATH,
     dest: APIDOC_DEST_PATH,
+    config: APIDOC_CONFIG_PATH,
   });
 
   if (result === false) {

gulp/gulp-sprites.js

@@ -1,16 +1,8 @@
 import gulp from 'gulp';
-import imagemin from 'gulp-imagemin';
 import spritesmith from 'gulp.spritesmith';
 import clean from 'rimraf';
-import sizeOf from 'image-size';
 import mergeStream from 'merge-stream';
-import { basename } from 'path';
 import { sync } from 'glob';
-import { each } from 'lodash';
-import vinylBuffer from 'vinyl-buffer';
-
-// https://github.com/Ensighten/grunt-spritesmith/issues/67#issuecomment-34786248
-const MAX_SPRITESHEET_SIZE = 1024 * 1024 * 3;
 
 const IMG_DIST_PATH = 'website/client/src/assets/images/sprites/';
 const CSS_DIST_PATH = 'website/client/src/assets/css/sprites/';
@@ -20,49 +12,6 @@ function checkForSpecialTreatment (name) {
   return name.match(regex) || name === 'head_0';
 }
 
-function calculateImgDimensions (img, addPadding) {
-  let dims = sizeOf(img);
-
-  const requiresSpecialTreatment = checkForSpecialTreatment(img);
-  if (requiresSpecialTreatment) {
-    const newWidth = dims.width < 90 ? 90 : dims.width;
-    const newHeight = dims.height < 90 ? 90 : dims.height;
-    dims = {
-      width: newWidth,
-      height: newHeight,
-    };
-  }
-
-  let padding = 0;
-
-  if (addPadding) {
-    padding = dims.width * 8 + dims.height * 8;
-  }
-
-  if (!dims.width || !dims.height) console.error('MISSING DIMENSIONS:', dims); // eslint-disable-line no-console
-
-  const totalPixelSize = dims.width * dims.height + padding;
-
-  return totalPixelSize;
-}
-
-function calculateSpritesheetsSrcIndicies (src) {
-  let totalPixels = 0;
-  const slices = [0];
-
-  each(src, (img, index) => {
-    const imageSize = calculateImgDimensions(img, true);
-    totalPixels += imageSize;
-
-    if (totalPixels > MAX_SPRITESHEET_SIZE) {
-      slices.push(index - 1);
-      totalPixels = imageSize;
-    }
-  });
-
-  return slices;
-}
-
 function cssVarMap (sprite) {
   // For hair, skins, beards, etc. we want to output a '.customize-options.WHATEVER' class,
   // which works as a 60x60 image pointing at the proper part of the 90x90 sprite.
@@ -71,94 +20,56 @@ function cssVarMap (sprite) {
   if (requiresSpecialTreatment) {
     sprite.custom = {
       px: {
-        offsetX: `-${sprite.x + 25}px`,
-        offsetY: `-${sprite.y + 15}px`,
+        offsetX: '-25px',
+        offsetY: '-15px',
         width: '60px',
         height: '60px',
       },
     };
   }
-  if (sprite.name.indexOf('shirt') !== -1) sprite.custom.px.offsetY = `-${sprite.y + 35}px`; // even more for shirts
+
+  // even more for shirts
+  if (sprite.name.indexOf('shirt') !== -1) {
+    sprite.custom.px.offsetX = '-29px';
+    sprite.custom.px.offsetY = '-42px';
+  }
+
   if (sprite.name.indexOf('hair_base') !== -1) {
     const styleArray = sprite.name.split('_').slice(2, 3);
-    if (Number(styleArray[0]) > 14) sprite.custom.px.offsetY = `-${sprite.y}px`; // don't crop updos
+    if (Number(styleArray[0]) > 14) {
+      sprite.custom.px.offsetY = '0'; // don't crop updos
+    }
   }
 }
 
 function createSpritesStream (name, src) {
-  const spritesheetSliceIndicies = calculateSpritesheetsSrcIndicies(src);
   const stream = mergeStream();
 
-  each(spritesheetSliceIndicies, (start, index) => {
-    const slicedSrc = src.slice(start, spritesheetSliceIndicies[index + 1]);
+  const spriteData = gulp.src(src)
+    .pipe(spritesmith({
+      imgName: `spritesmith-${name}.png`,
+      cssName: `spritesmith-${name}.css`,
+      algorithm: 'binary-tree',
+      padding: 1,
+      cssTemplate: 'website/raw_sprites/css/css.template.handlebars',
+      cssVarMap,
+    }));
 
-    const spriteData = gulp.src(slicedSrc)
-      .pipe(spritesmith({
-        imgName: `spritesmith-${name}-${index}.png`,
-        cssName: `spritesmith-${name}-${index}.css`,
-        algorithm: 'binary-tree',
-        padding: 1,
-        cssTemplate: 'website/raw_sprites/css/css.template.handlebars',
-        cssVarMap,
-      }));
+  const cssStream = spriteData.css
+    .pipe(gulp.dest(CSS_DIST_PATH));
 
-    const imgStream = spriteData.img
-      .pipe(vinylBuffer())
-      .pipe(imagemin())
-      .pipe(gulp.dest(IMG_DIST_PATH));
-
-    const cssStream = spriteData.css
-      .pipe(gulp.dest(CSS_DIST_PATH));
-
-    stream.add(imgStream);
-    stream.add(cssStream);
-  });
+  stream.add(cssStream);
 
   return stream;
 }
 
 gulp.task('sprites:main', () => {
-  const mainSrc = sync('website/raw_sprites/spritesmith/**/*.png');
+  const mainSrc = sync('habitica-images/**/*.png');
   return createSpritesStream('main', mainSrc);
 });
 
-gulp.task('sprites:largeSprites', () => {
-  const largeSrc = sync('website/raw_sprites/spritesmith_large/**/*.png');
-  return createSpritesStream('largeSprites', largeSrc);
-});
-
 gulp.task('sprites:clean', done => {
   clean(`${IMG_DIST_PATH}spritesmith*,${CSS_DIST_PATH}spritesmith*}`, done);
 });
 
-gulp.task('sprites:checkCompiledDimensions', gulp.series('sprites:main', 'sprites:largeSprites', done => {
-  console.log('Verifiying that images do not exceed max dimensions'); // eslint-disable-line no-console
-
-  let numberOfSheetsThatAreTooBig = 0;
-
-  const distSpritesheets = sync(`${IMG_DIST_PATH}*.png`);
-
-  each(distSpritesheets, img => {
-    const spriteSize = calculateImgDimensions(img);
-
-    if (spriteSize > MAX_SPRITESHEET_SIZE) {
-      numberOfSheetsThatAreTooBig += 1;
-      const name = basename(img, '.png');
-      console.error(`WARNING: ${name} might be too big - ${spriteSize} > ${MAX_SPRITESHEET_SIZE}`); // eslint-disable-line no-console
-    }
-  });
-
-  if (numberOfSheetsThatAreTooBig > 0) {
-    // https://github.com/HabitRPG/habitica/pull/6683#issuecomment-185462180
-    console.error( // eslint-disable-line no-console
-      `${numberOfSheetsThatAreTooBig} sheets might too big for mobile Safari to be able to handle
-      them, but there is a margin of error in these calculations so it is probably okay. Mention
-      this to an admin so they can test a staging site on mobile Safari after your PR is merged.`,
-    );
-  } else {
-    console.log('All images are within the correct dimensions'); // eslint-disable-line no-console
-  }
-  done();
-}));
-
-gulp.task('sprites:compile', gulp.series('sprites:clean', 'sprites:checkCompiledDimensions', done => done()));
+gulp.task('sprites:compile', gulp.series('sprites:clean', 'sprites:main', done => done()));

migrations/archive/2021/20210824_pet_group_achievements.js

@@ -0,0 +1,138 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20210824_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['FlyingPig-Base']
+      && pets['FlyingPig-CottonCandyBlue']
+      && pets['FlyingPig-CottonCandyPink']
+      && pets['FlyingPig-Desert']
+      && pets['FlyingPig-Golden']
+      && pets['FlyingPig-Red']
+      && pets['FlyingPig-Shade']
+      && pets['FlyingPig-Skeleton']
+      && pets['FlyingPig-White']
+      && pets['FlyingPig-Zombie']
+      && pets['Ferret-Base']
+      && pets['Ferret-CottonCandyBlue']
+      && pets['Ferret-CottonCandyPink']
+      && pets['Ferret-Desert']
+      && pets['Ferret-Golden']
+      && pets['Ferret-Red']
+      && pets['Ferret-Shade']
+      && pets['Ferret-Skeleton']
+      && pets['Ferret-White']
+      && pets['Ferret-Zombie']
+      && pets['GuineaPig-Base']
+      && pets['GuineaPig-CottonCandyBlue']
+      && pets['GuineaPig-CottonCandyPink']
+      && pets['GuineaPig-Desert']
+      && pets['GuineaPig-Golden']
+      && pets['GuineaPig-Red']
+      && pets['GuineaPig-Shade']
+      && pets['GuineaPig-Skeleton']
+      && pets['GuineaPig-White']
+      && pets['GuineaPig-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['Rat-Base']
+      && pets['Rat-CottonCandyBlue']
+      && pets['Rat-CottonCandyPink']
+      && pets['Rat-Desert']
+      && pets['Rat-Golden']
+      && pets['Rat-Red']
+      && pets['Rat-Shade']
+      && pets['Rat-Skeleton']
+      && pets['Rat-White']
+      && pets['Rat-Zombie']
+      && pets['Bunny-Base']
+      && pets['Bunny-CottonCandyBlue']
+      && pets['Bunny-CottonCandyPink']
+      && pets['Bunny-Desert']
+      && pets['Bunny-Golden']
+      && pets['Bunny-Red']
+      && pets['Bunny-Shade']
+      && pets['Bunny-Skeleton']
+      && pets['Bunny-White']
+      && pets['Bunny-Zombie']
+      && pets['Horse-Base']
+      && pets['Horse-CottonCandyBlue']
+      && pets['Horse-CottonCandyPink']
+      && pets['Horse-Desert']
+      && pets['Horse-Golden']
+      && pets['Horse-Red']
+      && pets['Horse-Shade']
+      && pets['Horse-Skeleton']
+      && pets['Horse-White']
+      && pets['Horse-Zombie']
+      && pets['Cow-Base']
+      && pets['Cow-CottonCandyBlue']
+      && pets['Cow-CottonCandyPink']
+      && pets['Cow-Desert']
+      && pets['Cow-Golden']
+      && pets['Cow-Red']
+      && pets['Cow-Shade']
+      && pets['Cow-Skeleton']
+      && pets['Cow-White']
+      && pets['Cow-Zombie']) {
+        set['achievements.domesticated'] = 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('2021-08-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/2021/20211021_pet_color_achievements.js

@@ -0,0 +1,82 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20211021_pet_color_achievements';
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = {
+    migration: MIGRATION_NAME,
+  };
+
+  if (user && user.items && user.items.pets) {
+    const pets = user.items.pets;
+    if (pets['Wolf-Shade'] > 0
+      && pets['TigerCub-Shade'] > 0
+      && pets['PandaCub-Shade'] > 0
+      && pets['LionCub-Shade'] > 0
+      && pets['Fox-Shade'] > 0
+      && pets['FlyingPig-Shade'] > 0
+      && pets['Dragon-Shade'] > 0
+      && pets['Cactus-Shade'] > 0
+      && pets['BearCub-Shade'] > 0) {
+        set['achievements.shadyCustomer'] = true;
+      }
+  }
+
+  if (user && user.items && user.items.mounts) {
+    const mounts = user.items.mounts;
+    if (mounts['Wolf-Shade']
+      && mounts['TigerCub-Shade']
+      && mounts['PandaCub-Shade']
+      && mounts['LionCub-Shade']
+      && mounts['Fox-Shade']
+      && mounts['FlyingPig-Shade']
+      && mounts['Dragon-Shade']
+      && mounts['Cactus-Shade']
+      && mounts['BearCub-Shade'] ) {
+        set['achievements.shadeOfItAll'] = 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('2021-10-01') },
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1]._id,
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2021/20211028_habitoween_ladder.js

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

migrations/archive/2021/20211124_harvest_feast.js

@@ -0,0 +1,126 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20211124_harvest_feast';
+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++;
+
+  const set = {};
+  let inc;
+  let push;
+
+  set.migration = MIGRATION_NAME;
+
+  if (typeof user.items.gear.owned.head_special_turkeyHelmGilded !== 'undefined') {
+    inc = {
+      'items.food.Pie_Base': 1,
+      'items.food.Pie_CottonCandyBlue': 1,
+      'items.food.Pie_CottonCandyPink': 1,
+      'items.food.Pie_Desert': 1,
+      'items.food.Pie_Golden': 1,
+      'items.food.Pie_Red': 1,
+      'items.food.Pie_Shade': 1,
+      'items.food.Pie_Skeleton': 1,
+      'items.food.Pie_Zombie': 1,
+      'items.food.Pie_White': 1,
+    }
+  } else if (typeof user.items.gear.owned.armor_special_turkeyArmorBase !== 'undefined') {
+    set['items.gear.owned.head_special_turkeyHelmGilded'] = false;
+    set['items.gear.owned.armor_special_turkeyArmorGilded'] = false;
+    set['items.gear.owned.back_special_turkeyTailGilded'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_turkeyHelmGilded',
+        _id: uuid(),
+      },
+      {
+        type: 'marketGear',
+        path: 'gear.flat.armor_special_turkeyArmorGilded',
+        _id: uuid(),
+      },
+      {
+        type: 'marketGear',
+        path: 'gear.flat.back_special_turkeyTailGilded',
+        _id: uuid(),
+      },
+    ];
+  } else if (user.items && user.items.mounts && user.items.mounts['Turkey-Gilded']) {
+    set['items.gear.owned.head_special_turkeyHelmBase'] = false;
+    set['items.gear.owned.armor_special_turkeyArmorBase'] = false;
+    set['items.gear.owned.back_special_turkeyTailBase'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_turkeyHelmBase',
+        _id: uuid(),
+      },
+      {
+        type: 'marketGear',
+        path: 'gear.flat.armor_special_turkeyArmorBase',
+        _id: uuid(),
+      },
+      {
+        type: 'marketGear',
+        path: 'gear.flat.back_special_turkeyTailBase',
+        _id: uuid(),
+      },
+    ];
+  } else if (user.items && user.items.pets && user.items.pets['Turkey-Gilded']) {
+    set['items.mounts.Turkey-Gilded'] = true;
+  } else if (user.items && user.items.mounts && user.items.mounts['Turkey-Base']) {
+    set['items.pets.Turkey-Gilded'] = 5;
+  } else if (user.items && user.items.pets && user.items.pets['Turkey-Base']) {
+    set['items.mounts.Turkey-Base'] = true;
+  } else {
+    set['items.pets.Turkey-Base'] = 5;
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  if (inc) {
+    return await User.update({_id: user._id}, {$inc: inc, $set: set}).exec();
+  } else if (push) {
+    return await User.update({_id: user._id}, {$set: set, $push: {pinnedItems: {$each: push}}}).exec();
+  } else {
+    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('2021-11-01')},
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2021/20211230_nye.js

@@ -0,0 +1,135 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20211230_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_nye2020 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2021'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2021',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2019 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2020'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2020',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2018 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2019'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2019',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2017 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2018'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2018',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2016 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2017'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2017',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2015 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2016'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2016',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2014 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2015'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2015',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye !== 'undefined') {
+    set['items.gear.owned.head_special_nye2014'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2014',
+        _id: uuid(),
+      },
+    ];
+  } else {
+    set['items.gear.owned.head_special_nye'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye',
+        _id: uuid(),
+      },
+    ];
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({_id: user._id}, {$set: set, $push: {pinnedItems: {$each: push}}}).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    'auth.timestamps.loggedin': {$gt: new Date('2021-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/2022/20220131_habit_birthday.js

@@ -0,0 +1,97 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20220131_habit_birthday';
+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++;
+
+  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 = {};
+  let push;
+
+  set.migration = MIGRATION_NAME;
+
+  if (typeof user.items.gear.owned.armor_special_birthday2021 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2022'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_birthday2022', _id: uuid()}};
+  } else if (typeof user.items.gear.owned.armor_special_birthday2020 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2021'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_birthday2021', _id: uuid()}};
+  } else if (typeof user.items.gear.owned.armor_special_birthday2019 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2020'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_birthday2020', _id: uuid()}};
+  } else if (typeof user.items.gear.owned.armor_special_birthday2018 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2019'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_birthday2019', _id: uuid()}};
+  } else if (typeof user.items.gear.owned.armor_special_birthday2017 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2018'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_birthday2018', _id: uuid()}};
+  } else if (typeof user.items.gear.owned.armor_special_birthday2016 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2017'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_birthday2017', _id: uuid()}};
+  } else if (typeof user.items.gear.owned.armor_special_birthday2015 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2016'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_birthday2016', _id: uuid()}};
+  } else if (typeof user.items.gear.owned.armor_special_birthday !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2015'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_birthday2015', _id: uuid()}};
+  } else {
+    set['items.gear.owned.armor_special_birthday'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_birthday', _id: uuid()}};
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({_id: user._id}, {$inc: inc, $set: set, $push: push}).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'auth.timestamps.loggedin': {$gt: new Date('2022-01-01')},
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2022/20220201_pet_group_achievements.js

@@ -0,0 +1,178 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20220201_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['FlyingPig-Base']
+      && pets['FlyingPig-CottonCandyBlue']
+      && pets['FlyingPig-CottonCandyPink']
+      && pets['FlyingPig-Desert']
+      && pets['FlyingPig-Golden']
+      && pets['FlyingPig-Red']
+      && pets['FlyingPig-Shade']
+      && pets['FlyingPig-Skeleton']
+      && pets['FlyingPig-White']
+      && pets['FlyingPig-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['Sheep-Base']
+      && pets['Sheep-CottonCandyBlue']
+      && pets['Sheep-CottonCandyPink']
+      && pets['Sheep-Desert']
+      && pets['Sheep-Golden']
+      && pets['Sheep-Red']
+      && pets['Sheep-Shade']
+      && pets['Sheep-Skeleton']
+      && pets['Sheep-White']
+      && pets['Sheep-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['Rat-Base']
+      && pets['Rat-CottonCandyBlue']
+      && pets['Rat-CottonCandyPink']
+      && pets['Rat-Desert']
+      && pets['Rat-Golden']
+      && pets['Rat-Red']
+      && pets['Rat-Shade']
+      && pets['Rat-Skeleton']
+      && pets['Rat-White']
+      && pets['Rat-Zombie']
+      && pets['Bunny-Base']
+      && pets['Bunny-CottonCandyBlue']
+      && pets['Bunny-CottonCandyPink']
+      && pets['Bunny-Desert']
+      && pets['Bunny-Golden']
+      && pets['Bunny-Red']
+      && pets['Bunny-Shade']
+      && pets['Bunny-Skeleton']
+      && pets['Bunny-White']
+      && pets['Bunny-Zombie']
+      && pets['Horse-Base']
+      && pets['Horse-CottonCandyBlue']
+      && pets['Horse-CottonCandyPink']
+      && pets['Horse-Desert']
+      && pets['Horse-Golden']
+      && pets['Horse-Red']
+      && pets['Horse-Shade']
+      && pets['Horse-Skeleton']
+      && pets['Horse-White']
+      && pets['Horse-Zombie']
+      && pets['Cow-Base']
+      && pets['Cow-CottonCandyBlue']
+      && pets['Cow-CottonCandyPink']
+      && pets['Cow-Desert']
+      && pets['Cow-Golden']
+      && pets['Cow-Red']
+      && pets['Cow-Shade']
+      && pets['Cow-Skeleton']
+      && pets['Cow-White']
+      && pets['Cow-Zombie']
+      && pets['Monkey-Base']
+      && pets['Monkey-CottonCandyBlue']
+      && pets['Monkey-CottonCandyPink']
+      && pets['Monkey-Desert']
+      && pets['Monkey-Golden']
+      && pets['Monkey-Red']
+      && pets['Monkey-Shade']
+      && pets['Monkey-Skeleton']
+      && pets['Monkey-White']
+      && pets['Monkey-Zombie']
+      && pets['Wolf-Base']
+      && pets['Wolf-CottonCandyBlue']
+      && pets['Wolf-CottonCandyPink']
+      && pets['Wolf-Desert']
+      && pets['Wolf-Golden']
+      && pets['Wolf-Red']
+      && pets['Wolf-Shade']
+      && pets['Wolf-Skeleton']
+      && pets['Wolf-White']
+      && pets['Wolf-Zombie']
+      && pets['Tiger-Base']
+      && pets['Tiger-CottonCandyBlue']
+      && pets['Tiger-CottonCandyPink']
+      && pets['Tiger-Desert']
+      && pets['Tiger-Golden']
+      && pets['Tiger-Red']
+      && pets['Tiger-Shade']
+      && pets['Tiger-Skeleton']
+      && pets['Tiger-White']
+      && pets['Tiger-Zombie']
+      && pets['Dragon-Base']
+      && pets['Dragon-CottonCandyBlue']
+      && pets['Dragon-CottonCandyPink']
+      && pets['Dragon-Desert']
+      && pets['Dragon-Golden']
+      && pets['Dragon-Red']
+      && pets['Dragon-Shade']
+      && pets['Dragon-Skeleton']
+      && pets['Dragon-White']
+      && pets['Dragon-Zombie']) {
+        set['achievements.zodiacZookeeper'] = 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('2021-08-01') },
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1]._id,
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/archive/2022/20220309_pet_group_achievements.js

@@ -0,0 +1,138 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20220309_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['FlyingPig-Base']
+      && pets['FlyingPig-CottonCandyBlue']
+      && pets['FlyingPig-CottonCandyPink']
+      && pets['FlyingPig-Desert']
+      && pets['FlyingPig-Golden']
+      && pets['FlyingPig-Red']
+      && pets['FlyingPig-Shade']
+      && pets['FlyingPig-Skeleton']
+      && pets['FlyingPig-White']
+      && pets['FlyingPig-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['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['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['Gryphon-Base']
+      && pets['Gryphon-CottonCandyBlue']
+      && pets['Gryphon-CottonCandyPink']
+      && pets['Gryphon-Desert']
+      && pets['Gryphon-Golden']
+      && pets['Gryphon-Red']
+      && pets['Gryphon-Shade']
+      && pets['Gryphon-Skeleton']
+      && pets['Gryphon-White']
+      && pets['Gryphon-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.birdsOfAFeather'] = 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('2021-08-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/users/pi-day.js

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

package.json

@@ -1,80 +1,80 @@
 {
   "name": "habitica",
   "description": "A habit tracker app which treats your goals like a Role Playing Game.",
-  "version": "4.195.0",
+  "version": "4.229.1",
   "main": "./website/server/index.js",
   "dependencies": {
-    "@babel/core": "^7.13.16",
-    "@babel/preset-env": "^7.14.1",
-    "@babel/register": "^7.13.16",
-    "@google-cloud/trace-agent": "^5.1.3",
-    "@parse/node-apn": "^4.1.1",
-    "@slack/webhook": "^6.0.0",
-    "accepts": "^1.3.5",
-    "amazon-payments": "^0.2.8",
-    "amplitude": "^5.1.5",
-    "apidoc": "^0.27.1",
+    "@babel/core": "^7.17.9",
+    "@babel/preset-env": "^7.16.11",
+    "@babel/register": "^7.17.7",
+    "@google-cloud/trace-agent": "^5.1.6",
+    "@parse/node-apn": "^5.1.3",
+    "@slack/webhook": "^6.1.0",
+    "accepts": "^1.3.8",
+    "amazon-payments": "^0.2.9",
+    "amplitude": "^6.0.0",
+    "apidoc": "^0.51.1",
     "apple-auth": "^1.0.7",
     "bcrypt": "^5.0.1",
-    "body-parser": "^1.18.3",
+    "body-parser": "^1.20.0",
     "bootstrap": "^4.6.0",
     "compression": "^1.7.4",
-    "cookie-session": "^1.4.0",
+    "cookie-session": "^2.0.0",
     "coupon-code": "^0.4.5",
-    "csv-stringify": "^5.6.2",
+    "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-plugin-mocha": "^5.0.0",
-    "express": "^4.16.3",
-    "express-basic-auth": "^1.1.5",
+    "express": "^4.17.3",
+    "express-basic-auth": "^1.2.1",
     "express-validator": "^5.2.0",
-    "glob": "^7.1.6",
-    "got": "^11.8.2",
+    "glob": "^7.2.0",
+    "got": "^11.8.3",
     "gulp": "^4.0.0",
     "gulp-babel": "^8.0.0",
     "gulp-imagemin": "^7.1.0",
     "gulp-nodemon": "^2.5.0",
-    "gulp.spritesmith": "^6.9.0",
+    "gulp.spritesmith": "^6.12.1",
     "habitica-markdown": "^3.0.0",
     "helmet": "^4.6.0",
-    "image-size": "^1.0.0",
+    "image-size": "^1.0.1",
     "in-app-purchase": "^1.11.3",
-    "js2xmlparser": "^4.0.1",
+    "js2xmlparser": "^4.0.2",
     "jsonwebtoken": "^8.5.1",
-    "jwks-rsa": "^2.0.3",
+    "jwks-rsa": "^2.0.5",
     "lodash": "^4.17.21",
     "merge-stream": "^2.0.0",
     "method-override": "^3.0.0",
-    "moment": "^2.29.1",
+    "moment": "^2.29.3",
     "moment-recur": "^1.0.7",
-    "mongoose": "^5.12.7",
+    "mongoose": "^5.13.7",
     "morgan": "^1.10.0",
-    "nconf": "^0.11.2",
-    "node-gcm": "^1.0.4",
+    "nconf": "^0.12.0",
+    "node-gcm": "^1.0.5",
     "on-headers": "^1.0.2",
-    "passport": "^0.4.1",
+    "passport": "^0.5.0",
     "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.2.1",
+    "rate-limiter-flexible": "^2.3.6",
     "redis": "^3.1.2",
-    "regenerator-runtime": "^0.13.7",
+    "regenerator-runtime": "^0.13.9",
     "remove-markdown": "^0.3.0",
     "rimraf": "^3.0.2",
-    "short-uuid": "^4.1.0",
-    "stripe": "^8.145.0",
-    "superagent": "^6.1.0",
-    "universal-analytics": "^0.4.23",
+    "short-uuid": "^4.2.0",
+    "stripe": "^8.219.0",
+    "superagent": "^7.1.2",
+    "universal-analytics": "^0.5.3",
     "useragent": "^2.1.9",
     "uuid": "^8.3.2",
-    "validator": "^13.6.0",
+    "validator": "^13.7.0",
     "vinyl-buffer": "^1.0.1",
-    "winston": "^3.3.3",
+    "winston": "^3.7.2",
     "winston-loggly-bulk": "^3.2.1",
     "xml2js": "^0.4.23"
   },
@@ -106,24 +106,24 @@
     "start": "gulp nodemon",
     "debug": "gulp nodemon --inspect",
     "mongo:dev": "run-rs -v 4.2.8 -l ubuntu1804 --keep --dbpath mongodb-data --number 1 --quiet",
-    "postinstall": "gulp build && cd website/client && npm install",
+    "postinstall": "git config --global url.\"https://\".insteadOf git:// && gulp build && cd website/client && npm install",
     "apidoc": "gulp apidoc"
   },
   "devDependencies": {
-    "axios": "^0.21.1",
-    "chai": "^4.3.4",
+    "axios": "^0.26.1",
+    "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
     "chai-moment": "^0.1.0",
-    "chalk": "^4.1.1",
+    "chalk": "^4.1.2",
     "cross-spawn": "^7.0.3",
     "expect.js": "^0.3.1",
     "istanbul": "^1.1.0-alpha.1",
     "mocha": "^5.1.1",
     "monk": "^7.3.4",
     "require-again": "^2.0.0",
-    "run-rs": "^0.7.4",
-    "sinon": "^10.0.0",
-    "sinon-chai": "^3.6.0",
+    "run-rs": "^0.7.6",
+    "sinon": "^13.0.2",
+    "sinon-chai": "^3.7.0",
     "sinon-stub-promise": "^4.0.0"
   },
   "optionalDependencies": {}

scripts/gdpr-delete-users.js

@@ -31,7 +31,6 @@ async function deleteAmplitudeData (userId, email) {
       console.log(`${userId} (${email}) Amplitude response: ${response.status} ${response.statusText}`);
     }
   }
-  await new Promise(resolve => setTimeout(resolve, 1000));
 }
 
 async function deleteHabiticaData (user, email) {
@@ -41,7 +40,7 @@ async function deleteHabiticaData (user, email) {
     'auth.local.passwordHashMethod': 'bcrypt',
   };
   if (!user.auth.local.email) set['auth.local.email'] = `${user._id}@example.com`;
-  await User.update(
+  await User.updateOne(
     { _id: user._id },
     { $set: set },
   );
@@ -83,6 +82,7 @@ async function processEmailAddress (email) {
       $or: [
         { 'auth.facebook.emails.value': email },
         { 'auth.google.emails.value': email },
+        { 'auth.apple.emails.value': email },
       ],
     },
     { _id: 1, apiToken: 1, auth: 1 },
@@ -96,6 +96,7 @@ async function processEmailAddress (email) {
     return console.log(`No users found with email address ${email}`);
   }
 
+  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
     await deleteHabiticaData(user, email); // eslint-disable-line no-await-in-loop

test/README.md

@@ -1 +1 @@
-For information about writing and running tests, see [Using Your Local Install to Modify Habitica's Website and API](http://habitica.fandom.com/wiki/Using_Your_Local_Install_to_Modify_Habitica%27s_Website_and_API).
+For information about writing and running tests, see [Using Your Local Install to Modify Habitica's Website and API](https://habitica.fandom.com/wiki/Using_Your_Local_Install_to_Modify_Habitica's_Website_and_API).

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

@@ -0,0 +1,57 @@
+/* eslint-disable global-require */
+import nconf from 'nconf';
+import { generateUser } from '../../../helpers/api-unit.helper';
+import * as emailLib from '../../../../website/server/libs/email';
+import { bugReportLogic } from '../../../../website/server/libs/bug-report';
+
+describe('bug-report', () => {
+  beforeEach(() => {
+    sandbox.stub(emailLib, 'sendTxn').returns(Promise.resolve());
+
+    const nconfGetStub = sandbox.stub(nconf, 'get');
+    nconfGetStub.withArgs('ADMIN_EMAIL').returns('true');
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it('sends a mail using sendTxn', async () => {
+    const userId = '2b58daeb-bc50-4a83-b5d3-4ac52c7c0608';
+    const userMail = 'me@me.com';
+    const userMessage = 'The power is over 9000, please fix it';
+    const userAgent = 'The UserAgent with a bunch of weird browser engine levels';
+
+    const user = generateUser({
+      _id: userId,
+    });
+
+    const result = await bugReportLogic(
+      user, userMail, userMessage, userAgent,
+    );
+
+    expect(emailLib.sendTxn).to.be.called;
+    expect(result).to.deep.equal({
+      sendMailResult: undefined,
+      emailData: {
+        BROWSER_UA: userAgent,
+        REPORT_MSG: userMessage,
+        USER_CLASS: 'warrior',
+        USER_CONSECUTIVE_MONTHS: 0,
+        USER_COSTUME: 'false',
+        USER_CUSTOMER_ID: undefined,
+        USER_CUSTOM_DAY: 0,
+        USER_DAILIES_PAUSED: 'false',
+        USER_EMAIL: userMail,
+        USER_HOURGLASSES: 0,
+        USER_ID: userId,
+        USER_LEVEL: 1,
+        USER_OFFSET_MONTHS: 0,
+        USER_PAYMENT_PLATFORM: undefined,
+        USER_SUBSCRIPTION: undefined,
+        USER_TIMEZONE_OFFSET: 0,
+        USER_USERNAME: undefined,
+      },
+    });
+  });
+});

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

@@ -148,9 +148,18 @@ describe('emails', () => {
     });
   });
 
-  describe('sendTxnEmail', () => {
+  describe('sendTxn', () => {
+    let sendTxn = null;
+
     beforeEach(() => {
       sandbox.stub(got, 'post').returns(defer().promise);
+
+      const nconfGetStub = sandbox.stub(nconf, 'get');
+      nconfGetStub.withArgs('IS_PROD').returns(true);
+      nconfGetStub.withArgs('BASE_URL').returns('BASE_URL');
+
+      const attachEmail = requireAgain(pathToEmailLib);
+      sendTxn = attachEmail.sendTxn;
     });
 
     afterEach(() => {
@@ -158,16 +167,14 @@ describe('emails', () => {
     });
 
     it('can send a txn email to one recipient', () => {
-      sandbox.stub(nconf, 'get').withArgs('IS_PROD').returns(true);
-      const attachEmail = requireAgain(pathToEmailLib);
-      const sendTxnEmail = attachEmail.sendTxn;
       const emailType = 'an email type';
       const mailingInfo = {
         name: 'my name',
         email: 'my@email',
       };
 
-      sendTxnEmail(mailingInfo, emailType);
+      sendTxn(mailingInfo, emailType);
+      expect(got.post).to.be.called;
       expect(got.post).to.be.calledWith('undefined/job', sinon.match({
         json: {
           data: {
@@ -179,27 +186,77 @@ describe('emails', () => {
     });
 
     it('does not send email if address is missing', () => {
-      sandbox.stub(nconf, 'get').withArgs('IS_PROD').returns(true);
-      const attachEmail = requireAgain(pathToEmailLib);
-      const sendTxnEmail = attachEmail.sendTxn;
       const emailType = 'an email type';
       const mailingInfo = {
         name: 'my name',
         // email: 'my@email',
       };
 
-      sendTxnEmail(mailingInfo, emailType);
+      sendTxn(mailingInfo, emailType);
       expect(got.post).not.to.be.called;
     });
 
+    it('throws error when mail target is only a string', () => {
+      const emailType = 'an email type';
+      const mailingInfo = 'my email';
+
+      expect(sendTxn(mailingInfo, emailType)).to.throw;
+    });
+
+    it('throws error when mail target has no _id or email', () => {
+      const emailType = 'an email type';
+      const mailingInfo = {
+
+      };
+
+      expect(sendTxn(mailingInfo, emailType)).to.throw;
+    });
+
+    it('throws error when variables not an array', () => {
+      const emailType = 'an email type';
+      const mailingInfo = {
+        name: 'my name',
+        email: 'my@email',
+      };
+      const variables = {};
+
+      expect(sendTxn(mailingInfo, emailType, variables)).to.throw;
+    });
+    it('throws error when variables array not contain name/content', () => {
+      const emailType = 'an email type';
+      const mailingInfo = {
+        name: 'my name',
+        email: 'my@email',
+      };
+      const variables = [
+        {
+
+        },
+      ];
+
+      expect(sendTxn(mailingInfo, emailType, variables)).to.throw;
+    });
+    it('throws no error when variables array contain name but no content', () => {
+      const emailType = 'an email type';
+      const mailingInfo = {
+        name: 'my name',
+        email: 'my@email',
+      };
+      const variables = [
+        {
+          name: 'MY_VAR',
+        },
+      ];
+
+      expect(sendTxn(mailingInfo, emailType, variables)).to.not.throw;
+    });
+
     it('uses getUserInfo in case of user data', () => {
-      sandbox.stub(nconf, 'get').withArgs('IS_PROD').returns(true);
-      const attachEmail = requireAgain(pathToEmailLib);
-      const sendTxnEmail = attachEmail.sendTxn;
       const emailType = 'an email type';
       const mailingInfo = getUser();
 
-      sendTxnEmail(mailingInfo, emailType);
+      sendTxn(mailingInfo, emailType);
+      expect(got.post).to.be.called;
       expect(got.post).to.be.calledWith('undefined/job', sinon.match({
         json: {
           data: {
@@ -211,17 +268,15 @@ describe('emails', () => {
     });
 
     it('sends email with some default variables', () => {
-      sandbox.stub(nconf, 'get').withArgs('IS_PROD').returns(true);
-      const attachEmail = requireAgain(pathToEmailLib);
-      const sendTxnEmail = attachEmail.sendTxn;
       const emailType = 'an email type';
       const mailingInfo = {
         name: 'my name',
         email: 'my@email',
       };
-      const variables = [1, 2, 3];
+      const variables = [];
 
-      sendTxnEmail(mailingInfo, emailType, variables);
+      sendTxn(mailingInfo, emailType, variables);
+      expect(got.post).to.be.called;
       expect(got.post).to.be.calledWith('undefined/job', sinon.match({
         json: {
           data: {

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

@@ -256,7 +256,7 @@ describe('Google Payments', () => {
           expirationDate,
         });
       iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
-        .returns([{ expirationDate: expirationDate.toDate() }]);
+        .returns([{ expirationDate: expirationDate.toDate(), autoRenewing: false }]);
       iapIsValidatedStub = sinon.stub(iap, 'isValidated')
         .returns(true);
 
@@ -325,5 +325,26 @@ describe('Google Payments', () => {
         headers,
       });
     });
+
+    it('should not cancel a user subscription with autorenew', async () => {
+      iap.getPurchaseData.restore();
+      iapGetPurchaseDataStub = sinon.stub(iap, 'getPurchaseData')
+        .returns([{ autoRenewing: true }]);
+      await googlePayments.cancelSubscribe(user, headers);
+
+      expect(iapSetupStub).to.be.calledOnce;
+      expect(iapValidateStub).to.be.calledOnce;
+      expect(iapValidateStub).to.be.calledWith(iap.GOOGLE, {
+        data: receipt,
+        signature,
+      });
+      expect(iapIsValidatedStub).to.be.calledOnce;
+      expect(iapIsValidatedStub).to.be.calledWith({
+        expirationDate,
+      });
+      expect(iapGetPurchaseDataStub).to.be.calledOnce;
+
+      expect(paymentCancelSubscriptionSpy).to.not.be.called;
+    });
   });
 });

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

@@ -247,11 +247,11 @@ describe('payments/index', () => {
 
       context('No Active Promotion', () => {
         beforeEach(() => {
-          sinon.stub(worldState, 'getCurrentEvent').returns(null);
+          sinon.stub(worldState, 'getCurrentEventList').returns([]);
         });
 
         afterEach(() => {
-          worldState.getCurrentEvent.restore();
+          worldState.getCurrentEventList.restore();
         });
 
         it('sends a private message about the gift', async () => {
@@ -268,14 +268,14 @@ describe('payments/index', () => {
 
       context('Active Promotion', () => {
         beforeEach(() => {
-          sinon.stub(worldState, 'getCurrentEvent').returns({
+          sinon.stub(worldState, 'getCurrentEventList').returns([{
             ...common.content.events.winter2021Promo,
             event: 'winter2021',
-          });
+          }]);
         });
 
         afterEach(() => {
-          worldState.getCurrentEvent.restore();
+          worldState.getCurrentEventList.restore();
         });
 
         it('creates a gift subscription for purchaser and recipient if none exist', async () => {

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

@@ -656,9 +656,11 @@ describe('webhooks', () => {
           id: 'group-id',
           name: 'some group',
           otherData: 'foo',
+          quest: {},
         },
         quest: {
           key: 'some-key',
+          questOwner: 'user-id',
         },
       };
     });

test/api/unit/middlewares/cronMiddleware.js

@@ -128,6 +128,22 @@ describe('cron middleware', () => {
     });
   });
 
+  it('runs cron if previous cron was incomplete', async () => {
+    user.lastCron = moment(new Date()).subtract({ days: 1 });
+    user.auth.timestamps.loggedin = moment(new Date()).subtract({ days: 4 });
+    const now = new Date();
+    await user.save();
+
+    await new Promise((resolve, reject) => {
+      cronMiddleware(req, res, err => {
+        if (err) return reject(err);
+        expect(moment(now).isSame(user.lastCron, 'day'));
+        expect(moment(now).isSame(user.auth.timestamps.loggedin, 'day'));
+        return resolve();
+      });
+    });
+  });
+
   it('updates user.auth.timestamps.loggedin and lastCron', async () => {
     user.lastCron = moment(new Date()).subtract({ days: 2 });
     const now = new Date();
@@ -294,89 +310,32 @@ describe('cron middleware', () => {
     });
   });
 
-  context('Drop Cap A/B Test', async () => {
-    it('enrolls web users', async () => {
-      user.lastCron = moment(new Date()).subtract({ days: 2 });
-      await user.save();
-      req.headers['x-client'] = 'habitica-web';
+  it('cron should not run more than once', async () => {
+    user.lastCron = moment(new Date()).subtract({ days: 2 });
+    await user.save();
 
-      await new Promise((resolve, reject) => {
-        cronMiddleware(req, res, async err => {
+    sandbox.spy(cronLib, 'cron');
+
+    await Promise.all([new Promise((resolve, reject) => {
+      cronMiddleware(req, res, err => {
+        if (err) return reject(err);
+        return resolve();
+      });
+    }), new Promise((resolve, reject) => {
+      cronMiddleware(req, res, err => {
+        if (err) return reject(err);
+        return resolve();
+      });
+    }), new Promise((resolve, reject) => {
+      setTimeout(() => {
+        cronMiddleware(req, res, err => {
           if (err) return reject(err);
-          user = await User.findById(user._id).exec();
-          expect(user._ABtests.dropCapNotif).to.be.a.string;
-
           return resolve();
         });
-      });
-    });
+      }, 400);
+    }),
+    ]);
 
-    it('enables the new notification for 50% of users', async () => {
-      sandbox.stub(Math, 'random').returns(0.5);
-      user.lastCron = moment(new Date()).subtract({ days: 2 });
-      await user.save();
-      req.headers['x-client'] = 'habitica-web';
-
-      await new Promise((resolve, reject) => {
-        cronMiddleware(req, res, async err => {
-          if (err) return reject(err);
-          user = await User.findById(user._id).exec();
-          expect(user._ABtests.dropCapNotif).to.be.equal('drop-cap-notif-enabled');
-
-          return resolve();
-        });
-      });
-    });
-
-    it('disables the new notification for 50% of users', async () => {
-      sandbox.stub(Math, 'random').returns(0.51);
-      user.lastCron = moment(new Date()).subtract({ days: 2 });
-      await user.save();
-      req.headers['x-client'] = 'habitica-web';
-
-      await new Promise((resolve, reject) => {
-        cronMiddleware(req, res, async err => {
-          if (err) return reject(err);
-          user = await User.findById(user._id).exec();
-          expect(user._ABtests.dropCapNotif).to.be.equal('drop-cap-notif-disabled');
-
-          return resolve();
-        });
-      });
-    });
-
-    it('does not affect subscribers', async () => {
-      sandbox.stub(Math, 'random').returns(0.2);
-      user.lastCron = moment(new Date()).subtract({ days: 2 });
-      await user.save();
-      req.headers['x-client'] = 'habitica-web';
-      sandbox.stub(User.prototype, 'isSubscribed').returns(true);
-
-      await new Promise((resolve, reject) => {
-        cronMiddleware(req, res, async err => {
-          if (err) return reject(err);
-          user = await User.findById(user._id).exec();
-          expect(user._ABtests.dropCapNotif).to.not.exist;
-
-          return resolve();
-        });
-      });
-    });
-
-    it('does not affect mobile users', async () => {
-      user.lastCron = moment(new Date()).subtract({ days: 2 });
-      await user.save();
-      req.headers['x-client'] = 'habitica-ios';
-
-      await new Promise((resolve, reject) => {
-        cronMiddleware(req, res, async err => {
-          if (err) return reject(err);
-          user = await User.findById(user._id).exec();
-          expect(user._ABtests.dropCapNotif).to.not.exist;
-
-          return resolve();
-        });
-      });
-    });
+    expect(cronLib.cron).to.be.calledOnce;
   });
 });

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

@@ -488,20 +488,6 @@ describe('Group Model', () => {
           expect(party.quest.progress.collect.soapBars).to.eq(5);
         });
 
-        it('does not drop an item if not need when on a collection quest', async () => {
-          party.quest.key = 'dilatoryDistress1';
-          party.quest.active = false;
-          await party.startQuest(questLeader);
-          party.quest.progress.collect.fireCoral = 20;
-          await party.save();
-
-          await Group.processQuestProgress(participatingMember, progress);
-
-          party = await Group.findOne({ _id: party._id });
-
-          expect(party.quest.progress.collect.fireCoral).to.eq(20);
-        });
-
         it('sends a chat message about progress', async () => {
           await Group.processQuestProgress(participatingMember, progress);
 
@@ -538,8 +524,8 @@ describe('Group Model', () => {
           });
         });
 
-        describe('collection quests with multiple items', () => {
-          it('sends a chat message if no progress is made on quest with multiple items', async () => {
+        describe('collection quests with multiple item types', () => {
+          it('sends a chat message if no progress is made', async () => {
             progress.collectedItems = 0;
             party.quest.key = 'dilatoryDistress1';
             party.quest.active = false;
@@ -609,6 +595,28 @@ describe('Group Model', () => {
           });
         });
 
+        it('does not drop items when an item type becomes full', async () => {
+          progress.collectedItems = 20;
+          party.quest.key = 'dilatoryDistress1';
+          party.quest.active = false;
+
+          await party.startQuest(questLeader);
+          party.quest.progress.collect.fireCoral = 19;
+          await party.save();
+
+          await Group.processQuestProgress(participatingMember, progress);
+
+          party = await Group.findOne({ _id: party._id });
+
+          // There is a very small chance (~1 in 500K) that blueFins will
+          // be 19 or 20 due to randomness and not any bug. In these cases, this
+          // test doesn't actually verify anything, but it's rare enough that it
+          // shouldn't be a problem, and to make it deterministic would require
+          // stubbing out methods in implementation-specific ways.
+          expect(party.quest.progress.collect.fireCoral).to.be.within(19, 20);
+          expect(party.quest.progress.collect.blueFins).to.be.within(19, 20);
+        });
+
         it('sends message about victory', async () => {
           progress.collectedItems = 500;
 

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

@@ -592,20 +592,6 @@ describe('User Model', () => {
   });
 
   context('pre-save hook', () => {
-    it('enrolls users that signup through web in the Drop Cap AB test', async () => {
-      let user = new User();
-      user.registeredThrough = 'habitica-web';
-      user = await user.save();
-      expect(user._ABtests.dropCapNotif).to.exist;
-    });
-
-    it('does not enroll users that signup through modal in the Drop Cap AB test', async () => {
-      let user = new User();
-      user.registeredThrough = 'habitica-ios';
-      user = await user.save();
-      expect(user._ABtests.dropCapNotif).to.not.exist;
-    });
-
     it('marks the last news post as read for new users', async () => {
       const lastNewsPost = { _id: '1' };
       sandbox.stub(NewsPost, 'lastNewsPost').returns(lastNewsPost);
@@ -825,6 +811,16 @@ describe('User Model', () => {
       expect(daysMissed).to.eql(5);
     });
 
+    it('correctly handles a cron that did not complete', () => {
+      const now = moment();
+      user.lastCron = moment(now).subtract(2, 'days');
+      user.auth.timestamps.loggedIn = moment(now).subtract(5, 'days');
+
+      const { daysMissed } = user.daysUserHasMissed(now);
+
+      expect(daysMissed).to.eql(5);
+    });
+
     it('uses timezone from preferences to calculate days missed', () => {
       const now = moment('2017-07-08 01:00:00Z');
       user.lastCron = moment('2017-07-04 13:00:00Z');

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

@@ -74,7 +74,6 @@ describe('PUT /challenges/:challengeId', () => {
     expect(res.memberCount).to.equal(2);
     expect(res.tasksOrder).not.to.equal('new order');
     expect(res.official).to.equal(false);
-    expect(res.shortName).not.to.equal('new short name');
 
     expect(res.leader).to.eql({
       _id: user._id,

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

@@ -7,7 +7,7 @@ import {
 } from '../../../../helpers/api-integration/v3';
 
 const INVITES_LIMIT = 100;
-const PARTY_LIMIT_MEMBERS = 30;
+const PARTY_LIMIT_MEMBERS = 29;
 const MAX_EMAIL_INVITES_BY_USER = 200;
 
 describe('Post /groups/:groupId/invite', () => {
@@ -650,7 +650,7 @@ describe('Post /groups/:groupId/invite', () => {
         .to.eventually.be.rejected.and.eql({
           code: 400,
           error: 'BadRequest',
-          message: t('partyExceedsMembersLimit', { maxMembersParty: PARTY_LIMIT_MEMBERS }),
+          message: t('partyExceedsMembersLimit', { maxMembersParty: PARTY_LIMIT_MEMBERS + 1 }),
         });
     }).timeout(10000);
   });

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

@@ -263,6 +263,7 @@ describe('POST /groups/:groupId/quests/invite/:questKey', () => {
         expect(body.group.id).to.eql(questingGroup.id);
         expect(body.group.name).to.eql(questingGroup.name);
         expect(body.quest.key).to.eql(PET_QUEST);
+        expect(body.quest.questOwner).to.eql(questingGroup.leader._id);
       });
     });
   });

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

@@ -61,15 +61,6 @@ describe('POST /groups/:groupId/quests/leave', () => {
         });
     });
 
-    it('returns an error when quest is not active', async () => {
-      await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/leave`))
-        .to.eventually.be.rejected.and.eql({
-          code: 404,
-          error: 'NotFound',
-          message: t('noActiveQuestToLeave'),
-        });
-    });
-
     it('returns an error when quest leader attempts to leave', async () => {
       await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
       await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
@@ -97,18 +88,14 @@ describe('POST /groups/:groupId/quests/leave', () => {
     });
   });
 
-  it('leaves a quest', async () => {
-    await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
-    await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
-    await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
-
-    const leaveResult = await partyMembers[0].post(`/groups/${questingGroup._id}/quests/leave`);
+  async function letPartyMemberLeaveAndCheckChanges (partyMember) {
+    const leaveResult = await partyMember.post(`/groups/${questingGroup._id}/quests/leave`);
     await Promise.all([
-      partyMembers[0].sync(),
+      partyMember.sync(),
       questingGroup.sync(),
     ]);
 
-    expect(partyMembers[0].party.quest).to.eql({
+    expect(partyMember.party.quest).to.eql({
       key: null,
       progress: {
         up: 0,
@@ -120,6 +107,29 @@ describe('POST /groups/:groupId/quests/leave', () => {
       RSVPNeeded: false,
     });
     expect(questingGroup.quest).to.deep.equal(leaveResult);
-    expect(questingGroup.quest.members[partyMembers[0]._id]).to.be.false;
+    expect(questingGroup.quest.members[partyMember._id]).to.be.false;
+  }
+
+  it('leaves an active quest', async () => {
+    await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
+    await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
+    await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
+
+    await questingGroup.sync();
+
+    expect(questingGroup.quest.active).to.eql(true);
+
+    await letPartyMemberLeaveAndCheckChanges(partyMembers[0]);
+  });
+
+  it('leaves an inactive quest ', async () => {
+    await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
+    await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
+
+    await questingGroup.sync();
+
+    expect(questingGroup.quest.active).to.eql(false);
+
+    await letPartyMemberLeaveAndCheckChanges(partyMembers[0]);
   });
 });

test/api/v3/integration/shops/GET-shops_backgrounds.test.js

@@ -14,7 +14,7 @@ describe('GET /shops/backgrounds', () => {
     const shop = await user.get('/shops/backgrounds');
     expect(shop.identifier).to.equal('backgroundShop');
     expect(shop.text).to.eql(t('backgroundShop'));
-    expect(shop.notes).to.eql(t('backgroundShopText'));
+    expect(shop.notes).to.eql(t('backgroundShop'));
     expect(shop.imageName).to.equal('background_shop');
     expect(shop.sets).to.be.an('array');
 

test/api/v3/integration/tasks/DELETE-tasks_id.test.js

@@ -31,7 +31,7 @@ describe('DELETE /tasks/:id', () => {
       await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
     });
 
@@ -41,7 +41,7 @@ describe('DELETE /tasks/:id', () => {
       await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
     });
   });
@@ -123,7 +123,7 @@ describe('DELETE /tasks/:id', () => {
       await expect(user.del('/tasks/550e8400-e29b-41d4-a716-446655440000')).to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
     });
 
@@ -137,7 +137,7 @@ describe('DELETE /tasks/:id', () => {
       await expect(user.del(`/tasks/${anotherUsersTask._id}`)).to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
     });
 

test/api/v3/integration/tasks/GET-tasks_challenge_challengeId.test.js

@@ -47,7 +47,7 @@ describe('GET /tasks/:taskId', () => {
     await expect(user.get(`/tasks/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
   });
 
@@ -68,7 +68,7 @@ describe('GET /tasks/:taskId', () => {
         await expect(anotherUser.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
           code: 404,
           error: 'NotFound',
-          message: t('taskNotFound'),
+          message: t('messageTaskNotFound'),
         });
       });
     });

test/api/v3/integration/tasks/GET-tasks_id.test.js

@@ -21,7 +21,7 @@ describe('GET /tasks/:id', () => {
         await expect(user.get(`/tasks/${dummyId}`)).to.eventually.be.rejected.and.eql({
           code: 404,
           error: 'NotFound',
-          message: t('taskNotFound'),
+          message: t('messageTaskNotFound'),
         });
       });
     });
@@ -63,7 +63,7 @@ describe('GET /tasks/:id', () => {
         await expect(anotherUser.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
           code: 404,
           error: 'NotFound',
-          message: t('taskNotFound'),
+          message: t('messageTaskNotFound'),
         });
       });
     });
@@ -118,7 +118,7 @@ describe('GET /tasks/:id', () => {
         await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
           code: 404,
           error: 'NotFound',
-          message: t('taskNotFound'),
+          message: t('messageTaskNotFound'),
         });
       });
     });
@@ -163,7 +163,7 @@ describe('GET /tasks/:id', () => {
         await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
           code: 404,
           error: 'NotFound',
-          message: t('taskNotFound'),
+          message: t('messageTaskNotFound'),
         });
       });
     });

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

@@ -23,7 +23,7 @@ describe('POST /tasks/:taskId/move/to/:position', () => {
     await expect(user.post(`/tasks/${generateUUID()}/move/to/1`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
   });
 

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

@@ -80,7 +80,7 @@ describe('POST /tasks/unlink-all/:challengeId', () => {
     await expect(user.get(`/tasks/${daily._id}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
   });
 

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

@@ -65,7 +65,7 @@ describe('POST /tasks/unlink-one/:taskId', () => {
       .to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
   });
 

test/api/v3/integration/tasks/challenges/DELETE-tasks_challenge_challengeId_checklist_itemId.test.js

@@ -22,7 +22,7 @@ describe('DELETE /tasks/:taskId/checklist/:itemId', () => {
     await expect(user.del(`/tasks/${generateUUID()}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
   });
 

test/api/v3/integration/tasks/challenges/DELETE-tasks_id_challenge_challengeId.test.js

@@ -31,7 +31,7 @@ describe('DELETE /tasks/:id', () => {
     await expect(user.del(`/tasks/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
   });
 
@@ -51,7 +51,7 @@ describe('DELETE /tasks/:id', () => {
     await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
   });
 
@@ -93,7 +93,7 @@ describe('DELETE /tasks/:id', () => {
       await expect(anotherUser.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
     });
 
@@ -111,7 +111,7 @@ describe('DELETE /tasks/:id', () => {
       await expect(anotherUser.get(`/tasks/${anotherUsersNewChallengeTaskID}`)).to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
     });
   });

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

@@ -24,7 +24,7 @@ describe('POST /tasks/:taskId/checklist/', () => {
     })).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
   });
 

test/api/v3/integration/tasks/challenges/PUT-tasks_challenge_challengeId.test.js

@@ -37,7 +37,7 @@ describe('PUT /tasks/:id', () => {
       })).to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
     });
 

test/api/v3/integration/tasks/challenges/PUT-tasks_challenge_challengeId_tasksId_checklist_itemId.test.js

@@ -137,7 +137,7 @@ describe('PUT /tasks/:taskId/checklist/:itemId', () => {
     await expect(user.put(`/tasks/${generateUUID()}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
   });
 

test/api/v3/integration/tasks/checklists/DELETE-tasks_taskId_checklist_itemId.test.js

@@ -70,7 +70,7 @@ describe('DELETE /tasks/:taskId/checklist/:itemId', () => {
     await expect(user.del(`/tasks/${generateUUID()}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
   });
 

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

@@ -88,7 +88,7 @@ describe('POST /tasks/:taskId/checklist/', () => {
     })).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
   });
 });

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

@@ -80,7 +80,7 @@ describe('POST /tasks/:taskId/checklist/:itemId/score', () => {
     await expect(user.post(`/tasks/${generateUUID()}/checklist/${generateUUID()}/score`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
   });
 

test/api/v3/integration/tasks/checklists/PUT-tasks_taskId_checklist_itemId.test.js

@@ -88,7 +88,7 @@ describe('PUT /tasks/:taskId/checklist/:itemId', () => {
     await expect(user.put(`/tasks/${generateUUID()}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
   });
 

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

@@ -45,7 +45,7 @@ describe('Groups DELETE /tasks/:id', () => {
       .to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
   });
 
@@ -60,7 +60,7 @@ describe('Groups DELETE /tasks/:id', () => {
       .to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
   });
 

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

@@ -38,7 +38,7 @@ describe('POST /tasks/:id/approve/:userId', () => {
       .to.eventually.be.rejected.and.to.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
   });
 

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

@@ -38,7 +38,7 @@ describe('POST /tasks/:id/needs-work/:userId', () => {
       .to.eventually.be.rejected.and.to.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
   });
 

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

@@ -42,7 +42,7 @@ describe('POST /tasks/:taskId/assign/:memberId', () => {
       .to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
   });
 

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

@@ -44,7 +44,7 @@ describe('POST /tasks/:taskId/unassign/:memberId', () => {
       .to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
   });
 

test/api/v3/integration/tasks/groups/checklists/DELETE-group_tasks_taskId_checklist_item.test.js

@@ -65,7 +65,7 @@ describe('DELETE group /tasks/:taskId/checklist/:itemId', () => {
     await expect(user.del(`/tasks/${generateUUID()}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
   });
 

test/api/v3/integration/tasks/groups/checklists/POST-group_tasks_taskId_checklist.test.js

@@ -80,7 +80,7 @@ describe('POST group /tasks/:taskId/checklist/', () => {
     })).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
   });
 });

test/api/v3/integration/tasks/groups/checklists/PUT-group_tasks_taskId_checklist_itemId.test.js

@@ -74,7 +74,7 @@ describe('PUT group /tasks/:taskId/checklist/:itemId', () => {
     await expect(user.put(`/tasks/${generateUUID()}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
   });
 

test/api/v3/integration/user/POST-user_class_cast_spellId.test.js

@@ -116,7 +116,7 @@ describe('POST /user/class/cast/:spellId', () => {
       .to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
   });
 

test/api/v3/integration/user/POST-user_reset.test.js

@@ -27,7 +27,7 @@ describe('POST /user/reset', () => {
     await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
 
     expect(user.tasksOrder.habits).to.be.empty;
@@ -45,7 +45,7 @@ describe('POST /user/reset', () => {
     await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
 
     expect(user.tasksOrder.dailys).to.be.empty;
@@ -63,7 +63,7 @@ describe('POST /user/reset', () => {
     await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
 
     expect(user.tasksOrder.todos).to.be.empty;
@@ -81,7 +81,7 @@ describe('POST /user/reset', () => {
     await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
 
     expect(user.tasksOrder.rewards).to.be.empty;

test/api/v3/integration/user/auth/GET-user_auth_apple.test.js

@@ -1,3 +1,4 @@
+import { v4 as generateUUID } from 'uuid';
 import {
   generateUser,
   requester,
@@ -9,15 +10,18 @@ describe('GET /user/auth/apple', () => {
   let api;
   let user;
   const appleEndpoint = '/user/auth/apple';
-
-  before(async () => {
-    const expectedResult = { id: 'appleId', name: 'an apple user' };
-    sandbox.stub(appleAuth, 'appleProfile').returns(Promise.resolve(expectedResult));
-  });
+  let randomAppleId = '123456';
 
   beforeEach(async () => {
     api = requester();
     user = await generateUser();
+    randomAppleId = generateUUID();
+    const expectedResult = { id: randomAppleId, name: 'an apple user' };
+    sandbox.stub(appleAuth, 'appleProfile').returns(Promise.resolve(expectedResult));
+  });
+
+  afterEach(async () => {
+    appleAuth.appleProfile.restore();
   });
 
   it('registers a new user', async () => {
@@ -26,7 +30,7 @@ describe('GET /user/auth/apple', () => {
     expect(response.apiToken).to.exist;
     expect(response.id).to.exist;
     expect(response.newUser).to.be.true;
-    await expect(getProperty('users', response.id, 'auth.apple.id')).to.eventually.equal('appleId');
+    await expect(getProperty('users', response.id, 'auth.apple.id')).to.eventually.equal(randomAppleId);
     await expect(getProperty('users', response.id, 'profile.name')).to.eventually.equal('an apple user');
   });
 

test/api/v3/integration/user/auth/POST-user_auth_social.test.js

@@ -1,4 +1,5 @@
 import passport from 'passport';
+import { v4 as generateUUID } from 'uuid';
 import {
   generateUser,
   requester,
@@ -10,14 +11,15 @@ describe('POST /user/auth/social', () => {
   let api;
   let user;
   const endpoint = '/user/auth/social';
-  const randomAccessToken = '123456';
-  const facebookId = 'facebookId';
-  const googleId = 'googleId';
+  let randomAccessToken = '123456';
+  let randomFacebookId = 'facebookId';
+  let randomGoogleId = 'googleId';
   let network = 'NoNetwork';
 
   beforeEach(async () => {
     api = requester();
     user = await generateUser();
+    randomAccessToken = generateUUID();
   });
 
   it('fails if network is not supported', async () => {
@@ -32,12 +34,23 @@ describe('POST /user/auth/social', () => {
   });
 
   describe('facebook', () => {
-    before(async () => {
-      const expectedResult = { id: facebookId, displayName: 'a facebook user' };
+    beforeEach(async () => {
+      randomFacebookId = generateUUID();
+      const expectedResult = {
+        id: randomFacebookId,
+        displayName: 'a facebook user',
+        emails: [
+          { value: `${user.auth.local.username}+facebook@example.com` },
+        ],
+      };
       sandbox.stub(passport._strategies.facebook, 'userProfile').yields(null, expectedResult);
       network = 'facebook';
     });
 
+    afterEach(async () => {
+      passport._strategies.facebook.userProfile.restore();
+    });
+
     it('registers a new user', async () => {
       const response = await api.post(endpoint, {
         authResponse: { access_token: randomAccessToken }, // eslint-disable-line camelcase
@@ -51,7 +64,8 @@ describe('POST /user/auth/social', () => {
 
       await expect(getProperty('users', response.id, 'profile.name')).to.eventually.equal('a facebook user');
       await expect(getProperty('users', response.id, 'auth.local.lowerCaseUsername')).to.exist;
-      await expect(getProperty('users', response.id, 'auth.facebook.id')).to.eventually.equal(facebookId);
+      await expect(getProperty('users', response.id, 'auth.local.email')).to.eventually.equal(`${user.auth.local.username}+facebook@example.com`);
+      await expect(getProperty('users', response.id, 'auth.facebook.id')).to.eventually.equal(randomFacebookId);
     });
 
     it('logs an existing user in', async () => {
@@ -68,6 +82,57 @@ describe('POST /user/auth/social', () => {
       expect(response.apiToken).to.eql(registerResponse.apiToken);
       expect(response.id).to.eql(registerResponse.id);
       expect(response.newUser).to.be.false;
+      expect(registerResponse.newUser).to.be.true;
+    });
+
+    it('logs an existing user in if they have local auth with matching email', async () => {
+      passport._strategies.facebook.userProfile.restore();
+      const expectedResult = {
+        id: randomFacebookId,
+        displayName: 'a facebook user',
+        emails: [
+          { value: user.auth.local.email },
+        ],
+      };
+      sandbox.stub(passport._strategies.facebook, 'userProfile').yields(null, expectedResult);
+
+      const response = await api.post(endpoint, {
+        authResponse: { access_token: randomAccessToken }, // eslint-disable-line camelcase
+        network,
+      });
+
+      expect(response.apiToken).to.eql(user.apiToken);
+      expect(response.id).to.eql(user._id);
+      expect(response.newUser).to.be.false;
+    });
+
+    it('logs an existing user into their social account if they have local auth with matching email', async () => {
+      const registerResponse = await api.post(endpoint, {
+        authResponse: { access_token: randomAccessToken }, // eslint-disable-line camelcase
+        network,
+      });
+      expect(registerResponse.newUser).to.be.true;
+      // This is important for existing accounts before the new social handling
+      passport._strategies.facebook.userProfile.restore();
+      const expectedResult = {
+        id: randomFacebookId,
+        displayName: 'a facebook user',
+        emails: [
+          { value: user.auth.local.email },
+        ],
+      };
+      sandbox.stub(passport._strategies.facebook, 'userProfile').yields(null, expectedResult);
+
+      const response = await api.post(endpoint, {
+        authResponse: { access_token: randomAccessToken }, // eslint-disable-line camelcase
+        network,
+      });
+
+      expect(response.apiToken).to.eql(registerResponse.apiToken);
+      expect(response.id).to.eql(registerResponse.id);
+      expect(response.apiToken).not.to.eql(user.apiToken);
+      expect(response.id).not.to.eql(user._id);
+      expect(response.newUser).to.be.false;
     });
 
     it('add social auth to an existing user', async () => {
@@ -76,11 +141,28 @@ describe('POST /user/auth/social', () => {
         network,
       });
 
-      expect(response.apiToken).to.exist;
-      expect(response.id).to.exist;
+      expect(response.apiToken).to.eql(user.apiToken);
+      expect(response.id).to.eql(user._id);
       expect(response.newUser).to.be.false;
     });
 
+    it('does not log into other account if social auth already exists', async () => {
+      const registerResponse = await api.post(endpoint, {
+        authResponse: { access_token: randomAccessToken }, // eslint-disable-line camelcase
+        network,
+      });
+      expect(registerResponse.newUser).to.be.true;
+
+      await expect(user.post(endpoint, {
+        authResponse: { access_token: randomAccessToken }, // eslint-disable-line camelcase
+        network,
+      })).to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('socialAlreadyExists'),
+      });
+    });
+
     xit('enrolls a new user in an A/B test', async () => {
       await api.post(endpoint, {
         authResponse: { access_token: randomAccessToken }, // eslint-disable-line camelcase
@@ -92,12 +174,23 @@ describe('POST /user/auth/social', () => {
   });
 
   describe('google', () => {
-    before(async () => {
-      const expectedResult = { id: googleId, displayName: 'a google user' };
+    beforeEach(async () => {
+      randomGoogleId = generateUUID();
+      const expectedResult = {
+        id: randomGoogleId,
+        displayName: 'a google user',
+        emails: [
+          { value: `${user.auth.local.username}+google@example.com` },
+        ],
+      };
       sandbox.stub(passport._strategies.google, 'userProfile').yields(null, expectedResult);
       network = 'google';
     });
 
+    afterEach(async () => {
+      passport._strategies.google.userProfile.restore();
+    });
+
     it('registers a new user', async () => {
       const response = await api.post(endpoint, {
         authResponse: { access_token: randomAccessToken }, // eslint-disable-line camelcase
@@ -107,7 +200,8 @@ describe('POST /user/auth/social', () => {
       expect(response.apiToken).to.exist;
       expect(response.id).to.exist;
       expect(response.newUser).to.be.true;
-      await expect(getProperty('users', response.id, 'auth.google.id')).to.eventually.equal(googleId);
+      await expect(getProperty('users', response.id, 'auth.google.id')).to.eventually.equal(randomGoogleId);
+      await expect(getProperty('users', response.id, 'auth.local.email')).to.eventually.equal(`${user.auth.local.username}+google@example.com`);
       await expect(getProperty('users', response.id, 'profile.name')).to.eventually.equal('a google user');
     });
 
@@ -125,6 +219,57 @@ describe('POST /user/auth/social', () => {
       expect(response.apiToken).to.eql(registerResponse.apiToken);
       expect(response.id).to.eql(registerResponse.id);
       expect(response.newUser).to.be.false;
+      expect(registerResponse.newUser).to.be.true;
+    });
+
+    it('logs an existing user in if they have local auth with matching email', async () => {
+      passport._strategies.google.userProfile.restore();
+      const expectedResult = {
+        id: randomGoogleId,
+        displayName: 'a google user',
+        emails: [
+          { value: user.auth.local.email },
+        ],
+      };
+      sandbox.stub(passport._strategies.google, 'userProfile').yields(null, expectedResult);
+
+      const response = await api.post(endpoint, {
+        authResponse: { access_token: randomAccessToken }, // eslint-disable-line camelcase
+        network,
+      });
+
+      expect(response.apiToken).to.eql(user.apiToken);
+      expect(response.id).to.eql(user._id);
+      expect(response.newUser).to.be.false;
+    });
+
+    it('logs an existing user into their social account if they have local auth with matching email', async () => {
+      const registerResponse = await api.post(endpoint, {
+        authResponse: { access_token: randomAccessToken }, // eslint-disable-line camelcase
+        network,
+      });
+      expect(registerResponse.newUser).to.be.true;
+      // This is important for existing accounts before the new social handling
+      passport._strategies.google.userProfile.restore();
+      const expectedResult = {
+        id: randomGoogleId,
+        displayName: 'a google user',
+        emails: [
+          { value: user.auth.local.email },
+        ],
+      };
+      sandbox.stub(passport._strategies.google, 'userProfile').yields(null, expectedResult);
+
+      const response = await api.post(endpoint, {
+        authResponse: { access_token: randomAccessToken }, // eslint-disable-line camelcase
+        network,
+      });
+
+      expect(response.apiToken).to.eql(registerResponse.apiToken);
+      expect(response.id).to.eql(registerResponse.id);
+      expect(response.apiToken).not.to.eql(user.apiToken);
+      expect(response.id).not.to.eql(user._id);
+      expect(response.newUser).to.be.false;
     });
 
     it('add social auth to an existing user', async () => {
@@ -133,11 +278,28 @@ describe('POST /user/auth/social', () => {
         network,
       });
 
-      expect(response.apiToken).to.exist;
-      expect(response.id).to.exist;
+      expect(response.apiToken).to.eql(user.apiToken);
+      expect(response.id).to.eql(user._id);
       expect(response.newUser).to.be.false;
     });
 
+    it('does not log into other account if social auth already exists', async () => {
+      const registerResponse = await api.post(endpoint, {
+        authResponse: { access_token: randomAccessToken }, // eslint-disable-line camelcase
+        network,
+      });
+      expect(registerResponse.newUser).to.be.true;
+
+      await expect(user.post(endpoint, {
+        authResponse: { access_token: randomAccessToken }, // eslint-disable-line camelcase
+        network,
+      })).to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('socialAlreadyExists'),
+      });
+    });
+
     xit('enrolls a new user in an A/B test', async () => {
       await api.post(endpoint, {
         authResponse: { access_token: randomAccessToken }, // eslint-disable-line camelcase

test/api/v4/POST-bug-report.test.js

@@ -0,0 +1,49 @@
+import {
+  generateUser,
+} from '../../helpers/api-integration/v4';
+
+describe('POST /bug-report', () => {
+  let user;
+
+  beforeEach(async () => {
+    user = await generateUser();
+  });
+
+  it('returns an error when message is not added', async () => {
+    await expect(user.post('/bug-report', {
+      message: '',
+    }))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 400,
+        error: 'BadRequest',
+        // seems it is not possible to get the real error message
+        message: 'Invalid request parameters.',
+      });
+  });
+
+  it('returns an error when email is not added', async () => {
+    await expect(user.post('/bug-report', {
+      message: 'message',
+      email: '',
+    }))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 400,
+        error: 'BadRequest',
+        // seems it is not possible to get the real error message
+        message: 'Invalid request parameters.',
+      });
+  });
+
+  it('returns an error when email is not valid', async () => {
+    await expect(user.post('/bug-report', {
+      message: 'message',
+      email: 'notamail',
+    }))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 400,
+        error: 'BadRequest',
+        // seems it is not possible to get the real error message
+        message: 'Invalid request parameters.',
+      });
+  });
+});

test/api/v4/members/GET-purchase_history.test.js

@@ -0,0 +1,38 @@
+import {
+  generateUser,
+  translate as t,
+} from '../../../helpers/api-integration/v4';
+
+describe('GET /members/:memberId/purchase-history', () => {
+  let user;
+
+  before(async () => {
+    user = await generateUser({
+      contributor: { admin: true },
+    });
+  });
+
+  it('validates req.params.memberId', async () => {
+    await expect(user.get('/members/invalidUUID/purchase-history')).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('invalidReqParams'),
+    });
+  });
+
+  it('returns error if user is not admin', async () => {
+    const member = await generateUser();
+    const nonAdmin = await generateUser();
+    await expect(nonAdmin.get(`/members/${member._id}/purchase-history`)).to.eventually.be.rejected.and.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('noAdminAccess'),
+    });
+  });
+
+  it('returns purchase history based on given user', async () => {
+    const member = await generateUser();
+    const response = await user.get(`/members/${member._id}/purchase-history`);
+    expect(response.length).to.equal(0);
+  });
+});

test/api/v4/user/POST-user_class_cast_spellId.test.js

@@ -101,7 +101,7 @@ describe('POST /user/class/cast/:spellId', () => {
       .to.eventually.be.rejected.and.eql({
         code: 404,
         error: 'NotFound',
-        message: t('taskNotFound'),
+        message: t('messageTaskNotFound'),
       });
   });
 

test/api/v4/user/POST-user_reset.test.js

@@ -27,7 +27,7 @@ describe('POST /user/reset', () => {
     await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
 
     expect(user.tasksOrder.habits).to.be.empty;
@@ -45,7 +45,7 @@ describe('POST /user/reset', () => {
     await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
 
     expect(user.tasksOrder.dailys).to.be.empty;
@@ -63,7 +63,7 @@ describe('POST /user/reset', () => {
     await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
 
     expect(user.tasksOrder.todos).to.be.empty;
@@ -81,7 +81,7 @@ describe('POST /user/reset', () => {
     await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
       code: 404,
       error: 'NotFound',
-      message: t('taskNotFound'),
+      message: t('messageTaskNotFound'),
     });
 
     expect(user.tasksOrder.rewards).to.be.empty;

test/common/fns/randomDrop.test.js

@@ -1,5 +1,4 @@
 import randomDrop from '../../../website/common/script/fns/randomDrop';
-import i18n from '../../../website/common/script/i18n';
 import {
   generateUser,
   generateTodo,
@@ -145,148 +144,5 @@ describe('common.fns.randomDrop', () => {
         expect(acceptableDrops).to.contain(user._tmp.drop.key); // always Desert
       });
     });
-
-    context('drop cap notification', () => {
-      let analytics;
-      const req = {};
-      let isSubscribedStub;
-
-      beforeEach(() => {
-        user.addNotification = () => {};
-        sandbox.stub(user, 'addNotification');
-        user.isSubscribed = () => {};
-        isSubscribedStub = sandbox.stub(user, 'isSubscribed');
-        isSubscribedStub.returns(false);
-        analytics = { track () {} };
-        sandbox.stub(analytics, 'track');
-      });
-
-      it('sends a notification if A/B test is enabled when drop cap is reached', () => {
-        user._ABtests.dropCapNotif = 'drop-cap-notif-enabled';
-        predictableRandom.returns(0.1);
-
-        // Max Drop Count is 5
-        expect(user.items.lastDrop.count).to.equal(0);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        expect(user.items.lastDrop.count).to.equal(5);
-        expect(user.addNotification).to.be.calledOnce;
-        expect(user.addNotification).to.be.calledWith('DROP_CAP_REACHED', {
-          message: i18n.t('dropCapReached'),
-          items: 5,
-        });
-      });
-
-      it('does not send a notification if user is enrolled in disabled A/B test group', () => {
-        user._ABtests.dropCapNotif = 'drop-cap-notif-disabled';
-        predictableRandom.returns(0.1);
-
-        // Max Drop Count is 5
-        expect(user.items.lastDrop.count).to.equal(0);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        expect(user.items.lastDrop.count).to.equal(5);
-        expect(user.addNotification).to.not.be.called;
-      });
-
-      it('does not send a notification if user is enrolled in disabled A/B test group', () => {
-        user._ABtests.dropCapNotif = 'drop-cap-notif-not-enrolled';
-        predictableRandom.returns(0.1);
-
-        // Max Drop Count is 5
-        expect(user.items.lastDrop.count).to.equal(0);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        expect(user.items.lastDrop.count).to.equal(5);
-        expect(user.addNotification).to.not.be.called;
-      });
-
-      it('does not send a notification if drop cap is not reached', () => {
-        user._ABtests.dropCapNotif = 'drop-cap-notif-enabled';
-        predictableRandom.returns(0.1);
-
-        // Max Drop Count is 5
-        expect(user.items.lastDrop.count).to.equal(0);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        expect(user.items.lastDrop.count).to.equal(4);
-        expect(user.addNotification).to.not.be.called;
-      });
-
-      it('does not send a notification if user is subscribed', () => {
-        user._ABtests.dropCapNotif = 'drop-cap-notif-enabled';
-        predictableRandom.returns(0.1);
-        isSubscribedStub.returns(true);
-
-        // Max Drop Count is 5
-        expect(user.items.lastDrop.count).to.equal(0);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        expect(user.items.lastDrop.count).to.equal(5);
-        expect(user.addNotification).to.not.be.called;
-      });
-
-      it('tracks drop cap reached event for enrolled users (notification enabled)', () => {
-        user._ABtests.dropCapNotif = 'drop-cap-notif-enabled';
-        predictableRandom.returns(0.1);
-        isSubscribedStub.returns(true);
-
-        // Max Drop Count is 5
-        expect(user.items.lastDrop.count).to.equal(0);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        expect(user.items.lastDrop.count).to.equal(5);
-        expect(analytics.track).to.be.calledWith('drop cap reached');
-      });
-
-      it('tracks drop cap reached event for enrolled users (notification disabled)', () => {
-        user._ABtests.dropCapNotif = 'drop-cap-notif-disabled';
-        predictableRandom.returns(0.1);
-        isSubscribedStub.returns(true);
-
-        // Max Drop Count is 5
-        expect(user.items.lastDrop.count).to.equal(0);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        expect(user.items.lastDrop.count).to.equal(5);
-        expect(analytics.track).to.be.calledWith('drop cap reached');
-      });
-
-      it('does not track drop cap reached event for users not enrolled in A/B test', () => {
-        user._ABtests.dropCapNotif = 'drop-cap-notif-not-enrolled';
-        predictableRandom.returns(0.1);
-        isSubscribedStub.returns(true);
-
-        // Max Drop Count is 5
-        expect(user.items.lastDrop.count).to.equal(0);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        randomDrop(user, { task, predictableRandom }, req, analytics);
-        expect(user.items.lastDrop.count).to.equal(5);
-        expect(analytics.track).to.not.be.calledWith('drop cap reached');
-      });
-    });
   });
 });

test/common/libs/cron.test.js

@@ -1,6 +1,6 @@
 import moment from 'moment';
 
-import { startOfDay, daysSince } from '../../../website/common/script/cron';
+import { startOfDay, daysSince, getPlanContext } from '../../../website/common/script/cron';
 
 function localMoment (timeString, utcOffset) {
   return moment(timeString).utcOffset(utcOffset, true);
@@ -181,4 +181,63 @@ describe('cron utility functions', () => {
       expect(result).to.equal(0);
     });
   });
+
+  describe('getPlanContext', () => {
+    const now = new Date(2022, 5, 1);
+
+    function baseUserData (count, offset, planId) {
+      return {
+        purchased: {
+          plan: {
+            consecutive: {
+              count,
+              offset,
+              gemCapExtra: 25,
+              trinkets: 19,
+            },
+            quantity: 1,
+            extraMonths: 0,
+            gemsBought: 0,
+            owner: '116b4133-8fb7-43f2-b0de-706621a8c9d8',
+            nextBillingDate: null,
+            nextPaymentProcessing: null,
+            planId,
+            customerId: 'group-plan',
+            dateUpdated: '2022-05-10T03:00:00.144+01:00',
+            paymentMethod: 'Group Plan',
+            dateTerminated: null,
+            lastBillingDate: null,
+            dateCreated: '2017-02-10T19:00:00.355+01:00',
+          },
+        },
+      };
+    }
+
+    it('offset 0, next date in 3 months', () => {
+      const user = baseUserData(60, 0, 'group_plan_auto');
+
+      const planContext = getPlanContext(user, now);
+
+      expect(planContext.nextHourglassDate)
+        .to.be.sameMoment('2022-08-10T02:00:00.144Z');
+    });
+
+    it('offset 1, next date in 1 months', () => {
+      const user = baseUserData(60, 1, 'group_plan_auto');
+
+      const planContext = getPlanContext(user, now);
+
+      expect(planContext.nextHourglassDate)
+        .to.be.sameMoment('2022-06-10T02:00:00.144Z');
+    });
+
+    it('offset 2, next date in 2 months - with any plan', () => {
+      const user = baseUserData(60, 2, 'basic_3mo');
+
+      const planContext = getPlanContext(user, now);
+
+      expect(planContext.nextHourglassDate)
+        .to.be.sameMoment('2022-07-10T02:00:00.144Z');
+    });
+  });
 });

test/common/ops/buy/buy.js

@@ -40,28 +40,27 @@ describe('shared.ops.buy', () => {
     analytics.track.restore();
   });
 
-  it('returns error when key is not provided', done => {
+  it('returns error when key is not provided', async () => {
     try {
-      buy(user);
+      await buy(user);
     } catch (err) {
       expect(err).to.be.an.instanceof(BadRequest);
       expect(err.message).to.equal(errorMessage('missingKeyParam'));
-      done();
     }
   });
 
-  it('recovers 15 hp', () => {
+  it('recovers 15 hp', async () => {
     user.stats.hp = 30;
-    buy(user, { params: { key: 'potion' } }, analytics);
+    await buy(user, { params: { key: 'potion' } }, analytics);
     expect(user.stats.hp).to.eql(45);
 
     expect(analytics.track).to.be.calledOnce;
   });
 
-  it('adds equipment to inventory', () => {
+  it('adds equipment to inventory', async () => {
     user.stats.gp = 31;
 
-    buy(user, { params: { key: 'armor_warrior_1' } });
+    await buy(user, { params: { key: 'armor_warrior_1' } });
 
     expect(user.items.gear.owned).to.eql({
       weapon_warrior_0: true,
@@ -90,10 +89,10 @@ describe('shared.ops.buy', () => {
     });
   });
 
-  it('buys Steampunk Accessories Set', () => {
+  it('buys Steampunk Accessories Set', async () => {
     user.purchased.plan.consecutive.trinkets = 1;
 
-    buy(user, {
+    await buy(user, {
       params: {
         key: '301404',
       },
@@ -108,10 +107,10 @@ describe('shared.ops.buy', () => {
     expect(user.items.gear.owned).to.have.property('eyewear_mystery_301404', true);
   });
 
-  it('buys a Quest scroll', () => {
+  it('buys a Quest scroll', async () => {
     user.stats.gp = 205;
 
-    buy(user, {
+    await buy(user, {
       params: {
         key: 'dilatoryDistress1',
       },
@@ -122,11 +121,11 @@ describe('shared.ops.buy', () => {
     expect(user.stats.gp).to.equal(5);
   });
 
-  it('buys a special item', () => {
+  it('buys a special item', async () => {
     user.stats.gp = 11;
     const item = content.special.thankyou;
 
-    const [data, message] = buy(user, {
+    const [data, message] = await buy(user, {
       params: {
         key: 'thankyou',
       },
@@ -144,15 +143,15 @@ describe('shared.ops.buy', () => {
     }));
   });
 
-  it('allows for bulk purchases', () => {
+  it('allows for bulk purchases', async () => {
     user.stats.hp = 30;
-    buy(user, { params: { key: 'potion' }, quantity: 2 });
+    await buy(user, { params: { key: 'potion' }, quantity: 2 });
     expect(user.stats.hp).to.eql(50);
   });
 
-  it('errors if user supplies a non-numeric quantity', done => {
+  it('errors if user supplies a non-numeric quantity', async () => {
     try {
-      buy(user, {
+      await buy(user, {
         params: {
           key: 'dilatoryDistress1',
         },
@@ -162,13 +161,12 @@ describe('shared.ops.buy', () => {
     } catch (err) {
       expect(err).to.be.an.instanceof(BadRequest);
       expect(err.message).to.equal(errorMessage('invalidQuantity'));
-      done();
     }
   });
 
-  it('errors if user supplies a negative quantity', done => {
+  it('errors if user supplies a negative quantity', async () => {
     try {
-      buy(user, {
+      await buy(user, {
         params: {
           key: 'dilatoryDistress1',
         },
@@ -178,13 +176,12 @@ describe('shared.ops.buy', () => {
     } catch (err) {
       expect(err).to.be.an.instanceof(BadRequest);
       expect(err.message).to.equal(errorMessage('invalidQuantity'));
-      done();
     }
   });
 
-  it('errors if user supplies a decimal quantity', done => {
+  it('errors if user supplies a decimal quantity', async () => {
     try {
-      buy(user, {
+      await buy(user, {
         params: {
           key: 'dilatoryDistress1',
         },
@@ -194,7 +191,6 @@ describe('shared.ops.buy', () => {
     } catch (err) {
       expect(err).to.be.an.instanceof(BadRequest);
       expect(err.message).to.equal(errorMessage('invalidQuantity'));
-      done();
     }
   });
 });

test/common/ops/buy/buyArmoire.js

@@ -33,7 +33,7 @@ describe('shared.ops.buyArmoire', () => {
   const YIELD_EXP = 0.9;
   const analytics = { track () {} };
 
-  function buyArmoire (_user, _req, _analytics) {
+  async function buyArmoire (_user, _req, _analytics) {
     const buyOp = new BuyArmoireOperation(_user, _req, _analytics);
 
     return buyOp.purchase();
@@ -61,11 +61,11 @@ describe('shared.ops.buyArmoire', () => {
   });
 
   context('failure conditions', () => {
-    it('does not open if user does not have enough gold', done => {
+    it('does not open if user does not have enough gold', async () => {
       user.stats.gp = 50;
 
       try {
-        buyArmoire(user);
+        await buyArmoire(user);
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('messageNotEnoughGold'));
@@ -74,17 +74,16 @@ describe('shared.ops.buyArmoire', () => {
         });
         expect(user.items.food).to.be.empty;
         expect(user.stats.exp).to.eql(0);
-        done();
       }
     });
   });
 
   context('non-gear awards', () => {
-    it('gives Experience', () => {
+    it('gives Experience', async () => {
       const previousExp = user.stats.exp;
       randomValFns.trueRandom.returns(YIELD_EXP);
 
-      buyArmoire(user);
+      await buyArmoire(user);
 
       expect(user.items.gear.owned).to.eql({ weapon_warrior_0: true });
       expect(user.items.food).to.be.empty;
@@ -92,12 +91,12 @@ describe('shared.ops.buyArmoire', () => {
       expect(user.stats.gp).to.equal(100);
     });
 
-    it('gives food', () => {
+    it('gives food', async () => {
       const previousExp = user.stats.exp;
 
       randomValFns.trueRandom.returns(YIELD_FOOD);
 
-      buyArmoire(user);
+      await buyArmoire(user);
 
       expect(user.items.gear.owned).to.eql({ weapon_warrior_0: true });
       expect(user.items.food).to.not.be.empty;
@@ -105,12 +104,12 @@ describe('shared.ops.buyArmoire', () => {
       expect(user.stats.gp).to.equal(100);
     });
 
-    it('does not give equipment if all equipment has been found', () => {
+    it('does not give equipment if all equipment has been found', async () => {
       randomValFns.trueRandom.returns(YIELD_EQUIPMENT);
       user.items.gear.owned = getFullArmoire();
       user.stats.gp = 150;
 
-      buyArmoire(user);
+      await buyArmoire(user);
 
       expect(user.items.gear.owned).to.eql(getFullArmoire());
       const armoireCount = count.remainingGearInSet(user.items.gear.owned, 'armoire');
@@ -122,13 +121,13 @@ describe('shared.ops.buyArmoire', () => {
   });
 
   context('gear awards', () => {
-    it('always drops equipment the first time', () => {
+    it('always drops equipment the first time', async () => {
       delete user.flags.armoireOpened;
       randomValFns.trueRandom.returns(YIELD_EXP);
 
       expect(_.size(user.items.gear.owned)).to.equal(1);
 
-      buyArmoire(user);
+      await buyArmoire(user);
 
       expect(_.size(user.items.gear.owned)).to.equal(2);
 
@@ -140,7 +139,7 @@ describe('shared.ops.buyArmoire', () => {
       expect(user.stats.gp).to.equal(100);
     });
 
-    it('gives more equipment', () => {
+    it('gives more equipment', async () => {
       randomValFns.trueRandom.returns(YIELD_EQUIPMENT);
       user.items.gear.owned = {
         weapon_warrior_0: true,
@@ -150,7 +149,7 @@ describe('shared.ops.buyArmoire', () => {
 
       expect(_.size(user.items.gear.owned)).to.equal(2);
 
-      buyArmoire(user, {}, analytics);
+      await buyArmoire(user, {}, analytics);
 
       expect(_.size(user.items.gear.owned)).to.equal(3);
 

test/common/ops/buy/buyGem.js

@@ -11,7 +11,7 @@ import i18n from '../../../../website/common/script/i18n';
 import { BuyGemOperation } from '../../../../website/common/script/ops/buy/buyGem';
 import planGemLimits from '../../../../website/common/script/libs/planGemLimits';
 
-function buyGem (user, req, analytics) {
+async function buyGem (user, req, analytics) {
   const buyOp = new BuyGemOperation(user, req, analytics);
 
   return buyOp.purchase();
@@ -44,8 +44,8 @@ describe('shared.ops.buyGem', () => {
   });
 
   context('Gems', () => {
-    it('purchases gems', () => {
-      const [, message] = buyGem(user, { params: { type: 'gems', key: 'gem' } }, analytics);
+    it('purchases gems', async () => {
+      const [, message] = await buyGem(user, { params: { type: 'gems', key: 'gem' } }, analytics);
 
       expect(message).to.equal(i18n.t('plusGem', { count: 1 }));
       expect(user.balance).to.equal(userGemAmount + 0.25);
@@ -54,8 +54,8 @@ describe('shared.ops.buyGem', () => {
       expect(analytics.track).to.be.calledOnce;
     });
 
-    it('purchases gems with a different language than the default', () => {
-      const [, message] = buyGem(user, { params: { type: 'gems', key: 'gem' }, language: 'de' });
+    it('purchases gems with a different language than the default', async () => {
+      const [, message] = await buyGem(user, { params: { type: 'gems', key: 'gem' }, language: 'de' });
 
       expect(message).to.equal(i18n.t('plusGem', { count: 1 }, 'de'));
       expect(user.balance).to.equal(userGemAmount + 0.25);
@@ -63,8 +63,8 @@ describe('shared.ops.buyGem', () => {
       expect(user.stats.gp).to.equal(goldPoints - planGemLimits.convRate);
     });
 
-    it('makes bulk purchases of gems', () => {
-      const [, message] = buyGem(user, {
+    it('makes bulk purchases of gems', async () => {
+      const [, message] = await buyGem(user, {
         params: { type: 'gems', key: 'gem' },
         quantity: 2,
       });
@@ -76,63 +76,58 @@ describe('shared.ops.buyGem', () => {
     });
 
     context('Failure conditions', () => {
-      it('returns an error when key is not provided', done => {
+      it('returns an error when key is not provided', async () => {
         try {
-          buyGem(user, { params: { type: 'gems' } });
+          await buyGem(user, { params: { type: 'gems' } });
         } catch (err) {
           expect(err).to.be.an.instanceof(BadRequest);
           expect(err.message).to.equal(i18n.t('missingKeyParam'));
-          done();
         }
       });
 
-      it('prevents unsubscribed user from buying gems', done => {
+      it('prevents unsubscribed user from buying gems', async () => {
         delete user.purchased.plan.customerId;
 
         try {
-          buyGem(user, { params: { type: 'gems', key: 'gem' } });
+          await buyGem(user, { params: { type: 'gems', key: 'gem' } });
         } catch (err) {
           expect(err).to.be.an.instanceof(NotAuthorized);
           expect(err.message).to.equal(i18n.t('mustSubscribeToPurchaseGems'));
-          done();
         }
       });
 
-      it('prevents user with not enough gold from buying gems', done => {
+      it('prevents user with not enough gold from buying gems', async () => {
         user.stats.gp = 15;
 
         try {
-          buyGem(user, { params: { type: 'gems', key: 'gem' } });
+          await buyGem(user, { params: { type: 'gems', key: 'gem' } });
         } catch (err) {
           expect(err).to.be.an.instanceof(NotAuthorized);
           expect(err.message).to.equal(i18n.t('messageNotEnoughGold'));
-          done();
         }
       });
 
-      it('prevents user that have reached the conversion cap from buying gems', done => {
+      it('prevents user that have reached the conversion cap from buying gems', async () => {
         user.stats.gp = goldPoints;
         user.purchased.plan.gemsBought = gemsBought;
 
         try {
-          buyGem(user, { params: { type: 'gems', key: 'gem' } });
+          await buyGem(user, { params: { type: 'gems', key: 'gem' } });
         } catch (err) {
           expect(err).to.be.an.instanceof(NotAuthorized);
           expect(err.message).to.equal(i18n.t('maxBuyGems', { convCap: planGemLimits.convCap }));
-          done();
         }
       });
 
-      it('prevents user from buying an invalid quantity', done => {
+      it('prevents user from buying an invalid quantity', async () => {
         user.stats.gp = goldPoints;
         user.purchased.plan.gemsBought = gemsBought;
 
         try {
-          buyGem(user, { params: { type: 'gems', key: 'gem' }, quantity: 'a' });
+          await buyGem(user, { params: { type: 'gems', key: 'gem' }, quantity: 'a' });
         } catch (err) {
           expect(err).to.be.an.instanceof(BadRequest);
           expect(err.message).to.equal(i18n.t('invalidQuantity'));
-          done();
         }
       });
     });

test/common/ops/buy/buyHealthPotion.js

@@ -12,7 +12,7 @@ describe('shared.ops.buyHealthPotion', () => {
   let user;
   const analytics = { track () {} };
 
-  function buyHealthPotion (_user, _req, _analytics) {
+  async function buyHealthPotion (_user, _req, _analytics) {
     const buyOp = new BuyHealthPotionOperation(_user, _req, _analytics);
 
     return buyOp.purchase();
@@ -40,83 +40,75 @@ describe('shared.ops.buyHealthPotion', () => {
   });
 
   context('Potion', () => {
-    it('recovers 15 hp', () => {
+    it('recovers 15 hp', async () => {
       user.stats.hp = 30;
-      buyHealthPotion(user, {}, analytics);
+      await buyHealthPotion(user, {}, analytics);
       expect(user.stats.hp).to.eql(45);
       expect(analytics.track).to.be.calledOnce;
     });
 
-    it('does not increase hp above 50', () => {
+    it('does not increase hp above 50', async () => {
       user.stats.hp = 45;
-      buyHealthPotion(user);
+      await buyHealthPotion(user);
       expect(user.stats.hp).to.eql(50);
     });
 
-    it('deducts 25 gp', () => {
+    it('deducts 25 gp', async () => {
       user.stats.hp = 45;
-      buyHealthPotion(user);
+      await buyHealthPotion(user);
 
       expect(user.stats.gp).to.eql(175);
     });
 
-    it('does not purchase if not enough gp', done => {
+    it('does not purchase if not enough gp', async () => {
       user.stats.hp = 45;
       user.stats.gp = 5;
       try {
-        buyHealthPotion(user);
+        await buyHealthPotion(user);
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('messageNotEnoughGold'));
         expect(user.stats.hp).to.eql(45);
         expect(user.stats.gp).to.eql(5);
-
-        done();
       }
     });
 
-    it('does not purchase if hp is full', done => {
+    it('does not purchase if hp is full', async () => {
       user.stats.hp = 50;
       user.stats.gp = 40;
       try {
-        buyHealthPotion(user);
+        await buyHealthPotion(user);
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('messageHealthAlreadyMax'));
         expect(user.stats.hp).to.eql(50);
         expect(user.stats.gp).to.eql(40);
-
-        done();
       }
     });
 
-    it('does not allow potion purchases when hp is zero', done => {
+    it('does not allow potion purchases when hp is zero', async () => {
       user.stats.hp = 0;
       user.stats.gp = 40;
       try {
-        buyHealthPotion(user);
+        await buyHealthPotion(user);
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('messageHealthAlreadyMin'));
         expect(user.stats.hp).to.eql(0);
         expect(user.stats.gp).to.eql(40);
-
-        done();
       }
     });
 
-    it('does not allow potion purchases when hp is negative', done => {
+    it('does not allow potion purchases when hp is negative', async () => {
       user.stats.hp = -8;
       user.stats.gp = 40;
       try {
-        buyHealthPotion(user);
+        await buyHealthPotion(user);
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('messageHealthAlreadyMin'));
         expect(user.stats.hp).to.eql(-8);
         expect(user.stats.gp).to.eql(40);
-
-        done();
       }
     });
   });

test/common/ops/buy/buyMarketGear.js

@@ -13,7 +13,7 @@ import {
 import i18n from '../../../../website/common/script/i18n';
 import errorMessage from '../../../../website/common/script/libs/errorMessage';
 
-function buyGear (user, req, analytics) {
+async function buyGear (user, req, analytics) {
   const buyOp = new BuyMarketGearOperation(user, req, analytics);
 
   return buyOp.purchase();
@@ -57,10 +57,10 @@ describe('shared.ops.buyMarketGear', () => {
   });
 
   context('Gear', () => {
-    it('adds equipment to inventory', () => {
+    it('adds equipment to inventory', async () => {
       user.stats.gp = 31;
 
-      buyGear(user, { params: { key: 'armor_warrior_1' } }, analytics);
+      await buyGear(user, { params: { key: 'armor_warrior_1' } }, analytics);
 
       expect(user.items.gear.owned).to.eql({
         weapon_warrior_0: true,
@@ -90,10 +90,10 @@ describe('shared.ops.buyMarketGear', () => {
       expect(analytics.track).to.be.calledOnce;
     });
 
-    it('adds the onboarding achievement to the user and checks the onboarding status', () => {
+    it('adds the onboarding achievement to the user and checks the onboarding status', async () => {
       user.stats.gp = 31;
 
-      buyGear(user, { params: { key: 'armor_warrior_1' } }, analytics);
+      await buyGear(user, { params: { key: 'armor_warrior_1' } }, analytics);
 
       expect(user.addAchievement).to.be.calledOnce;
       expect(user.addAchievement).to.be.calledWith('purchasedEquipment');
@@ -102,36 +102,36 @@ describe('shared.ops.buyMarketGear', () => {
       expect(shared.onboarding.checkOnboardingStatus).to.be.calledWith(user);
     });
 
-    it('does not add the onboarding achievement to the user if it\'s already been awarded', () => {
+    it('does not add the onboarding achievement to the user if it\'s already been awarded', async () => {
       user.stats.gp = 31;
       user.achievements.purchasedEquipment = true;
 
-      buyGear(user, { params: { key: 'armor_warrior_1' } }, analytics);
+      await buyGear(user, { params: { key: 'armor_warrior_1' } }, analytics);
 
       expect(user.addAchievement).to.not.be.called;
     });
 
-    it('deducts gold from user', () => {
+    it('deducts gold from user', async () => {
       user.stats.gp = 31;
 
-      buyGear(user, { params: { key: 'armor_warrior_1' } });
+      await buyGear(user, { params: { key: 'armor_warrior_1' } });
 
       expect(user.stats.gp).to.eql(1);
     });
 
-    it('auto equips equipment if user has auto-equip preference turned on', () => {
+    it('auto equips equipment if user has auto-equip preference turned on', async () => {
       user.stats.gp = 31;
       user.preferences.autoEquip = true;
 
-      buyGear(user, { params: { key: 'armor_warrior_1' } });
+      await buyGear(user, { params: { key: 'armor_warrior_1' } });
 
       expect(user.items.gear.equipped).to.have.property('armor', 'armor_warrior_1');
     });
 
-    it('updates the pinnedItems to the next item in the set if one exists', () => {
+    it('updates the pinnedItems to the next item in the set if one exists', async () => {
       user.stats.gp = 31;
 
-      buyGear(user, { params: { key: 'armor_warrior_1' } });
+      await buyGear(user, { params: { key: 'armor_warrior_1' } });
 
       expect(user.pinnedItems).to.deep.include({
         type: 'marketGear',
@@ -139,155 +139,147 @@ describe('shared.ops.buyMarketGear', () => {
       });
     });
 
-    it('buyGears equipment but does not auto-equip', () => {
+    it('buyGears equipment but does not auto-equip', async () => {
       user.stats.gp = 31;
       user.preferences.autoEquip = false;
 
-      buyGear(user, { params: { key: 'armor_warrior_1' } });
+      await buyGear(user, { params: { key: 'armor_warrior_1' } });
 
       expect(user.items.gear.equipped.property).to.not.equal('armor_warrior_1');
     });
 
-    it('does not buyGear equipment twice', done => {
+    it('does not buyGear equipment twice', async () => {
       user.stats.gp = 62;
-      buyGear(user, { params: { key: 'armor_warrior_1' } });
+      await buyGear(user, { params: { key: 'armor_warrior_1' } });
 
       try {
-        buyGear(user, { params: { key: 'armor_warrior_1' } });
+        await buyGear(user, { params: { key: 'armor_warrior_1' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('equipmentAlreadyOwned'));
-        done();
       }
     });
 
-    it('does not buy equipment of different class', done => {
+    it('does not buy equipment of different class', async () => {
       user.stats.gp = 82;
       user.stats.class = 'warrior';
 
       try {
-        buyGear(user, { params: { key: 'weapon_special_winter2018Rogue' } });
+        await buyGear(user, { params: { key: 'weapon_special_winter2018Rogue' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('cannotBuyItem'));
-        done();
       }
     });
 
-    it('does not buy equipment in bulk', done => {
+    it('does not buy equipment in bulk', async () => {
       user.stats.gp = 82;
 
       try {
-        buyGear(user, { params: { key: 'armor_warrior_1' }, quantity: 3 });
+        await buyGear(user, { params: { key: 'armor_warrior_1' }, quantity: 3 });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('messageNotAbleToBuyInBulk'));
-        done();
       }
     });
 
     // TODO after user.ops.equip is done
-    xit('removes one-handed weapon and shield if auto-equip is on and a two-hander is bought', () => {
+    xit('removes one-handed weapon and shield if auto-equip is on and a two-hander is bought', async () => {
       user.stats.gp = 100;
       user.preferences.autoEquip = true;
-      buyGear(user, { params: { key: 'shield_warrior_1' } });
+      await buyGear(user, { params: { key: 'shield_warrior_1' } });
       user.ops.equip({ params: { key: 'shield_warrior_1' } });
-      buyGear(user, { params: { key: 'weapon_warrior_1' } });
+      await buyGear(user, { params: { key: 'weapon_warrior_1' } });
       user.ops.equip({ params: { key: 'weapon_warrior_1' } });
 
-      buyGear(user, { params: { key: 'weapon_wizard_1' } });
+      await buyGear(user, { params: { key: 'weapon_wizard_1' } });
 
       expect(user.items.gear.equipped).to.have.property('shield', 'shield_base_0');
       expect(user.items.gear.equipped).to.have.property('weapon', 'weapon_wizard_1');
     });
 
     // TODO after user.ops.equip is done
-    xit('buyGears two-handed equipment but does not automatically remove sword or shield', () => {
+    xit('buyGears two-handed equipment but does not automatically remove sword or shield', async () => {
       user.stats.gp = 100;
       user.preferences.autoEquip = false;
-      buyGear(user, { params: { key: 'shield_warrior_1' } });
+      await buyGear(user, { params: { key: 'shield_warrior_1' } });
       user.ops.equip({ params: { key: 'shield_warrior_1' } });
-      buyGear(user, { params: { key: 'weapon_warrior_1' } });
+      await buyGear(user, { params: { key: 'weapon_warrior_1' } });
       user.ops.equip({ params: { key: 'weapon_warrior_1' } });
 
-      buyGear(user, { params: { key: 'weapon_wizard_1' } });
+      await buyGear(user, { params: { key: 'weapon_wizard_1' } });
 
       expect(user.items.gear.equipped).to.have.property('shield', 'shield_warrior_1');
       expect(user.items.gear.equipped).to.have.property('weapon', 'weapon_warrior_1');
     });
 
-    it('does not buyGear equipment without enough Gold', done => {
+    it('does not buyGear equipment without enough Gold', async () => {
       user.stats.gp = 20;
 
       try {
-        buyGear(user, { params: { key: 'armor_warrior_1' } });
+        await buyGear(user, { params: { key: 'armor_warrior_1' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('messageNotEnoughGold'));
         expect(user.items.gear.owned).to.not.have.property('armor_warrior_1');
-        done();
       }
     });
 
-    it('returns error when key is not provided', done => {
+    it('returns error when key is not provided', async () => {
       try {
-        buyGear(user);
+        await buyGear(user);
       } catch (err) {
         expect(err).to.be.an.instanceof(BadRequest);
         expect(err.message).to.equal(errorMessage('missingKeyParam'));
-        done();
       }
     });
 
-    it('returns error when item is not found', done => {
+    it('returns error when item is not found', async () => {
       const params = { key: 'armor_warrior_notExisting' };
 
       try {
-        buyGear(user, { params });
+        await buyGear(user, { params });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotFound);
         expect(err.message).to.equal(errorMessage('itemNotFound', params));
-        done();
       }
     });
 
-    it('does not buyGear equipment without the previous equipment', done => {
+    it('does not buyGear equipment without the previous equipment', async () => {
       try {
-        buyGear(user, { params: { key: 'armor_warrior_2' } });
+        await buyGear(user, { params: { key: 'armor_warrior_2' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('previousGearNotOwned'));
-        done();
       }
     });
 
-    it('does not buyGear equipment if user does not own prior item in sequence', done => {
+    it('does not buyGear equipment if user does not own prior item in sequence', async () => {
       user.stats.gp = 200;
 
       try {
-        buyGear(user, { params: { key: 'armor_warrior_2' } });
+        await buyGear(user, { params: { key: 'armor_warrior_2' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('previousGearNotOwned'));
         expect(user.items.gear.owned).to.not.have.property('armor_warrior_2');
-        done();
       }
     });
 
-    it('does buyGear equipment if item is a numbered special item user qualifies for', () => {
+    it('does buyGear equipment if item is a numbered special item user qualifies for', async () => {
       user.stats.gp = 200;
       user.items.gear.owned.head_special_2 = false;
 
-      buyGear(user, { params: { key: 'head_special_2' } });
+      await buyGear(user, { params: { key: 'head_special_2' } });
 
       expect(user.items.gear.owned).to.have.property('head_special_2', true);
     });
 
-    it('does buyGear equipment if it is an armoire item that an user previously lost', () => {
+    it('does buyGear equipment if it is an armoire item that an user previously lost', async () => {
       user.stats.gp = 200;
       user.items.gear.owned.shield_armoire_ramHornShield = false;
 
-      buyGear(user, { params: { key: 'shield_armoire_ramHornShield' } });
+      await buyGear(user, { params: { key: 'shield_armoire_ramHornShield' } });
 
       expect(user.items.gear.owned).to.have.property('shield_armoire_ramHornShield', true);
     });

test/common/ops/buy/buyMysterySet.js

@@ -35,18 +35,17 @@ describe('shared.ops.buyMysterySet', () => {
 
   context('Mystery Sets', () => {
     context('failure conditions', () => {
-      it('does not grant mystery sets without Mystic Hourglasses', done => {
+      it('does not grant mystery sets without Mystic Hourglasses', async () => {
         try {
-          buyMysterySet(user, { params: { key: '201501' } });
+          await buyMysterySet(user, { params: { key: '201501' } });
         } catch (err) {
           expect(err).to.be.an.instanceof(NotAuthorized);
           expect(err.message).to.eql(i18n.t('notEnoughHourglasses'));
           expect(user.items.gear.owned).to.have.property('weapon_warrior_0', true);
-          done();
         }
       });
 
-      it('does not grant mystery set that has already been purchased', done => {
+      it('does not grant mystery set that has already been purchased', async () => {
         user.purchased.plan.consecutive.trinkets = 1;
         user.items.gear.owned = {
           weapon_warrior_0: true,
@@ -57,30 +56,28 @@ describe('shared.ops.buyMysterySet', () => {
         };
 
         try {
-          buyMysterySet(user, { params: { key: '301404' } });
+          await buyMysterySet(user, { params: { key: '301404' } });
         } catch (err) {
           expect(err).to.be.an.instanceof(NotFound);
           expect(err.message).to.eql(i18n.t('mysterySetNotFound'));
           expect(user.purchased.plan.consecutive.trinkets).to.eql(1);
-          done();
         }
       });
 
-      it('returns error when key is not provided', done => {
+      it('returns error when key is not provided', async () => {
         try {
-          buyMysterySet(user);
+          await buyMysterySet(user);
         } catch (err) {
           expect(err).to.be.an.instanceof(BadRequest);
           expect(err.message).to.equal(errorMessage('missingKeyParam'));
-          done();
         }
       });
     });
 
     context('successful purchases', () => {
-      it('buys Steampunk Accessories Set', () => {
+      it('buys Steampunk Accessories Set', async () => {
         user.purchased.plan.consecutive.trinkets = 1;
-        buyMysterySet(user, { params: { key: '301404' } }, analytics);
+        await buyMysterySet(user, { params: { key: '301404' } }, analytics);
 
         expect(user.purchased.plan.consecutive.trinkets).to.eql(0);
         expect(user.items.gear.owned).to.have.property('weapon_warrior_0', true);
@@ -88,14 +85,6 @@ describe('shared.ops.buyMysterySet', () => {
         expect(user.items.gear.owned).to.have.property('armor_mystery_301404', true);
         expect(user.items.gear.owned).to.have.property('head_mystery_301404', true);
         expect(user.items.gear.owned).to.have.property('eyewear_mystery_301404', true);
-        expect(analytics.track).to.be.calledOnce;
-        expect(analytics.track).to.be.calledWithMatch('acquire item', {
-          uuid: user._id,
-          itemKey: '301404',
-          itemType: 'Subscriber Gear',
-          acquireMethod: 'Hourglass',
-          category: 'behavior',
-        });
       });
     });
   });

test/common/ops/buy/buyQuestGems.js

@@ -13,7 +13,7 @@ describe('shared.ops.buyQuestGems', () => {
   const goldPoints = 40;
   const analytics = { track () {} };
 
-  function buyQuest (_user, _req, _analytics) {
+  async function buyQuest (_user, _req, _analytics) {
     const buyOp = new BuyQuestWithGemOperation(_user, _req, _analytics);
 
     return buyOp.purchase();
@@ -44,19 +44,19 @@ describe('shared.ops.buyQuestGems', () => {
       user.pinnedItems.push({ type: 'quests', key: 'gryphon' });
     });
 
-    it('purchases quests', () => {
+    it('purchases quests', async () => {
       const key = 'gryphon';
 
-      buyQuest(user, { params: { key } });
+      await buyQuest(user, { params: { key } });
 
       expect(user.items.quests[key]).to.equal(1);
       expect(pinnedGearUtils.removeItemByPath.notCalled).to.equal(true);
     });
-    it('if a user\'s count of a quest scroll is negative, it will be reset to 0 before incrementing when they buy a new one.', () => {
+    it('if a user\'s count of a quest scroll is negative, it will be reset to 0 before incrementing when they buy a new one.', async () => {
       const key = 'dustbunnies';
       user.items.quests[key] = -1;
 
-      buyQuest(user, { params: { key } });
+      await buyQuest(user, { params: { key } });
 
       expect(user.items.quests[key]).to.equal(1);
       expect(pinnedGearUtils.removeItemByPath.notCalled).to.equal(true);
@@ -73,26 +73,25 @@ describe('shared.ops.buyQuestGems', () => {
       user.purchased.plan.customerId = 'customer-id';
     });
 
-    it('errors when user does not have enough gems', done => {
+    it('errors when user does not have enough gems', async () => {
       user.balance = 1;
       const key = 'gryphon';
 
       try {
-        buyQuest(user, {
+        await buyQuest(user, {
           params: { key },
           quantity: 2,
         });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('notEnoughGems'));
-        done();
       }
     });
 
-    it('makes bulk purchases of quests', () => {
+    it('makes bulk purchases of quests', async () => {
       const key = 'gryphon';
 
-      buyQuest(user, {
+      await buyQuest(user, {
         params: { key },
         quantity: 3,
       });

test/common/ops/buy/buyQuestGold.js

@@ -14,7 +14,7 @@ describe('shared.ops.buyQuest', () => {
   let user;
   const analytics = { track () {} };
 
-  function buyQuest (_user, _req, _analytics) {
+  async function buyQuest (_user, _req, _analytics) {
     const buyOp = new BuyQuestWithGoldOperation(_user, _req, _analytics);
 
     return buyOp.purchase();
@@ -29,9 +29,9 @@ describe('shared.ops.buyQuest', () => {
     analytics.track.restore();
   });
 
-  it('buys a Quest scroll', () => {
+  it('buys a Quest scroll', async () => {
     user.stats.gp = 205;
-    buyQuest(user, {
+    await buyQuest(user, {
       params: {
         key: 'dilatoryDistress1',
       },
@@ -43,11 +43,11 @@ describe('shared.ops.buyQuest', () => {
     expect(analytics.track).to.be.calledOnce;
   });
 
-  it('if a user\'s count of a quest scroll is negative, it will be reset to 0 before incrementing when they buy a new one.', () => {
+  it('if a user\'s count of a quest scroll is negative, it will be reset to 0 before incrementing when they buy a new one.', async () => {
     user.stats.gp = 205;
     const key = 'dilatoryDistress1';
     user.items.quests[key] = -1;
-    buyQuest(user, {
+    await buyQuest(user, {
       params: { key },
     }, analytics);
     expect(user.items.quests[key]).to.equal(1);
@@ -55,14 +55,14 @@ describe('shared.ops.buyQuest', () => {
     expect(analytics.track).to.be.calledOnce;
   });
 
-  it('buys a Quest scroll with the right quantity if a string is passed for quantity', () => {
+  it('buys a Quest scroll with the right quantity if a string is passed for quantity', async () => {
     user.stats.gp = 1000;
-    buyQuest(user, {
+    await buyQuest(user, {
       params: {
         key: 'dilatoryDistress1',
       },
     }, analytics);
-    buyQuest(user, {
+    await buyQuest(user, {
       params: {
         key: 'dilatoryDistress1',
       },
@@ -74,10 +74,10 @@ describe('shared.ops.buyQuest', () => {
     });
   });
 
-  it('does not buy a Quest scroll when an invalid quantity is passed', done => {
+  it('does not buy a Quest scroll when an invalid quantity is passed', async () => {
     user.stats.gp = 1000;
     try {
-      buyQuest(user, {
+      await buyQuest(user, {
         params: {
           key: 'dilatoryDistress1',
         },
@@ -88,14 +88,13 @@ describe('shared.ops.buyQuest', () => {
       expect(err.message).to.equal(i18n.t('invalidQuantity'));
       expect(user.items.quests).to.eql({});
       expect(user.stats.gp).to.equal(1000);
-      done();
     }
   });
 
-  it('does not buy Quests without enough Gold', done => {
+  it('does not buy Quests without enough Gold', async () => {
     user.stats.gp = 1;
     try {
-      buyQuest(user, {
+      await buyQuest(user, {
         params: {
           key: 'dilatoryDistress1',
         },
@@ -105,14 +104,13 @@ describe('shared.ops.buyQuest', () => {
       expect(err.message).to.equal(i18n.t('messageNotEnoughGold'));
       expect(user.items.quests).to.eql({});
       expect(user.stats.gp).to.equal(1);
-      done();
     }
   });
 
-  it('does not buy nonexistent Quests', done => {
+  it('does not buy nonexistent Quests', async () => {
     user.stats.gp = 9999;
     try {
-      buyQuest(user, {
+      await buyQuest(user, {
         params: {
           key: 'snarfblatter',
         },
@@ -122,13 +120,12 @@ describe('shared.ops.buyQuest', () => {
       expect(err.message).to.equal(errorMessage('questNotFound', { key: 'snarfblatter' }));
       expect(user.items.quests).to.eql({});
       expect(user.stats.gp).to.equal(9999);
-      done();
     }
   });
 
-  it('does not buy the Mystery of the Masterclassers', done => {
+  it('does not buy the Mystery of the Masterclassers', async () => {
     try {
-      buyQuest(user, {
+      await buyQuest(user, {
         params: {
           key: 'lostMasterclasser1',
         },
@@ -137,14 +134,13 @@ describe('shared.ops.buyQuest', () => {
       expect(err).to.be.an.instanceof(NotAuthorized);
       expect(err.message).to.equal(i18n.t('questUnlockLostMasterclasser'));
       expect(user.items.quests).to.eql({});
-      done();
     }
   });
 
-  it('does not buy Gem-premium Quests', done => {
+  it('does not buy Gem-premium Quests', async () => {
     user.stats.gp = 9999;
     try {
-      buyQuest(user, {
+      await buyQuest(user, {
         params: {
           key: 'kraken',
         },
@@ -154,23 +150,21 @@ describe('shared.ops.buyQuest', () => {
       expect(err.message).to.equal(i18n.t('questNotGoldPurchasable', { key: 'kraken' }));
       expect(user.items.quests).to.eql({});
       expect(user.stats.gp).to.equal(9999);
-      done();
     }
   });
 
-  it('returns error when key is not provided', done => {
+  it('returns error when key is not provided', async () => {
     try {
-      buyQuest(user);
+      await buyQuest(user);
     } catch (err) {
       expect(err).to.be.an.instanceof(BadRequest);
       expect(err.message).to.equal(errorMessage('missingKeyParam'));
-      done();
     }
   });
 
-  it('does not buy a quest without completing previous quests', done => {
+  it('does not buy a quest without completing previous quests', async () => {
     try {
-      buyQuest(user, {
+      await buyQuest(user, {
         params: {
           key: 'dilatoryDistress3',
         },
@@ -179,7 +173,6 @@ describe('shared.ops.buyQuest', () => {
       expect(err).to.be.an.instanceof(NotAuthorized);
       expect(err.message).to.equal(i18n.t('mustComplete', { quest: 'dilatoryDistress2' }));
       expect(user.items.quests).to.eql({});
-      done();
     }
   });
 });

test/common/ops/buy/buySpell.js

@@ -15,7 +15,7 @@ describe('shared.ops.buySpecialSpell', () => {
   let user;
   const analytics = { track () {} };
 
-  function buySpecialSpell (_user, _req, _analytics) {
+  async function buySpecialSpell (_user, _req, _analytics) {
     const buyOp = new BuySpellOperation(_user, _req, _analytics);
 
     return buyOp.purchase();
@@ -29,19 +29,18 @@ describe('shared.ops.buySpecialSpell', () => {
     analytics.track.restore();
   });
 
-  it('throws an error if params.key is missing', done => {
+  it('throws an error if params.key is missing', async () => {
     try {
-      buySpecialSpell(user);
+      await buySpecialSpell(user);
     } catch (err) {
       expect(err).to.be.an.instanceof(BadRequest);
       expect(err.message).to.equal(errorMessage('missingKeyParam'));
-      done();
     }
   });
 
-  it('throws an error if the spell doesn\'t exists', done => {
+  it('throws an error if the spell doesn\'t exists', async () => {
     try {
-      buySpecialSpell(user, {
+      await buySpecialSpell(user, {
         params: {
           key: 'notExisting',
         },
@@ -49,14 +48,13 @@ describe('shared.ops.buySpecialSpell', () => {
     } catch (err) {
       expect(err).to.be.an.instanceof(NotFound);
       expect(err.message).to.equal(errorMessage('spellNotFound', { spellId: 'notExisting' }));
-      done();
     }
   });
 
-  it('throws an error if the user doesn\'t have enough gold', done => {
+  it('throws an error if the user doesn\'t have enough gold', async () => {
     user.stats.gp = 1;
     try {
-      buySpecialSpell(user, {
+      await buySpecialSpell(user, {
         params: {
           key: 'thankyou',
         },
@@ -64,15 +62,14 @@ describe('shared.ops.buySpecialSpell', () => {
     } catch (err) {
       expect(err).to.be.an.instanceof(NotAuthorized);
       expect(err.message).to.equal(i18n.t('messageNotEnoughGold'));
-      done();
     }
   });
 
-  it('buys an item', () => {
+  it('buys an item', async () => {
     user.stats.gp = 11;
     const item = content.special.thankyou;
 
-    const [data, message] = buySpecialSpell(user, {
+    const [data, message] = await buySpecialSpell(user, {
       params: {
         key: 'thankyou',
       },

test/common/ops/buy/hourglassPurchase.js

@@ -15,7 +15,7 @@ describe('common.ops.hourglassPurchase', () => {
   let user;
   const analytics = { track () {} };
 
-  function buyMount (_user, _req, _analytics) {
+  async function buyMount (_user, _req, _analytics) {
     const buyOp = new BuyHourglassMountOperation(_user, _req, _analytics);
 
     return buyOp.purchase();
@@ -31,116 +31,107 @@ describe('common.ops.hourglassPurchase', () => {
   });
 
   context('failure conditions', () => {
-    it('return error when key is not provided', done => {
+    it('return error when key is not provided', async () => {
       try {
-        hourglassPurchase(user, { params: {} });
+        await hourglassPurchase(user, { params: {} });
       } catch (err) {
         expect(err).to.be.an.instanceof(BadRequest);
         expect(err.message).to.eql(errorMessage('missingKeyParam'));
-        done();
       }
     });
 
-    it('returns error when type is not provided', done => {
+    it('returns error when type is not provided', async () => {
       try {
-        hourglassPurchase(user, { params: { key: 'Base' } });
+        await hourglassPurchase(user, { params: { key: 'Base' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(BadRequest);
         expect(err.message).to.eql(errorMessage('missingTypeParam'));
-        done();
       }
     });
 
-    it('returns error when inccorect type is provided', done => {
+    it('returns error when inccorect type is provided', async () => {
       try {
-        hourglassPurchase(user, { params: { type: 'notAType', key: 'MantisShrimp-Base' } });
+        await hourglassPurchase(user, { params: { type: 'notAType', key: 'MantisShrimp-Base' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.eql(i18n.t('typeNotAllowedHourglass', { allowedTypes: _.keys(content.timeTravelStable).toString() }));
-        done();
       }
     });
 
-    it('does not grant to pets without Mystic Hourglasses', done => {
+    it('does not grant to pets without Mystic Hourglasses', async () => {
       try {
-        hourglassPurchase(user, { params: { type: 'pets', key: 'MantisShrimp-Base' } });
+        await hourglassPurchase(user, { params: { type: 'pets', key: 'MantisShrimp-Base' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.eql(i18n.t('notEnoughHourglasses'));
-        done();
       }
     });
 
-    it('does not grant to mounts without Mystic Hourglasses', done => {
+    it('does not grant to mounts without Mystic Hourglasses', async () => {
       try {
-        buyMount(user, { params: { key: 'MantisShrimp-Base' } });
+        await buyMount(user, { params: { key: 'MantisShrimp-Base' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.eql(i18n.t('notEnoughHourglasses'));
-        done();
       }
     });
 
-    it('does not grant pet that is not part of the Time Travel Stable', done => {
+    it('does not grant pet that is not part of the Time Travel Stable', async () => {
       user.purchased.plan.consecutive.trinkets = 1;
 
       try {
-        hourglassPurchase(user, { params: { type: 'pets', key: 'Wolf-Veteran' } });
+        await hourglassPurchase(user, { params: { type: 'pets', key: 'Wolf-Veteran' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.eql(i18n.t('notAllowedHourglass'));
-        done();
       }
     });
 
-    it('does not grant mount that is not part of the Time Travel Stable', done => {
+    it('does not grant mount that is not part of the Time Travel Stable', async () => {
       user.purchased.plan.consecutive.trinkets = 1;
 
       try {
-        buyMount(user, { params: { key: 'Orca-Base' } });
+        await buyMount(user, { params: { key: 'Orca-Base' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.eql(i18n.t('notAllowedHourglass'));
-        done();
       }
     });
 
-    it('does not grant pet that has already been purchased', done => {
+    it('does not grant pet that has already been purchased', async () => {
       user.purchased.plan.consecutive.trinkets = 1;
       user.items.pets = {
         'MantisShrimp-Base': true,
       };
 
       try {
-        hourglassPurchase(user, { params: { type: 'pets', key: 'MantisShrimp-Base' } });
+        await hourglassPurchase(user, { params: { type: 'pets', key: 'MantisShrimp-Base' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.eql(i18n.t('petsAlreadyOwned'));
-        done();
       }
     });
 
-    it('does not grant mount that has already been purchased', done => {
+    it('does not grant mount that has already been purchased', async () => {
       user.purchased.plan.consecutive.trinkets = 1;
       user.items.mounts = {
         'MantisShrimp-Base': true,
       };
 
       try {
-        buyMount(user, { params: { key: 'MantisShrimp-Base' } });
+        await buyMount(user, { params: { key: 'MantisShrimp-Base' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.eql(i18n.t('mountsAlreadyOwned'));
-        done();
       }
     });
   });
 
   context('successful purchases', () => {
-    it('buys a pet', () => {
+    it('buys a pet', async () => {
       user.purchased.plan.consecutive.trinkets = 2;
 
-      const [, message] = hourglassPurchase(user, { params: { type: 'pets', key: 'MantisShrimp-Base' } }, analytics);
+      const [, message] = await hourglassPurchase(user, { params: { type: 'pets', key: 'MantisShrimp-Base' } }, analytics);
 
       expect(message).to.eql(i18n.t('hourglassPurchase'));
       expect(user.purchased.plan.consecutive.trinkets).to.eql(1);
@@ -148,10 +139,10 @@ describe('common.ops.hourglassPurchase', () => {
       expect(analytics.track).to.be.calledOnce;
     });
 
-    it('buys a mount', () => {
+    it('buys a mount', async () => {
       user.purchased.plan.consecutive.trinkets = 2;
 
-      const [, message] = buyMount(user, { params: { key: 'MantisShrimp-Base' } });
+      const [, message] = await buyMount(user, { params: { key: 'MantisShrimp-Base' } });
       expect(message).to.eql(i18n.t('hourglassPurchase'));
       expect(user.purchased.plan.consecutive.trinkets).to.eql(1);
       expect(user.items.mounts).to.eql({ 'MantisShrimp-Base': true });

test/common/ops/buy/purchase.js

@@ -13,7 +13,7 @@ import {
 } from '../../../helpers/common.helper';
 
 describe('shared.ops.purchase', () => {
-  const SEASONAL_FOOD = 'Meat';
+  const SEASONAL_FOOD = moment().isBefore('2021-11-02T20:00-04:00') ? 'Candy_Base' : 'Meat';
   let user;
   const goldPoints = 40;
   const analytics = { track () {} };
@@ -33,118 +33,108 @@ describe('shared.ops.purchase', () => {
   });
 
   context('failure conditions', () => {
-    it('returns an error when type is not provided', done => {
+    it('returns an error when type is not provided', async () => {
       try {
-        purchase(user, { params: {} });
+        await purchase(user, { params: {} });
       } catch (err) {
         expect(err).to.be.an.instanceof(BadRequest);
         expect(err.message).to.equal(i18n.t('typeRequired'));
-        done();
       }
     });
 
-    it('returns error when unknown type is provided', done => {
+    it('returns error when unknown type is provided', async () => {
       try {
-        purchase(user, { params: { type: 'randomType', key: 'gem' } });
+        await purchase(user, { params: { type: 'randomType', key: 'gem' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotFound);
         expect(err.message).to.equal(i18n.t('notAccteptedType'));
-        done();
       }
     });
 
-    it('returns error when user attempts to purchase a piece of gear they own', done => {
+    it('returns error when user attempts to purchase a piece of gear they own', async () => {
       user.items.gear.owned['shield_rogue_1'] = true; // eslint-disable-line dot-notation
 
       try {
-        purchase(user, { params: { type: 'gear', key: 'shield_rogue_1' } });
+        await purchase(user, { params: { type: 'gear', key: 'shield_rogue_1' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('alreadyHave'));
-        done();
       }
     });
 
-    it('returns error when unknown item is requested', done => {
+    it('returns error when unknown item is requested', async () => {
       try {
-        purchase(user, { params: { type: 'gear', key: 'randomKey' } });
+        await purchase(user, { params: { type: 'gear', key: 'randomKey' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotFound);
         expect(err.message).to.equal(i18n.t('contentKeyNotFound', { type: 'gear' }));
-        done();
       }
     });
 
-    it('returns error when user does not have permission to buy an item', done => {
+    it('returns error when user does not have permission to buy an item', async () => {
       try {
-        purchase(user, { params: { type: 'gear', key: 'eyewear_mystery_301405' } });
+        await purchase(user, { params: { type: 'gear', key: 'eyewear_mystery_301405' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('messageNotAvailable'));
-        done();
       }
     });
 
-    it('returns error when user does not have enough gems to buy an item', done => {
+    it('returns error when user does not have enough gems to buy an item', async () => {
       try {
-        purchase(user, { params: { type: 'gear', key: 'headAccessory_special_wolfEars' } });
+        await purchase(user, { params: { type: 'gear', key: 'headAccessory_special_wolfEars' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('notEnoughGems'));
-        done();
       }
     });
 
-    it('returns error when item is not found', done => {
+    it('returns error when item is not found', async () => {
       const params = { key: 'notExisting', type: 'food' };
 
       try {
-        purchase(user, { params });
+        await purchase(user, { params });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotFound);
         expect(err.message).to.equal(i18n.t('contentKeyNotFound', params));
-        done();
       }
     });
 
-    it('returns error when user supplies a non-numeric quantity', done => {
+    it('returns error when user supplies a non-numeric quantity', async () => {
       const type = 'eggs';
       const key = 'Wolf';
 
       try {
-        purchase(user, { params: { type, key }, quantity: 'jamboree' }, analytics);
+        await purchase(user, { params: { type, key }, quantity: 'jamboree' }, analytics);
       } catch (err) {
         expect(err).to.be.an.instanceof(BadRequest);
         expect(err.message).to.equal(i18n.t('invalidQuantity'));
-        done();
       }
     });
 
-    it('returns error when user supplies a negative quantity', done => {
+    it('returns error when user supplies a negative quantity', async () => {
       const type = 'eggs';
       const key = 'Wolf';
       user.balance = 10;
 
       try {
-        purchase(user, { params: { type, key }, quantity: -2 }, analytics);
+        await purchase(user, { params: { type, key }, quantity: -2 }, analytics);
       } catch (err) {
         expect(err).to.be.an.instanceof(BadRequest);
         expect(err.message).to.equal(i18n.t('invalidQuantity'));
-        done();
       }
     });
 
-    it('returns error when user supplies a decimal quantity', done => {
+    it('returns error when user supplies a decimal quantity', async () => {
       const type = 'eggs';
       const key = 'Wolf';
       user.balance = 10;
 
       try {
-        purchase(user, { params: { type, key }, quantity: 2.9 }, analytics);
+        await purchase(user, { params: { type, key }, quantity: 2.9 }, analytics);
       } catch (err) {
         expect(err).to.be.an.instanceof(BadRequest);
         expect(err.message).to.equal(i18n.t('invalidQuantity'));
-        done();
       }
     });
   });
@@ -164,48 +154,48 @@ describe('shared.ops.purchase', () => {
       user.pinnedItems.push({ type: 'bundles', key: 'featheredFriends' });
     });
 
-    it('purchases eggs', () => {
+    it('purchases eggs', async () => {
       const type = 'eggs';
       const key = 'Wolf';
 
-      purchase(user, { params: { type, key } }, analytics);
+      await purchase(user, { params: { type, key } }, analytics);
 
       expect(user.items[type][key]).to.equal(1);
       expect(pinnedGearUtils.removeItemByPath.notCalled).to.equal(true);
       expect(analytics.track).to.be.calledOnce;
     });
 
-    it('purchases hatchingPotions', () => {
+    it('purchases hatchingPotions', async () => {
       const type = 'hatchingPotions';
       const key = 'Base';
 
-      purchase(user, { params: { type, key } });
+      await purchase(user, { params: { type, key } });
 
       expect(user.items[type][key]).to.equal(1);
       expect(pinnedGearUtils.removeItemByPath.notCalled).to.equal(true);
     });
 
-    it('purchases food', () => {
+    it('purchases food', async () => {
       const type = 'food';
       const key = SEASONAL_FOOD;
 
-      purchase(user, { params: { type, key } });
+      await purchase(user, { params: { type, key } });
 
       expect(user.items[type][key]).to.equal(1);
       expect(pinnedGearUtils.removeItemByPath.notCalled).to.equal(true);
     });
 
-    it('purchases gear', () => {
+    it('purchases gear', async () => {
       const type = 'gear';
       const key = 'headAccessory_special_tigerEars';
 
-      purchase(user, { params: { type, key } });
+      await purchase(user, { params: { type, key } });
 
       expect(user.items.gear.owned[key]).to.be.true;
       expect(pinnedGearUtils.removeItemByPath.calledOnce).to.equal(true);
     });
 
-    it('purchases quest bundles', () => {
+    it('purchases quest bundles', async () => {
       const startingBalance = user.balance;
       const clock = sandbox.useFakeTimers(moment('2019-05-20').valueOf());
       const type = 'bundles';
@@ -217,7 +207,7 @@ describe('shared.ops.purchase', () => {
         'owl',
       ];
 
-      purchase(user, { params: { type, key } });
+      await purchase(user, { params: { type, key } });
 
       forEach(questList, bundledKey => {
         expect(user.items.quests[bundledKey]).to.equal(1);
@@ -240,28 +230,27 @@ describe('shared.ops.purchase', () => {
       user.purchased.plan.customerId = 'customer-id';
     });
 
-    it('errors when user does not have enough gems', done => {
+    it('errors when user does not have enough gems', async () => {
       user.balance = 1;
       const type = 'eggs';
       const key = 'TigerCub';
 
       try {
-        purchase(user, {
+        await purchase(user, {
           params: { type, key },
           quantity: 2,
         });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('notEnoughGems'));
-        done();
       }
     });
 
-    it('makes bulk purchases of eggs', () => {
+    it('makes bulk purchases of eggs', async () => {
       const type = 'eggs';
       const key = 'TigerCub';
 
-      purchase(user, {
+      await purchase(user, {
         params: { type, key },
         quantity: 2,
       });

test/common/ops/changeClass.js

@@ -19,51 +19,48 @@ describe('shared.ops.changeClass', () => {
     user.stats.flagSelected = false;
   });
 
-  it('user is not level 10', done => {
+  it('user is not level 10', async () => {
     user.stats.lvl = 9;
     try {
-      changeClass(user, { query: { class: 'rogue' } });
+      await await changeClass(user, { query: { class: 'rogue' } });
     } catch (err) {
       expect(err).to.be.an.instanceof(NotAuthorized);
       expect(err.message).to.equal(i18n.t('lvl10ChangeClass'));
-      done();
     }
   });
 
-  it('req.query.class is an invalid class', done => {
+  it('req.query.class is an invalid class', async () => {
     user.flags.classSelected = false;
     user.preferences.disableClasses = false;
 
     try {
-      changeClass(user, { query: { class: 'cellist' } });
+      await changeClass(user, { query: { class: 'cellist' } });
     } catch (err) {
       expect(err).to.be.an.instanceof(BadRequest);
       expect(err.message).to.equal(i18n.t('invalidClass'));
-      done();
     }
   });
 
   context('req.query.class is a valid class', () => {
-    it('errors if user.stats.flagSelected is true and user.balance < 0.75', done => {
+    it('errors if user.stats.flagSelected is true and user.balance < 0.75', async () => {
       user.flags.classSelected = true;
       user.preferences.disableClasses = false;
       user.balance = 0;
 
       try {
-        changeClass(user, { query: { class: 'rogue' } });
+        await changeClass(user, { query: { class: 'rogue' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('notEnoughGems'));
-        done();
       }
     });
 
-    it('changes class', () => {
+    it('changes class', async () => {
       user.stats.class = 'healer';
       user.items.gear.owned.weapon_healer_3 = true;
       user.items.gear.equipped.weapon = 'weapon_healer_3';
 
-      const [data] = changeClass(user, { query: { class: 'rogue' } });
+      const [data] = await changeClass(user, { query: { class: 'rogue' } });
       expect(data).to.eql({
         preferences: user.preferences,
         stats: user.stats,
@@ -81,7 +78,7 @@ describe('shared.ops.changeClass', () => {
   });
 
   context('req.query.class is missing or user.stats.flagSelected is true', () => {
-    it('has user.preferences.disableClasses === true', () => {
+    it('has user.preferences.disableClasses === true', async () => {
       user.balance = 1;
       user.preferences.disableClasses = true;
       user.preferences.autoAllocate = true;
@@ -92,7 +89,7 @@ describe('shared.ops.changeClass', () => {
       user.stats.int = 4;
       user.flags.classSelected = true;
 
-      const [data] = changeClass(user);
+      const [data] = await changeClass(user);
       expect(data).to.eql({
         preferences: user.preferences,
         stats: user.stats,
@@ -112,18 +109,17 @@ describe('shared.ops.changeClass', () => {
     });
 
     context('has user.preferences.disableClasses !== true', () => {
-      it('and less than 3 gems', done => {
+      it('and less than 3 gems', async () => {
         user.balance = 0.5;
         try {
-          changeClass(user);
+          await changeClass(user);
         } catch (err) {
           expect(err).to.be.an.instanceof(NotAuthorized);
           expect(err.message).to.equal(i18n.t('notEnoughGems'));
-          done();
         }
       });
 
-      it('and at least 3 gems', () => {
+      it('and at least 3 gems', async () => {
         user.balance = 1;
         user.stats.points = 45;
         user.stats.str = 1;
@@ -132,7 +128,7 @@ describe('shared.ops.changeClass', () => {
         user.stats.int = 4;
         user.flags.classSelected = true;
 
-        const [data] = changeClass(user);
+        const [data] = await changeClass(user);
         expect(data).to.eql({
           preferences: user.preferences,
           stats: user.stats,

test/common/ops/rebirth.js

@@ -24,60 +24,59 @@ describe('shared.ops.rebirth', () => {
     tasks = [generateHabit(), generateDaily(), generateTodo(), generateReward()];
   });
 
-  it('returns an error when user balance is too low and user is less than max level', done => {
+  it('returns an error when user balance is too low and user is less than max level', async () => {
     user.balance = 0;
 
     try {
-      rebirth(user);
+      await rebirth(user);
     } catch (err) {
       expect(err).to.be.an.instanceof(NotAuthorized);
       expect(err.message).to.equal(i18n.t('notEnoughGems'));
-      done();
     }
   });
 
-  it('rebirths a user with enough gems', () => {
-    const [, message] = rebirth(user);
+  it('rebirths a user with enough gems', async () => {
+    const [, message] = await rebirth(user);
 
     expect(message).to.equal(i18n.t('rebirthComplete'));
   });
 
-  it('rebirths a user with not enough gems but max level', () => {
+  it('rebirths a user with not enough gems but max level', async () => {
     user.balance = 0;
     user.stats.lvl = MAX_LEVEL;
 
-    const [, message] = rebirth(user);
+    const [, message] = await rebirth(user);
 
     expect(message).to.equal(i18n.t('rebirthComplete'));
     expect(user.flags.lastFreeRebirth).to.exist;
   });
 
-  it('rebirths a user with not enough gems but more than max level', () => {
+  it('rebirths a user with not enough gems but more than max level', async () => {
     user.balance = 0;
     user.stats.lvl = MAX_LEVEL + 1;
 
-    const [, message] = rebirth(user);
+    const [, message] = await rebirth(user);
 
     expect(message).to.equal(i18n.t('rebirthComplete'));
   });
 
-  it('rebirths a user using gems if over max level but rebirthed recently', () => {
+  it('rebirths a user using gems if over max level but rebirthed recently', async () => {
     user.stats.lvl = MAX_LEVEL + 1;
     user.flags.lastFreeRebirth = new Date();
 
-    const [, message] = rebirth(user);
+    const [, message] = await rebirth(user);
 
     expect(message).to.equal(i18n.t('rebirthComplete'));
     expect(user.balance).to.equal(0);
   });
 
-  it('resets user\'s tasks values except for rewards to 0', () => {
+  it('resets user\'s tasks values except for rewards to 0', async () => {
     tasks[0].value = 1;
     tasks[1].value = 1;
     tasks[2].value = 1;
     tasks[3].value = 1; // Reward
 
-    rebirth(user, tasks);
+    await rebirth(user, tasks);
 
     expect(tasks[0].value).to.equal(0);
     expect(tasks[1].value).to.equal(0);
@@ -85,99 +84,99 @@ describe('shared.ops.rebirth', () => {
     expect(tasks[3].value).to.equal(1); // Reward
   });
 
-  it('resets user\'s daily streaks to 0', () => {
+  it('resets user\'s daily streaks to 0', async () => {
     tasks[0].counterDown = 1; // Habit
     tasks[0].counterUp = 1; // Habit
     tasks[1].streak = 1; // Daily
 
-    rebirth(user, tasks);
+    await rebirth(user, tasks);
 
     expect(tasks[0].counterDown).to.equal(0);
     expect(tasks[0].counterUp).to.equal(0);
     expect(tasks[1].streak).to.equal(0);
   });
 
-  it('resets a user\'s buffs', () => {
+  it('resets a user\'s buffs', async () => {
     user.stats.buffs = { test: 'test' };
 
-    rebirth(user);
+    await rebirth(user);
 
     expect(user.stats.buffs).to.be.empty;
   });
 
-  it('resets a user\'s health points', () => {
+  it('resets a user\'s health points', async () => {
     user.stats.hp = 40;
 
-    rebirth(user);
+    await rebirth(user);
 
     expect(user.stats.hp).to.equal(50);
   });
 
-  it('resets a user\'s class', () => {
+  it('resets a user\'s class', async () => {
     user.stats.class = 'rouge';
 
-    rebirth(user);
+    await rebirth(user);
 
     expect(user.stats.class).to.equal('warrior');
   });
 
-  it('resets a user\'s stats', () => {
+  it('resets a user\'s stats', async () => {
     user.stats.class = 'rouge';
     _.each(userStats, value => {
       user.stats[value] = 10;
     });
 
-    rebirth(user);
+    await rebirth(user);
 
     _.each(userStats, value => {
       user.stats[value] = 0;
     });
   });
 
-  it('retains a user\'s gear', () => {
+  it('retains a user\'s gear', async () => {
     const prevGearEquipped = user.items.gear.equipped;
     const prevGearCostume = user.items.gear.costume;
     const prevPrefCostume = user.preferences.costume;
 
-    rebirth(user);
+    await rebirth(user);
 
     expect(user.items.gear.equipped).to.deep.equal(prevGearEquipped);
     expect(user.items.gear.costume).to.deep.equal(prevGearCostume);
     expect(user.preferences.costume).to.equal(prevPrefCostume);
   });
 
-  it('retains a user\'s gear owned', () => {
+  it('retains a user\'s gear owned', async () => {
     user.items.gear.owned.weapon_warrior_1 = true; // eslint-disable-line camelcase
     const prevGearOwned = user.items.gear.owned;
 
-    rebirth(user);
+    await rebirth(user);
 
     expect(user.items.gear.owned).to.equal(prevGearOwned);
   });
 
-  it('resets a user\'s current pet', () => {
+  it('resets a user\'s current pet', async () => {
     user.items.pets[animal] = true;
     user.items.currentPet = animal;
-    rebirth(user);
+    await rebirth(user);
 
     expect(user.items.currentPet).to.be.empty;
   });
 
-  it('resets a user\'s current mount', () => {
+  it('resets a user\'s current mount', async () => {
     user.items.mounts[animal] = true;
     user.items.currentMount = animal;
-    rebirth(user);
+    await rebirth(user);
 
     expect(user.items.currentMount).to.be.empty;
   });
 
-  it('resets a user\'s flags', () => {
+  it('resets a user\'s flags', async () => {
     user.flags.itemsEnabled = true;
     user.flags.classSelected = true;
     user.flags.rebirthEnabled = true;
     user.flags.levelDrops = { test: 'test' };
 
-    rebirth(user);
+    await rebirth(user);
 
     expect(user.flags.itemsEnabled).to.be.false;
     expect(user.flags.classSelected).to.be.false;
@@ -185,80 +184,80 @@ describe('shared.ops.rebirth', () => {
     expect(user.flags.levelDrops).to.be.empty;
   });
 
-  it('reset rebirthEnabled even if user has beastMaster', () => {
+  it('reset rebirthEnabled even if user has beastMaster', async () => {
     user.achievements.beastMaster = 1;
     user.flags.rebirthEnabled = true;
 
-    rebirth(user);
+    await rebirth(user);
 
     expect(user.flags.rebirthEnabled).to.be.false;
   });
 
-  it('sets rebirth achievement', () => {
-    rebirth(user);
+  it('sets rebirth achievement', async () => {
+    await rebirth(user);
 
     expect(user.achievements.rebirths).to.equal(1);
     expect(user.achievements.rebirthLevel).to.equal(user.stats.lvl);
   });
 
-  it('increments rebirth achievements', () => {
+  it('increments rebirth achievements', async () => {
     user.stats.lvl = 2;
     user.achievements.rebirths = 1;
     user.achievements.rebirthLevel = 1;
 
-    rebirth(user);
+    await rebirth(user);
 
     expect(user.achievements.rebirths).to.equal(2);
     expect(user.achievements.rebirthLevel).to.equal(2);
   });
 
-  it('does not increment rebirth achievements when level is lower than previous', () => {
+  it('does not increment rebirth achievements when level is lower than previous', async () => {
     user.stats.lvl = 2;
     user.achievements.rebirths = 1;
     user.achievements.rebirthLevel = 3;
 
-    rebirth(user);
+    await rebirth(user);
 
     expect(user.achievements.rebirths).to.equal(1);
     expect(user.achievements.rebirthLevel).to.equal(3);
   });
 
-  it('always increments rebirth achievements when level is MAX_LEVEL', () => {
+  it('always increments rebirth achievements when level is MAX_LEVEL', async () => {
     user.stats.lvl = MAX_LEVEL;
     user.achievements.rebirths = 1;
     // this value is not actually possible (actually capped at MAX_LEVEL) but makes a good test
     user.achievements.rebirthLevel = MAX_LEVEL + 1;
 
-    rebirth(user);
+    await rebirth(user);
 
     expect(user.achievements.rebirths).to.equal(2);
     expect(user.achievements.rebirthLevel).to.equal(MAX_LEVEL);
   });
 
-  it('always increments rebirth achievements when level is greater than MAX_LEVEL', () => {
+  it('always increments rebirth achievements when level is greater than MAX_LEVEL', async () => {
     user.stats.lvl = MAX_LEVEL + 1;
     user.achievements.rebirths = 1;
     // this value is not actually possible (actually capped at MAX_LEVEL) but makes a good test
     user.achievements.rebirthLevel = MAX_LEVEL + 2;
 
-    rebirth(user);
+    await rebirth(user);
 
     expect(user.achievements.rebirths).to.equal(2);
     expect(user.achievements.rebirthLevel).to.equal(MAX_LEVEL);
   });
 
-  it('keeps automaticAllocation false', () => {
+  it('keeps automaticAllocation false', async () => {
     user.preferences.automaticAllocation = false;
 
-    rebirth(user);
+    await rebirth(user);
 
     expect(user.preferences.automaticAllocation).to.be.false;
   });
 
-  it('sets automaticAllocation to false when true', () => {
+  it('sets automaticAllocation to false when true', async () => {
     user.preferences.automaticAllocation = true;
 
-    rebirth(user);
+    await rebirth(user);
 
     expect(user.preferences.automaticAllocation).to.be.false;
   });

test/common/ops/releaseMounts.js

@@ -23,87 +23,85 @@ describe('shared.ops.releaseMounts', () => {
     user.balance = 1;
   });
 
-  it('returns an error when user balance is too low', done => {
+  it('returns an error when user balance is too low', async () => {
     user.balance = 0;
 
     try {
-      releaseMounts(user);
+      await releaseMounts(user);
     } catch (err) {
       expect(err).to.be.an.instanceof(NotAuthorized);
       expect(err.message).to.equal(i18n.t('notEnoughGems'));
-      done();
     }
   });
 
-  it('returns an error when user does not have all pets', done => {
+  it('returns an error when user does not have all pets', async () => {
     const mountsKeys = Object.keys(user.items.mounts);
     delete user.items.mounts[mountsKeys[0]];
 
     try {
-      releaseMounts(user);
+      await releaseMounts(user);
     } catch (err) {
       expect(err).to.be.an.instanceof(NotAuthorized);
       expect(err.message).to.equal(i18n.t('notEnoughMounts'));
-      done();
     }
   });
 
-  it('releases mounts', () => {
-    const message = releaseMounts(user)[1];
+  it('releases mounts', async () => {
+    const result = await releaseMounts(user);
 
-    expect(message).to.equal(i18n.t('mountsReleased'));
+    expect(result[1]).to.equal(i18n.t('mountsReleased'));
     expect(user.items.mounts[animal]).to.equal(null);
   });
 
-  it('removes drop currentMount', () => {
+  it('removes drop currentMount', async () => {
     const mountInfo = content.mountInfo[user.items.currentMount];
     expect(mountInfo.type).to.equal('drop');
-    releaseMounts(user);
+    await releaseMounts(user);
 
     expect(user.items.currentMount).to.be.empty;
   });
 
-  it('leaves non-drop mount equipped', () => {
+  it('leaves non-drop mount equipped', async () => {
     const questAnimal = 'Gryphon-Base';
     user.items.currentMount = questAnimal;
     user.items.mounts[questAnimal] = true;
 
     const mountInfo = content.mountInfo[user.items.currentMount];
     expect(mountInfo.type).to.not.equal('drop');
-    releaseMounts(user);
+    await releaseMounts(user);
 
     expect(user.items.currentMount).to.equal(questAnimal);
   });
 
-  it('increases mountMasterCount achievement', () => {
-    releaseMounts(user);
+  it('increases mountMasterCount achievement', async () => {
+    await releaseMounts(user);
     expect(user.achievements.mountMasterCount).to.equal(1);
   });
 
-  it('does not increase mountMasterCount achievement if mount is missing (null)', () => {
+  it('does not increase mountMasterCount achievement if mount is missing (null)', async () => {
     const mountMasterCountBeforeRelease = user.achievements.mountMasterCount;
     user.items.mounts[animal] = null;
 
     try {
-      releaseMounts(user);
+      await releaseMounts(user);
     } catch (e) {
       expect(user.achievements.mountMasterCount).to.equal(mountMasterCountBeforeRelease);
     }
   });
 
-  it('does not increase mountMasterCount achievement if mount is missing (undefined)', () => {
+  it('does not increase mountMasterCount achievement if mount is missing (undefined)', async () => {
     const mountMasterCountBeforeRelease = user.achievements.mountMasterCount;
     delete user.items.mounts[animal];
 
     try {
-      releaseMounts(user);
+      await releaseMounts(user);
     } catch (e) {
       expect(user.achievements.mountMasterCount).to.equal(mountMasterCountBeforeRelease);
     }
   });
 
-  it('subtracts gems from balance', () => {
-    releaseMounts(user);
+  it('subtracts gems from balance', async () => {
+    await releaseMounts(user);
 
     expect(user.balance).to.equal(0);
   });

test/common/ops/releasePets.js

@@ -23,98 +23,96 @@ describe('shared.ops.releasePets', () => {
     user.balance = 1;
   });
 
-  it('returns an error when user balance is too low', done => {
+  it('returns an error when user balance is too low', async () => {
     user.balance = 0;
 
     try {
-      releasePets(user);
+      await releasePets(user);
     } catch (err) {
       expect(err).to.be.an.instanceof(NotAuthorized);
       expect(err.message).to.equal(i18n.t('notEnoughGems'));
-      done();
     }
   });
 
-  it('returns an error when user does not have all pets', done => {
+  it('returns an error when user does not have all pets', async () => {
     const petKeys = Object.keys(user.items.pets);
     delete user.items.pets[petKeys[0]];
 
     try {
-      releasePets(user);
+      await releasePets(user);
     } catch (err) {
       expect(err).to.be.an.instanceof(NotAuthorized);
       expect(err.message).to.equal(i18n.t('notEnoughPets'));
-      done();
     }
   });
 
-  it('releases pets', () => {
-    const message = releasePets(user)[1];
+  it('releases pets', async () => {
+    const message = await releasePets(user)[1];
 
     expect(message).to.equal(i18n.t('petsReleased'));
     expect(user.items.pets[animal]).to.equal(0);
   });
 
-  it('removes drop currentPet', () => {
+  it('removes drop currentPet', async () => {
     const petInfo = content.petInfo[user.items.currentPet];
     expect(petInfo.type).to.equal('drop');
-    releasePets(user);
+    await releasePets(user);
 
     expect(user.items.currentPet).to.be.empty;
   });
 
-  it('leaves non-drop pets equipped', () => {
+  it('leaves non-drop pets equipped', async () => {
     const questAnimal = 'Gryphon-Base';
     user.items.currentPet = questAnimal;
     user.items.pets[questAnimal] = 5;
 
     const petInfo = content.petInfo[user.items.currentPet];
     expect(petInfo.type).to.not.equal('drop');
-    releasePets(user);
+    await releasePets(user);
 
     expect(user.items.currentPet).to.equal(questAnimal);
   });
 
-  it('decreases user\'s balance', () => {
-    releasePets(user);
+  it('decreases user\'s balance', async () => {
+    await releasePets(user);
 
     expect(user.balance).to.equal(0);
   });
 
-  it('incremenets beastMasterCount', () => {
-    releasePets(user);
+  it('incremenets beastMasterCount', async () => {
+    await releasePets(user);
 
     expect(user.achievements.beastMasterCount).to.equal(1);
   });
 
-  it('does not increment beastMasterCount if any pet is level 0 (released)', () => {
+  it('does not increment beastMasterCount if any pet is level 0 (released)', async () => {
     const beastMasterCountBeforeRelease = user.achievements.beastMasterCount;
     user.items.pets[animal] = 0;
 
     try {
-      releasePets(user);
+      await releasePets(user);
     } catch (e) {
       expect(user.achievements.beastMasterCount).to.equal(beastMasterCountBeforeRelease);
     }
   });
 
-  it('does not increment beastMasterCount if any pet is missing (null)', () => {
+  it('does not increment beastMasterCount if any pet is missing (null)', async () => {
     const beastMasterCountBeforeRelease = user.achievements.beastMasterCount;
     user.items.pets[animal] = null;
 
     try {
-      releasePets(user);
+      await releasePets(user);
     } catch (e) {
       expect(user.achievements.beastMasterCount).to.equal(beastMasterCountBeforeRelease);
     }
   });
 
-  it('does not increment beastMasterCount if any pet is missing (undefined)', () => {
+  it('does not increment beastMasterCount if any pet is missing (undefined)', async () => {
     const beastMasterCountBeforeRelease = user.achievements.beastMasterCount;
     delete user.items.pets[animal];
 
     try {
-      releasePets(user);
+      await releasePets(user);
     } catch (e) {
       expect(user.achievements.beastMasterCount).to.equal(beastMasterCountBeforeRelease);
     }

test/common/ops/reroll.js

@@ -19,43 +19,42 @@ describe('shared.ops.reroll', () => {
     tasks = [generateDaily(), generateReward()];
   });
 
-  it('returns an error when user balance is too low', done => {
+  it('returns an error when user balance is too low', async () => {
     user.balance = 0;
 
     try {
-      reroll(user);
+      await reroll(user);
     } catch (err) {
       expect(err).to.be.an.instanceof(NotAuthorized);
       expect(err.message).to.equal(i18n.t('notEnoughGems'));
-      done();
     }
   });
 
-  it('rerolls a user with enough gems', () => {
-    const [, message] = reroll(user);
+  it('rerolls a user with enough gems', async () => {
+    const [, message] = await reroll(user);
 
     expect(message).to.equal(i18n.t('fortifyComplete'));
   });
 
-  it('reduces a user\'s balance', () => {
-    reroll(user);
+  it('reduces a user\'s balance', async () => {
+    await reroll(user);
 
     expect(user.balance).to.equal(0);
   });
 
-  it('resets a user\'s health points', () => {
+  it('resets a user\'s health points', async () => {
     user.stats.hp = 40;
 
-    reroll(user);
+    await reroll(user);
 
     expect(user.stats.hp).to.equal(50);
   });
 
-  it('resets user\'s taks values except for rewards to 0', () => {
+  it('resets user\'s taks values except for rewards to 0', async () => {
     tasks[0].value = 1;
     tasks[1].value = 1;
 
-    reroll(user, tasks);
+    await reroll(user, tasks);
 
     expect(tasks[0].value).to.equal(0);
     expect(tasks[1].value).to.equal(1);

test/common/ops/unlock.js

@@ -19,184 +19,173 @@ describe('shared.ops.unlock', () => {
     user.balance = usersStartingGems;
   });
 
-  it('returns an error when path is not provided', done => {
+  it('returns an error when path is not provided', async () => {
     try {
-      unlock(user);
+      await unlock(user);
     } catch (err) {
       expect(err).to.be.an.instanceof(BadRequest);
       expect(err.message).to.equal(i18n.t('pathRequired'));
-      done();
     }
   });
 
-  it('does not unlock lost gear', done => {
+  it('does not unlock lost gear', async () => {
     user.items.gear.owned.headAccessory_special_bearEars = false;
 
-    unlock(user, { query: { path: 'items.gear.owned.headAccessory_special_bearEars' } });
+    await unlock(user, { query: { path: 'items.gear.owned.headAccessory_special_bearEars' } });
 
     expect(user.balance).to.equal(usersStartingGems);
-    done();
   });
 
-  it('returns an error when user balance is too low', done => {
+  it('returns an error when user balance is too low', async () => {
     user.balance = 0;
 
     try {
-      unlock(user, { query: { path: unlockPath } });
+      await unlock(user, { query: { path: unlockPath } });
     } catch (err) {
       expect(err).to.be.an.instanceof(NotAuthorized);
       expect(err.message).to.equal(i18n.t('notEnoughGems'));
-      done();
     }
   });
 
-  it('returns an error when user already owns a full set', done => {
+  it('returns an error when user already owns a full set', async () => {
     let expectedBalance;
 
     try {
-      unlock(user, { query: { path: unlockPath } });
+      await unlock(user, { query: { path: unlockPath } });
       expectedBalance = user.balance;
-      unlock(user, { query: { path: unlockPath } });
+      await unlock(user, { query: { path: unlockPath } });
     } catch (err) {
       expect(err).to.be.an.instanceof(NotAuthorized);
       expect(err.message).to.equal(i18n.t('alreadyUnlocked'));
       expect(user.balance).to.equal(expectedBalance);
-      done();
     }
   });
 
-  it('returns an error when user already owns a full set of gear', done => {
+  it('returns an error when user already owns a full set of gear', async () => {
     let expectedBalance;
 
     try {
-      unlock(user, { query: { path: unlockGearSetPath } });
+      await unlock(user, { query: { path: unlockGearSetPath } });
       expectedBalance = user.balance;
-      unlock(user, { query: { path: unlockGearSetPath } });
+      await unlock(user, { query: { path: unlockGearSetPath } });
     } catch (err) {
       expect(err).to.be.an.instanceof(NotAuthorized);
       expect(err.message).to.equal(i18n.t('alreadyUnlocked'));
       expect(user.balance).to.equal(expectedBalance);
-      done();
     }
   });
 
-  it('returns an error if an item does not exists', done => {
+  it('returns an error if an item does not exists', async () => {
     try {
-      unlock(user, { query: { path: 'background.invalid_background' } });
+      await unlock(user, { query: { path: 'background.invalid_background' } });
     } catch (err) {
       expect(err).to.be.an.instanceof(BadRequest);
       expect(err.message).to.equal(i18n.t('invalidUnlockSet'));
-      done();
     }
   });
 
-  it('returns an error if there are items from multiple sets', done => {
+  it('returns an error if there are items from multiple sets', async () => {
     try {
-      unlock(user, { query: { path: 'shirt.convict,skin.0ff591' } });
+      await unlock(user, { query: { path: 'shirt.convict,skin.0ff591' } });
     } catch (err) {
       expect(err).to.be.an.instanceof(BadRequest);
       expect(err.message).to.equal(i18n.t('invalidUnlockSet'));
-      done();
     }
   });
 
-  it('returns an error if gear is not from the animal set', done => {
+  it('returns an error if gear is not from the animal set', async () => {
     try {
-      unlock(user, { query: { path: 'items.gear.owned.back_mystery_202004' } });
+      await unlock(user, { query: { path: 'items.gear.owned.back_mystery_202004' } });
     } catch (err) {
       expect(err).to.be.an.instanceof(BadRequest);
       expect(err.message).to.equal(i18n.t('invalidUnlockSet'));
-      done();
     }
   });
 
-  it('returns an error if the item is free', done => {
+  it('returns an error if the item is free', async () => {
     try {
-      unlock(user, { query: { path: 'shirt.black' } });
+      await unlock(user, { query: { path: 'shirt.black' } });
     } catch (err) {
       expect(err).to.be.an.instanceof(BadRequest);
       expect(err.message).to.equal(i18n.t('invalidUnlockSet'));
-      done();
     }
   });
 
-  it('returns an error if an item does not belong to a set (appearances)', done => {
+  it('returns an error if an item does not belong to a set (appearances)', async () => {
     try {
-      unlock(user, { query: { path: 'shirt.pink' } });
+      await unlock(user, { query: { path: 'shirt.pink' } });
     } catch (err) {
       expect(err).to.be.an.instanceof(BadRequest);
       expect(err.message).to.equal(i18n.t('invalidUnlockSet'));
-      done();
     }
   });
 
-  it('returns an error when user already owns items in a full set and it would be more expensive to buy the entire set', done => {
+  it('returns an error when user already owns items in a full set and it would be more expensive to buy the entire set', async () => {
     try {
       // There are 11 shirts in the set, each cost 2 gems, the full set 5 gems
       // In order for the full purchase not to be worth, we must own 9
       const partialUnlockPaths = unlockPath.split(',');
-      unlock(user, { query: { path: partialUnlockPaths[0] } });
-      unlock(user, { query: { path: partialUnlockPaths[1] } });
-      unlock(user, { query: { path: partialUnlockPaths[2] } });
-      unlock(user, { query: { path: partialUnlockPaths[3] } });
-      unlock(user, { query: { path: partialUnlockPaths[4] } });
-      unlock(user, { query: { path: partialUnlockPaths[5] } });
-      unlock(user, { query: { path: partialUnlockPaths[6] } });
-      unlock(user, { query: { path: partialUnlockPaths[7] } });
-      unlock(user, { query: { path: partialUnlockPaths[8] } });
+      await unlock(user, { query: { path: partialUnlockPaths[0] } });
+      await unlock(user, { query: { path: partialUnlockPaths[1] } });
+      await unlock(user, { query: { path: partialUnlockPaths[2] } });
+      await unlock(user, { query: { path: partialUnlockPaths[3] } });
+      await unlock(user, { query: { path: partialUnlockPaths[4] } });
+      await unlock(user, { query: { path: partialUnlockPaths[5] } });
+      await unlock(user, { query: { path: partialUnlockPaths[6] } });
+      await unlock(user, { query: { path: partialUnlockPaths[7] } });
+      await unlock(user, { query: { path: partialUnlockPaths[8] } });
 
-      unlock(user, { query: { path: unlockPath } });
+      await unlock(user, { query: { path: unlockPath } });
     } catch (err) {
       expect(err).to.be.an.instanceof(NotAuthorized);
       expect(err.message).to.equal(i18n.t('alreadyUnlockedPart'));
-      done();
     }
   });
 
-  it('does not return an error when user already owns items in a full set and it would not be more expensive to buy the entire set', () => {
+  it('does not return an error when user already owns items in a full set and it would not be more expensive to buy the entire set', async () => {
     // There are 11 shirts in the set, each cost 2 gems, the full set 5 gems
     // In order for the full purchase to be worth, we can own already 8
     const partialUnlockPaths = unlockPath.split(',');
-    unlock(user, { query: { path: partialUnlockPaths[0] } });
-    unlock(user, { query: { path: partialUnlockPaths[1] } });
-    unlock(user, { query: { path: partialUnlockPaths[2] } });
-    unlock(user, { query: { path: partialUnlockPaths[3] } });
-    unlock(user, { query: { path: partialUnlockPaths[4] } });
-    unlock(user, { query: { path: partialUnlockPaths[5] } });
-    unlock(user, { query: { path: partialUnlockPaths[6] } });
-    unlock(user, { query: { path: partialUnlockPaths[7] } });
+    await unlock(user, { query: { path: partialUnlockPaths[0] } });
+    await unlock(user, { query: { path: partialUnlockPaths[1] } });
+    await unlock(user, { query: { path: partialUnlockPaths[2] } });
+    await unlock(user, { query: { path: partialUnlockPaths[3] } });
+    await unlock(user, { query: { path: partialUnlockPaths[4] } });
+    await unlock(user, { query: { path: partialUnlockPaths[5] } });
+    await unlock(user, { query: { path: partialUnlockPaths[6] } });
+    await unlock(user, { query: { path: partialUnlockPaths[7] } });
 
-    unlock(user, { query: { path: unlockPath } });
+    await unlock(user, { query: { path: unlockPath } });
   });
 
-  it('equips an item already owned', () => {
+  it('equips an item already owned', async () => {
     expect(user.purchased.background.giant_florals).to.not.exist;
 
-    unlock(user, { query: { path: backgroundUnlockPath } });
+    await unlock(user, { query: { path: backgroundUnlockPath } });
     const afterBalance = user.balance;
-    const response = unlock(user, { query: { path: backgroundUnlockPath } });
+    const response = await unlock(user, { query: { path: backgroundUnlockPath } });
     expect(user.balance).to.equal(afterBalance); // do not bill twice
 
     expect(response.message).to.not.exist;
     expect(user.preferences.background).to.equal('giant_florals');
   });
 
-  it('un-equips a background already equipped', () => {
+  it('un-equips a background already equipped', async () => {
     expect(user.purchased.background.giant_florals).to.not.exist;
 
-    unlock(user, { query: { path: backgroundUnlockPath } }); // unlock
+    await unlock(user, { query: { path: backgroundUnlockPath } }); // unlock
     const afterBalance = user.balance;
-    unlock(user, { query: { path: backgroundUnlockPath } }); // equip
-    const response = unlock(user, { query: { path: backgroundUnlockPath } });
+    await unlock(user, { query: { path: backgroundUnlockPath } }); // equip
+    const response = await unlock(user, { query: { path: backgroundUnlockPath } });
     expect(user.balance).to.equal(afterBalance); // do not bill twice
 
     expect(response.message).to.not.exist;
     expect(user.preferences.background).to.equal('');
   });
 
-  it('unlocks a full set of appearance items', () => {
+  it('unlocks a full set of appearance items', async () => {
     const initialShirts = Object.keys(user.purchased.shirt).length;
-    const [, message] = unlock(user, { query: { path: unlockPath } });
+    const [, message] = await unlock(user, { query: { path: unlockPath } });
 
     expect(message).to.equal(i18n.t('unlocked'));
     const individualPaths = unlockPath.split(',');
@@ -208,11 +197,11 @@ describe('shared.ops.unlock', () => {
     expect(user.balance).to.equal(usersStartingGems - 1.25);
   });
 
-  it('unlocks a full set of hair items', () => {
+  it('unlocks a full set of hair items', async () => {
     user.purchased.hair.color = {};
 
     const initialHairColors = Object.keys(user.purchased.hair.color).length;
-    const [, message] = unlock(user, { query: { path: hairUnlockPath } });
+    const [, message] = await unlock(user, { query: { path: hairUnlockPath } });
 
     expect(message).to.equal(i18n.t('unlocked'));
     const individualPaths = hairUnlockPath.split(',');
@@ -224,13 +213,13 @@ describe('shared.ops.unlock', () => {
     expect(user.balance).to.equal(usersStartingGems - 1.25);
   });
 
-  it('unlocks the facial hair set', () => {
+  it('unlocks the facial hair set', async () => {
     user.purchased.hair.mustache = {};
     user.purchased.hair.beard = {};
 
     const initialMustache = Object.keys(user.purchased.hair.mustache).length;
     const initialBeard = Object.keys(user.purchased.hair.mustache).length;
-    const [, message] = unlock(user, { query: { path: facialHairUnlockPath } });
+    const [, message] = await unlock(user, { query: { path: facialHairUnlockPath } });
 
     expect(message).to.equal(i18n.t('unlocked'));
     const individualPaths = facialHairUnlockPath.split(',');
@@ -242,9 +231,9 @@ describe('shared.ops.unlock', () => {
     expect(user.balance).to.equal(usersStartingGems - 1.25);
   });
 
-  it('unlocks a full set of gear', () => {
+  it('unlocks a full set of gear', async () => {
     const initialGear = Object.keys(user.items.gear.owned).length;
-    const [, message] = unlock(user, { query: { path: unlockGearSetPath } });
+    const [, message] = await unlock(user, { query: { path: unlockGearSetPath } });
 
     expect(message).to.equal(i18n.t('unlocked'));
 
@@ -257,9 +246,9 @@ describe('shared.ops.unlock', () => {
     expect(user.balance).to.equal(usersStartingGems - 1.25);
   });
 
-  it('unlocks a full set of backgrounds', () => {
+  it('unlocks a full set of backgrounds', async () => {
     const initialBackgrounds = Object.keys(user.purchased.background).length;
-    const [, message] = unlock(user, { query: { path: backgroundSetUnlockPath } });
+    const [, message] = await unlock(user, { query: { path: backgroundSetUnlockPath } });
 
     expect(message).to.equal(i18n.t('unlocked'));
     const individualPaths = backgroundSetUnlockPath.split(',');
@@ -271,10 +260,10 @@ describe('shared.ops.unlock', () => {
     expect(user.balance).to.equal(usersStartingGems - 3.75);
   });
 
-  it('unlocks an item (appearance)', () => {
+  it('unlocks an item (appearance)', async () => {
     const path = unlockPath.split(',')[0];
     const initialShirts = Object.keys(user.purchased.shirt).length;
-    const [, message] = unlock(user, { query: { path } });
+    const [, message] = await unlock(user, { query: { path } });
 
     expect(message).to.equal(i18n.t('unlocked'));
     expect(Object.keys(user.purchased.shirt).length).to.equal(initialShirts + 1);
@@ -282,12 +271,12 @@ describe('shared.ops.unlock', () => {
     expect(user.balance).to.equal(usersStartingGems - 0.5);
   });
 
-  it('unlocks an item (hair color)', () => {
+  it('unlocks an item (hair color)', async () => {
     user.purchased.hair.color = {};
 
     const path = hairUnlockPath.split(',')[0];
     const initialColorHair = Object.keys(user.purchased.hair.color).length;
-    const [, message] = unlock(user, { query: { path } });
+    const [, message] = await unlock(user, { query: { path } });
 
     expect(message).to.equal(i18n.t('unlocked'));
     expect(Object.keys(user.purchased.hair.color).length).to.equal(initialColorHair + 1);
@@ -295,14 +284,14 @@ describe('shared.ops.unlock', () => {
     expect(user.balance).to.equal(usersStartingGems - 0.5);
   });
 
-  it('unlocks an item (facial hair)', () => {
+  it('unlocks an item (facial hair)', async () => {
     user.purchased.hair.mustache = {};
     user.purchased.hair.beard = {};
 
     const path = facialHairUnlockPath.split(',')[0];
     const initialMustache = Object.keys(user.purchased.hair.mustache).length;
     const initialBeard = Object.keys(user.purchased.hair.beard).length;
-    const [, message] = unlock(user, { query: { path } });
+    const [, message] = await unlock(user, { query: { path } });
 
     expect(message).to.equal(i18n.t('unlocked'));
 
@@ -313,10 +302,10 @@ describe('shared.ops.unlock', () => {
     expect(user.balance).to.equal(usersStartingGems - 0.5);
   });
 
-  it('unlocks an item (gear)', () => {
+  it('unlocks an item (gear)', async () => {
     const path = unlockGearSetPath.split(',')[0];
     const initialGear = Object.keys(user.items.gear.owned).length;
-    const [, message] = unlock(user, { query: { path } });
+    const [, message] = await unlock(user, { query: { path } });
 
     expect(message).to.equal(i18n.t('unlocked'));
     expect(Object.keys(user.items.gear.owned).length).to.equal(initialGear + 1);
@@ -324,9 +313,9 @@ describe('shared.ops.unlock', () => {
     expect(user.balance).to.equal(usersStartingGems - 0.5);
   });
 
-  it('unlocks an item (background)', () => {
+  it('unlocks an item (background)', async () => {
     const initialBackgrounds = Object.keys(user.purchased.background).length;
-    const [, message] = unlock(user, { query: { path: backgroundUnlockPath } });
+    const [, message] = await unlock(user, { query: { path: backgroundUnlockPath } });
 
     expect(message).to.equal(i18n.t('unlocked'));
     expect(Object.keys(user.purchased.background).length).to.equal(initialBackgrounds + 1);

website/client/.eslintrc.js

@@ -13,6 +13,7 @@ module.exports = {
     'no-debugger': process.env.NODE_ENV === 'production' ? 'error' : 'off',
     // TODO find a way to let eslint understand webpack aliases
     'import/no-unresolved': 'off',
+    'import/extensions': 'off',
     'vue/no-v-html': 'off',
     'vue/html-self-closing': ['error', {
       html: {

website/client/config/storybook/README.md

@@ -0,0 +1,8 @@
+# Storybook Updates
+
+Addon-Knobs has been deprecated inorder to update to the new `addons-controls` we need to:
+
+1. Change to the new export syntax for each story `export const StoryTemplate`
+2. And use `StoryTemplate.args` and `StoryTemplate.argTypes` to have the same `knobs` as before
+
+Maybe this can be made story by story and not all at once

website/client/config/storybook/config.js

@@ -2,53 +2,64 @@
 import { configure } from '@storybook/vue';
 import './margin.css';
 import '../../src/assets/scss/index.scss';
-import '../../src/assets/css/sprites.css';
 
-import '../../src/assets/css/sprites/spritesmith-main-0.css';
-import '../../src/assets/css/sprites/spritesmith-main-1.css';
-import '../../src/assets/css/sprites/spritesmith-main-2.css';
-import '../../src/assets/css/sprites/spritesmith-main-3.css';
-import '../../src/assets/css/sprites/spritesmith-main-4.css';
-import '../../src/assets/css/sprites/spritesmith-main-5.css';
-import '../../src/assets/css/sprites/spritesmith-main-6.css';
-import '../../src/assets/css/sprites/spritesmith-main-7.css';
-import '../../src/assets/css/sprites/spritesmith-main-8.css';
-import '../../src/assets/css/sprites/spritesmith-main-9.css';
-import '../../src/assets/css/sprites/spritesmith-main-10.css';
-import '../../src/assets/css/sprites/spritesmith-main-11.css';
-import '../../src/assets/css/sprites/spritesmith-main-12.css';
-import '../../src/assets/css/sprites/spritesmith-main-13.css';
-import '../../src/assets/css/sprites/spritesmith-main-14.css';
-import '../../src/assets/css/sprites/spritesmith-main-15.css';
-import '../../src/assets/css/sprites/spritesmith-main-16.css';
-import '../../src/assets/css/sprites/spritesmith-main-17.css';
-import '../../src/assets/css/sprites/spritesmith-main-18.css';
-import '../../src/assets/css/sprites/spritesmith-main-19.css';
-import '../../src/assets/css/sprites/spritesmith-main-20.css';
-import '../../src/assets/css/sprites/spritesmith-main-21.css';
-import '../../src/assets/css/sprites/spritesmith-main-22.css';
-import '../../src/assets/css/sprites/spritesmith-main-23.css';
-import '../../src/assets/css/sprites/spritesmith-main-24.css';
-import '../../src/assets/css/sprites/spritesmith-main-25.css';
-import '../../src/assets/css/sprites/spritesmith-main-26.css';
+import '../../src/assets/scss/sprites.scss';
+
 import Vue from 'vue';
 import BootstrapVue from 'bootstrap-vue';
 import StoreModule from '@/libs/store';
+import getStore from '@/store';
+import '../../src/filters/registerGlobals';
+
+import i18n from '../../../common/script/i18n';
 
 // couldn't inject the languages easily,
 // so just a "$t()" string to show that this will be translated
-Vue.prototype.$t = function translateString (...args) {
+i18n.t = function translateString (...args) {
   return `$t(${JSON.stringify(args)})`;
 };
+Vue.prototype.$t = i18n.t;
 
 Vue.use(BootstrapVue);
 Vue.use(StoreModule);
 
+const store = getStore();
+store.state.user.data = {
+  stats: {},
+  tags: [],
+  items: {
+    quests: {
+      moon1: 3,
+    },
+  },
+  party: {
+    quest: {
+
+    },
+  },
+  preferences: {
+
+  },
+  auth: {
+    local: {
+      // email: 'example@example.com',
+    },
+    facebook: {
+      emails: [
+        {
+          value: 'test@test.de',
+        },
+      ],
+    },
+  },
+};
+
+Vue.prototype.$store = store;
+
 const req = require.context('../../src', true, /.stories.js$/);
 
 function loadStories () {
   req.keys().forEach(filename => req(filename));
 }
 
-
 configure(loadStories, module);

website/client/config/storybook/margin.css

@@ -3,11 +3,12 @@
     display: inline-block;
 }
 
-.content {
-    color: white;
-    background: grey;
-}
-
 .inline-block {
     display: inline-block;
 }
+
+.component-showcase {
+    position: absolute;
+    margin: 20px;
+    width: calc(100% - 40px);
+}

website/client/config/storybook/mock.data.js

@@ -1,3 +1,6 @@
+import { v4 as generateUUID } from 'uuid';
+import getters from '@/store/getters';
+
 export const userStyles = {
   contributor: {
     admin: true,
@@ -72,4 +75,33 @@ export const userStyles = {
     maxHealth: 50,
     maxMP: 158,
   },
+  profile: {
+    name: 'user',
+  },
+  _id: generateUUID(),
+  flags: {
+    classSelected: true,
+  },
 };
+
+
+export function mockStore ({
+  userData,
+  ...state
+}) {
+  return {
+    getters,
+    dispatch: () => {
+    },
+    watch: () => {
+    },
+    state: {
+      user: {
+        data: {
+          ...userData,
+        },
+      },
+      ...state,
+    },
+  };
+}

website/client/package.json

@@ -13,56 +13,57 @@
     "storybook:serve": "vue-cli-service storybook:serve -p 6006 -c config/storybook"
   },
   "dependencies": {
-    "@storybook/addon-actions": "^6.2.9",
-    "@storybook/addon-knobs": "^6.2.9",
-    "@storybook/addon-links": "^6.2.9",
-    "@storybook/addon-notes": "^5.3.21",
-    "@storybook/vue": "^6.2.9",
-    "@vue/cli-plugin-babel": "^4.5.12",
-    "@vue/cli-plugin-eslint": "^4.5.12",
-    "@vue/cli-plugin-router": "^4.5.12",
-    "@vue/cli-plugin-unit-mocha": "^4.5.12",
-    "@vue/cli-service": "^4.5.12",
+    "@storybook/addon-actions": "6.4.19",
+    "@storybook/addon-knobs": "6.2.9",
+    "@storybook/addon-links": "6.4.18",
+    "@storybook/addon-notes": "5.3.21",
+    "@storybook/addons": "6.4.19",
+    "@storybook/vue": "6.3.13",
+    "@vue/cli-plugin-babel": "^4.5.15",
+    "@vue/cli-plugin-eslint": "^4.5.15",
+    "@vue/cli-plugin-router": "^4.5.15",
+    "@vue/cli-plugin-unit-mocha": "^4.5.15",
+    "@vue/cli-service": "^4.5.15",
     "@vue/test-utils": "1.0.0-beta.29",
-    "amplitude-js": "^8.2.1",
-    "axios": "^0.21.1",
+    "amplitude-js": "^8.17.0",
+    "axios": "^0.25.0",
     "axios-progress-bar": "^1.2.0",
     "babel-eslint": "^10.1.0",
     "bootstrap": "^4.6.0",
     "bootstrap-vue": "^2.21.2",
-    "chai": "^4.3.4",
-    "core-js": "^3.11.1",
+    "chai": "^4.3.6",
+    "core-js": "^3.21.0",
     "eslint": "^6.8.0",
     "eslint-config-habitrpg": "^6.2.0",
     "eslint-plugin-mocha": "^5.3.0",
     "eslint-plugin-vue": "^6.2.2",
     "habitica-markdown": "^3.0.0",
-    "hellojs": "^1.19.3",
+    "hellojs": "^1.19.5",
     "inspectpack": "^4.7.1",
-    "intro.js": "^3.4.0",
+    "intro.js": "^5.0.0",
     "jquery": "^3.6.0",
     "lodash": "^4.17.21",
     "moment": "^2.29.1",
-    "nconf": "^0.11.2",
-    "sass": "^1.32.12",
+    "nconf": "^0.11.3",
+    "sass": "^1.34.0",
     "sass-loader": "^8.0.2",
-    "smartbanner.js": "^1.16.0",
+    "smartbanner.js": "^1.17.0",
     "svg-inline-loader": "^0.8.2",
     "svg-url-loader": "^7.1.1",
     "svgo": "^1.3.2",
     "svgo-loader": "^2.2.1",
     "uuid": "^8.3.2",
-    "validator": "^13.6.0",
-    "vue": "^2.6.12",
-    "vue-cli-plugin-storybook": "^2.0.0",
+    "validator": "^13.7.0",
+    "vue": "^2.6.14",
+    "vue-cli-plugin-storybook": "2.1.0",
     "vue-mugen-scroll": "^0.2.6",
-    "vue-router": "^3.5.1",
-    "vue-template-compiler": "^2.6.12",
+    "vue-router": "^3.5.3",
+    "vue-template-compiler": "^2.6.14",
     "vuedraggable": "^2.24.3",
     "vuejs-datepicker": "git://github.com/habitrpg/vuejs-datepicker.git#153d339e4dbebb73733658aeda1d5b7fcc55b0a0",
     "webpack": "^4.46.0"
   },
   "devDependencies": {
-    "@babel/plugin-proposal-optional-chaining": "^7.13.12"
+    "@babel/plugin-proposal-optional-chaining": "^7.16.7"
   }
 }

website/client/src/app.vue

@@ -33,12 +33,14 @@
       <payments-success-modal />
       <sub-cancel-modal-confirm v-if="isUserLoaded" />
       <sub-canceled-modal v-if="isUserLoaded" />
+      <bug-report-modal v-if="isUserLoaded" />
+      <bug-report-success-modal v-if="isUserLoaded" />
       <snackbars />
       <router-view v-if="!isUserLoggedIn || isStaticPage" />
       <template v-else>
         <template v-if="isUserLoaded">
           <damage-paused-banner />
-          <!-- <gems-promo-banner /> -->
+          <gems-promo-banner />
           <gift-promo-banner />
           <notifications-display />
           <app-menu />
@@ -154,7 +156,7 @@ import { loadProgressBar } from 'axios-progress-bar';
 import AppMenu from './components/header/menu';
 import AppHeader from './components/header/index';
 import DamagePausedBanner from './components/header/banners/damagePaused';
-// import GemsPromoBanner from './components/header/banners/gemsPromo';
+import GemsPromoBanner from './components/header/banners/gemsPromo';
 import GiftPromoBanner from './components/header/banners/giftPromo';
 import AppFooter from './components/appFooter';
 import notificationsDisplay from './components/notifications';
@@ -177,6 +179,10 @@ import {
   removeLocalSetting,
 } from '@/libs/userlocalManager';
 
+const bugReportModal = () => import(/* webpackChunkName: "bug-report-modal" */'@/components/bugReportModal');
+const bugReportSuccessModal = () => import(/* webpackChunkName: "bug-report-success-modal" */'@/components/bugReportSuccessModal');
+
+
 const COMMUNITY_MANAGER_EMAIL = process.env.EMAILS_COMMUNITY_MANAGER_EMAIL; // eslint-disable-line
 
 export default {
@@ -186,7 +192,7 @@ export default {
     AppHeader,
     AppFooter,
     DamagePausedBanner,
-    // GemsPromoBanner,
+    GemsPromoBanner,
     GiftPromoBanner,
     notificationsDisplay,
     snackbars,
@@ -196,6 +202,8 @@ export default {
     paymentsSuccessModal,
     subCancelModalConfirm,
     subCanceledModal,
+    bugReportModal,
+    bugReportSuccessModal,
   },
   mixins: [notifications, spellsMixin],
   data () {
@@ -261,6 +269,12 @@ export default {
       this.$root.$emit('bv::show::modal', 'buy-modal');
     });
 
+    this.$root.$on('bv::modal::hidden', event => {
+      if (event.componentId === 'buy-modal') {
+        this.$root.$emit('buyModal::hidden', this.selectedItemToBuy.key);
+      }
+    });
+
     this.$root.$on('selectMembersModal::showItem', item => {
       this.selectedSpellToBuy = item;
       this.$root.$emit('bv::show::modal', 'select-member-modal');
@@ -400,7 +414,10 @@ export default {
         this.$store.state.isUserLoaded = true;
         Analytics.setUser();
         Analytics.updateUser();
-
+        return axios.get('/api/v4/i18n/browser-script', { language: this.user.preferences.language });
+      }).then(() => {
+        const i18nData = window && window['habitica-i18n'];
+        this.$loadLocale(i18nData);
         this.hideLoadingScreen();
 
         // Adjust the timezone offset
@@ -513,37 +530,5 @@ export default {
 <style src="intro.js/minified/introjs.min.css"></style>
 <style src="axios-progress-bar/dist/nprogress.css"></style>
 <style src="@/assets/scss/index.scss" lang="scss"></style>
-<style src="@/assets/css/sprites/spritesmith-largeSprites-0.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-0.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-1.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-2.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-3.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-4.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-5.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-6.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-7.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-8.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-9.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-10.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-11.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-12.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-13.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-14.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-15.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-16.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-17.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-18.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-19.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-20.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-21.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-22.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-23.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-24.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-25.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-26.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-27.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-28.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-29.css"></style>
-<style src="@/assets/css/sprites/spritesmith-main-30.css"></style>
-<style src="@/assets/css/sprites.css"></style>
+<style src="@/assets/scss/sprites.scss" lang="scss"></style>
 <style src="smartbanner.js/dist/smartbanner.min.css"></style>

website/client/src/assets/css/sprites.css

@@ -1,30 +1,46 @@
 .quest_lostMasterclasser4 {
-  background: url("~@/assets/images/animated/quest_lostMasterclasser4.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/quest_lostMasterclasser4.gif") no-repeat;
   width: 219px;
   height: 219px;
 }
 
 .quest_windup {
-  background: url("~@/assets/images/animated/quest_windup.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/quest_windup.gif") no-repeat;
   width: 219px;
   height: 219px;
 }
 
-.Pet_HatchingPotion_Dessert, .Pet_HatchingPotion_Veggie, .Pet_HatchingPotion_Windup {
+.quest_solarSystem {
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/quest_solarSystem.gif") no-repeat;
+  width: 219px;
+  height: 219px;
+}
+
+.quest_virtualpet {
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/quest_virtualpet.gif") no-repeat;
+  width: 219px;
+  height: 219px;
+}
+
+.Pet_HatchingPotion_Dessert, .Pet_HatchingPotion_Veggie, .Pet_HatchingPotion_Windup, .Pet_HatchingPotion_VirtualPet {
   width: 68px;
   height: 68px;
 }
 
 .Pet_HatchingPotion_Dessert {
-  background: url("~@/assets/images/animated/Pet_HatchingPotion_Dessert.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/Pet_HatchingPotion_Dessert.gif") no-repeat;
 }
 
 .Pet_HatchingPotion_Veggie {
-  background: url("~@/assets/images/animated/Pet_HatchingPotion_Veggie.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/Pet_HatchingPotion_Veggie.gif") no-repeat;
 }
 
 .Pet_HatchingPotion_Windup {
-  background: url("~@/assets/images/animated/Pet_HatchingPotion_Windup.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/Pet_HatchingPotion_Windup.gif") no-repeat;
+}
+
+.Pet_HatchingPotion_VirtualPet {
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/Pet_HatchingPotion_VirtualPet.gif") no-repeat;
 }
 
 .Gems {
@@ -62,7 +78,7 @@
 
 /* Critical */
 .weapon_special_critical {
-  background: url("~@/assets/images/animated/weapon_special_critical.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/weapon_special_critical.gif") no-repeat;
   width: 90px;
   height: 90px;
   margin-left:-12px;
@@ -79,32 +95,32 @@
 }
 
 .head_special_0 {
-  background: url("~@/assets/images/animated/BackerOnly-Equip-ShadeHelmet.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/BackerOnly-Equip-ShadeHelmet.gif") no-repeat;
 }
 .head_special_1 {
-  background: url("~@/assets/images/animated/ContributorOnly-Equip-CrystalHelmet.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/ContributorOnly-Equip-CrystalHelmet.gif") no-repeat;
   margin-top: 3px;
 }
 
 .broad_armor_special_0,.slim_armor_special_0 {
-  background: url("~@/assets/images/animated/BackerOnly-Equip-ShadeArmor.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/BackerOnly-Equip-ShadeArmor.gif") no-repeat;
 }
 .broad_armor_special_1,.slim_armor_special_1 {
-  background: url("~@/assets/images/animated/ContributorOnly-Equip-CrystalArmor.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/ContributorOnly-Equip-CrystalArmor.gif") no-repeat;
 }
 
 .shield_special_0 {
-  background: url("~@/assets/images/animated/BackerOnly-Shield-TormentedSkull.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/BackerOnly-Shield-TormentedSkull.gif") no-repeat;
 }
 
 .weapon_special_0 {
-  background: url("~@/assets/images/animated/BackerOnly-Weapon-DarkSoulsBlade.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/BackerOnly-Weapon-DarkSoulsBlade.gif") no-repeat;
 }
 
 .Pet-Wolf-Cerberus {
   width: 105px;
   height: 72px;
-  background: url("~@/assets/images/animated/BackerOnly-Pet-CerberusPup.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/BackerOnly-Pet-CerberusPup.gif") no-repeat;
 }
 
 .broad_armor_special_ks2019, .slim_armor_special_ks2019, .eyewear_special_ks2019, .head_special_ks2019, .shield_special_ks2019 {
@@ -113,29 +129,29 @@
 }
 
 .broad_armor_special_ks2019, .slim_armor_special_ks2019 {
-  background: url("~@/assets/images/animated/BackerOnly-Equip-MythicGryphonArmor.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/BackerOnly-Equip-MythicGryphonArmor.gif") no-repeat;
 }
 
 .eyewear_special_ks2019 {
-  background: url("~@/assets/images/animated/BackerOnly-Equip-MythicGryphonVisor.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/BackerOnly-Equip-MythicGryphonVisor.gif") no-repeat;
 }
 
 .head_special_ks2019 {
-  background: url("~@/assets/images/animated/BackerOnly-Equip-MythicGryphonHelm.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/BackerOnly-Equip-MythicGryphonHelm.gif") no-repeat;
 }
 
 .shield_special_ks2019 {
-  background: url("~@/assets/images/animated/BackerOnly-Equip-MythicGryphonShield.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/BackerOnly-Equip-MythicGryphonShield.gif") no-repeat;
 }
 
 .weapon_special_ks2019 {
-  background: url("~@/assets/images/animated/BackerOnly-Equip-MythicGryphonGlaive.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/BackerOnly-Equip-MythicGryphonGlaive.gif") no-repeat;
   width: 120px;
   height: 120px;
 }
 
 .Pet-Gryphon-Gryphatrice {
-  background: url("~@/assets/images/animated/BackerOnly-Pet-Gryphatrice.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/BackerOnly-Pet-Gryphatrice.gif") no-repeat;
   width: 81px;
   height: 99px;
 }
@@ -146,11 +162,11 @@
 }
 
 .Mount_Head_Gryphon-Gryphatrice {
-  background: url("~@/assets/images/animated/BackerOnly-Mount-Head-Gryphatrice.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/BackerOnly-Mount-Head-Gryphatrice.gif") no-repeat;
 }
 
 .Mount_Body_Gryphon-Gryphatrice {
-  background: url("~@/assets/images/animated/BackerOnly-Mount-Body-Gryphatrice.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/BackerOnly-Mount-Body-Gryphatrice.gif") no-repeat;
 }
 
 .background_airship, .background_clocktower, .background_steamworks {
@@ -159,15 +175,15 @@
 }
 
 .background_airship {
-  background: url("~@/assets/images/animated/background_airship.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/background_airship.gif") no-repeat;
 }
 
 .background_clocktower {
-  background: url("~@/assets/images/animated/background_clocktower.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/background_clocktower.gif") no-repeat;
 }
 
 .background_steamworks {
-  background: url("~@/assets/images/animated/background_steamworks.gif") no-repeat;
+  background: url("https://habitica-assets.s3.amazonaws.com/mobileApp/images/background_steamworks.gif") no-repeat;
 }
 
 /* FIXME figure out how to handle customize menu!!