5.26.1

Currently translated at 99.2% (3080 of 3103 strings)

Co-authored-by: Natalie Luhrs <eilatan@gmail.com>
Translate-URL: https://translate.habitica.com/projects/habitica/gear/ja/
Translation: Habitica/Gear

.eslintrc.js

@@ -5,6 +5,7 @@ module.exports = {
     'habitrpg/lib/node',
   ],
   rules: {
+    'prefer-regex-literals': 'warn',
     'import/no-extraneous-dependencies': 'off',
   },
 };

.github/dependabot.yml

@@ -1,150 +0,0 @@
-version: 2
-updates:
-- package-ecosystem: npm
-  directory: "/"
-  schedule:
-    interval: weekly
-    time: "06:00"
-    timezone: Europe/Rome
-  open-pull-requests-limit: 99
-  ignore:
-  - dependency-name: express-validator
-    versions:
-    - 6.10.0
-    - 6.10.1
-    - 6.9.2
-  - dependency-name: "@babel/core"
-    versions:
-    - 7.12.13
-    - 7.12.16
-    - 7.12.17
-    - 7.13.1
-    - 7.13.10
-    - 7.13.13
-    - 7.13.14
-    - 7.13.15
-    - 7.13.8
-  - dependency-name: redis
-    versions:
-    - 3.1.0
-  - dependency-name: stripe
-    versions:
-    - 8.134.0
-    - 8.135.0
-    - 8.137.0
-    - 8.138.0
-    - 8.140.0
-    - 8.142.0
-  - dependency-name: "@babel/register"
-    versions:
-    - 7.12.13
-    - 7.13.14
-    - 7.13.8
-  - dependency-name: mongoose
-    versions:
-    - 5.11.14
-    - 5.11.15
-    - 5.11.16
-    - 5.11.17
-    - 5.11.18
-    - 5.11.19
-    - 5.12.0
-    - 5.12.1
-    - 5.12.2
-    - 5.12.3
-  - dependency-name: jwks-rsa
-    versions:
-    - 1.12.3
-    - 2.0.1
-    - 2.0.2
-  - dependency-name: "@babel/preset-env"
-    versions:
-    - 7.12.13
-    - 7.12.16
-    - 7.12.17
-    - 7.13.10
-    - 7.13.12
-    - 7.13.8
-    - 7.13.9
-  - dependency-name: image-size
-    versions:
-    - 0.9.4
-    - 0.9.5
-    - 0.9.7
-  - dependency-name: winston-loggly-bulk
-    versions:
-    - 3.2.0
-  - dependency-name: chai
-    versions:
-    - 4.3.0
-    - 4.3.3
-  - dependency-name: mocha
-    versions:
-    - 8.2.1
-    - 8.3.0
-    - 8.3.1
-  - dependency-name: "@google-cloud/trace-agent"
-    versions:
-    - 5.1.2
-  - dependency-name: monk
-    versions:
-    - 7.3.3
-- package-ecosystem: npm
-  directory: "/website/client"
-  schedule:
-    interval: weekly
-    time: "06:00"
-    timezone: Europe/Rome
-  open-pull-requests-limit: 99
-  ignore:
-  - dependency-name: eslint-plugin-vue
-    versions:
-    - 7.5.0
-    - 7.6.0
-    - 7.7.0
-    - 7.8.0
-    - 7.9.0
-  - dependency-name: core-js
-    versions:
-    - 3.10.0
-    - 3.10.1
-    - 3.9.0
-    - 3.9.1
-  - dependency-name: bootstrap
-    versions:
-    - 4.6.0
-  - dependency-name: y18n
-    versions:
-    - 4.0.1
-  - dependency-name: hellojs
-    versions:
-    - 1.18.8
-    - 1.19.2
-  - dependency-name: chai
-    versions:
-    - 4.3.0
-    - 4.3.3
-  - dependency-name: amplitude-js
-    versions:
-    - 7.4.2
-    - 7.4.3
-    - 7.4.4
-  - dependency-name: pug
-    versions:
-    - 3.0.2
-  - dependency-name: sass
-    versions:
-    - 1.32.6
-    - 1.32.7
-    - 1.32.8
-  - dependency-name: "@vue/test-utils"
-    versions:
-    - 1.1.2
-    - 1.1.3
-  - dependency-name: intro.js
-    versions:
-    - 3.2.1
-    - 3.3.1
-  - dependency-name: sass-loader
-    versions:
-    - 10.1.1

.github/workflows/test.yml

@@ -10,19 +10,20 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [14.x]
+        node-version: [21.x]
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 1
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
+    - run: sudo apt-get -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
-        npm ci
+        npm i
       env:
         CI: true
         NODE_ENV: test
@@ -31,19 +32,20 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [14.x]
+        node-version: [21.x]
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 1
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
+    - run: sudo apt-get -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
-        npm ci
+        npm i
       env:
         CI: true
         NODE_ENV: test
@@ -52,19 +54,20 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [14.x]
+        node-version: [21.x]
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 1
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
+    - run: sudo apt-get -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
-        npm ci
+        npm i
       env:
         CI: true
         NODE_ENV: test
@@ -74,19 +77,20 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [14.x]
+        node-version: [21.x]
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 1
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
+    - run: sudo apt-get -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
-        npm ci
+        npm i
       env:
         CI: true
         NODE_ENV: test
@@ -95,19 +99,20 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [14.x]
+        node-version: [21.x]
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 1
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
+    - run: sudo apt-get -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
-        npm ci
+        npm i
       env:
         CI: true
         NODE_ENV: test
@@ -117,14 +122,14 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [14.x]
+        node-version: [21.x]
         mongodb-version: [4.2]
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 1
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
     - name: Start MongoDB ${{ matrix.mongodb-version }} Replica Set
@@ -132,10 +137,11 @@ jobs:
       with:
         mongodb-version: ${{ matrix.mongodb-version }}
         mongodb-replica-set: rs
+    - run: sudo apt-get -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
-        npm ci
+        npm i
       env:
         CI: true
         NODE_ENV: test
@@ -146,14 +152,14 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [14.x]
+        node-version: [21.x]
         mongodb-version: [4.2]
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 1
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
     - name: Start MongoDB ${{ matrix.mongodb-version }} Replica Set
@@ -161,10 +167,11 @@ jobs:
       with:
         mongodb-version: ${{ matrix.mongodb-version }}
         mongodb-replica-set: rs
+    - run: sudo apt-get -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
-        npm ci
+        npm i
       env:
         CI: true
         NODE_ENV: test
@@ -175,14 +182,14 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [14.x]
+        node-version: [21.x]
         mongodb-version: [4.2]
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 1
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
     - name: Start MongoDB ${{ matrix.mongodb-version }} Replica Set
@@ -190,10 +197,11 @@ jobs:
       with:
         mongodb-version: ${{ matrix.mongodb-version }}
         mongodb-replica-set: rs
+    - run: sudo apt-get -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
-        npm ci
+        npm i
       env:
         CI: true
         NODE_ENV: test
@@ -205,19 +213,20 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [14.x]
+        node-version: [21.x]
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 1
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
+    - run: sudo apt-get -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
-        npm ci
+        npm i
       env:
         CI: true
         NODE_ENV: test
@@ -228,15 +237,16 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [14.x]
+        node-version: [21.x]
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 1
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
+    - run: sudo apt-get -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |

.gitignore

@@ -8,7 +8,7 @@ i18n_cache
 apidoc/html
 *.swp
 .idea*
-config.json
+config*.json
 npm-debug.log*
 lib
 newrelic_agent.log
@@ -48,3 +48,4 @@ webpack.webstorm.config
 # mongodb replica set for local dev
 mongodb-*.tgz
 /mongodb-data
+/.nyc_output

.nvmrc

@@ -1 +1 @@
-14
+20

Dockerfile-Dev

@@ -1,14 +1,15 @@
-FROM node:14
+FROM node:20
 
 # Install global packages
 RUN npm install -g gulp-cli mocha
 
-# Copy package.json and package-lock.json into image, then install
-# dependencies.
+# Copy package.json and package-lock.json into image
 WORKDIR /usr/src/habitica
 COPY ["package.json", "package-lock.json", "./"]
-RUN npm install
-
 # Copy the remaining source files in.
 COPY . /usr/src/habitica
+# Install dependencies
+RUN npm install
 RUN npm run postinstall
+RUN npm run client:build
+RUN gulp build:prod

README.md

@@ -1,7 +1,7 @@
 Habitica ![Build Status](https://github.com/HabitRPG/habitica/workflows/Test/badge.svg) [![Code Climate](https://codeclimate.com/github/HabitRPG/habitrpg.svg)](https://codeclimate.com/github/HabitRPG/habitrpg) [![Bountysource](https://api.bountysource.com/badge/tracker?tracker_id=68393)](https://www.bountysource.com/trackers/68393-habitrpg?utm_source=68393&utm_medium=shield&utm_campaign=TRACKER_BADGE)
 ===============
 
-[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.
+[Habitica](https://habitica.com) is an open-source habit-building program that treats your life like a role-playing game. Level up as you succeed, lose HP as you fail, and 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](https://habitica.fandom.com/wiki/Guidance_for_Blacksmiths) - an introduction to the technologies used and how the software is organized.

config.json.example

@@ -32,6 +32,7 @@
   "LOGGLY_CLIENT_TOKEN": "token",
   "LOGGLY_SUBDOMAIN": "example-subdomain",
   "LOGGLY_TOKEN": "example-token",
+  "LOG_REQUESTS_EXCESSIVE_MODE": "false",
   "MAINTENANCE_MODE": "false",
   "NODE_DB_URI": "mongodb://localhost:27017/habitica-dev?replicaSet=rs",
   "TEST_DB_URI": "mongodb://localhost:27017/habitica-test?replicaSet=rs",
@@ -84,8 +85,12 @@
   "BLOCKED_IPS": "",
   "LOG_AMPLITUDE_EVENTS": "false",
   "RATE_LIMITER_ENABLED": "false",
+  "LIVELINESS_PROBE_KEY": "",
   "REDIS_HOST": "aaabbbcccdddeeefff",
   "REDIS_PORT": "1234",
   "REDIS_PASSWORD": "12345678",
-  "TRUSTED_DOMAINS": "localhost,habitica.com"
+  "TRUSTED_DOMAINS": "localhost,https://habitica.com",
+  "TIME_TRAVEL_ENABLED": "false",
+  "DEBUG_ENABLED": "false",
+  "CONTENT_SWITCHOVER_TIME_OFFSET": 8
 }

gulp/gulp-tests.js

@@ -44,8 +44,8 @@ function runInChildProcess (command, options = {}, envVariables = '') {
   return done => pipe(exec(testBin(command, envVariables), options, done));
 }
 
-function integrationTestCommand (testDir, coverageDir) {
-  return `istanbul cover --dir coverage/${coverageDir} --report lcovonly node_modules/mocha/bin/_mocha -- ${testDir} --recursive --require ./test/helpers/start-server`;
+function integrationTestCommand (testDir) {
+  return `nyc --silent --no-clean mocha ${testDir} --recursive --require ./test/helpers/start-server`;
 }
 
 /* Test task definitions */
@@ -148,7 +148,7 @@ gulp.task('test:content:safe', gulp.series('test:prepare:build', cb => {
 
 gulp.task(
   'test:api:unit:run',
-  runInChildProcess(integrationTestCommand('test/api/unit', 'coverage/api-unit')),
+  runInChildProcess(integrationTestCommand('test/api/unit')),
 );
 
 gulp.task('test:api:unit:watch', () => gulp.watch(['website/server/libs/*', 'test/api/unit/**/*', 'website/server/controllers/**/*'], gulp.series('test:api:unit:run', done => done())));
@@ -156,7 +156,7 @@ gulp.task('test:api:unit:watch', () => gulp.watch(['website/server/libs/*', 'tes
 gulp.task('test:api-v3:integration', gulp.series(
   'test:prepare:mongo',
   runInChildProcess(
-    integrationTestCommand('test/api/v3/integration', 'coverage/api-v3-integration'),
+    integrationTestCommand('test/api/v3/integration'),
     LIMIT_MAX_BUFFER_OPTIONS,
   ),
 ));
@@ -175,7 +175,7 @@ gulp.task('test:api-v3:integration:separate-server', runInChildProcess(
 gulp.task('test:api-v4:integration', gulp.series(
   'test:prepare:mongo',
   runInChildProcess(
-    integrationTestCommand('test/api/v4', 'api-v4-integration'),
+    integrationTestCommand('test/api/v4'),
     LIMIT_MAX_BUFFER_OPTIONS,
   ),
 ));

migrations/archive/2024/20240516_pet_group_achievements.js

@@ -0,0 +1,99 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '202405_pet_group_achievements';
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  let set = {
+    migration: MIGRATION_NAME,
+  };
+
+  if (user && user.items && user.items.pets) {
+    const pets = user.items.pets;
+    if (pets['LionCub-Zombie'] > 0
+      && pets['LionCub-Skeleton'] > 0
+      && pets['LionCub-Base'] > 0
+      && pets['LionCub-Desert'] > 0
+      && pets['LionCub-Red'] > 0
+      && pets['LionCub-Shade'] > 0
+      && pets['LionCub-White']> 0
+      && pets['LionCub-Golden'] > 0
+      && pets['LionCub-CottonCandyBlue'] > 0
+      && pets['LionCub-CottonCandyPink'] > 0
+      && pets['TigerCub-Zombie'] > 0
+      && pets['TigerCub-Skeleton'] > 0
+      && pets['TigerCub-Base'] > 0
+      && pets['TigerCub-Desert'] > 0
+      && pets['TigerCub-Red'] > 0
+      && pets['TigerCub-Shade'] > 0
+      && pets['TigerCub-White'] > 0
+      && pets['TigerCub-Golden'] > 0
+      && pets['TigerCub-CottonCandyBlue'] > 0
+      && pets['TigerCub-CottonCandyPink'] > 0
+      && pets['Sabretooth-Zombie'] > 0
+      && pets['Sabretooth-Skeleton'] > 0
+      && pets['Sabretooth-Base'] > 0
+      && pets['Sabretooth-Desert'] > 0
+      && pets['Sabretooth-Red'] > 0
+      && pets['Sabretooth-Shade'] > 0
+      && pets['Sabretooth-White'] > 0
+      && pets['Sabretooth-Golden'] > 0
+      && pets['Sabretooth-CottonCandyBlue'] > 0
+      && pets['Sabretooth-CottonCandyPink'] > 0 
+      && pets['Cheetah-Zombie'] > 0
+      && pets['Cheetah-Skeleton'] > 0
+      && pets['Cheetah-Base'] > 0
+      && pets['Cheetah-Desert'] > 0
+      && pets['Cheetah-Red'] > 0
+      && pets['Cheetah-Shade'] > 0
+      && pets['Cheetah-White'] > 0
+      && pets['Cheetah-Golden'] > 0
+      && pets['Cheetah-CottonCandyBlue'] > 0
+      && pets['Cheetah-CottonCandyPink'] > 0 ) {
+        set['achievements.cats'] = true;
+      
+    }
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.updateOne({ _id: user._id }, { $set: set }).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    migration: { $ne: MIGRATION_NAME },
+    'auth.timestamps.loggedin': { $gt: new Date('2024-03-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/2024/20240621_veteran_pets.js

@@ -0,0 +1,149 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20240621_veteran_pet_ladder';
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = {};
+  let push = { notifications: { $each: [] }};
+
+  set.migration = MIGRATION_NAME;
+  if (user.items.pets['Dragon-Veteran']) {
+    set['items.pets.Cactus-Veteran'] = 5;
+    push.notifications.$each.push({
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'icon_pet_veteran_cactus',
+        title: 'You’ve received a Veteran Pet!',
+        text: 'To commemorate being here for a new era of Habitica, we’ve awarded you a Veteran Cactus and 24 Gems!',
+        destination: '/inventory/stable',
+      },
+      seen: false,
+    });
+  } else if (user.items.pets['Fox-Veteran']) {
+    set['items.pets.Dragon-Veteran'] = 5;
+    push.notifications.$each.push({
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'icon_pet_veteran_dragon',
+        title: 'You’ve received a Veteran Pet!',
+        text: 'To commemorate being here for a new era of Habitica, we’ve awarded you a Veteran Dragon and 24 Gems!',
+        destination: '/inventory/stable',
+      },
+      seen: false,
+    });
+  } else if (user.items.pets['Bear-Veteran']) {
+    set['items.pets.Fox-Veteran'] = 5;
+    push.notifications.$each.push({
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'icon_pet_veteran_fox',
+        title: 'You’ve received a Veteran Pet!',
+        text: 'To commemorate being here for a new era of Habitica, we’ve awarded you a Veteran Fox and 24 Gems!',
+        destination: '/inventory/stable',
+      },
+      seen: false,
+    });
+  } else if (user.items.pets['Lion-Veteran']) {
+    set['items.pets.Bear-Veteran'] = 5;
+    push.notifications.$each.push({
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'icon_pet_veteran_bear',
+        title: 'You’ve received a Veteran Pet!',
+        text: 'To commemorate being here for a new era of Habitica, we’ve awarded you a Veteran Bear and 24 Gems!',
+        destination: '/inventory/stable',
+      },
+      seen: false,
+    });
+  } else if (user.items.pets['Tiger-Veteran']) {
+    set['items.pets.Lion-Veteran'] = 5;
+    push.notifications.$each.push({
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'icon_pet_veteran_lion',
+        title: 'You’ve received a Veteran Pet!',
+        text: 'To commemorate being here for a new era of Habitica, we’ve awarded you a Veteran Lion and 24 Gems!',
+        destination: '/inventory/stable',
+      },
+      seen: false,
+    });
+  } else if (user.items.pets['Wolf-Veteran']) {
+    set['items.pets.Tiger-Veteran'] = 5;
+    push.notifications.$each.push({
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'icon_pet_veteran_tiger',
+        title: 'You’ve received a Veteran Pet!',
+        text: 'To commemorate being here for a new era of Habitica, we’ve awarded you a Veteran Tiger and 24 Gems!',
+        destination: '/inventory/stable',
+      },
+      seen: false,
+    });
+  } else {
+    set['items.pets.Wolf-Veteran'] = 5;
+    push.notifications.$each.push({
+      type: 'ITEM_RECEIVED',
+      data: {
+        icon: 'icon_pet_veteran_wolf',
+        title: 'You’ve received a Veteran Pet!',
+        text: 'To commemorate being here for a new era of Habitica, we’ve awarded you a Veteran Wolf and 24 Gems!',
+        destination: '/inventory/stable',
+      },
+      seen: false,
+    });
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  await user.updateBalance(
+    6,
+    'admin_update_balance',
+    '',
+    'Veteran Ladder award',
+  );
+
+  return await User.updateOne(
+    { _id: user._id },
+    { $set: set, $push: push, $inc: { balance: 6 } },
+  ).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'auth.timestamps.loggedin': { $gt: new Date('2024-05-21') },
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+    migration: 1,
+    contributor: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .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
+  }
+};

package.json

@@ -1,7 +1,7 @@
 {
   "name": "habitica",
   "description": "A habit tracker app which treats your goals like a Role Playing Game.",
-  "version": "5.19.0",
+  "version": "5.26.1",
   "main": "./website/server/index.js",
   "dependencies": {
     "@babel/core": "^7.22.10",
@@ -27,9 +27,10 @@
     "eslint": "^8.55.0",
     "eslint-config-habitrpg": "^6.2.3",
     "eslint-plugin-mocha": "^5.0.0",
-    "express": "^4.18.2",
+    "express": "^4.19.2",
     "express-basic-auth": "^1.2.1",
     "express-validator": "^5.2.0",
+    "firebase-admin": "^12.1.1",
     "glob": "^8.1.0",
     "got": "^11.8.6",
     "gulp": "^4.0.0",
@@ -66,6 +67,7 @@
     "remove-markdown": "^0.5.0",
     "rimraf": "^3.0.2",
     "short-uuid": "^4.2.2",
+    "sinon": "^15.2.0",
     "stripe": "^12.18.0",
     "superagent": "^8.1.2",
     "universal-analytics": "^0.5.3",
@@ -78,8 +80,8 @@
   },
   "private": true,
   "engines": {
-    "node": "^14",
-    "npm": "^6"
+    "node": "20",
+    "npm": "^10"
   },
   "scripts": {
     "lint": "eslint --ext .js --fix . && cd website/client && npm run lint",
@@ -92,11 +94,11 @@
     "test:api-v3:integration:separate-server": "NODE_ENV=test gulp test:api-v3:integration:separate-server",
     "test:api-v4:integration": "gulp test:api-v4:integration",
     "test:api-v4:integration:separate-server": "NODE_ENV=test gulp test:api-v4:integration:separate-server",
-    "test:sanity": "istanbul cover --dir coverage/sanity --report lcovonly node_modules/mocha/bin/_mocha -- test/sanity --recursive",
-    "test:common": "istanbul cover --dir coverage/common --report lcovonly node_modules/mocha/bin/_mocha -- test/common --recursive",
-    "test:content": "istanbul cover --dir coverage/content --report lcovonly node_modules/mocha/bin/_mocha -- test/content --recursive",
+    "test:sanity": "nyc --silent --no-clean mocha test/sanity --recursive",
+    "test:common": "nyc --silent --no-clean mocha test/common --recursive",
+    "test:content": "nyc --silent --no-clean mocha test/content --recursive",
     "test:nodemon": "gulp test:nodemon",
-    "coverage": "COVERAGE=true mocha --require register-handlers.js --reporter html-cov > coverage.html; open coverage.html",
+    "coverage": "nyc report --reporter=html --report-dir coverage/results; open coverage/results/index.html",
     "sprites": "gulp sprites:compile",
     "client:dev": "cd website/client && npm run serve",
     "client:build": "cd website/client && npm run build",
@@ -105,7 +107,8 @@
     "debug": "gulp nodemon --inspect",
     "mongo:dev": "run-rs -v 5.0.23 -l ubuntu1804 --keep --dbpath mongodb-data --number 1 --quiet",
     "postinstall": "git config --global url.\"https://\".insteadOf git:// && gulp build && cd website/client && npm install",
-    "apidoc": "gulp apidoc"
+    "apidoc": "gulp apidoc",
+    "heroku-postbuild": "npm run client:build"
   },
   "devDependencies": {
     "axios": "^1.4.0",
@@ -114,15 +117,12 @@
     "chai-moment": "^0.1.0",
     "chalk": "^5.3.0",
     "cross-spawn": "^7.0.3",
-    "expect.js": "^0.3.1",
-    "istanbul": "^1.1.0-alpha.1",
     "mocha": "^5.1.1",
     "monk": "^7.3.4",
+    "nyc": "^15.1.0",
     "require-again": "^2.0.0",
     "run-rs": "^0.7.7",
-    "sinon": "^15.2.0",
     "sinon-chai": "^3.7.0",
     "sinon-stub-promise": "^4.0.0"
-  },
-  "optionalDependencies": {}
+  }
 }

test/api/unit/libs/apiError.js

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

test/api/unit/libs/content.test.js

@@ -1,5 +1,9 @@
+import fs from 'fs';
 import * as contentLib from '../../../../website/server/libs/content';
 import content from '../../../../website/common/script/content';
+import {
+  generateRes,
+} from '../../../helpers/api-unit.helper';
 
 describe('contentLib', () => {
   describe('CONTENT_CACHE_PATH', () => {
@@ -13,5 +17,90 @@ describe('contentLib', () => {
       contentLib.getLocalizedContentResponse();
       expect(typeof content.backgrounds.backgrounds062014.beach.text).to.equal('function');
     });
+
+    it('removes keys from the content data', () => {
+      const response = contentLib.localizeContentData(content, 'en', { backgroundsFlat: true, dropHatchingPotions: true });
+      expect(response.backgroundsFlat).to.not.exist;
+      expect(response.backgrounds).to.exist;
+      expect(response.dropHatchingPotions).to.not.exist;
+      expect(response.hatchingPotions).to.exist;
+    });
+
+    it('removes nested keys from the content data', () => {
+      const response = contentLib.localizeContentData(content, 'en', { gear: { tree: true } });
+      expect(response.gear.tree).to.not.exist;
+      expect(response.gear.flat).to.exist;
+    });
+  });
+
+  it('generates a hash for a filter', () => {
+    const hash = contentLib.hashForFilter('backgroundsFlat,gear.flat');
+    expect(hash).to.equal('-1791877526');
+  });
+
+  it('serves content', () => {
+    const resSpy = generateRes();
+    contentLib.serveContent(resSpy, 'en', '', false);
+    expect(resSpy.send).to.have.been.calledOnce;
+  });
+
+  it('serves filtered content', () => {
+    const resSpy = generateRes();
+    contentLib.serveContent(resSpy, 'en', 'backgroundsFlat,gear.flat', false);
+    expect(resSpy.send).to.have.been.calledOnce;
+  });
+
+  describe('caches content', async () => {
+    let resSpy;
+    beforeEach(() => {
+      resSpy = generateRes();
+      if (fs.existsSync(contentLib.CONTENT_CACHE_PATH)) {
+        fs.rmSync(contentLib.CONTENT_CACHE_PATH, { recursive: true });
+      }
+      fs.mkdirSync(contentLib.CONTENT_CACHE_PATH);
+    });
+
+    it('does not cache requests in development mode', async () => {
+      contentLib.serveContent(resSpy, 'en', '', false);
+      expect(fs.existsSync(`${contentLib.CONTENT_CACHE_PATH}en.json`)).to.be.false;
+    });
+
+    it('caches unfiltered requests', async () => {
+      expect(fs.existsSync(`${contentLib.CONTENT_CACHE_PATH}en.json`)).to.be.false;
+      contentLib.serveContent(resSpy, 'en', '', true);
+      expect(fs.existsSync(`${contentLib.CONTENT_CACHE_PATH}en.json`)).to.be.true;
+    });
+
+    it('serves cached requests', async () => {
+      fs.writeFileSync(
+        `${contentLib.CONTENT_CACHE_PATH}en.json`,
+        '{"success": true, "data": {"all": {}}}',
+        'utf8',
+      );
+      contentLib.serveContent(resSpy, 'en', '', true);
+      expect(resSpy.sendFile).to.have.been.calledOnce;
+      expect(resSpy.sendFile).to.have.been.calledWith(`${contentLib.CONTENT_CACHE_PATH}en.json`);
+    });
+
+    it('caches filtered requests', async () => {
+      const filter = 'backgroundsFlat,gear.flat';
+      const hash = contentLib.hashForFilter(filter);
+      expect(fs.existsSync(`${contentLib.CONTENT_CACHE_PATH}en${hash}.json`)).to.be.false;
+      contentLib.serveContent(resSpy, 'en', filter, true);
+      expect(fs.existsSync(`${contentLib.CONTENT_CACHE_PATH}en${hash}.json`)).to.be.true;
+    });
+
+    it('serves filtered cached requests', async () => {
+      const filter = 'backgroundsFlat,gear.flat';
+      const hash = contentLib.hashForFilter(filter);
+      fs.writeFileSync(
+        `${contentLib.CONTENT_CACHE_PATH}en${hash}.json`,
+        '{"success": true, "data": {}}',
+        'utf8',
+      );
+      contentLib.serveContent(resSpy, 'en', filter, true);
+      expect(resSpy.sendFile).to.have.been.calledOnce;
+      expect(resSpy.sendFile).to.have.been.calledWith(`${contentLib.CONTENT_CACHE_PATH}en${hash}.json`);
+    });
   });
 });

test/api/unit/libs/items/utils.test.js

@@ -117,7 +117,7 @@ describe('Items Utils', () => {
     it('converts values for owned gear to true/false', () => {
       expect(castItemVal('items.gear.owned.shield_warrior_0', 'true')).to.equal(true);
       expect(castItemVal('items.gear.owned.invalid', 'false')).to.equal(false);
-      expect(castItemVal('items.gear.owned.invalid', 'null')).to.equal(false);
+      expect(castItemVal('items.gear.owned.invalid', 'null')).to.equal(undefined);
       expect(castItemVal('items.gear.owned.invalid', 'truthy')).to.equal(true);
       expect(castItemVal('items.gear.owned.invalid', 0)).to.equal(false);
     });

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

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

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

@@ -4,7 +4,7 @@ import nconf from 'nconf';
 import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
 import { model as User } from '../../../../../../website/server/models/user';
 import common from '../../../../../../website/common';
-import apiError from '../../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../../website/server/libs/apiError';
 import * as gems from '../../../../../../website/server/libs/payments/gems';
 
 const BASE_URL = nconf.get('BASE_URL');

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

@@ -1,4 +1,4 @@
-import apiError from '../../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../../website/server/libs/apiError';
 import common from '../../../../../../website/common';
 import {
   getOneTimePaymentInfo,

test/api/unit/libs/pushNotifications.js

@@ -1,184 +0,0 @@
-import apn from '@parse/node-apn/mock';
-import _ from 'lodash';
-import nconf from 'nconf';
-import gcmLib from 'node-gcm'; // works with FCM notifications too
-import { model as User } from '../../../../website/server/models/user';
-import {
-  sendNotification as sendPushNotification,
-  MAX_MESSAGE_LENGTH,
-} from '../../../../website/server/libs/pushNotifications';
-
-describe('pushNotifications', () => {
-  let user;
-  let fcmSendSpy;
-  let apnSendSpy;
-
-  const identifier = 'identifier';
-  const title = 'title';
-  const message = 'message';
-
-  beforeEach(() => {
-    user = new User();
-    fcmSendSpy = sinon.spy();
-    apnSendSpy = sinon.spy();
-
-    sandbox.stub(nconf, 'get').returns('true-key');
-
-    sandbox.stub(gcmLib.Sender.prototype, 'send').callsFake(fcmSendSpy);
-
-    sandbox.stub(apn.Provider.prototype, 'send').returns({
-      on: () => null,
-      send: apnSendSpy,
-    });
-  });
-
-  afterEach(() => {
-    sandbox.restore();
-  });
-
-  it('throws if user is not supplied', () => {
-    expect(sendPushNotification).to.throw;
-    expect(fcmSendSpy).to.not.have.been.called;
-    expect(apnSendSpy).to.not.have.been.called;
-  });
-
-  it('throws if user.preferences.pushNotifications.unsubscribeFromAll is true', () => {
-    user.preferences.pushNotifications.unsubscribeFromAll = true;
-    expect(() => sendPushNotification(user)).to.throw;
-    expect(fcmSendSpy).to.not.have.been.called;
-    expect(apnSendSpy).to.not.have.been.called;
-  });
-
-  it('throws if details.identifier is not supplied', () => {
-    expect(() => sendPushNotification(user, {
-      title,
-      message,
-    })).to.throw;
-    expect(fcmSendSpy).to.not.have.been.called;
-    expect(apnSendSpy).to.not.have.been.called;
-  });
-
-  it('throws if details.title is not supplied', () => {
-    expect(() => sendPushNotification(user, {
-      identifier,
-      message,
-    })).to.throw;
-    expect(fcmSendSpy).to.not.have.been.called;
-    expect(apnSendSpy).to.not.have.been.called;
-  });
-
-  it('throws if details.message is not supplied', () => {
-    expect(() => sendPushNotification(user, {
-      identifier,
-      title,
-    })).to.throw;
-    expect(fcmSendSpy).to.not.have.been.called;
-    expect(apnSendSpy).to.not.have.been.called;
-  });
-
-  it('returns if no device is registered', () => {
-    sendPushNotification(user, {
-      identifier,
-      title,
-      message,
-    });
-    expect(fcmSendSpy).to.not.have.been.called;
-    expect(apnSendSpy).to.not.have.been.called;
-  });
-
-  it('cuts the message to 300 chars', () => {
-    const longMessage = `12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345`;
-
-    expect(longMessage.length > MAX_MESSAGE_LENGTH).to.equal(true);
-
-    const details = {
-      identifier,
-      title,
-      message: longMessage,
-      payload: {
-        message: longMessage,
-      },
-    };
-
-    sendPushNotification(user, details);
-
-    expect(details.message).to.equal(_.truncate(longMessage, { length: MAX_MESSAGE_LENGTH }));
-    expect(details.payload.message)
-      .to.equal(_.truncate(longMessage, { length: MAX_MESSAGE_LENGTH }));
-
-    expect(details.message.length).to.equal(MAX_MESSAGE_LENGTH);
-    expect(details.payload.message.length).to.equal(MAX_MESSAGE_LENGTH);
-  });
-
-  it('cuts the message to 300 chars (no payload)', () => {
-    const longMessage = `12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
-      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345`;
-
-    expect(longMessage.length > MAX_MESSAGE_LENGTH).to.equal(true);
-
-    const details = {
-      identifier,
-      title,
-      message: longMessage,
-    };
-
-    sendPushNotification(user, details);
-
-    expect(details.message).to.equal(_.truncate(longMessage, { length: MAX_MESSAGE_LENGTH }));
-    expect(details.message.length).to.equal(MAX_MESSAGE_LENGTH);
-  });
-
-  // TODO disabled because APN relies on a Promise
-  xit('uses APN for iOS devices', () => {
-    user.pushDevices.push({
-      type: 'ios',
-      regId: '123',
-    });
-
-    const details = {
-      identifier,
-      title,
-      message,
-      category: 'fun',
-      payload: {
-        a: true,
-        b: true,
-      },
-    };
-
-    const expectedNotification = new apn.Notification({
-      alert: message,
-      sound: 'default',
-      category: 'fun',
-      payload: {
-        identifier,
-        a: true,
-        b: true,
-      },
-    });
-
-    sendPushNotification(user, details);
-    expect(apnSendSpy).to.have.been.calledOnce;
-    expect(apnSendSpy).to.have.been.calledWithMatch(expectedNotification, '123');
-    expect(fcmSendSpy).to.not.have.been.called;
-  });
-});

test/api/unit/libs/pushNotifications.test.js

@@ -0,0 +1,354 @@
+import apn from '@parse/node-apn';
+import _ from 'lodash';
+import nconf from 'nconf';
+import admin from 'firebase-admin';
+import { model as User } from '../../../../website/server/models/user';
+import {
+  MAX_MESSAGE_LENGTH,
+} from '../../../../website/server/libs/pushNotifications';
+
+let sendPushNotification;
+
+describe('pushNotifications', () => {
+  let user;
+  let fcmSendSpy;
+  let apnSendSpy;
+  let updateStub;
+  let classStubbedInstance;
+
+  const identifier = 'identifier';
+  const title = 'title';
+  const message = 'message';
+
+  beforeEach(() => {
+    user = new User();
+    fcmSendSpy = sinon.stub().returns(Promise.resolve('success'));
+    apnSendSpy = sinon.stub().returns(Promise.resolve());
+
+    nconf.set('PUSH_CONFIGS_APN_ENABLED', 'true');
+
+    classStubbedInstance = sandbox.createStubInstance(apn.Provider, {
+      send: apnSendSpy,
+    });
+    sandbox.stub(apn, 'Provider').returns(classStubbedInstance);
+
+    delete require.cache[require.resolve('../../../../website/server/libs/pushNotifications')];
+    // eslint-disable-next-line global-require
+    sendPushNotification = require('../../../../website/server/libs/pushNotifications').sendNotification;
+
+    updateStub = sandbox.stub(User, 'updateOne').resolves();
+    sandbox.stub(admin, 'messaging').get(() => () => ({ send: fcmSendSpy }));
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('validates supplied data', () => {
+    it('throws if user is not supplied', () => {
+      expect(sendPushNotification).to.throw;
+      expect(fcmSendSpy).to.not.have.been.called;
+      expect(apnSendSpy).to.not.have.been.called;
+    });
+
+    it('throws if user.preferences.pushNotifications.unsubscribeFromAll is true', () => {
+      user.preferences.pushNotifications.unsubscribeFromAll = true;
+      expect(() => sendPushNotification(user)).to.throw;
+      expect(fcmSendSpy).to.not.have.been.called;
+      expect(apnSendSpy).to.not.have.been.called;
+    });
+
+    it('throws if details.identifier is not supplied', () => {
+      expect(() => sendPushNotification(user, {
+        title,
+        message,
+      })).to.throw;
+      expect(fcmSendSpy).to.not.have.been.called;
+      expect(apnSendSpy).to.not.have.been.called;
+    });
+
+    it('throws if details.title is not supplied', () => {
+      expect(() => sendPushNotification(user, {
+        identifier,
+        message,
+      })).to.throw;
+      expect(fcmSendSpy).to.not.have.been.called;
+      expect(apnSendSpy).to.not.have.been.called;
+    });
+
+    it('throws if details.message is not supplied', () => {
+      expect(() => sendPushNotification(user, {
+        identifier,
+        title,
+      })).to.throw;
+      expect(fcmSendSpy).to.not.have.been.called;
+      expect(apnSendSpy).to.not.have.been.called;
+    });
+
+    it('returns if no device is registered', () => {
+      sendPushNotification(user, {
+        identifier,
+        title,
+        message,
+      });
+      expect(fcmSendSpy).to.not.have.been.called;
+      expect(apnSendSpy).to.not.have.been.called;
+    });
+  });
+
+  it('cuts the message to 300 chars', () => {
+    const longMessage = `12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345`;
+
+    expect(longMessage.length > MAX_MESSAGE_LENGTH).to.equal(true);
+
+    const details = {
+      identifier,
+      title,
+      message: longMessage,
+      payload: {
+        message: longMessage,
+      },
+    };
+
+    sendPushNotification(user, details);
+
+    expect(details.message).to.equal(_.truncate(longMessage, { length: MAX_MESSAGE_LENGTH }));
+    expect(details.payload.message)
+      .to.equal(_.truncate(longMessage, { length: MAX_MESSAGE_LENGTH }));
+
+    expect(details.message.length).to.equal(MAX_MESSAGE_LENGTH);
+    expect(details.payload.message.length).to.equal(MAX_MESSAGE_LENGTH);
+  });
+
+  it('cuts the message to 300 chars (no payload)', () => {
+    const longMessage = `12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345
+      12345 12345 12345 12345 12345 12345 12345 12345 12345 12345`;
+
+    expect(longMessage.length > MAX_MESSAGE_LENGTH).to.equal(true);
+
+    const details = {
+      identifier,
+      title,
+      message: longMessage,
+    };
+
+    sendPushNotification(user, details);
+
+    expect(details.message).to.equal(_.truncate(longMessage, { length: MAX_MESSAGE_LENGTH }));
+    expect(details.message.length).to.equal(MAX_MESSAGE_LENGTH);
+  });
+
+  describe('sends notifications', () => {
+    let details;
+
+    beforeEach(() => {
+      details = {
+        identifier,
+        title,
+        message,
+        category: 'fun',
+        payload: {
+          a: true,
+          b: true,
+        },
+      };
+    });
+
+    it('uses APN for iOS devices', async () => {
+      user.pushDevices.push({
+        type: 'ios',
+        regId: '123',
+      });
+
+      const expectedNotification = new apn.Notification({
+        alert: {
+          title,
+          body: message,
+        },
+        sound: 'default',
+        category: 'fun',
+        payload: {
+          identifier,
+          a: true,
+          b: true,
+        },
+      });
+
+      await sendPushNotification(user, details);
+      expect(apnSendSpy).to.have.been.calledOnce;
+      expect(apnSendSpy).to.have.been.calledWithMatch(expectedNotification, '123');
+      expect(fcmSendSpy).to.not.have.been.called;
+    });
+
+    it('uses FCM for Android devices', async () => {
+      user.pushDevices.push({
+        type: 'android',
+        regId: '123',
+      });
+
+      const expectedMessage = {
+        notification: {
+          title,
+          body: message,
+        },
+        data: {
+          identifier,
+          notificationIdentifier: identifier,
+        },
+        token: '123',
+      };
+
+      await sendPushNotification(user, details);
+      expect(fcmSendSpy).to.have.been.calledOnce;
+      expect(fcmSendSpy).to.have.been.calledWithMatch(expectedMessage);
+      expect(apnSendSpy).to.not.have.been.called;
+    });
+
+    it('handles multiple devices', async () => {
+      user.pushDevices.push({
+        type: 'android',
+        regId: '123',
+      });
+      user.pushDevices.push({
+        type: 'ios',
+        regId: '456',
+      });
+      user.pushDevices.push({
+        type: 'android',
+        regId: '789',
+      });
+
+      await sendPushNotification(user, details);
+      expect(fcmSendSpy).to.have.been.calledTwice;
+      expect(apnSendSpy).to.have.been.calledOnce;
+    });
+  });
+
+  describe('handles sending errors', () => {
+    let clock;
+
+    beforeEach(() => {
+      clock = sinon.useFakeTimers();
+    });
+
+    afterEach(() => {
+      clock.restore();
+    });
+
+    it('removes unregistered fcm devices', async () => {
+      user.pushDevices.push({
+        type: 'android',
+        regId: '123',
+      });
+
+      const error = new Error();
+      error.code = 'messaging/registration-token-not-registered';
+      fcmSendSpy.rejects(error);
+
+      await sendPushNotification(user, {
+        identifier,
+        title,
+        message,
+      });
+
+      expect(fcmSendSpy).to.have.been.calledOnce;
+      expect(apnSendSpy).to.not.have.been.called;
+      await clock.tick(10);
+      expect(updateStub).to.have.been.calledOnce;
+    });
+
+    it('removes invalid fcm devices', async () => {
+      user.pushDevices.push({
+        type: 'android',
+        regId: '123',
+      });
+
+      const error = new Error();
+      error.code = 'messaging/registration-token-not-registered';
+      fcmSendSpy.rejects(error);
+
+      await sendPushNotification(user, {
+        identifier,
+        title,
+        message,
+      });
+
+      expect(fcmSendSpy).to.have.been.calledOnce;
+      expect(apnSendSpy).to.not.have.been.called;
+      expect(updateStub).to.have.been.calledOnce;
+    });
+
+    it('removes unregistered apn devices', async () => {
+      user.pushDevices.push({
+        type: 'ios',
+        regId: '123',
+      });
+
+      const error = {
+        failed: [
+          {
+            device: '123',
+            response: { reason: 'Unregistered' },
+          },
+        ],
+      };
+      apnSendSpy.resolves(error);
+
+      await sendPushNotification(user, {
+        identifier,
+        title,
+        message,
+      });
+
+      expect(fcmSendSpy).to.not.have.been.called;
+      expect(apnSendSpy).to.have.been.calledOnce;
+      expect(updateStub).to.have.been.calledOnce;
+    });
+
+    it('removes invalid apn devices', async () => {
+      user.pushDevices.push({
+        type: 'ios',
+        regId: '123',
+      });
+
+      const error = {
+        failed: [
+          {
+            device: '123',
+            response: { reason: 'BadDeviceToken' },
+          },
+        ],
+      };
+      apnSendSpy.resolves(error);
+
+      await sendPushNotification(user, {
+        identifier,
+        title,
+        message,
+      });
+
+      expect(fcmSendSpy).to.not.have.been.called;
+      expect(apnSendSpy).to.have.been.calledOnce;
+      expect(updateStub).to.have.been.calledOnce;
+    });
+  });
+});

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

@@ -6,7 +6,7 @@ import {
 } from '../../../helpers/api-unit.helper';
 import { ensurePermission } from '../../../../website/server/middlewares/ensureAccessRight';
 import { NotAuthorized } from '../../../../website/server/libs/errors';
-import apiError from '../../../../website/server/libs/apiError';
+import { apiError } from '../../../../website/server/libs/apiError';
 
 describe('ensure access middlewares', () => {
   let res; let req; let

test/api/unit/middlewares/ensureDevelopmentMode.js

@@ -0,0 +1,51 @@
+/* eslint-disable global-require */
+import nconf from 'nconf';
+import {
+  generateRes,
+  generateReq,
+  generateNext,
+} from '../../../helpers/api-unit.helper';
+import ensureDevelopmentMode from '../../../../website/server/middlewares/ensureDevelopmentMode';
+import { NotFound } from '../../../../website/server/libs/errors';
+
+describe('developmentMode middleware', () => {
+  let res; let req; let next;
+  let nconfStub;
+
+  beforeEach(() => {
+    res = generateRes();
+    req = generateReq();
+    next = generateNext();
+    nconfStub = sandbox.stub(nconf, 'get');
+  });
+
+  it('returns not found when on production URL', () => {
+    nconfStub.withArgs('DEBUG_ENABLED').returns(true);
+    nconfStub.withArgs('BASE_URL').returns('https://habitica.com');
+
+    ensureDevelopmentMode(req, res, next);
+
+    const calledWith = next.getCall(0).args;
+    expect(calledWith[0] instanceof NotFound).to.equal(true);
+  });
+
+  it('returns not found when intentionally disabled', () => {
+    nconfStub.withArgs('DEBUG_ENABLED').returns(false);
+    nconfStub.withArgs('BASE_URL').returns('http://localhost:3000');
+
+    ensureDevelopmentMode(req, res, next);
+
+    const calledWith = next.getCall(0).args;
+    expect(calledWith[0] instanceof NotFound).to.equal(true);
+  });
+
+  it('passes when enabled and on non-production URL', () => {
+    nconfStub.withArgs('DEBUG_ENABLED').returns(true);
+    nconfStub.withArgs('BASE_URL').returns('http://localhost:3000');
+
+    ensureDevelopmentMode(req, res, next);
+
+    expect(next).to.be.calledOnce;
+    expect(next.args[0]).to.be.empty;
+  });
+});

test/api/unit/middlewares/ensureDevelpmentMode.js

@@ -1,38 +0,0 @@
-/* eslint-disable global-require */
-import nconf from 'nconf';
-import {
-  generateRes,
-  generateReq,
-  generateNext,
-} from '../../../helpers/api-unit.helper';
-import ensureDevelpmentMode from '../../../../website/server/middlewares/ensureDevelpmentMode';
-import { NotFound } from '../../../../website/server/libs/errors';
-
-describe('developmentMode middleware', () => {
-  let res; let req; let
-    next;
-
-  beforeEach(() => {
-    res = generateRes();
-    req = generateReq();
-    next = generateNext();
-  });
-
-  it('returns not found when in production mode', () => {
-    sandbox.stub(nconf, 'get').withArgs('IS_PROD').returns(true);
-
-    ensureDevelpmentMode(req, res, next);
-
-    const calledWith = next.getCall(0).args;
-    expect(calledWith[0] instanceof NotFound).to.equal(true);
-  });
-
-  it('passes when not in production', () => {
-    sandbox.stub(nconf, 'get').withArgs('IS_PROD').returns(false);
-
-    ensureDevelpmentMode(req, res, next);
-
-    expect(next).to.be.calledOnce;
-    expect(next.args[0]).to.be.empty;
-  });
-});

test/api/unit/middlewares/ensureTimeTravelMode.js

@@ -0,0 +1,51 @@
+/* eslint-disable global-require */
+import nconf from 'nconf';
+import {
+  generateRes,
+  generateReq,
+  generateNext,
+} from '../../../helpers/api-unit.helper';
+import { NotFound } from '../../../../website/server/libs/errors';
+import ensureTimeTravelMode from '../../../../website/server/middlewares/ensureTimeTravelMode';
+
+describe('timetravelMode middleware', () => {
+  let res; let req; let next;
+  let nconfStub;
+
+  beforeEach(() => {
+    res = generateRes();
+    req = generateReq();
+    next = generateNext();
+    nconfStub = sandbox.stub(nconf, 'get');
+  });
+
+  it('returns not found when using production URL', () => {
+    nconfStub.withArgs('TIME_TRAVEL_ENABLED').returns(false);
+    nconfStub.withArgs('BASE_URL').returns('https://habitica.com');
+
+    ensureTimeTravelMode(req, res, next);
+
+    const calledWith = next.getCall(0).args;
+    expect(calledWith[0] instanceof NotFound).to.equal(true);
+  });
+
+  it('returns not found when not in time travel mode', () => {
+    nconfStub.withArgs('TIME_TRAVEL_ENABLED').returns(false);
+    nconfStub.withArgs('BASE_URL').returns('http://localhost:3000');
+
+    ensureTimeTravelMode(req, res, next);
+
+    const calledWith = next.getCall(0).args;
+    expect(calledWith[0] instanceof NotFound).to.equal(true);
+  });
+
+  it('passes when in time travel mode', () => {
+    nconfStub.withArgs('TIME_TRAVEL_ENABLED').returns(true);
+    nconfStub.withArgs('BASE_URL').returns('http://localhost:3000');
+
+    ensureTimeTravelMode(req, res, next);
+
+    expect(next).to.be.calledOnce;
+    expect(next.args[0]).to.be.empty;
+  });
+});

test/api/unit/middlewares/ipBlocker.test.js

@@ -6,7 +6,7 @@ import {
   generateNext,
 } from '../../../helpers/api-unit.helper';
 import { Forbidden } from '../../../../website/server/libs/errors';
-import apiError from '../../../../website/server/libs/apiError';
+import { apiError } from '../../../../website/server/libs/apiError';
 
 function checkErrorThrown (next) {
   expect(next).to.have.been.calledOnce;

test/api/unit/middlewares/rateLimiter.test.js

@@ -7,7 +7,7 @@ import {
   generateNext,
 } from '../../../helpers/api-unit.helper';
 import { TooManyRequests } from '../../../../website/server/libs/errors';
-import apiError from '../../../../website/server/libs/apiError';
+import { apiError } from '../../../../website/server/libs/apiError';
 import logger from '../../../../website/server/libs/logger';
 
 describe('rateLimiter middleware', () => {
@@ -87,6 +87,67 @@ describe('rateLimiter middleware', () => {
     expect(logger.error).to.have.been.calledWithMatch(Error, 'Rate Limiter Error');
   });
 
+  it('does not throw when LIVELINESS_PROBE_KEY is correct', async () => {
+    nconfGetStub.withArgs('RATE_LIMITER_ENABLED').returns('true');
+    nconfGetStub.withArgs('LIVELINESS_PROBE_KEY').returns('abc');
+    const attachRateLimiter = requireAgain(pathToRateLimiter).default;
+
+    req.query.liveliness = 'abc';
+    await attachRateLimiter(req, res, next);
+
+    expect(next).to.have.been.calledOnce;
+    const calledWith = next.getCall(0).args;
+    expect(typeof calledWith[0] === 'undefined').to.equal(true);
+    expect(res.set).to.not.have.been.called;
+  });
+
+  it('limits when LIVELINESS_PROBE_KEY is incorrect', async () => {
+    nconfGetStub.withArgs('RATE_LIMITER_ENABLED').returns('true');
+    nconfGetStub.withArgs('LIVELINESS_PROBE_KEY').returns('abc');
+    const attachRateLimiter = requireAgain(pathToRateLimiter).default;
+
+    req.query.liveliness = 'das';
+    await attachRateLimiter(req, res, next);
+
+    expect(next).to.have.been.calledOnce;
+    expect(res.set).to.have.been.calledWithMatch({
+      'X-RateLimit-Limit': 30,
+      'X-RateLimit-Remaining': 29,
+      'X-RateLimit-Reset': sinon.match(Date),
+    });
+  });
+
+  it('limits when LIVELINESS_PROBE_KEY is not set', async () => {
+    nconfGetStub.withArgs('RATE_LIMITER_ENABLED').returns('true');
+    nconfGetStub.withArgs('LIVELINESS_PROBE_KEY').returns(undefined);
+    const attachRateLimiter = requireAgain(pathToRateLimiter).default;
+
+    await attachRateLimiter(req, res, next);
+
+    expect(next).to.have.been.calledOnce;
+    expect(res.set).to.have.been.calledWithMatch({
+      'X-RateLimit-Limit': 30,
+      'X-RateLimit-Remaining': 29,
+      'X-RateLimit-Reset': sinon.match(Date),
+    });
+  });
+
+  it('throws when LIVELINESS_PROBE_KEY is blank', async () => {
+    nconfGetStub.withArgs('RATE_LIMITER_ENABLED').returns('true');
+    nconfGetStub.withArgs('LIVELINESS_PROBE_KEY').returns('');
+    const attachRateLimiter = requireAgain(pathToRateLimiter).default;
+
+    req.query.liveliness = '';
+    await attachRateLimiter(req, res, next);
+
+    expect(next).to.have.been.calledOnce;
+    expect(res.set).to.have.been.calledWithMatch({
+      'X-RateLimit-Limit': 30,
+      'X-RateLimit-Remaining': 29,
+      'X-RateLimit-Reset': sinon.match(Date),
+    });
+  });
+
   it('throws when there are no available points remaining', async () => {
     nconfGetStub.withArgs('RATE_LIMITER_ENABLED').returns('true');
     const attachRateLimiter = requireAgain(pathToRateLimiter).default;

test/api/unit/middlewares/requestLogHandler.test.js

@@ -0,0 +1,37 @@
+/* eslint-disable global-require */
+import requireAgain from 'require-again';
+import {
+  generateRes,
+  generateReq,
+  generateNext,
+} from '../../../helpers/api-unit.helper';
+
+describe('requestLogHandler middleware', () => {
+  let res; let req; let
+    next;
+  const pathToMiddleWare = '../../../../website/server/middlewares/requestLogHandler';
+
+  beforeEach(() => {
+    res = generateRes();
+    req = generateReq();
+    next = generateNext();
+  });
+
+  it('attaches start time and request ID object to req', () => {
+    const middleware = requireAgain(pathToMiddleWare);
+
+    middleware.logRequestData(req, res, next);
+
+    expect(req.requestStartTime).to.exist;
+    expect(req.requestStartTime).to.be.a('number');
+    expect(req.requestIdentifier).to.exist;
+    expect(req.requestIdentifier).to.be.a('string');
+  });
+
+  it('calls next', () => {
+    const middleware = requireAgain(pathToMiddleWare);
+    const spy = sinon.spy();
+    middleware.logRequestData(req, res, spy);
+    expect(spy.calledOnce).to.be.true;
+  });
+});

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

@@ -1362,8 +1362,8 @@ describe('Group Model', () => {
         sandbox.spy(User, 'updateMany');
       });
 
-      it('formats message', () => {
-        const chatMessage = party.sendChat({
+      it('formats message', async () => {
+        const chatMessage = await party.sendChat({
           message: 'a _new_ message with *markdown*',
           user: {
             _id: 'user-id',
@@ -1396,8 +1396,8 @@ describe('Group Model', () => {
         expect(chat.user).to.eql('user name');
       });
 
-      it('formats message as system if no user is passed in', () => {
-        const chat = party.sendChat({ message: 'a system message' });
+      it('formats message as system if no user is passed in', async () => {
+        const chat = await party.sendChat({ message: 'a system message' });
 
         expect(chat.text).to.eql('a system message');
         expect(validator.isUUID(chat.id)).to.eql(true);
@@ -1411,8 +1411,8 @@ describe('Group Model', () => {
         expect(chat.user).to.not.exist;
       });
 
-      it('updates users about new messages in party', () => {
-        party.sendChat({ message: 'message' });
+      it('updates users about new messages in party', async () => {
+        await party.sendChat({ message: 'message' });
 
         expect(User.updateMany).to.be.calledOnce;
         expect(User.updateMany).to.be.calledWithMatch({
@@ -1421,12 +1421,12 @@ describe('Group Model', () => {
         });
       });
 
-      it('updates users about new messages in group', () => {
+      it('updates users about new messages in group', async () => {
         const group = new Group({
           type: 'guild',
         });
 
-        group.sendChat({ message: 'message' });
+        await group.sendChat({ message: 'message' });
 
         expect(User.updateMany).to.be.calledOnce;
         expect(User.updateMany).to.be.calledWithMatch({
@@ -1435,8 +1435,8 @@ describe('Group Model', () => {
         });
       });
 
-      it('does not send update to user that sent the message', () => {
-        party.sendChat({ message: 'message', user: { _id: 'user-id', profile: { name: 'user' } } });
+      it('does not send update to user that sent the message', async () => {
+        await party.sendChat({ message: 'message', user: { _id: 'user-id', profile: { name: 'user' } } });
 
         expect(User.updateMany).to.be.calledOnce;
         expect(User.updateMany).to.be.calledWithMatch({
@@ -1445,18 +1445,18 @@ describe('Group Model', () => {
         });
       });
 
-      it('skips sending new message notification for guilds with > 5000 members', () => {
+      it('skips sending new message notification for guilds with > 5000 members', async () => {
         party.memberCount = 5001;
 
-        party.sendChat({ message: 'message' });
+        await party.sendChat({ message: 'message' });
 
         expect(User.updateMany).to.not.be.called;
       });
 
-      it('skips sending messages to the tavern', () => {
+      it('skips sending messages to the tavern', async () => {
         party._id = TAVERN_ID;
 
-        party.sendChat({ message: 'message' });
+        await party.sendChat({ message: 'message' });
 
         expect(User.updateMany).to.not.be.called;
       });
@@ -2326,7 +2326,7 @@ describe('Group Model', () => {
 
         await guild.save();
 
-        const groupMessage = guild.sendChat({ message: 'Test message.' });
+        const groupMessage = await guild.sendChat({ message: 'Test message.' });
         await groupMessage.save();
 
         await sleep();

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

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

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

@@ -7,6 +7,7 @@ import {
 
 describe('POST /challenges/:challengeId/flag', () => {
   let user;
+  let challengeGroup;
   let challenge;
 
   beforeEach(async () => {
@@ -20,6 +21,7 @@ describe('POST /challenges/:challengeId/flag', () => {
     });
 
     user = groupLeader;
+    challengeGroup = group;
 
     challenge = await generateChallenge(user, group);
   });
@@ -59,4 +61,19 @@ describe('POST /challenges/:challengeId/flag', () => {
         message: t('messageChallengeFlagAlreadyReported'),
       });
   });
+
+  it('returns an error when user tries to flag an official challenge', async () => {
+    await user.updateOne({
+      permissions: {
+        challengeAdmin: true,
+      },
+    });
+    challenge = await generateChallenge(user, challengeGroup, { official: true });
+    await expect(user.post(`/challenges/${challenge._id}/flag`))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('messageChallengeFlagOfficial'),
+      });
+  });
 });

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

@@ -331,5 +331,71 @@ describe('POST /challenges', () => {
 
       expect(updatedChallenge.summary).to.eql(summary);
     });
+
+    it('sets categories for challenges', async () => {
+      const testCategory = { _id: '65c1172997c0b24600371ea9', slug: 'test', name: 'Test' };
+      const challenge = await groupLeader.post('/challenges', {
+        group: group._id,
+        name: 'Test Challenge',
+        shortName: 'TC Label',
+        categories: [testCategory],
+      });
+
+      const updatedChallenge = await groupLeader.get(`/challenges/${challenge._id}`);
+
+      expect(updatedChallenge.categories).to.eql([testCategory]);
+    });
+
+    it('does not set habitica_official category for non-admins', async () => {
+      const testCategory = { _id: '65c1172997c0b24600371ea9', slug: 'habitica_official', name: 'habitica_official' };
+      await expect(groupLeader.post('/challenges', {
+        group: group._id,
+        name: 'Test Challenge',
+        shortName: 'TC Label',
+        categories: [testCategory],
+      })).to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('noPrivAccess'),
+      });
+    });
+
+    it('sets habitica_official category for admins', async () => {
+      await groupLeader.updateOne({
+        permissions: {
+          challengeAdmin: true,
+        },
+      });
+
+      const testCategory = { _id: '65c1172997c0b24600371ea9', slug: 'habitica_official', name: 'habitica_official' };
+      const challenge = await groupLeader.post('/challenges', {
+        group: group._id,
+        name: 'Test Challenge',
+        shortName: 'TC Label',
+        categories: [testCategory],
+      });
+
+      const updatedChallenge = await groupLeader.get(`/challenges/${challenge._id}`);
+      expect(updatedChallenge.categories).to.eql([testCategory]);
+    });
+
+    it('sets official if the habitica_official category is set for admins', async () => {
+      await groupLeader.updateOne({
+        permissions: {
+          challengeAdmin: true,
+        },
+      });
+
+      const testCategory = { _id: '65c1172997c0b24600371ea9', slug: 'habitica_official', name: 'habitica_official' };
+      const challenge = await groupLeader.post('/challenges', {
+        group: group._id,
+        name: 'Test Challenge',
+        shortName: 'TC Label',
+        categories: [testCategory],
+      });
+
+      const updatedChallenge = await groupLeader.get(`/challenges/${challenge._id}`);
+      expect(updatedChallenge.official).to.eql(true);
+    });
   });
 });

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

@@ -223,4 +223,23 @@ describe('POST /chat/:chatId/flag', () => {
 
     expect(auMessageToCheck).to.not.exist;
   });
+
+  it('validates that the message belongs to the passed group', async () => {
+    const { group: anotherGroup, groupLeader: anotherLeader } = await createAndPopulateGroup({
+      groupDetails: {
+        name: 'Another Guild',
+        type: 'guild',
+        privacy: 'private',
+      },
+      upgradeToGroupPlan: true,
+    });
+
+    const message = await anotherUser.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
+    await expect(anotherLeader.post(`/groups/${anotherGroup._id}/chat/${message.message.id}/flag`))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('messageGroupChatNotFound'),
+      });
+  });
 });

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

@@ -1,5 +1,6 @@
 import { find } from 'lodash';
 import {
+  generateUser,
   createAndPopulateGroup,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
@@ -79,4 +80,35 @@ describe('POST /chat/:chatId/like', () => {
     const messageToCheck = find(groupWithoutChatLikes.chat, { id: message.message.id });
     expect(messageToCheck.likes[user._id]).to.equal(false);
   });
+
+  it('validates that the message belongs to the passed group', async () => {
+    const { group: anotherGroup, groupLeader: anotherLeader } = await createAndPopulateGroup({
+      groupDetails: {
+        name: 'Another Guild',
+        type: 'guild',
+        privacy: 'private',
+      },
+      upgradeToGroupPlan: true,
+    });
+
+    const message = await anotherUser.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
+    await expect(anotherLeader.post(`/groups/${anotherGroup._id}/chat/${message.message.id}/like`))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('messageGroupChatNotFound'),
+      });
+  });
+
+  it('does not like a message if the user is not in the group', async () => {
+    const thirdUser = await generateUser();
+
+    const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
+    await expect(thirdUser.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('groupNotFound'),
+      });
+  });
 });

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

@@ -22,4 +22,38 @@ describe('GET /content', () => {
     expect(res).to.have.nested.property('backgrounds.backgrounds062014.beach');
     expect(res.backgrounds.backgrounds062014.beach.text).to.equal(t('backgroundBeachText'));
   });
+
+  it('does not filter content for regular requests', async () => {
+    const res = await requester().get('/content');
+    expect(res).to.have.nested.property('backgrounds.backgrounds062014');
+    expect(res).to.have.nested.property('gear.tree');
+  });
+
+  it('filters content automatically for iOS requests', async () => {
+    const res = await requester(null, { 'x-client': 'habitica-ios' }).get('/content');
+    expect(res).to.have.nested.property('appearances.background.beach');
+    expect(res).to.not.have.nested.property('backgrounds.backgrounds062014');
+    expect(res).to.not.have.property('backgroundsFlat');
+    expect(res).to.not.have.nested.property('gear.tree');
+  });
+
+  it('filters content automatically for Android requests', async () => {
+    const res = await requester(null, { 'x-client': 'habitica-android' }).get('/content');
+    expect(res).to.not.have.nested.property('appearances.background.beach');
+    expect(res).to.have.nested.property('backgrounds.backgrounds062014');
+    expect(res).to.not.have.property('backgroundsFlat');
+    expect(res).to.not.have.nested.property('gear.tree');
+  });
+
+  it('filters content if the request specifies a filter', async () => {
+    const res = await requester().get('/content?filter=backgroundsFlat,gear.flat');
+    expect(res).to.not.have.property('backgroundsFlat');
+    expect(res).to.have.nested.property('gear.tree');
+    expect(res).to.not.have.nested.property('gear.flat');
+  });
+
+  it('filters content if the request contains invalid filters', async () => {
+    const res = await requester().get('/content?filter=backgroundsFlat,invalid');
+    expect(res).to.not.have.property('backgroundsFlat');
+  });
 });

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

@@ -2,7 +2,7 @@ import {
   generateUser,
   resetHabiticaDB,
 } from '../../../../helpers/api-integration/v3';
-import apiError from '../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../website/server/libs/apiError';
 
 describe('GET /coupons/', () => {
   let user;

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

@@ -4,7 +4,7 @@ import {
   translate as t,
   resetHabiticaDB,
 } from '../../../../helpers/api-integration/v3';
-import apiError from '../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../website/server/libs/apiError';
 
 describe('POST /coupons/generate/:event', () => {
   let user;

test/api/v3/integration/debug/GET-debug-timeTravelTime.test.js

@@ -0,0 +1,46 @@
+import nconf from 'nconf';
+import {
+  generateUser,
+} from '../../../../helpers/api-integration/v3';
+
+describe('GET /debug/time-travel-time', () => {
+  let user;
+  let nconfStub;
+
+  before(async () => {
+    user = await generateUser({ permissions: { fullAccess: true } });
+  });
+
+  beforeEach(() => {
+    nconfStub = sandbox.stub(nconf, 'get');
+  });
+
+  afterEach(() => {
+    nconfStub.restore();
+  });
+
+  it('returns the shifted time', async () => {
+    nconfStub.withArgs('TIME_TRAVEL_ENABLED').returns(true);
+    const result = await user.get('/debug/time-travel-time');
+    expect(result.time).to.exist;
+    await user.post('/debug/jump-time', { disable: true });
+  });
+
+  it('returns shifted when the user is not an admin', async () => {
+    nconfStub.withArgs('TIME_TRAVEL_ENABLED').returns(true);
+    const regularUser = await generateUser();
+    const result = await regularUser.get('/debug/time-travel-time');
+    expect(result.time).to.exist;
+  });
+
+  it('returns error when not in time travel mode', async () => {
+    nconfStub.withArgs('TIME_TRAVEL_ENABLED').returns(false);
+
+    await expect(user.get('/debug/time-travel-time'))
+      .eventually.be.rejected.and.to.deep.equal({
+        code: 404,
+        error: 'NotFound',
+        message: 'Not found.',
+      });
+  });
+});

test/api/v3/integration/debug/POST-debug_addHourglass.test.js

@@ -5,16 +5,23 @@ import {
 
 describe('POST /debug/add-hourglass', () => {
   let userToGetHourGlass;
+  let nconfStub;
 
   before(async () => {
     userToGetHourGlass = await generateUser();
   });
 
-  after(() => {
-    nconf.set('IS_PROD', false);
+  beforeEach(() => {
+    nconfStub = sandbox.stub(nconf, 'get');
+    nconfStub.withArgs('BASE_URL').returns('https://example.com');
+  });
+
+  afterEach(() => {
+    nconfStub.restore();
   });
 
   it('adds Hourglass to the current user', async () => {
+    nconfStub.withArgs('DEBUG_ENABLED').returns(true);
     await userToGetHourGlass.post('/debug/add-hourglass');
 
     const userWithHourGlass = await userToGetHourGlass.get('/user');
@@ -23,7 +30,7 @@ describe('POST /debug/add-hourglass', () => {
   });
 
   it('returns error when not in production mode', async () => {
-    nconf.set('IS_PROD', true);
+    nconfStub.withArgs('DEBUG_ENABLED').returns(false);
 
     await expect(userToGetHourGlass.post('/debug/add-hourglass'))
       .eventually.be.rejected.and.to.deep.equal({

test/api/v3/integration/debug/POST-debug_addTenGems.test.js

@@ -5,16 +5,23 @@ import {
 
 describe('POST /debug/add-ten-gems', () => {
   let userToGainTenGems;
+  let nconfStub;
 
   before(async () => {
     userToGainTenGems = await generateUser();
   });
 
-  after(() => {
-    nconf.set('IS_PROD', false);
+  beforeEach(() => {
+    nconfStub = sandbox.stub(nconf, 'get');
+    nconfStub.withArgs('BASE_URL').returns('https://example.com');
+  });
+
+  afterEach(() => {
+    nconfStub.restore();
   });
 
   it('adds ten gems to the current user', async () => {
+    nconfStub.withArgs('DEBUG_ENABLED').returns(true);
     await userToGainTenGems.post('/debug/add-ten-gems');
 
     const userWithTenGems = await userToGainTenGems.get('/user');
@@ -23,7 +30,7 @@ describe('POST /debug/add-ten-gems', () => {
   });
 
   it('returns error when not in production mode', async () => {
-    nconf.set('IS_PROD', true);
+    nconfStub.withArgs('DEBUG_ENABLED').returns(false);
 
     await expect(userToGainTenGems.post('/debug/add-ten-gems'))
       .eventually.be.rejected.and.to.deep.equal({

test/api/v3/integration/debug/POST-debug_jumpTime.test.js

@@ -0,0 +1,82 @@
+import nconf from 'nconf';
+import {
+  generateUser,
+} from '../../../../helpers/api-integration/v3';
+
+describe('POST /debug/jump-time', () => {
+  let user;
+  let today;
+  let nconfStub;
+
+  before(async () => {
+    user = await generateUser({ permissions: { fullAccess: true } });
+    today = new Date();
+  });
+
+  beforeEach(() => {
+    nconfStub = sandbox.stub(nconf, 'get');
+    nconfStub.withArgs('TIME_TRAVEL_ENABLED').returns(true);
+  });
+
+  afterEach(() => {
+    nconfStub.restore();
+  });
+
+  after(async () => {
+    nconf.set('TIME_TRAVEL_ENABLED', true);
+    await user.post('/debug/jump-time', { disable: true });
+    nconf.set('TIME_TRAVEL_ENABLED', false);
+  });
+
+  it('Jumps forward', async () => {
+    const resultDate = new Date((await user.post('/debug/jump-time', { reset: true })).time);
+    expect(resultDate.getDate()).to.eql(today.getDate());
+    expect(resultDate.getMonth()).to.eql(today.getMonth());
+    expect(resultDate.getFullYear()).to.eql(today.getFullYear());
+    const newResultDate = new Date((await user.post('/debug/jump-time', { offsetDays: 1 })).time);
+    expect(newResultDate.getDate()).to.eql(today.getDate() + 1);
+    expect(newResultDate.getMonth()).to.eql(today.getMonth());
+    expect(newResultDate.getFullYear()).to.eql(today.getFullYear());
+  });
+
+  it('jumps back', async () => {
+    const resultDate = new Date((await user.post('/debug/jump-time', { reset: true })).time);
+    expect(resultDate.getDate()).to.eql(today.getDate());
+    expect(resultDate.getMonth()).to.eql(today.getMonth());
+    expect(resultDate.getFullYear()).to.eql(today.getFullYear());
+    const newResultDate = new Date((await user.post('/debug/jump-time', { offsetDays: -1 })).time);
+    expect(newResultDate.getDate()).to.eql(today.getDate() - 1);
+    expect(newResultDate.getMonth()).to.eql(today.getMonth());
+    expect(newResultDate.getFullYear()).to.eql(today.getFullYear());
+  });
+
+  it('can jump a lot', async () => {
+    const resultDate = new Date((await user.post('/debug/jump-time', { reset: true })).time);
+    expect(resultDate.getDate()).to.eql(today.getDate());
+    expect(resultDate.getMonth()).to.eql(today.getMonth());
+    expect(resultDate.getFullYear()).to.eql(today.getFullYear());
+    const newResultDate = new Date((await user.post('/debug/jump-time', { offsetDays: 355 })).time);
+    expect(newResultDate.getFullYear()).to.eql(today.getFullYear() + 1);
+  });
+
+  it('returns error when the user is not an admin', async () => {
+    const regularUser = await generateUser();
+    await expect(regularUser.post('/debug/jump-time', { offsetDays: 1 }))
+      .eventually.be.rejected.and.to.deep.equal({
+        code: 400,
+        error: 'BadRequest',
+        message: 'You do not have permission to time travel.',
+      });
+  });
+
+  it('returns error when not in time travel mode', async () => {
+    nconfStub.withArgs('TIME_TRAVEL_ENABLED').returns(false);
+
+    await expect(user.post('/debug/jump-time', { offsetDays: 1 }))
+      .eventually.be.rejected.and.to.deep.equal({
+        code: 404,
+        error: 'NotFound',
+        message: 'Not found.',
+      });
+  });
+});

test/api/v3/integration/debug/POST-debug_make-admin.test.js

@@ -5,16 +5,23 @@ import {
 
 describe('POST /debug/make-admin', () => {
   let user;
+  let nconfStub;
 
   before(async () => {
     user = await generateUser();
   });
 
+  beforeEach(() => {
+    nconfStub = sandbox.stub(nconf, 'get');
+    nconfStub.withArgs('BASE_URL').returns('https://example.com');
+  });
+
   afterEach(() => {
-    nconf.set('IS_PROD', false);
+    nconfStub.restore();
   });
 
   it('makes user an admin', async () => {
+    nconfStub.withArgs('DEBUG_ENABLED').returns(true);
     await user.post('/debug/make-admin');
 
     await user.sync();
@@ -23,7 +30,7 @@ describe('POST /debug/make-admin', () => {
   });
 
   it('returns error when not in production mode', async () => {
-    nconf.set('IS_PROD', true);
+    nconfStub.withArgs('DEBUG_ENABLED').returns(false);
 
     await expect(user.post('/debug/make-admin'))
       .eventually.be.rejected.and.to.deep.equal({

test/api/v3/integration/debug/POST-debug_modify-inventory.test.js

@@ -8,6 +8,7 @@ import {
 describe('POST /debug/modify-inventory', () => {
   let user; let
     originalItems;
+  let nconfStub;
 
   before(async () => {
     originalItems = {
@@ -39,8 +40,14 @@ describe('POST /debug/modify-inventory', () => {
     });
   });
 
+  beforeEach(() => {
+    nconfStub = sandbox.stub(nconf, 'get');
+    nconfStub.withArgs('DEBUG_ENABLED').returns(true);
+    nconfStub.withArgs('BASE_URL').returns('https://example.com');
+  });
+
   afterEach(() => {
-    nconf.set('IS_PROD', false);
+    nconfStub.restore();
   });
 
   it('sets equipment', async () => {
@@ -149,7 +156,7 @@ describe('POST /debug/modify-inventory', () => {
   });
 
   it('returns error when not in production mode', async () => {
-    nconf.set('IS_PROD', true);
+    nconfStub.withArgs('DEBUG_ENABLED').returns(false);
 
     await expect(user.post('/debug/modify-inventory'))
       .eventually.be.rejected.and.to.deep.equal({

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

@@ -5,13 +5,20 @@ import {
 
 describe('POST /debug/quest-progress', () => {
   let user;
+  let nconfStub;
 
   beforeEach(async () => {
     user = await generateUser();
   });
 
+  beforeEach(() => {
+    nconfStub = sandbox.stub(nconf, 'get');
+    nconfStub.withArgs('DEBUG_ENABLED').returns(true);
+    nconfStub.withArgs('BASE_URL').returns('https://example.com');
+  });
+
   afterEach(() => {
-    nconf.set('IS_PROD', false);
+    nconfStub.restore();
   });
 
   it('errors if user is not on a quest', async () => {
@@ -48,7 +55,7 @@ describe('POST /debug/quest-progress', () => {
   });
 
   it('returns error when not in production mode', async () => {
-    nconf.set('IS_PROD', true);
+    nconfStub.withArgs('DEBUG_ENABLED').returns(false);
 
     await expect(user.post('/debug/quest-progress'))
       .eventually.be.rejected.and.to.deep.equal({

test/api/v3/integration/debug/POST-debug_set-cron.test.js

@@ -5,13 +5,20 @@ import {
 
 describe('POST /debug/set-cron', () => {
   let user;
+  let nconfStub;
 
   before(async () => {
     user = await generateUser();
   });
 
+  beforeEach(() => {
+    nconfStub = sandbox.stub(nconf, 'get');
+    nconfStub.withArgs('DEBUG_ENABLED').returns(true);
+    nconfStub.withArgs('BASE_URL').returns('https://example.com');
+  });
+
   afterEach(() => {
-    nconf.set('IS_PROD', false);
+    nconfStub.restore();
   });
 
   it('sets last cron', async () => {
@@ -27,7 +34,7 @@ describe('POST /debug/set-cron', () => {
   });
 
   it('returns error when not in production mode', async () => {
-    nconf.set('IS_PROD', true);
+    nconfStub.withArgs('DEBUG_ENABLED').returns(false);
 
     await expect(user.post('/debug/set-cron'))
       .eventually.be.rejected.and.to.deep.equal({

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

@@ -145,6 +145,18 @@ describe('POST /group', () => {
       expect(updatedUser.party._id).to.eql(party._id);
     });
 
+    it('removes seeking from user', async () => {
+      await user.updateOne({ 'party.seeking': new Date() });
+      await user.post('/groups', {
+        name: partyName,
+        type: partyType,
+      });
+
+      const updatedUser = await user.get('/user');
+
+      expect(updatedUser.party.seeking).to.not.exist;
+    });
+
     it('does not award Party Up achievement to solo partier', async () => {
       await user.post('/groups', {
         name: partyName,

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

@@ -178,6 +178,15 @@ describe('POST /group/:groupId/join', () => {
         await expect(invitedUser.get('/user')).to.eventually.not.have.nested.property('invitations.parties[0].id');
       });
 
+      it('clears party.seeking from user when joining party', async () => {
+        await invitedUser.updateOne({ 'party.seeking': new Date() });
+        await invitedUser.post(`/groups/${party._id}/join`);
+
+        const updatedUser = await invitedUser.get('/user');
+
+        await expect(updatedUser.party.seeking).to.not.exist;
+      });
+
       it('increments memberCount when joining party', async () => {
         const oldMemberCount = party.memberCount;
 

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

@@ -4,7 +4,7 @@ import {
   generateGroup,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
-import apiError from '../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../website/server/libs/apiError';
 
 describe('GET /heroes/party/:groupId', () => {
   let user; // admin user

test/api/v3/integration/payments/paypal/GET-payments_paypal_checkout_success.test.js

@@ -2,7 +2,7 @@ import {
   generateUser,
 } from '../../../../../helpers/api-integration/v3';
 import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
-import apiError from '../../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../../website/server/libs/apiError';
 
 describe('payments : paypal #checkoutSuccess', () => {
   const endpoint = '/paypal/checkout/success';

test/api/v3/integration/payments/paypal/GET-payments_paypal_subscribe.test.js

@@ -3,7 +3,7 @@ import {
 } from '../../../../../helpers/api-integration/v3';
 import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
 import shared from '../../../../../../website/common';
-import apiError from '../../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../../website/server/libs/apiError';
 
 describe('payments : paypal #subscribe', () => {
   const endpoint = '/paypal/subscribe';

test/api/v3/integration/payments/paypal/GET-payments_paypal_subscribe_success.test.js

@@ -1,7 +1,7 @@
 import {
   generateUser,
 } from '../../../../../helpers/api-integration/v3';
-import apiError from '../../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../../website/server/libs/apiError';
 import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
 
 describe('payments : paypal #subscribeSuccess', () => {

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

@@ -7,7 +7,7 @@ import {
 } from '../../../../helpers/api-integration/v3';
 import { quests as questScrolls } from '../../../../../website/common/script/content/quests';
 import { chatModel as Chat } from '../../../../../website/server/models/message';
-import apiError from '../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../website/server/libs/apiError';
 
 describe('POST /groups/:groupId/quests/invite/:questKey', () => {
   let questingGroup;

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

@@ -17,9 +17,5 @@ describe('GET /shops/backgrounds', () => {
     expect(shop.notes).to.eql(t('backgroundShop'));
     expect(shop.imageName).to.equal('background_shop');
     expect(shop.sets).to.be.an('array');
-
-    const sets = shop.sets.map(set => set.identifier);
-    expect(sets).to.include('incentiveBackgrounds');
-    expect(sets).to.include('backgrounds062014');
   });
 });

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

@@ -5,9 +5,15 @@ import {
 
 describe('GET /shops/time-travelers', () => {
   let user;
+  let clock;
 
   beforeEach(async () => {
     user = await generateUser();
+    clock = sinon.useFakeTimers(new Date('2024-06-08'));
+  });
+
+  afterEach(() => {
+    clock.restore();
   });
 
   it('returns a valid shop object', async () => {

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

@@ -1,5 +1,5 @@
 import { v4 as generateUUID } from 'uuid';
-import apiError from '../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../website/server/libs/apiError';
 import {
   generateUser,
   sleep,

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

@@ -8,7 +8,7 @@ import {
   generateChallenge,
   sleep,
 } from '../../../../helpers/api-integration/v3';
-import apiError from '../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../website/server/libs/apiError';
 
 describe('POST /user/class/cast/:spellId', () => {
   let user;

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

@@ -33,6 +33,20 @@ describe('POST /user/purchase/:type/:key', () => {
     expect(user.items[type][key]).to.equal(1);
   });
 
+  it('purchases animal ears', async () => {
+    await user.post('/user/purchase/gear/headAccessory_special_tigerEars');
+    await user.sync();
+
+    expect(user.items.gear.owned.headAccessory_special_tigerEars).to.equal(true);
+  });
+
+  it('purchases animal tails', async () => {
+    await user.post('/user/purchase/gear/back_special_pandaTail');
+    await user.sync();
+
+    expect(user.items.gear.owned.back_special_pandaTail).to.equal(true);
+  });
+
   it('can convert gold to gems if subscribed', async () => {
     const oldBalance = user.balance;
     await user.updateOne({

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

@@ -5,7 +5,7 @@ import {
 
 describe('POST /user/unlock', () => {
   let user;
-  const unlockPath = 'shirt.convict,shirt.cross,shirt.fire,shirt.horizon,shirt.ocean,shirt.purple,shirt.rainbow,shirt.redblue,shirt.thunder,shirt.tropical,shirt.zombie';
+  const unlockPath = 'shirt.convict,shirt.fire,shirt.horizon,shirt.ocean,shirt.purple,shirt.rainbow,shirt.redblue,shirt.thunder,shirt.tropical,shirt.zombie';
   const unlockGearSetPath = 'items.gear.owned.headAccessory_special_bearEars,items.gear.owned.headAccessory_special_cactusEars,items.gear.owned.headAccessory_special_foxEars,items.gear.owned.headAccessory_special_lionEars,items.gear.owned.headAccessory_special_pandaEars,items.gear.owned.headAccessory_special_pigEars,items.gear.owned.headAccessory_special_tigerEars,items.gear.owned.headAccessory_special_wolfEars';
   const unlockCost = 1.25;
   const usersStartingGems = 5;

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

@@ -274,6 +274,14 @@ describe('PUT /user', () => {
         expect(get(updatedUser.preferences, type)).to.eql(item);
       });
     });
+
+    it('updates user when background is unequipped', async () => {
+      expect(get(user.preferences, 'background')).to.not.eql('');
+
+      const updatedUser = await user.put('/user', { 'preferences.background': '' });
+
+      expect(get(updatedUser.preferences, 'background')).to.eql('');
+    });
   });
 
   context('Improvement Categories', () => {

test/api/v3/integration/user/auth/PUT-user_update_email.test.js

@@ -108,6 +108,20 @@ describe('PUT /user/auth/update-email', () => {
       const isValidPassword = await bcryptCompare(textPassword, user.auth.local.hashed_password);
       expect(isValidPassword).to.equal(true);
     });
+
+    it('invalidates any outstanding password reset code', async () => {
+      await user.updateOne({
+        'auth.local.passwordResetCode': 'impossible-reset-code',
+      });
+
+      await user.put(ENDPOINT, {
+        newEmail: 'bogo@example.com',
+        password: oldPassword,
+      });
+
+      await user.sync();
+      expect(user.auth.local.passwordResetCode).to.not.exist;
+    });
   });
 
   context('Social Login User', async () => {

test/api/v3/integration/user/buy/POST-user_buy.test.js

@@ -5,12 +5,13 @@ import {
   translate as t,
 } from '../../../../../helpers/api-integration/v3';
 import shared from '../../../../../../website/common/script';
-import apiError from '../../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../../website/server/libs/apiError';
 
 const { content } = shared;
 
 describe('POST /user/buy/:key', () => {
   let user;
+  let clock;
 
   beforeEach(async () => {
     user = await generateUser({
@@ -18,6 +19,12 @@ describe('POST /user/buy/:key', () => {
     });
   });
 
+  afterEach(() => {
+    if (clock) {
+      clock.restore();
+    }
+  });
+
   // More tests in common code unit tests
 
   it('returns an error if the item is not found', async () => {
@@ -68,9 +75,9 @@ describe('POST /user/buy/:key', () => {
   });
 
   it('buys a special spell', async () => {
+    clock = sinon.useFakeTimers(new Date('2024-10-31T00:00:00Z'));
     const key = 'spookySparkles';
     const item = content.special[key];
-    const stub = sinon.stub(item, 'canOwn').returns(true);
 
     await user.updateOne({ 'stats.gp': 250 });
     const res = await user.post(`/user/buy/${key}`);
@@ -83,8 +90,6 @@ describe('POST /user/buy/:key', () => {
     expect(res.message).to.equal(t('messageBought', {
       itemText: item.text(),
     }));
-
-    stub.restore();
   });
 
   it('allows for bulk purchases', async () => {

test/api/v3/integration/user/buy/POST-user_buy_gear.test.js

@@ -3,7 +3,7 @@
 import {
   generateUser,
 } from '../../../../../helpers/api-integration/v3';
-import apiError from '../../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../../website/server/libs/apiError';
 
 describe('POST /user/buy-gear/:key', () => {
   let user;

test/api/v3/integration/user/buy/POST-user_buy_quest.test.js

@@ -3,7 +3,7 @@ import {
   translate as t,
 } from '../../../../../helpers/api-integration/v3';
 import shared from '../../../../../../website/common/script';
-import apiError from '../../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../../website/server/libs/apiError';
 
 const { content } = shared;
 

test/api/v3/integration/user/buy/POST-user_buy_special_spell.test.js

@@ -3,7 +3,7 @@ import {
   translate as t,
 } from '../../../../../helpers/api-integration/v3';
 import shared from '../../../../../../website/common/script';
-import apiError from '../../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../../website/server/libs/apiError';
 
 const { content } = shared;
 

test/api/v3/integration/user/stats/POST-user_allocate.test.js

@@ -2,7 +2,7 @@ import {
   generateUser,
   translate as t,
 } from '../../../../../helpers/api-integration/v3';
-import apiError from '../../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../../website/server/libs/apiError';
 
 describe('POST /user/allocate', () => {
   let user;

test/api/v3/integration/webhook/POST-user_add_webhook.test.js

@@ -3,7 +3,7 @@ import {
   generateUser,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
-import apiError from '../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../website/server/libs/apiError';
 
 describe('POST /user/webhook', () => {
   let user; let

test/api/v3/integration/webhook/PUT-user_update_webhook.test.js

@@ -3,7 +3,7 @@ import {
   generateUser,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
-import apiError from '../../../../../website/server/libs/apiError';
+import { apiError } from '../../../../../website/server/libs/apiError';
 
 describe('PUT /user/webhook/:id', () => {
   let user; let

test/api/v3/integration/world-state/GET-world-state.test.js

@@ -1,5 +1,3 @@
-import { TAVERN_ID } from '../../../../../website/server/models/group';
-import { updateDocument } from '../../../../helpers/mongo';
 import {
   requester,
   resetHabiticaDB,
@@ -18,7 +16,9 @@ describe('GET /world-state', () => {
   });
 
   it('returns Tavern quest data when world boss is active', async () => {
-    await updateDocument('groups', { _id: TAVERN_ID }, { quest: { active: true, key: 'dysheartener', progress: { hp: 50000, rage: 9999 } } });
+    sinon.stub(worldState, 'getWorldBoss').returns({
+      active: true, extra: {}, key: 'dysheartener', progress: { hp: 50000, rage: 9999, collect: {} },
+    });
 
     const res = await requester().get('/world-state');
     expect(res).to.have.nested.property('worldBoss');
@@ -33,15 +33,29 @@ describe('GET /world-state', () => {
         rage: 9999,
       },
     });
+    worldState.getWorldBoss.restore();
+  });
+
+  it('calls getRepeatingEvents for data', async () => {
+    const getRepeatingEventsOnDate = sinon.stub(common.content, 'getRepeatingEventsOnDate').returns([]);
+    const getCurrentGalaEvent = sinon.stub(common.schedule, 'getCurrentGalaEvent').returns({});
+
+    await requester().get('/world-state');
+
+    expect(getRepeatingEventsOnDate).to.have.been.calledOnce;
+    expect(getCurrentGalaEvent).to.have.been.calledOnce;
+
+    getRepeatingEventsOnDate.restore();
+    getCurrentGalaEvent.restore();
   });
 
   context('no current event', () => {
     beforeEach(async () => {
-      sinon.stub(worldState, 'getCurrentEvent').returns(null);
+      sinon.stub(worldState, 'getCurrentEventList').returns([]);
     });
 
     afterEach(() => {
-      worldState.getCurrentEvent.restore();
+      worldState.getCurrentEventList.restore();
     });
 
     it('returns null for the current event when there is none active', async () => {
@@ -51,18 +65,18 @@ describe('GET /world-state', () => {
     });
   });
 
-  context('no current event', () => {
+  context('active event', () => {
     const evt = {
       ...common.content.events.fall2020,
       event: 'fall2020',
     };
 
     beforeEach(async () => {
-      sinon.stub(worldState, 'getCurrentEvent').returns(evt);
+      sinon.stub(worldState, 'getCurrentEventList').returns([evt]);
     });
 
     afterEach(() => {
-      worldState.getCurrentEvent.restore();
+      worldState.getCurrentEventList.restore();
     });
 
     it('returns the current event when there is an active one', async () => {
@@ -71,4 +85,45 @@ describe('GET /world-state', () => {
       expect(res.currentEvent).to.eql(evt);
     });
   });
+
+  context('active event with NPC image suffix', () => {
+    const evt = {
+      ...common.content.events.fall2020,
+      event: 'fall2020',
+      npcImageSuffix: 'fall',
+    };
+
+    beforeEach(async () => {
+      sinon.stub(worldState, 'getCurrentEventList').returns([evt]);
+    });
+
+    afterEach(() => {
+      worldState.getCurrentEventList.restore();
+    });
+
+    it('returns the NPC image suffix when present', async () => {
+      const res = await requester().get('/world-state');
+
+      expect(res.npcImageSuffix).to.equal('fall');
+    });
+
+    it('returns the NPC image suffix with multiple events present', async () => {
+      const evt2 = {
+        ...common.content.events.winter2020,
+        event: 'test',
+      };
+
+      const evt3 = {
+        ...common.content.events.winter2020,
+        event: 'winter2020',
+        npcImageSuffix: 'winter',
+      };
+
+      worldState.getCurrentEventList.returns([evt, evt2, evt3]);
+
+      const res = await requester().get('/world-state');
+
+      expect(res.npcImageSuffix).to.equal('winter');
+    });
+  });
 });

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

@@ -8,7 +8,7 @@ import {
   generateChallenge,
   sleep,
 } from '../../../helpers/api-integration/v4';
-import apiError from '../../../../website/server/libs/apiError';
+import { apiError } from '../../../../website/server/libs/apiError';
 
 describe('POST /user/class/cast/:spellId', () => {
   let user;

test/common/fns/datedMemoize.test.js

@@ -0,0 +1,67 @@
+/* eslint-disable global-require */
+import { expect } from 'chai';
+import nconf from 'nconf';
+
+const SWITCHOVER_TIME = nconf.get('CONTENT_SWITCHOVER_TIME_OFFSET') || 0;
+
+describe('datedMemoize', () => {
+  it('should return a function that returns a function', () => {
+    const datedMemoize = require('../../../website/common/script/fns/datedMemoize').default;
+    const memoized = datedMemoize(() => {});
+    expect(memoized).to.be.a('function');
+  });
+
+  it('should not call multiple times', () => {
+    const stub = sandbox.stub().returns({});
+    const datedMemoize = require('../../../website/common/script/fns/datedMemoize').default;
+    const memoized = datedMemoize(stub);
+    memoized(1, 2);
+    memoized(1, 3);
+    expect(stub).to.have.been.calledOnce;
+  });
+
+  it('call multiple times for different identifiers', () => {
+    const stub = sandbox.stub().returns({});
+    const datedMemoize = require('../../../website/common/script/fns/datedMemoize').default;
+    const memoized = datedMemoize(stub);
+    memoized({ identifier: 'a', memoizeConfig: true }, 1, 2);
+    memoized({ identifier: 'b', memoizeConfig: true }, 1, 2);
+    expect(stub).to.have.been.calledTwice;
+  });
+
+  it('call once for the same identifier', () => {
+    const stub = sandbox.stub().returns({});
+    const datedMemoize = require('../../../website/common/script/fns/datedMemoize').default;
+    const memoized = datedMemoize(stub);
+    memoized({ identifier: 'a', memoizeConfig: true }, 1, 2);
+    memoized({ identifier: 'a', memoizeConfig: true }, 1, 2);
+    expect(stub).to.have.been.calledOnce;
+  });
+
+  it('call once on the same day', () => {
+    const stub = sandbox.stub().returns({});
+    const datedMemoize = require('../../../website/common/script/fns/datedMemoize').default;
+    const memoized = datedMemoize(stub);
+    memoized({ date: new Date('2024-01-01'), memoizeConfig: true }, 1, 2);
+    memoized({ date: new Date('2024-01-01'), memoizeConfig: true }, 1, 2);
+    expect(stub).to.have.been.calledOnce;
+  });
+
+  it('call multiple times on different days', () => {
+    const stub = sandbox.stub().returns({});
+    const datedMemoize = require('../../../website/common/script/fns/datedMemoize').default;
+    const memoized = datedMemoize(stub);
+    memoized({ date: new Date('2024-01-01'), memoizeConfig: true }, 1, 2);
+    memoized({ date: new Date('2024-01-02'), memoizeConfig: true }, 1, 2);
+    expect(stub).to.have.been.calledTwice;
+  });
+
+  it('respects switchover time', () => {
+    const stub = sandbox.stub().returns({});
+    const datedMemoize = require('../../../website/common/script/fns/datedMemoize').default;
+    const memoized = datedMemoize(stub);
+    memoized({ date: new Date('2024-01-01T00:00:00.000Z'), memoizeConfig: true }, 1, 2);
+    memoized({ date: new Date(`2024-01-01T${String(SWITCHOVER_TIME).padStart(2, '0')}`), memoizeConfig: true }, 1, 2);
+    expect(stub).to.have.been.calledTwice;
+  });
+});

test/common/libs/cleanupPinnedItems.test.js

@@ -0,0 +1,123 @@
+import {
+  generateUser,
+} from '../../helpers/common.helper';
+import cleanupPinnedItems from '../../../website/common/script/libs/cleanupPinnedItems';
+
+describe('cleanupPinnedItems', () => {
+  let user;
+  let testPinnedItems;
+  let clock;
+
+  beforeEach(() => {
+    user = generateUser();
+    clock = sinon.useFakeTimers(new Date('2024-04-08'));
+
+    testPinnedItems = [
+      { type: 'armoire', path: 'armoire' },
+      { type: 'potion', path: 'potion' },
+      { type: 'background', path: 'backgrounds.backgrounds042020.heather_field' },
+      { type: 'background', path: 'backgrounds.backgrounds042021.heather_field' },
+      { type: 'premiumHatchingPotion', path: 'premiumHatchingPotions.Rainbow' },
+      { type: 'premiumHatchingPotion', path: 'premiumHatchingPotions.StainedGlass' },
+      { type: 'quests', path: 'quests.rat' },
+      { type: 'quests', path: 'quests.spider' },
+      { type: 'quests', path: 'quests.moon1' },
+      { type: 'quests', path: 'quests.silver' },
+      { type: 'marketGear', path: 'gear.flat.head_special_nye2021' },
+      { type: 'gear', path: 'gear.flat.armor_special_spring2019Rogue' },
+      { type: 'gear', path: 'gear.flat.armor_special_winter2021Rogue' },
+      { type: 'mystery_set', path: 'mystery.201804' },
+      { type: 'mystery_set', path: 'mystery.201506' },
+      { type: 'bundles', path: 'bundles.farmFriends' },
+      { type: 'bundles', path: 'bundles.birdBuddies' },
+      { type: 'customization', path: 'skin.birdBuddies' },
+    ];
+  });
+
+  afterEach(() => {
+    clock.restore();
+  });
+  it('always keeps armoire and potion', () => {
+    user.pinnedItems = testPinnedItems;
+
+    const result = cleanupPinnedItems(user);
+    expect(_.find(result, item => item.path === 'armoire')).to.exist;
+    expect(_.find(result, item => item.path === 'potion')).to.exist;
+  });
+
+  it('removes simple items that are no longer available', () => {
+    user.pinnedItems = testPinnedItems;
+
+    const result = cleanupPinnedItems(user);
+    expect(_.find(result, item => item.path === 'backgrounds.backgrounds042021.heather_field')).to.not.exist;
+    expect(_.find(result, item => item.path === 'premiumHatchingPotions.Rainbow')).to.not.exist;
+  });
+
+  it('keeps simple items that are still available', () => {
+    user.pinnedItems = testPinnedItems;
+    const result = cleanupPinnedItems(user);
+    expect(_.find(result, item => item.path === 'backgrounds.backgrounds042020.heather_field')).to.exist;
+    expect(_.find(result, item => item.path === 'premiumHatchingPotions.StainedGlass')).to.exist;
+  });
+
+  it('removes gear that is no longer available', () => {
+    user.pinnedItems = testPinnedItems;
+    const result = cleanupPinnedItems(user);
+    expect(_.find(result, item => item.path === 'gear.flat.armor_special_winter2021Rogue')).to.not.exist;
+  });
+
+  it('keeps gear that is still available', () => {
+    user.pinnedItems = testPinnedItems;
+    const result = cleanupPinnedItems(user);
+    expect(_.find(result, item => item.path === 'gear.flat.armor_special_spring2019Rogue')).to.exist;
+  });
+
+  it('keeps gear that is not seasonal', () => {
+    user.pinnedItems = testPinnedItems;
+    const result = cleanupPinnedItems(user);
+    expect(_.find(result, item => item.path === 'gear.flat.head_special_nye2021')).to.exist;
+  });
+
+  it('removes time traveler gear that is no longer available', () => {
+    user.pinnedItems = testPinnedItems;
+    const result = cleanupPinnedItems(user);
+    expect(_.find(result, item => item.path === 'mystery.201506')).to.not.exist;
+  });
+
+  it('keeps time traveler gear that is still available', () => {
+    user.pinnedItems = testPinnedItems;
+    const result = cleanupPinnedItems(user);
+    expect(_.find(result, item => item.path === 'mystery.201804')).to.exist;
+  });
+
+  it('removes quests that are no longer available', () => {
+    user.pinnedItems = testPinnedItems;
+    const result = cleanupPinnedItems(user);
+    expect(_.find(result, item => item.path === 'quests.rat')).to.not.exist;
+    expect(_.find(result, item => item.path === 'quests.silver')).to.not.exist;
+  });
+
+  it('keeps quests that are still available', () => {
+    user.pinnedItems = testPinnedItems;
+    const result = cleanupPinnedItems(user);
+    expect(_.find(result, item => item.path === 'quests.spider')).to.exist;
+  });
+
+  it('keeps quests that are not seasonal', () => {
+    user.pinnedItems = testPinnedItems;
+    const result = cleanupPinnedItems(user);
+    expect(_.find(result, item => item.path === 'quests.moon1')).to.exist;
+  });
+
+  it('removes bundles that are no longer available', () => {
+    user.pinnedItems = testPinnedItems;
+    const result = cleanupPinnedItems(user);
+    expect(_.find(result, item => item.path === 'bundles.farmFriends')).to.not.exist;
+  });
+
+  it('keeps bundles that are still available', () => {
+    user.pinnedItems = testPinnedItems;
+    const result = cleanupPinnedItems(user);
+    expect(_.find(result, item => item.path === 'bundles.birdBuddies')).to.exist;
+  });
+});

test/common/libs/shops.js

@@ -1,219 +0,0 @@
-import shared from '../../../website/common';
-import {
-  generateUser,
-} from '../../helpers/common.helper';
-
-describe('shops', () => {
-  const user = generateUser();
-
-  describe('market', () => {
-    const shopCategories = shared.shops.getMarketCategories(user);
-
-    it('contains at least the 3 default categories', () => {
-      expect(shopCategories.length).to.be.greaterThan(2);
-    });
-
-    it('does not contain an empty category', () => {
-      _.each(shopCategories, category => {
-        expect(category.items.length).to.be.greaterThan(0);
-      });
-    });
-
-    it('does not duplicate identifiers', () => {
-      const identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
-
-      expect(identifiers.length).to.eql(shopCategories.length);
-    });
-
-    it('items contain required fields', () => {
-      _.each(shopCategories, category => {
-        _.each(category.items, item => {
-          _.each(['key', 'text', 'notes', 'value', 'currency', 'locked', 'purchaseType', 'class'], key => {
-            expect(_.has(item, key)).to.eql(true);
-          });
-        });
-      });
-    });
-
-    it('shows relevant non class gear in special category', () => {
-      const contributor = generateUser({
-        contributor: {
-          level: 7,
-          critical: true,
-        },
-        items: {
-          gear: {
-            owned: {
-              weapon_armoire_basicCrossbow: true, // eslint-disable-line camelcase
-            },
-          },
-        },
-      });
-
-      const gearCategories = shared.shops.getMarketGearCategories(contributor);
-      const specialCategory = gearCategories.find(o => o.identifier === 'none');
-      expect(specialCategory.items.find(item => item.key === 'weapon_special_1'));
-      expect(specialCategory.items.find(item => item.key === 'armor_special_1'));
-      expect(specialCategory.items.find(item => item.key === 'head_special_1'));
-      expect(specialCategory.items.find(item => item.key === 'shield_special_1'));
-      expect(specialCategory.items.find(item => item.key === 'weapon_special_critical'));
-      expect(specialCategory.items.find(item => item.key === 'weapon_armoire_basicCrossbow'));// eslint-disable-line camelcase
-    });
-
-    it('does not show gear when it is all owned', () => {
-      const userWithItems = generateUser({
-        stats: {
-          class: 'wizard',
-        },
-        items: {
-          gear: {
-            owned: {
-              weapon_wizard_0: true, // eslint-disable-line camelcase
-              weapon_wizard_1: true, // eslint-disable-line camelcase
-              weapon_wizard_2: true, // eslint-disable-line camelcase
-              weapon_wizard_3: true, // eslint-disable-line camelcase
-              weapon_wizard_4: true, // eslint-disable-line camelcase
-              weapon_wizard_5: true, // eslint-disable-line camelcase
-              weapon_wizard_6: true, // eslint-disable-line camelcase
-              armor_wizard_1: true, // eslint-disable-line camelcase
-              armor_wizard_2: true, // eslint-disable-line camelcase
-              armor_wizard_3: true, // eslint-disable-line camelcase
-              armor_wizard_4: true, // eslint-disable-line camelcase
-              armor_wizard_5: true, // eslint-disable-line camelcase
-              head_wizard_1: true, // eslint-disable-line camelcase
-              head_wizard_2: true, // eslint-disable-line camelcase
-              head_wizard_3: true, // eslint-disable-line camelcase
-              head_wizard_4: true, // eslint-disable-line camelcase
-              head_wizard_5: true, // eslint-disable-line camelcase
-            },
-          },
-        },
-      });
-
-      const shopWizardItems = shared.shops.getMarketGearCategories(userWithItems).find(x => x.identifier === 'wizard').items.filter(x => x.klass === 'wizard' && (x.owned === false || x.owned === undefined));
-      expect(shopWizardItems.length).to.eql(0);
-    });
-
-    it('shows available gear not yet purchased and previously owned', () => {
-      const userWithItems = generateUser({
-        stats: {
-          class: 'wizard',
-        },
-        items: {
-          gear: {
-            owned: {
-              weapon_wizard_0: true, // eslint-disable-line camelcase
-              weapon_wizard_1: true, // eslint-disable-line camelcase
-              weapon_wizard_2: true, // eslint-disable-line camelcase
-              weapon_wizard_3: true, // eslint-disable-line camelcase
-              weapon_wizard_4: true, // eslint-disable-line camelcase
-              armor_wizard_1: true, // eslint-disable-line camelcase
-              armor_wizard_2: true, // eslint-disable-line camelcase
-              armor_wizard_3: false, // eslint-disable-line camelcase
-              armor_wizard_4: false, // eslint-disable-line camelcase
-              head_wizard_1: true, // eslint-disable-line camelcase
-              head_wizard_2: false, // eslint-disable-line camelcase
-              head_wizard_3: true, // eslint-disable-line camelcase
-              head_wizard_4: false, // eslint-disable-line camelcase
-              head_wizard_5: true, // eslint-disable-line camelcase
-            },
-          },
-        },
-      });
-
-      const shopWizardItems = shared.shops.getMarketGearCategories(userWithItems).find(x => x.identifier === 'wizard').items.filter(x => x.klass === 'wizard' && (x.owned === false || x.owned === undefined));
-      expect(shopWizardItems.find(item => item.key === 'weapon_wizard_5').locked).to.eql(false);
-      expect(shopWizardItems.find(item => item.key === 'weapon_wizard_6').locked).to.eql(true);
-      expect(shopWizardItems.find(item => item.key === 'armor_wizard_3').locked).to.eql(false);
-      expect(shopWizardItems.find(item => item.key === 'armor_wizard_4').locked).to.eql(true);
-      expect(shopWizardItems.find(item => item.key === 'head_wizard_2').locked).to.eql(false);
-      expect(shopWizardItems.find(item => item.key === 'head_wizard_4').locked).to.eql(true);
-    });
-  });
-
-  describe('questShop', () => {
-    const shopCategories = shared.shops.getQuestShopCategories(user);
-
-    it('does not contain an empty category', () => {
-      _.each(shopCategories, category => {
-        expect(category.items.length).to.be.greaterThan(0);
-      });
-    });
-
-    it('does not duplicate identifiers', () => {
-      const identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
-
-      expect(identifiers.length).to.eql(shopCategories.length);
-    });
-
-    it('items contain required fields', () => {
-      _.each(shopCategories, category => {
-        if (category.identifier === 'bundle') {
-          _.each(category.items, item => {
-            _.each(['key', 'text', 'notes', 'value', 'currency', 'purchaseType', 'class'], key => {
-              expect(_.has(item, key)).to.eql(true);
-            });
-          });
-        } else {
-          _.each(category.items, item => {
-            _.each(['key', 'text', 'notes', 'value', 'currency', 'locked', 'purchaseType', 'boss', 'class', 'collect', 'drop', 'unlockCondition', 'lvl'], key => {
-              expect(_.has(item, key)).to.eql(true);
-            });
-          });
-        }
-      });
-    });
-  });
-
-  describe('timeTravelers', () => {
-    const shopCategories = shared.shops.getTimeTravelersCategories(user);
-
-    it('does not contain an empty category', () => {
-      _.each(shopCategories, category => {
-        expect(category.items.length).to.be.greaterThan(0);
-      });
-    });
-
-    it('does not duplicate identifiers', () => {
-      const identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
-
-      expect(identifiers.length).to.eql(shopCategories.length);
-    });
-
-    it('items contain required fields', () => {
-      _.each(shopCategories, category => {
-        _.each(category.items, item => {
-          _.each(['key', 'text', 'value', 'currency', 'locked', 'purchaseType', 'class', 'notes', 'class'], key => {
-            expect(_.has(item, key)).to.eql(true);
-          });
-        });
-      });
-    });
-  });
-
-  describe('seasonalShop', () => {
-    const shopCategories = shared.shops.getSeasonalShopCategories(user);
-
-    it('does not contain an empty category', () => {
-      _.each(shopCategories, category => {
-        expect(category.items.length).to.be.greaterThan(0);
-      });
-    });
-
-    it('does not duplicate identifiers', () => {
-      const identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
-
-      expect(identifiers.length).to.eql(shopCategories.length);
-    });
-
-    it('items contain required fields', () => {
-      _.each(shopCategories, category => {
-        _.each(category.items, item => {
-          _.each(['key', 'text', 'notes', 'value', 'currency', 'locked', 'purchaseType', 'type'], key => {
-            expect(_.has(item, key)).to.eql(true);
-          });
-        });
-      });
-    });
-  });
-});

test/common/libs/shops.test.js

@@ -0,0 +1,430 @@
+import shared from '../../../website/common';
+import {
+  generateUser,
+} from '../../helpers/common.helper';
+
+import seasonalConfig from '../../../website/common/script/libs/shops-seasonal.config';
+
+describe('shops', () => {
+  const user = generateUser();
+  let clock;
+
+  afterEach(() => {
+    if (clock) {
+      clock.restore();
+    }
+    user.achievements.quests = {};
+  });
+
+  describe('market', () => {
+    const shopCategories = shared.shops.getMarketCategories(user);
+
+    it('contains at least the 3 default categories', () => {
+      expect(shopCategories.length).to.be.greaterThan(2);
+    });
+
+    it('does not contain an empty category', () => {
+      _.each(shopCategories, category => {
+        expect(category.items.length).to.be.greaterThan(0);
+      });
+    });
+
+    it('does not duplicate identifiers', () => {
+      const identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
+
+      expect(identifiers.length).to.eql(shopCategories.length);
+    });
+
+    it('items contain required fields', () => {
+      _.each(shopCategories, category => {
+        _.each(category.items, item => {
+          _.each(['key', 'text', 'notes', 'value', 'currency', 'locked', 'purchaseType', 'class'], key => {
+            expect(_.has(item, key)).to.eql(true);
+          });
+        });
+      });
+    });
+
+    describe('premium hatching potions', () => {
+      it('contains current scheduled premium hatching potions', async () => {
+        clock = sinon.useFakeTimers(new Date('2024-04-01'));
+        const potions = shared.shops.getMarketCategories(user).find(x => x.identifier === 'premiumHatchingPotions');
+        expect(potions.items.length).to.eql(2);
+      });
+
+      it('does not contain past scheduled premium hatching potions', async () => {
+        const potions = shared.shops.getMarketCategories(user).find(x => x.identifier === 'premiumHatchingPotions');
+        expect(potions.items.filter(x => x.key === 'Aquatic' || x.key === 'Celestial').length).to.eql(0);
+      });
+      it('returns end date for scheduled premium potions', async () => {
+        const potions = shared.shops.getMarketCategories(user).find(x => x.identifier === 'premiumHatchingPotions');
+        potions.items.forEach(potion => {
+          expect(potion.end).to.exist;
+        });
+      });
+
+      it('contains unlocked quest premium hatching potions', async () => {
+        user.achievements.quests = {
+          bronze: 1,
+          blackPearl: 1,
+        };
+        const potions = shared.shops.getMarketCategories(user).find(x => x.identifier === 'premiumHatchingPotions');
+        expect(potions.items.filter(x => x.key === 'Bronze' || x.key === 'BlackPearl').length).to.eql(2);
+      });
+
+      it('does not contain locked quest premium hatching potions', async () => {
+        clock = sinon.useFakeTimers(new Date('2024-04-01'));
+        const potions = shared.shops.getMarketCategories(user).find(x => x.identifier === 'premiumHatchingPotions');
+        expect(potions.items.length).to.eql(2);
+        expect(potions.items.filter(x => x.key === 'Bronze' || x.key === 'BlackPearl').length).to.eql(0);
+      });
+
+      it('does not return end date for quest premium potions', async () => {
+        user.achievements.quests = {
+          bronze: 1,
+          blackPearl: 1,
+        };
+        const potions = shared.shops.getMarketCategories(user).find(x => x.identifier === 'premiumHatchingPotions');
+        potions.items.filter(x => x.key === 'Bronze' || x.key === 'BlackPearl').forEach(potion => {
+          expect(potion.end).to.not.exist;
+        });
+      });
+    });
+
+    it('does not return items with event data', async () => {
+      shopCategories.forEach(category => {
+        category.items.forEach(item => {
+          expect(item.event).to.not.exist;
+          expect(item.season).to.not.exist;
+        });
+      });
+    });
+
+    it('shows relevant non class gear in special category', () => {
+      const contributor = generateUser({
+        contributor: {
+          level: 7,
+          critical: true,
+        },
+        items: {
+          gear: {
+            owned: {
+              weapon_armoire_basicCrossbow: true, // eslint-disable-line camelcase
+            },
+          },
+        },
+      });
+
+      const gearCategories = shared.shops.getMarketGearCategories(contributor);
+      const specialCategory = gearCategories.find(o => o.identifier === 'none');
+      expect(specialCategory.items.find(item => item.key === 'weapon_special_1'), 'weapon_special_1');
+      expect(specialCategory.items.find(item => item.key === 'armor_special_1'), 'armor_special_1');
+      expect(specialCategory.items.find(item => item.key === 'head_special_1'), 'head_special_1');
+      expect(specialCategory.items.find(item => item.key === 'shield_special_1'), 'shield_special_1');
+      expect(specialCategory.items.find(item => item.key === 'weapon_special_critical'), 'weapon_special_critical');
+      expect(specialCategory.items.find(item => item.key === 'weapon_armoire_basicCrossbow'), 'weapon_armoire_basicCrossbow');// eslint-disable-line camelcase
+    });
+
+    describe('handles seasonal gear', () => {
+      beforeEach(() => {
+        clock = sinon.useFakeTimers(new Date('2024-04-01'));
+      });
+
+      it('shows current seasonal gear for warriors', () => {
+        const warriorItems = shared.shops.getMarketGearCategories(user).find(x => x.identifier === 'warrior').items.filter(x => x.key.indexOf('spring2024') !== -1);
+        expect(warriorItems.length, 'Warrior seasonal gear').to.eql(4);
+      });
+
+      it('shows current seasonal gear for mages', () => {
+        const mageItems = shared.shops.getMarketGearCategories(user).find(x => x.identifier === 'wizard').items.filter(x => x.key.indexOf('spring2024') !== -1);
+        expect(mageItems.length, 'Mage seasonal gear').to.eql(3);
+      });
+
+      it('shows current seasonal gear for healers', () => {
+        const healerItems = shared.shops.getMarketGearCategories(user).find(x => x.identifier === 'healer').items.filter(x => x.key.indexOf('spring2024') !== -1);
+        expect(healerItems.length, 'Healer seasonal gear').to.eql(4);
+      });
+
+      it('shows current seasonal gear for rogues', () => {
+        const rogueItems = shared.shops.getMarketGearCategories(user).find(x => x.identifier === 'rogue').items.filter(x => x.key.indexOf('spring2024') !== -1);
+        expect(rogueItems.length, 'Rogue seasonal gear').to.eql(4);
+      });
+
+      it('seasonal gear contains end date', () => {
+        const categories = shared.shops.getMarketGearCategories(user);
+        categories.forEach(category => {
+          category.items.filter(x => x.key.indexOf('spring2024') !== -1).forEach(item => {
+            expect(item.end, item.key).to.exist;
+          });
+        });
+      });
+
+      it('only shows gear for the current season', () => {
+        const categories = shared.shops.getMarketGearCategories(user);
+        categories.forEach(category => {
+          const otherSeasons = category.items.filter(item => item.key.indexOf('winter') !== -1 || item.key.indexOf('summer') !== -1 || item.key.indexOf('fall') !== -1);
+          expect(otherSeasons.length).to.eql(0);
+        });
+      });
+
+      it('does not show gear from past seasons', () => {
+        const categories = shared.shops.getMarketGearCategories(user);
+        categories.forEach(category => {
+          const otherYears = category.items.filter(item => item.key.indexOf('spring') !== -1 && item.key.indexOf('2024') === -1);
+          expect(otherYears.length).to.eql(0);
+        });
+      });
+    });
+
+    it('does not show gear when it is all owned', () => {
+      const userWithItems = generateUser({
+        stats: {
+          class: 'wizard',
+        },
+        items: {
+          gear: {
+            owned: {
+              weapon_wizard_0: true, // eslint-disable-line camelcase
+              weapon_wizard_1: true, // eslint-disable-line camelcase
+              weapon_wizard_2: true, // eslint-disable-line camelcase
+              weapon_wizard_3: true, // eslint-disable-line camelcase
+              weapon_wizard_4: true, // eslint-disable-line camelcase
+              weapon_wizard_5: true, // eslint-disable-line camelcase
+              weapon_wizard_6: true, // eslint-disable-line camelcase
+              armor_wizard_1: true, // eslint-disable-line camelcase
+              armor_wizard_2: true, // eslint-disable-line camelcase
+              armor_wizard_3: true, // eslint-disable-line camelcase
+              armor_wizard_4: true, // eslint-disable-line camelcase
+              armor_wizard_5: true, // eslint-disable-line camelcase
+              head_wizard_1: true, // eslint-disable-line camelcase
+              head_wizard_2: true, // eslint-disable-line camelcase
+              head_wizard_3: true, // eslint-disable-line camelcase
+              head_wizard_4: true, // eslint-disable-line camelcase
+              head_wizard_5: true, // eslint-disable-line camelcase
+            },
+          },
+        },
+      });
+
+      const shopWizardItems = shared.shops.getMarketGearCategories(userWithItems).find(x => x.identifier === 'wizard').items.filter(x => x.klass === 'wizard' && (x.owned === false || x.owned === undefined));
+      expect(shopWizardItems.length).to.eql(0);
+    });
+
+    it('shows available gear not yet purchased and previously owned', () => {
+      const userWithItems = generateUser({
+        stats: {
+          class: 'wizard',
+        },
+        items: {
+          gear: {
+            owned: {
+              weapon_wizard_0: true, // eslint-disable-line camelcase
+              weapon_wizard_1: true, // eslint-disable-line camelcase
+              weapon_wizard_2: true, // eslint-disable-line camelcase
+              weapon_wizard_3: true, // eslint-disable-line camelcase
+              weapon_wizard_4: true, // eslint-disable-line camelcase
+              armor_wizard_1: true, // eslint-disable-line camelcase
+              armor_wizard_2: true, // eslint-disable-line camelcase
+              armor_wizard_3: false, // eslint-disable-line camelcase
+              armor_wizard_4: false, // eslint-disable-line camelcase
+              head_wizard_1: true, // eslint-disable-line camelcase
+              head_wizard_2: false, // eslint-disable-line camelcase
+              head_wizard_3: true, // eslint-disable-line camelcase
+              head_wizard_4: false, // eslint-disable-line camelcase
+              head_wizard_5: true, // eslint-disable-line camelcase
+            },
+          },
+        },
+      });
+
+      const shopWizardItems = shared.shops.getMarketGearCategories(userWithItems).find(x => x.identifier === 'wizard').items.filter(x => x.klass === 'wizard' && (x.owned === false || x.owned === undefined));
+      expect(shopWizardItems.find(item => item.key === 'weapon_wizard_5').locked).to.eql(false);
+      expect(shopWizardItems.find(item => item.key === 'weapon_wizard_6').locked).to.eql(true);
+      expect(shopWizardItems.find(item => item.key === 'armor_wizard_3').locked).to.eql(false);
+      expect(shopWizardItems.find(item => item.key === 'armor_wizard_4').locked).to.eql(true);
+      expect(shopWizardItems.find(item => item.key === 'head_wizard_2').locked).to.eql(false);
+      expect(shopWizardItems.find(item => item.key === 'head_wizard_4').locked).to.eql(true);
+    });
+  });
+
+  describe('questShop', () => {
+    const shopCategories = shared.shops.getQuestShopCategories(user);
+
+    it('does not contain an empty category', () => {
+      _.each(shopCategories, category => {
+        expect(category.items.length, category.identifier).to.be.greaterThan(0);
+      });
+    });
+
+    it('does not duplicate identifiers', () => {
+      const identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
+
+      expect(identifiers.length).to.eql(shopCategories.length);
+    });
+
+    it('items contain required fields', () => {
+      _.each(shopCategories, category => {
+        if (category.identifier === 'bundle') {
+          _.each(category.items, item => {
+            _.each(['key', 'text', 'notes', 'value', 'currency', 'purchaseType', 'class'], key => {
+              expect(_.has(item, key)).to.eql(true);
+            });
+          });
+        } else {
+          _.each(category.items, item => {
+            _.each(['key', 'text', 'notes', 'value', 'currency', 'locked', 'purchaseType', 'boss', 'class', 'collect', 'drop', 'unlockCondition', 'lvl'], key => {
+              expect(_.has(item, key)).to.eql(true);
+            });
+          });
+        }
+      });
+    });
+
+    it('does not return items with event data', async () => {
+      shopCategories.forEach(category => {
+        category.items.forEach(item => {
+          expect(item.event).to.not.exist;
+        });
+      });
+    });
+  });
+
+  describe('timeTravelers', () => {
+    const shopCategories = shared.shops.getTimeTravelersCategories(user);
+
+    it('does not contain an empty category', () => {
+      _.each(shopCategories, category => {
+        expect(category.items.length).to.be.greaterThan(0);
+      });
+    });
+
+    it('does not duplicate identifiers', () => {
+      const identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
+
+      expect(identifiers.length).to.eql(shopCategories.length);
+    });
+
+    it('items contain required fields', () => {
+      _.each(shopCategories, category => {
+        _.each(category.items, item => {
+          _.each(['key', 'text', 'value', 'currency', 'locked', 'purchaseType', 'class', 'notes', 'class'], key => {
+            expect(_.has(item, key)).to.eql(true);
+          });
+        });
+      });
+    });
+
+    it('does not return items with event data', async () => {
+      shopCategories.forEach(category => {
+        category.items.forEach(item => {
+          expect(item.event).to.not.exist;
+        });
+      });
+    });
+
+    it('returns pets', () => {
+      const pets = shopCategories.find(cat => cat.identifier === 'pets').items;
+      expect(pets.length).to.be.greaterThan(0);
+    });
+
+    it('returns mounts', () => {
+      const mounts = shopCategories.find(cat => cat.identifier === 'mounts').items;
+      expect(mounts.length).to.be.greaterThan(0);
+    });
+
+    it('returns quests', () => {
+      const quests = shopCategories.find(cat => cat.identifier === 'quests').items;
+      expect(quests.length).to.be.greaterThan(0);
+    });
+
+    it('returns backgrounds', () => {
+      const backgrounds = shopCategories.find(cat => cat.identifier === 'backgrounds').items;
+      expect(backgrounds.length).to.be.greaterThan(0);
+    });
+  });
+
+  describe('customizationShop', () => {
+    const shopCategories = shared.shops.getCustomizationsShopCategories(user, null);
+
+    it('does not return items with event data', async () => {
+      shopCategories.forEach(category => {
+        category.items.forEach(item => {
+          expect(item.event, item.key).to.not.exist;
+        });
+      });
+    });
+
+    it('backgrounds category contains end date', () => {
+      const backgroundCategory = shopCategories.find(cat => cat.identifier === 'backgrounds');
+      expect(backgroundCategory.end).to.exist;
+      expect(backgroundCategory.end).to.be.greaterThan(new Date());
+    });
+
+    it('hair color category contains end date', () => {
+      const colorCategory = shopCategories.find(cat => cat.identifier === 'color');
+      expect(colorCategory.end).to.exist;
+      expect(colorCategory.end).to.be.greaterThan(new Date());
+    });
+
+    it('skin category contains end date', () => {
+      const colorCategory = shopCategories.find(cat => cat.identifier === 'color');
+      expect(colorCategory.end).to.exist;
+      expect(colorCategory.end).to.be.greaterThan(new Date());
+    });
+  });
+
+  describe('seasonalShop', () => {
+    const shopCategories = shared.shops.getSeasonalShopCategories(user, null, seasonalConfig());
+    const today = new Date();
+
+    it('does not contain an empty category', () => {
+      _.each(shopCategories, category => {
+        expect(category.items.length).to.be.greaterThan(0);
+      });
+    });
+
+    it('does not duplicate identifiers', () => {
+      const identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
+
+      expect(identifiers.length).to.eql(shopCategories.length);
+    });
+
+    it('does not return items with event data', async () => {
+      shopCategories.forEach(category => {
+        category.items.forEach(item => {
+          expect(item.event, item.key).to.not.exist;
+        });
+      });
+    });
+
+    it('items contain required fields', () => {
+      _.each(shopCategories, category => {
+        _.each(category.items, item => {
+          _.each(['key', 'text', 'notes', 'value', 'currency', 'locked', 'purchaseType', 'type'], key => {
+            expect(_.has(item, key), item.key).to.eql(true);
+          });
+        });
+      });
+    });
+
+    it('items have a valid end date', () => {
+      shopCategories.forEach(category => {
+        category.items.forEach(item => {
+          expect(item.end, item.key).to.be.a('date');
+          expect(item.end, item.key).to.be.greaterThan(today);
+        });
+      });
+    });
+
+    it('items match current season', () => {
+      const currentSeason = seasonalConfig().currentSeason.toLowerCase();
+      shopCategories.forEach(category => {
+        category.items.forEach(item => {
+          if (item.klass === 'special') {
+            expect(item.season, item.key).to.eql(currentSeason);
+          }
+        });
+      });
+    });
+  });
+});

test/common/ops/armoireCanOwn.js

@@ -1,11 +1,11 @@
-import * as armoireSet from '../../../website/common/script/content/gear/sets/armoire';
+import armoireSet from '../../../website/common/script/content/gear/sets/armoire';
 
 describe('armoireSet items', () => {
   it('checks if canOwn has the same id', () => {
     Object.keys(armoireSet).forEach(type => {
+      if (type === 'all') return;
       Object.keys(armoireSet[type]).forEach(itemKey => {
         const ownedKey = `${type}_armoire_${itemKey}`;
-
         expect(armoireSet[type][itemKey].canOwn({
           items: {
             gear: {

test/common/ops/buy/buy.test.js

@@ -9,7 +9,7 @@ import {
 } from '../../../../website/common/script/libs/errors';
 import i18n from '../../../../website/common/script/i18n';
 import content from '../../../../website/common/script/content/index';
-import errorMessage from '../../../../website/common/script/libs/errorMessage';
+import { errorMessage } from '../../../../website/common/script/libs/errorMessage';
 
 describe('shared.ops.buy', () => {
   let user;
@@ -49,7 +49,7 @@ describe('shared.ops.buy', () => {
     }
   });
 
-  it('recovers 15 hp', async () => {
+  it('buys health potion', async () => {
     user.stats.hp = 30;
     await buy(user, { params: { key: 'potion' } }, analytics);
     expect(user.stats.hp).to.eql(45);

test/common/ops/buy/buyArmoire.test.js

@@ -17,9 +17,7 @@ function getFullArmoire () {
 
   _.each(content.gearTypes, type => {
     _.each(content.gear.tree[type].armoire, gearObject => {
-      if (gearObject.released) {
-        fullArmoire[gearObject.key] = true;
-      }
+      fullArmoire[gearObject.key] = true;
     });
   });
 

test/common/ops/buy/buyMarketGear.test.js

@@ -11,7 +11,7 @@ import {
   BadRequest, NotAuthorized, NotFound,
 } from '../../../../website/common/script/libs/errors';
 import i18n from '../../../../website/common/script/i18n';
-import errorMessage from '../../../../website/common/script/libs/errorMessage';
+import { errorMessage } from '../../../../website/common/script/libs/errorMessage';
 
 async function buyGear (user, req, analytics) {
   const buyOp = new BuyMarketGearOperation(user, req, analytics);
@@ -22,6 +22,7 @@ async function buyGear (user, req, analytics) {
 describe('shared.ops.buyMarketGear', () => {
   let user;
   const analytics = { track () {} };
+  let clock;
 
   beforeEach(() => {
     user = generateUser({
@@ -54,6 +55,10 @@ describe('shared.ops.buyMarketGear', () => {
     shared.fns.predictableRandom.restore();
     shared.onboarding.checkOnboardingStatus.restore();
     analytics.track.restore();
+
+    if (clock) {
+      clock.restore();
+    }
   });
 
   context('Gear', () => {
@@ -184,30 +189,28 @@ describe('shared.ops.buyMarketGear', () => {
     });
 
     // 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', async () => {
+    it('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;
-      await buyGear(user, { params: { key: 'shield_warrior_1' } });
-      user.ops.equip({ params: { key: 'shield_warrior_1' } });
-      await buyGear(user, { params: { key: 'weapon_warrior_1' } });
-      user.ops.equip({ params: { key: 'weapon_warrior_1' } });
+      user.items.gear.equipped.weapon = 'weapon_warrior_1';
+      user.items.gear.equipped.shield = 'shield_warrior_1';
+      user.stats.class = 'wizard';
 
-      await buyGear(user, { params: { key: 'weapon_wizard_1' } });
+      await buyGear(user, { params: { key: 'weapon_wizard_0' } });
 
       expect(user.items.gear.equipped).to.have.property('shield', 'shield_base_0');
-      expect(user.items.gear.equipped).to.have.property('weapon', 'weapon_wizard_1');
+      expect(user.items.gear.equipped).to.have.property('weapon', 'weapon_wizard_0');
     });
 
     // TODO after user.ops.equip is done
-    xit('buyGears two-handed equipment but does not automatically remove sword or shield', async () => {
+    it('buyGears two-handed equipment but does not automatically remove sword or shield', async () => {
       user.stats.gp = 100;
       user.preferences.autoEquip = false;
-      await buyGear(user, { params: { key: 'shield_warrior_1' } });
-      user.ops.equip({ params: { key: 'shield_warrior_1' } });
-      await buyGear(user, { params: { key: 'weapon_warrior_1' } });
-      user.ops.equip({ params: { key: 'weapon_warrior_1' } });
+      user.items.gear.equipped.weapon = 'weapon_warrior_1';
+      user.items.gear.equipped.shield = 'shield_warrior_1';
+      user.stats.class = 'wizard';
 
-      await buyGear(user, { params: { key: 'weapon_wizard_1' } });
+      await buyGear(user, { params: { key: 'weapon_wizard_0' } });
 
       expect(user.items.gear.equipped).to.have.property('shield', 'shield_warrior_1');
       expect(user.items.gear.equipped).to.have.property('weapon', 'weapon_warrior_1');
@@ -283,5 +286,40 @@ describe('shared.ops.buyMarketGear', () => {
 
       expect(user.items.gear.owned).to.have.property('shield_armoire_ramHornShield', true);
     });
+
+    it('buys current seasonal gear', async () => {
+      user.stats.gp = 200;
+      clock = sinon.useFakeTimers(new Date('2024-01-01'));
+
+      await buyGear(user, { params: { key: 'armor_special_winter2024Warrior' } });
+
+      expect(user.items.gear.owned).to.have.property('armor_special_winter2024Warrior', true);
+    });
+
+    it('errors when buying past seasonal gear', async () => {
+      clock = sinon.useFakeTimers(new Date('2024-01-01'));
+      user.stats.gp = 200;
+
+      try {
+        await buyGear(user, { params: { key: 'armor_special_winter2023Warrior' } });
+      } catch (err) {
+        expect(err).to.be.an.instanceof(NotAuthorized);
+        expect(err.message).to.equal(i18n.t('notAvailable'));
+        expect(user.items.gear.owned).to.not.have.property('armor_special_winter2023Warrior');
+      }
+    });
+
+    it('errors when buying gear from wrong season', async () => {
+      clock = sinon.useFakeTimers(new Date('2024-01-01'));
+      user.stats.gp = 200;
+
+      try {
+        await buyGear(user, { params: { key: 'weapon_special_spring2024Warrior' } });
+      } catch (err) {
+        expect(err).to.be.an.instanceof(NotAuthorized);
+        expect(err.message).to.equal(i18n.t('notAvailable'));
+        expect(user.items.gear.owned).to.not.have.property('weapon_special_spring2024Warrior');
+      }
+    });
   });
 });

test/common/ops/buy/buyMysterySet.test.js

@@ -10,11 +10,12 @@ import {
   NotFound,
 } from '../../../../website/common/script/libs/errors';
 import i18n from '../../../../website/common/script/i18n';
-import errorMessage from '../../../../website/common/script/libs/errorMessage';
+import { errorMessage } from '../../../../website/common/script/libs/errorMessage';
 
 describe('shared.ops.buyMysterySet', () => {
   let user;
   const analytics = { track () {} };
+  let clock;
 
   beforeEach(() => {
     user = generateUser({
@@ -31,6 +32,9 @@ describe('shared.ops.buyMysterySet', () => {
 
   afterEach(() => {
     analytics.track.restore();
+    if (clock) {
+      clock.restore();
+    }
   });
 
   context('Mystery Sets', () => {
@@ -41,7 +45,7 @@ describe('shared.ops.buyMysterySet', () => {
         } 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);
+          expect(user.items.gear.owned).to.not.have.property('armor_mystery_201501');
         }
       });
 
@@ -72,6 +76,18 @@ describe('shared.ops.buyMysterySet', () => {
           expect(err.message).to.equal(errorMessage('missingKeyParam'));
         }
       });
+
+      it('returns error if the set is not available', async () => {
+        user.purchased.plan.consecutive.trinkets = 1;
+        clock = sinon.useFakeTimers(new Date('2024-01-16'));
+        try {
+          await buyMysterySet(user, { params: { key: '201501' } });
+        } catch (err) {
+          expect(err).to.be.an.instanceof(NotAuthorized);
+          expect(err.message).to.eql(i18n.t('notAvailable'));
+          expect(user.items.gear.owned).to.not.have.property('armor_mystery_201501');
+        }
+      });
     });
 
     context('successful purchases', () => {
@@ -86,6 +102,16 @@ describe('shared.ops.buyMysterySet', () => {
         expect(user.items.gear.owned).to.have.property('head_mystery_301404', true);
         expect(user.items.gear.owned).to.have.property('eyewear_mystery_301404', true);
       });
+
+      it('buys mystery set if it is available', async () => {
+        clock = sinon.useFakeTimers(new Date('2024-01-16'));
+        user.purchased.plan.consecutive.trinkets = 1;
+        await buyMysterySet(user, { params: { key: '201601' } }, analytics);
+
+        expect(user.purchased.plan.consecutive.trinkets).to.eql(0);
+        expect(user.items.gear.owned).to.have.property('shield_mystery_201601', true);
+        expect(user.items.gear.owned).to.have.property('head_mystery_201601', true);
+      });
     });
   });
 });

test/common/ops/buy/buyQuestGems.test.js

@@ -10,6 +10,7 @@ import { BuyQuestWithGemOperation } from '../../../../website/common/script/ops/
 
 describe('shared.ops.buyQuestGems', () => {
   let user;
+  let clock;
   const goldPoints = 40;
   const analytics = { track () {} };
 
@@ -26,11 +27,13 @@ describe('shared.ops.buyQuestGems', () => {
   beforeEach(() => {
     sinon.stub(analytics, 'track');
     sinon.spy(pinnedGearUtils, 'removeItemByPath');
+    clock = sinon.useFakeTimers(new Date('2024-01-16'));
   });
 
   afterEach(() => {
     analytics.track.restore();
     pinnedGearUtils.removeItemByPath.restore();
+    clock.restore();
   });
 
   context('single purchase', () => {
@@ -44,7 +47,7 @@ describe('shared.ops.buyQuestGems', () => {
       user.pinnedItems.push({ type: 'quests', key: 'gryphon' });
     });
 
-    it('successfully purchases quest', async () => {
+    it('successfully purchases pet quest', async () => {
       const key = 'gryphon';
 
       await buyQuest(user, { params: { key } });
@@ -52,6 +55,61 @@ describe('shared.ops.buyQuestGems', () => {
       expect(user.items.quests[key]).to.equal(1);
       expect(pinnedGearUtils.removeItemByPath.notCalled).to.equal(true);
     });
+
+    it('successfully purchases hatching potion quest', async () => {
+      const key = 'silver';
+
+      await buyQuest(user, { params: { key } });
+
+      expect(user.items.quests[key]).to.equal(1);
+      expect(pinnedGearUtils.removeItemByPath.notCalled).to.equal(true);
+    });
+
+    it('successfully purchases seasonal quest', async () => {
+      const key = 'evilsanta';
+
+      await buyQuest(user, { params: { key } });
+
+      expect(user.items.quests[key]).to.equal(1);
+      expect(pinnedGearUtils.removeItemByPath.notCalled).to.equal(true);
+    });
+
+    it('errors if the pet quest is not available', async () => {
+      const key = 'sabretooth';
+
+      try {
+        await buyQuest(user, { params: { key } });
+      } catch (err) {
+        expect(err).to.be.an.instanceof(NotAuthorized);
+        expect(err.message).to.equal(i18n.t('notAvailable'));
+        expect(user.items.quests[key]).to.eql(undefined);
+      }
+    });
+
+    it('errors if the hatching potion quest is not available', async () => {
+      const key = 'ruby';
+
+      try {
+        await buyQuest(user, { params: { key } });
+      } catch (err) {
+        expect(err).to.be.an.instanceof(NotAuthorized);
+        expect(err.message).to.equal(i18n.t('notAvailable'));
+        expect(user.items.quests[key]).to.eql(undefined);
+      }
+    });
+
+    it('errors if the seasonal quest is not available', async () => {
+      const key = 'egg';
+
+      try {
+        await buyQuest(user, { params: { key } });
+      } catch (err) {
+        expect(err).to.be.an.instanceof(NotAuthorized);
+        expect(err.message).to.equal(i18n.t('notAvailable'));
+        expect(user.items.quests[key]).to.eql(undefined);
+      }
+    });
+
     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;
@@ -61,6 +119,7 @@ describe('shared.ops.buyQuestGems', () => {
       expect(user.items.quests[key]).to.equal(1);
       expect(pinnedGearUtils.removeItemByPath.notCalled).to.equal(true);
     });
+
     it('errors if the user has not completed prerequisite quests', async () => {
       const key = 'atom3';
       user.achievements.quests.atom1 = 1;
@@ -73,6 +132,7 @@ describe('shared.ops.buyQuestGems', () => {
         expect(user.items.quests[key]).to.eql(undefined);
       }
     });
+
     it('successfully purchases quest if user has completed all prerequisite quests', async () => {
       const key = 'atom3';
       user.achievements.quests.atom1 = 1;

test/common/ops/buy/buyQuestGold.test.js

@@ -8,7 +8,7 @@ import {
   NotFound,
 } from '../../../../website/common/script/libs/errors';
 import i18n from '../../../../website/common/script/i18n';
-import errorMessage from '../../../../website/common/script/libs/errorMessage';
+import { errorMessage } from '../../../../website/common/script/libs/errorMessage';
 
 describe('shared.ops.buyQuest', () => {
   let user;

test/common/ops/buy/buySpell.js

@@ -1,89 +0,0 @@
-import { BuySpellOperation } from '../../../../website/common/script/ops/buy/buySpell';
-import {
-  BadRequest,
-  NotFound,
-  NotAuthorized,
-} from '../../../../website/common/script/libs/errors';
-import i18n from '../../../../website/common/script/i18n';
-import {
-  generateUser,
-} from '../../../helpers/common.helper';
-import content from '../../../../website/common/script/content/index';
-import errorMessage from '../../../../website/common/script/libs/errorMessage';
-
-describe('shared.ops.buySpecialSpell', () => {
-  let user;
-  const analytics = { track () {} };
-
-  async function buySpecialSpell (_user, _req, _analytics) {
-    const buyOp = new BuySpellOperation(_user, _req, _analytics);
-
-    return buyOp.purchase();
-  }
-  beforeEach(() => {
-    user = generateUser();
-    sinon.stub(analytics, 'track');
-  });
-
-  afterEach(() => {
-    analytics.track.restore();
-  });
-
-  it('throws an error if params.key is missing', async () => {
-    try {
-      await buySpecialSpell(user);
-    } catch (err) {
-      expect(err).to.be.an.instanceof(BadRequest);
-      expect(err.message).to.equal(errorMessage('missingKeyParam'));
-    }
-  });
-
-  it('throws an error if the spell doesn\'t exists', async () => {
-    try {
-      await buySpecialSpell(user, {
-        params: {
-          key: 'notExisting',
-        },
-      });
-    } catch (err) {
-      expect(err).to.be.an.instanceof(NotFound);
-      expect(err.message).to.equal(errorMessage('spellNotFound', { spellId: 'notExisting' }));
-    }
-  });
-
-  it('throws an error if the user doesn\'t have enough gold', async () => {
-    user.stats.gp = 1;
-    try {
-      await buySpecialSpell(user, {
-        params: {
-          key: 'thankyou',
-        },
-      });
-    } catch (err) {
-      expect(err).to.be.an.instanceof(NotAuthorized);
-      expect(err.message).to.equal(i18n.t('messageNotEnoughGold'));
-    }
-  });
-
-  it('buys an item', async () => {
-    user.stats.gp = 11;
-    const item = content.special.thankyou;
-
-    const [data, message] = await buySpecialSpell(user, {
-      params: {
-        key: 'thankyou',
-      },
-    }, analytics);
-
-    expect(user.stats.gp).to.equal(1);
-    expect(user.items.special.thankyou).to.equal(1);
-    expect(data).to.eql({
-      items: user.items,
-      stats: user.stats,
-    });
-    expect(message).to.equal(i18n.t('messageBought', {
-      itemText: item.text(),
-    }));
-    expect(analytics.track).to.be.calledOnce;
-  });
-});

test/common/ops/buy/buySpell.test.js

@@ -0,0 +1,172 @@
+import { BuySpellOperation } from '../../../../website/common/script/ops/buy/buySpell';
+import {
+  BadRequest,
+  NotFound,
+  NotAuthorized,
+} from '../../../../website/common/script/libs/errors';
+import i18n from '../../../../website/common/script/i18n';
+import {
+  generateUser,
+} from '../../../helpers/common.helper';
+import content from '../../../../website/common/script/content/index';
+import { errorMessage } from '../../../../website/common/script/libs/errorMessage';
+
+describe('shared.ops.buySpecialSpell', () => {
+  let user;
+  let clock;
+  const analytics = { track () {} };
+
+  async function buySpecialSpell (_user, _req, _analytics) {
+    const buyOp = new BuySpellOperation(_user, _req, _analytics);
+
+    return buyOp.purchase();
+  }
+  beforeEach(() => {
+    user = generateUser();
+    sinon.stub(analytics, 'track');
+  });
+
+  afterEach(() => {
+    analytics.track.restore();
+    if (clock) {
+      clock.restore();
+    }
+  });
+
+  it('throws an error if params.key is missing', async () => {
+    try {
+      await buySpecialSpell(user);
+    } catch (err) {
+      expect(err).to.be.an.instanceof(BadRequest);
+      expect(err.message).to.equal(errorMessage('missingKeyParam'));
+    }
+  });
+
+  it('throws an error if the item doesn\'t exists', async () => {
+    try {
+      await buySpecialSpell(user, {
+        params: {
+          key: 'notExisting',
+        },
+      });
+    } catch (err) {
+      expect(err).to.be.an.instanceof(NotFound);
+      expect(err.message).to.equal(errorMessage('spellNotFound', { spellId: 'notExisting' }));
+    }
+  });
+
+  it('throws an error if the user doesn\'t have enough gold', async () => {
+    user.stats.gp = 1;
+    try {
+      await buySpecialSpell(user, {
+        params: {
+          key: 'thankyou',
+        },
+      });
+    } catch (err) {
+      expect(err).to.be.an.instanceof(NotAuthorized);
+      expect(err.message).to.equal(i18n.t('messageNotEnoughGold'));
+    }
+  });
+
+  describe('buying cards', () => {
+    it('buys a card that is always available', async () => {
+      user.stats.gp = 11;
+      const item = content.special.thankyou;
+
+      const [data, message] = await buySpecialSpell(user, {
+        params: {
+          key: 'thankyou',
+        },
+      }, analytics);
+
+      expect(user.stats.gp).to.equal(1);
+      expect(user.items.special.thankyou).to.equal(1);
+      expect(data).to.eql({
+        items: user.items,
+        stats: user.stats,
+      });
+      expect(message).to.equal(i18n.t('messageBought', {
+        itemText: item.text(),
+      }));
+      expect(analytics.track).to.be.calledOnce;
+    });
+
+    it('buys a limited card when it is available', async () => {
+      user.stats.gp = 11;
+      const item = content.special.nye;
+      clock = sinon.useFakeTimers(new Date('2024-01-01'));
+
+      const [data, message] = await buySpecialSpell(user, {
+        params: {
+          key: 'nye',
+        },
+      }, analytics);
+
+      expect(user.stats.gp).to.equal(1);
+      expect(user.items.special.nye).to.equal(1);
+      expect(data).to.eql({
+        items: user.items,
+        stats: user.stats,
+      });
+      expect(message).to.equal(i18n.t('messageBought', {
+        itemText: item.text(),
+      }));
+      expect(analytics.track).to.be.calledOnce;
+    });
+
+    it('throws an error if the card is not currently available', async () => {
+      user.stats.gp = 11;
+      clock = sinon.useFakeTimers(new Date('2024-06-01'));
+      try {
+        await buySpecialSpell(user, {
+          params: {
+            key: 'nye',
+          },
+        });
+      } catch (err) {
+        expect(err).to.be.an.instanceof(NotAuthorized);
+        expect(err.message).to.equal(i18n.t('cannotBuyItem'));
+      }
+    });
+  });
+
+  describe('buying spells', () => {
+    it('buys a spell if it is currently available', async () => {
+      user.stats.gp = 16;
+      clock = sinon.useFakeTimers(new Date('2024-06-22'));
+      const item = content.special.seafoam;
+      const [data, message] = await buySpecialSpell(user, {
+        params: {
+          key: 'seafoam',
+        },
+      }, analytics);
+
+      expect(user.stats.gp).to.equal(1);
+      expect(user.items.special.seafoam).to.equal(1);
+      expect(data).to.eql({
+        items: user.items,
+        stats: user.stats,
+      });
+      expect(message).to.equal(i18n.t('messageBought', {
+        itemText: item.text(),
+      }));
+      expect(analytics.track).to.be.calledOnce;
+    });
+
+    it('throws an error if the spell is not currently available', async () => {
+      user.stats.gp = 50;
+      clock = sinon.useFakeTimers(new Date('2024-01-22'));
+      try {
+        await buySpecialSpell(user, {
+          params: {
+            key: 'seafoam',
+          },
+        });
+      } catch (err) {
+        expect(err).to.be.an.instanceof(NotAuthorized);
+        expect(err.message).to.equal(i18n.t('cannotBuyItem'));
+      }
+    });
+  });
+});

test/common/ops/buy/hourglassPurchase.test.js

@@ -8,7 +8,7 @@ import content from '../../../../website/common/script/content/index';
 import {
   generateUser,
 } from '../../../helpers/common.helper';
-import errorMessage from '../../../../website/common/script/libs/errorMessage';
+import { errorMessage } from '../../../../website/common/script/libs/errorMessage';
 import { BuyHourglassMountOperation } from '../../../../website/common/script/ops/buy/buyMount';
 
 describe('common.ops.hourglassPurchase', () => {

test/common/ops/buy/purchase.test.js

@@ -15,6 +15,7 @@ import {
 describe('shared.ops.purchase', () => {
   const SEASONAL_FOOD = moment().isBefore('2021-11-02T20:00-04:00') ? 'Candy_Base' : 'Meat';
   let user;
+  let clock;
   const goldPoints = 40;
   const analytics = { track () {} };
 
@@ -25,11 +26,13 @@ describe('shared.ops.purchase', () => {
   beforeEach(() => {
     sinon.stub(analytics, 'track');
     sinon.spy(pinnedGearUtils, 'removeItemByPath');
+    clock = sandbox.useFakeTimers(new Date('2024-01-10'));
   });
 
   afterEach(() => {
     analytics.track.restore();
     pinnedGearUtils.removeItemByPath.restore();
+    clock.restore();
   });
 
   context('failure conditions', () => {
@@ -82,13 +85,77 @@ describe('shared.ops.purchase', () => {
 
     it('returns error when user does not have enough gems to buy an item', async () => {
       try {
-        await purchase(user, { params: { type: 'gear', key: 'headAccessory_special_wolfEars' } });
+        await purchase(user, { params: { type: 'gear', key: 'shield_special_winter2019Healer' } });
       } catch (err) {
         expect(err).to.be.an.instanceof(NotAuthorized);
         expect(err.message).to.equal(i18n.t('notEnoughGems'));
       }
     });
 
+    it('returns error when gear is not available', async () => {
+      try {
+        await purchase(user, { params: { type: 'gear', key: 'shield_special_spring2019Healer' } });
+      } catch (err) {
+        expect(err).to.be.an.instanceof(NotAuthorized);
+        expect(err.message).to.equal(i18n.t('messageNotAvailable'));
+      }
+    });
+
+    it('returns an error when purchasing current seasonal gear', async () => {
+      user.balance = 2;
+      try {
+        await purchase(user, { params: { type: 'gear', key: 'shield_special_winter2024Healer' } });
+      } catch (err) {
+        expect(err).to.be.an.instanceof(NotAuthorized);
+        expect(err.message).to.equal(i18n.t('messageNotAvailable'));
+      }
+    });
+
+    it('returns error when hatching potion is not available', async () => {
+      try {
+        await purchase(user, { params: { type: 'hatchingPotions', key: 'PolkaDot' } });
+      } catch (err) {
+        expect(err).to.be.an.instanceof(NotAuthorized);
+        expect(err.message).to.equal(i18n.t('messageNotAvailable'));
+      }
+    });
+
+    it('returns error when quest for hatching potion was not yet completed', async () => {
+      try {
+        await purchase(user, { params: { type: 'hatchingPotions', key: 'BlackPearl' } });
+      } catch (err) {
+        expect(err).to.be.an.instanceof(NotAuthorized);
+        expect(err.message).to.equal(i18n.t('messageNotAvailable'));
+      }
+    });
+
+    it('returns error when quest for egg was not yet completed', async () => {
+      try {
+        await purchase(user, { params: { type: 'eggs', key: 'Octopus' } });
+      } catch (err) {
+        expect(err).to.be.an.instanceof(NotAuthorized);
+        expect(err.message).to.equal(i18n.t('messageNotAvailable'));
+      }
+    });
+
+    it('returns error when bundle is not available', async () => {
+      try {
+        await purchase(user, { params: { type: 'bundles', key: 'forestFriends' } });
+      } catch (err) {
+        expect(err).to.be.an.instanceof(NotAuthorized);
+        expect(err.message).to.equal(i18n.t('notAvailable'));
+      }
+    });
+
+    it('returns error when gear is not gem purchasable', async () => {
+      try {
+        await purchase(user, { params: { type: 'gear', key: 'shield_healer_3' } });
+      } catch (err) {
+        expect(err).to.be.an.instanceof(NotAuthorized);
+        expect(err.message).to.equal(i18n.t('messageNotAvailable'));
+      }
+    });
+
     it('returns error when item is not found', async () => {
       const params = { key: 'notExisting', type: 'food' };
 
@@ -99,44 +166,6 @@ describe('shared.ops.purchase', () => {
         expect(err.message).to.equal(i18n.t('contentKeyNotFound', params));
       }
     });
-
-    it('returns error when user supplies a non-numeric quantity', async () => {
-      const type = 'eggs';
-      const key = 'Wolf';
-
-      try {
-        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'));
-      }
-    });
-
-    it('returns error when user supplies a negative quantity', async () => {
-      const type = 'eggs';
-      const key = 'Wolf';
-      user.balance = 10;
-
-      try {
-        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'));
-      }
-    });
-
-    it('returns error when user supplies a decimal quantity', async () => {
-      const type = 'eggs';
-      const key = 'Wolf';
-      user.balance = 10;
-
-      try {
-        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'));
-      }
-    });
   });
 
   context('successful purchase', () => {
@@ -150,7 +179,7 @@ describe('shared.ops.purchase', () => {
       user.pinnedItems.push({ type: 'eggs', key: 'Wolf' });
       user.pinnedItems.push({ type: 'hatchingPotions', key: 'Base' });
       user.pinnedItems.push({ type: 'food', key: SEASONAL_FOOD });
-      user.pinnedItems.push({ type: 'gear', key: 'headAccessory_special_tigerEars' });
+      user.pinnedItems.push({ type: 'gear', key: 'shield_special_winter2019Healer' });
       user.pinnedItems.push({ type: 'bundles', key: 'featheredFriends' });
     });
 
@@ -185,9 +214,9 @@ describe('shared.ops.purchase', () => {
       expect(pinnedGearUtils.removeItemByPath.notCalled).to.equal(true);
     });
 
-    it('purchases gear', async () => {
+    it('purchases past seasonal gear', async () => {
       const type = 'gear';
-      const key = 'headAccessory_special_tigerEars';
+      const key = 'shield_special_winter2019Healer';
 
       await purchase(user, { params: { type, key } });
 
@@ -195,9 +224,39 @@ describe('shared.ops.purchase', () => {
       expect(pinnedGearUtils.removeItemByPath.calledOnce).to.equal(true);
     });
 
+    it('purchases hatching potion', async () => {
+      const type = 'hatchingPotions';
+      const key = 'Peppermint';
+
+      await purchase(user, { params: { type, key } });
+
+      expect(user.items.hatchingPotions[key]).to.eql(1);
+    });
+
+    it('purchases hatching potion if user completed quest', async () => {
+      const type = 'hatchingPotions';
+      const key = 'Bronze';
+      user.achievements.quests.bronze = 1;
+
+      await purchase(user, { params: { type, key } });
+
+      expect(user.items.hatchingPotions[key]).to.eql(1);
+    });
+
+    it('purchases egg if user completed quest', async () => {
+      const type = 'eggs';
+      const key = 'Deer';
+      user.achievements.quests.ghost_stag = 1;
+
+      await purchase(user, { params: { type, key } });
+
+      expect(user.items.eggs[key]).to.eql(1);
+    });
+
     it('purchases quest bundles', async () => {
       const startingBalance = user.balance;
-      const clock = sandbox.useFakeTimers(moment('2024-03-20').valueOf());
+      clock.restore();
+      clock = sandbox.useFakeTimers(moment('2022-03-10').valueOf());
       const type = 'bundles';
       const key = 'cuddleBuddies';
       const price = 1.75;
@@ -216,7 +275,6 @@ describe('shared.ops.purchase', () => {
       expect(user.balance).to.equal(startingBalance - price);
 
       expect(pinnedGearUtils.removeItemByPath.notCalled).to.equal(true);
-      clock.restore();
     });
   });
 
@@ -257,5 +315,43 @@ describe('shared.ops.purchase', () => {
 
       expect(user.items[type][key]).to.equal(2);
     });
+
+    it('returns error when user supplies a non-numeric quantity', async () => {
+      const type = 'eggs';
+      const key = 'Wolf';
+
+      try {
+        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'));
+      }
+    });
+
+    it('returns error when user supplies a negative quantity', async () => {
+      const type = 'eggs';
+      const key = 'Wolf';
+      user.balance = 10;
+
+      try {
+        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'));
+      }
+    });
+
+    it('returns error when user supplies a decimal quantity', async () => {
+      const type = 'eggs';
+      const key = 'Wolf';
+      user.balance = 10;
+
+      try {
+        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'));
+      }
+    });
   });
 });

test/common/ops/feed.js

@@ -9,7 +9,7 @@ import i18n from '../../../website/common/script/i18n';
 import {
   generateUser,
 } from '../../helpers/common.helper';
-import errorMessage from '../../../website/common/script/libs/errorMessage';
+import { errorMessage } from '../../../website/common/script/libs/errorMessage';
 import shared from '../../../website/common/script';
 
 describe('shared.ops.feed', () => {

test/common/ops/hatch.js

@@ -8,7 +8,7 @@ import i18n from '../../../website/common/script/i18n';
 import {
   generateUser,
 } from '../../helpers/common.helper';
-import errorMessage from '../../../website/common/script/libs/errorMessage';
+import { errorMessage } from '../../../website/common/script/libs/errorMessage';
 import shared from '../../../website/common/script';
 
 describe('shared.ops.hatch', () => {

test/common/ops/sleep.js

@@ -1,4 +1,4 @@
-import sleep from '../../../website/common/script/ops/sleep';
+import { sleep } from '../../../website/common/script/ops/sleep';
 import {
   generateUser,
 } from '../../helpers/common.helper';

test/common/ops/stats/allocate.js

@@ -7,7 +7,7 @@ import i18n from '../../../../website/common/script/i18n';
 import {
   generateUser,
 } from '../../../helpers/common.helper';
-import errorMessage from '../../../../website/common/script/libs/errorMessage';
+import { errorMessage } from '../../../../website/common/script/libs/errorMessage';
 
 describe('shared.ops.allocate', () => {
   let user;

test/common/ops/stats/allocateBulk.js

@@ -7,7 +7,7 @@ import i18n from '../../../../website/common/script/i18n';
 import {
   generateUser,
 } from '../../../helpers/common.helper';
-import errorMessage from '../../../../website/common/script/libs/errorMessage';
+import { errorMessage } from '../../../../website/common/script/libs/errorMessage';
 
 describe('shared.ops.allocateBulk', () => {
   let user;

test/common/ops/unlock.test.js

@@ -2,14 +2,17 @@ import get from 'lodash/get';
 import unlock from '../../../website/common/script/ops/unlock';
 import i18n from '../../../website/common/script/i18n';
 import { generateUser } from '../../helpers/common.helper';
-import { NotAuthorized, BadRequest } from '../../../website/common/script/libs/errors';
+import {
+  NotAuthorized,
+  BadRequest,
+} from '../../../website/common/script/libs/errors';
 
 describe('shared.ops.unlock', () => {
   let user;
-  const unlockPath = 'shirt.convict,shirt.cross,shirt.fire,shirt.horizon,shirt.ocean,shirt.purple,shirt.rainbow,shirt.redblue,shirt.thunder,shirt.tropical,shirt.zombie';
+  let clock;
+  const unlockPath = 'shirt.convict,shirt.fire,shirt.horizon,shirt.ocean,shirt.purple,shirt.rainbow,shirt.redblue,shirt.thunder,shirt.tropical,shirt.zombie';
   const unlockGearSetPath = 'items.gear.owned.headAccessory_special_bearEars,items.gear.owned.headAccessory_special_cactusEars,items.gear.owned.headAccessory_special_foxEars,items.gear.owned.headAccessory_special_lionEars,items.gear.owned.headAccessory_special_pandaEars,items.gear.owned.headAccessory_special_pigEars,items.gear.owned.headAccessory_special_tigerEars,items.gear.owned.headAccessory_special_wolfEars';
   const backgroundUnlockPath = 'background.giant_florals';
-  const backgroundSetUnlockPath = 'background.archery_range,background.giant_florals,background.rainbows_end';
   const hairUnlockPath = 'hair.color.rainbow,hair.color.yellow,hair.color.green,hair.color.purple,hair.color.blue,hair.color.TRUred';
   const facialHairUnlockPath = 'hair.mustache.1,hair.mustache.2,hair.beard.1,hair.beard.2,hair.beard.3';
   const usersStartingGems = 50 / 4;
@@ -17,6 +20,11 @@ describe('shared.ops.unlock', () => {
   beforeEach(() => {
     user = generateUser();
     user.balance = usersStartingGems;
+    clock = sandbox.useFakeTimers(new Date('2024-04-10'));
+  });
+
+  afterEach(() => {
+    clock.restore();
   });
 
   it('returns an error when path is not provided', async () => {
@@ -31,7 +39,9 @@ describe('shared.ops.unlock', () => {
   it('does not unlock lost gear', async () => {
     user.items.gear.owned.headAccessory_special_bearEars = false;
 
-    await 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);
   });
@@ -95,7 +105,9 @@ describe('shared.ops.unlock', () => {
 
   it('returns an error if gear is not from the animal set', async () => {
     try {
-      await 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'));
@@ -153,7 +165,6 @@ describe('shared.ops.unlock', () => {
     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: unlockPath } });
   });
@@ -163,7 +174,9 @@ describe('shared.ops.unlock', () => {
 
     await unlock(user, { query: { path: backgroundUnlockPath } });
     const afterBalance = user.balance;
-    const response = await 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;
@@ -176,7 +189,9 @@ describe('shared.ops.unlock', () => {
     await unlock(user, { query: { path: backgroundUnlockPath } }); // unlock
     const afterBalance = user.balance;
     await unlock(user, { query: { path: backgroundUnlockPath } }); // equip
-    const response = await 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;
@@ -192,8 +207,9 @@ describe('shared.ops.unlock', () => {
     individualPaths.forEach(path => {
       expect(get(user.purchased, path)).to.be.true;
     });
-    expect(Object.keys(user.purchased.shirt).length)
-      .to.equal(initialShirts + individualPaths.length);
+    expect(Object.keys(user.purchased.shirt).length).to.equal(
+      initialShirts + individualPaths.length,
+    );
     expect(user.balance).to.equal(usersStartingGems - 1.25);
   });
 
@@ -208,8 +224,9 @@ describe('shared.ops.unlock', () => {
     individualPaths.forEach(path => {
       expect(get(user.purchased, path)).to.be.true;
     });
-    expect(Object.keys(user.purchased.hair.color).length)
-      .to.equal(initialHairColors + individualPaths.length);
+    expect(Object.keys(user.purchased.hair.color).length).to.equal(
+      initialHairColors + individualPaths.length,
+    );
     expect(user.balance).to.equal(usersStartingGems - 1.25);
   });
 
@@ -219,21 +236,28 @@ describe('shared.ops.unlock', () => {
 
     const initialMustache = Object.keys(user.purchased.hair.mustache).length;
     const initialBeard = Object.keys(user.purchased.hair.mustache).length;
-    const [, message] = await unlock(user, { query: { path: facialHairUnlockPath } });
+    const [, message] = await unlock(user, {
+      query: { path: facialHairUnlockPath },
+    });
 
     expect(message).to.equal(i18n.t('unlocked'));
     const individualPaths = facialHairUnlockPath.split(',');
     individualPaths.forEach(path => {
       expect(get(user.purchased, path)).to.be.true;
     });
-    expect(Object.keys(user.purchased.hair.mustache).length + Object.keys(user.purchased.hair.beard).length) // eslint-disable-line max-len
+    expect(
+      Object.keys(user.purchased.hair.mustache).length
+        + Object.keys(user.purchased.hair.beard).length,
+    ) // eslint-disable-line max-len
       .to.equal(initialMustache + initialBeard + individualPaths.length);
     expect(user.balance).to.equal(usersStartingGems - 1.25);
   });
 
   it('unlocks a full set of gear', async () => {
     const initialGear = Object.keys(user.items.gear.owned).length;
-    const [, message] = await unlock(user, { query: { path: unlockGearSetPath } });
+    const [, message] = await unlock(user, {
+      query: { path: unlockGearSetPath },
+    });
 
     expect(message).to.equal(i18n.t('unlocked'));
 
@@ -241,32 +265,21 @@ describe('shared.ops.unlock', () => {
     individualPaths.forEach(path => {
       expect(get(user, path)).to.be.true;
     });
-    expect(Object.keys(user.items.gear.owned).length)
-      .to.equal(initialGear + individualPaths.length);
+    expect(Object.keys(user.items.gear.owned).length).to.equal(
+      initialGear + individualPaths.length,
+    );
     expect(user.balance).to.equal(usersStartingGems - 1.25);
   });
 
-  it('unlocks a full set of backgrounds', async () => {
-    const initialBackgrounds = Object.keys(user.purchased.background).length;
-    const [, message] = await unlock(user, { query: { path: backgroundSetUnlockPath } });
-
-    expect(message).to.equal(i18n.t('unlocked'));
-    const individualPaths = backgroundSetUnlockPath.split(',');
-    individualPaths.forEach(path => {
-      expect(get(user.purchased, path)).to.be.true;
-    });
-    expect(Object.keys(user.purchased.background).length)
-      .to.equal(initialBackgrounds + individualPaths.length);
-    expect(user.balance).to.equal(usersStartingGems - 3.75);
-  });
-
   it('unlocks an item (appearance)', async () => {
     const path = unlockPath.split(',')[0];
     const initialShirts = Object.keys(user.purchased.shirt).length;
     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);
+    expect(Object.keys(user.purchased.shirt).length).to.equal(
+      initialShirts + 1,
+    );
     expect(get(user.purchased, path)).to.be.true;
     expect(user.balance).to.equal(usersStartingGems - 0.5);
   });
@@ -279,7 +292,9 @@ describe('shared.ops.unlock', () => {
     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);
+    expect(Object.keys(user.purchased.hair.color).length).to.equal(
+      initialColorHair + 1,
+    );
     expect(get(user.purchased, path)).to.be.true;
     expect(user.balance).to.equal(usersStartingGems - 0.5);
   });
@@ -295,8 +310,12 @@ describe('shared.ops.unlock', () => {
 
     expect(message).to.equal(i18n.t('unlocked'));
 
-    expect(Object.keys(user.purchased.hair.mustache).length).to.equal(initialMustache + 1);
-    expect(Object.keys(user.purchased.hair.beard).length).to.equal(initialBeard);
+    expect(Object.keys(user.purchased.hair.mustache).length).to.equal(
+      initialMustache + 1,
+    );
+    expect(Object.keys(user.purchased.hair.beard).length).to.equal(
+      initialBeard,
+    );
 
     expect(get(user.purchased, path)).to.be.true;
     expect(user.balance).to.equal(usersStartingGems - 0.5);
@@ -315,11 +334,24 @@ describe('shared.ops.unlock', () => {
 
   it('unlocks an item (background)', async () => {
     const initialBackgrounds = Object.keys(user.purchased.background).length;
-    const [, message] = await 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);
+    expect(Object.keys(user.purchased.background).length).to.equal(
+      initialBackgrounds + 1,
+    );
     expect(get(user.purchased, backgroundUnlockPath)).to.be.true;
     expect(user.balance).to.equal(usersStartingGems - 1.75);
   });
+
+  it('handles an invalid hair path gracefully', async () => {
+    try {
+      await unlock(user, { query: { path: 'hair.invalid' } });
+    } catch (err) {
+      expect(err).to.be.an.instanceof(BadRequest);
+      expect(err.message).to.equal(i18n.t('invalidUnlockSet'));
+    }
+  });
 });

test/common/test_helper.js

@@ -1,27 +0,0 @@
-/* eslint-disable prefer-template, no-shadow, func-names, import/no-commonjs */
-
-const expect = require('expect.js');
-
-module.exports.addCustomMatchers = function () {
-  const { Assertion } = expect;
-  Assertion.prototype.toHaveGP = function (gp) {
-    const actual = this.obj.stats.gp;
-    return this.assert(actual === gp, () => 'expected user to have ' + gp + ' gp, but got ' + actual, () => 'expected user to not have ' + gp + ' gp');
-  };
-  Assertion.prototype.toHaveHP = function (hp) {
-    const actual = this.obj.stats.hp;
-    return this.assert(actual === hp, () => 'expected user to have ' + hp + ' hp, but got ' + actual, () => 'expected user to not have ' + hp + ' hp');
-  };
-  Assertion.prototype.toHaveExp = function (exp) {
-    const actual = this.obj.stats.exp;
-    return this.assert(actual === exp, () => 'expected user to have ' + exp + ' experience points, but got ' + actual, () => 'expected user to not have ' + exp + ' experience points');
-  };
-  Assertion.prototype.toHaveLevel = function (lvl) {
-    const actual = this.obj.stats.lvl;
-    return this.assert(actual === lvl, () => 'expected user to be level ' + lvl + ', but got ' + actual, () => 'expected user to not be level ' + lvl);
-  };
-  Assertion.prototype.toHaveMaxMP = function (mp) {
-    const actual = this.obj._statsComputed.maxMP;
-    return this.assert(actual === mp, () => 'expected user to have ' + mp + ' max mp, but got ' + actual, () => 'expected user to not have ' + mp + ' max mp');
-  };
-};

test/content/armoire.test.js

@@ -0,0 +1,72 @@
+/* eslint-disable global-require */
+import forEach from 'lodash/forEach';
+import {
+  expectValidTranslationString,
+} from '../helpers/content.helper';
+import armoire from '../../website/common/script/content/gear/sets/armoire';
+
+describe('armoire', () => {
+  let clock;
+  afterEach(() => {
+    if (clock) {
+      clock.restore();
+    }
+  });
+
+  it('does not return unreleased gear', async () => {
+    clock = sinon.useFakeTimers(new Date('2024-01-02'));
+    const items = armoire.all;
+    expect(items.length).to.equal(377);
+    expect(items.filter(item => item.set === 'pottersSet' || item.set === 'optimistSet' || item.set === 'schoolUniform')).to.be.an('array').that.is.empty;
+  });
+
+  it('released gear has all required properties', async () => {
+    clock = sinon.useFakeTimers(new Date('2024-05-08'));
+    const items = armoire.all;
+    expect(items.length).to.equal(396);
+    forEach(items, item => {
+      if (item.set !== undefined) {
+        expect(item.set, item.key).to.be.a('string');
+        expect(item.set, item.key).to.not.be.empty;
+      }
+      expectValidTranslationString(item.text);
+      expect(item.value, item.key).to.be.a('number');
+    });
+  });
+
+  it('releases gear when appropriate', async () => {
+    clock = sinon.useFakeTimers(new Date('2024-01-01T00:00:00.000Z'));
+    const items = armoire.all;
+    expect(items.length).to.equal(377);
+    clock.restore();
+    delete require.cache[require.resolve('../../website/common/script/content/gear/sets/armoire')];
+    clock = sinon.useFakeTimers(new Date('2024-01-08'));
+    const januaryItems = armoire.all;
+    expect(januaryItems.length).to.equal(381);
+    clock.restore();
+    delete require.cache[require.resolve('../../website/common/script/content/gear/sets/armoire')];
+    clock = sinon.useFakeTimers(new Date('2024-02-07'));
+    const januaryItems2 = armoire.all;
+    expect(januaryItems2.length).to.equal(381);
+    clock.restore();
+    delete require.cache[require.resolve('../../website/common/script/content/gear/sets/armoire')];
+    clock = sinon.useFakeTimers(new Date('2024-02-07T09:00:00.000Z'));
+    const febuaryItems = armoire.all;
+    expect(febuaryItems.length).to.equal(384);
+  });
+
+  it('sets have at least 2 items', () => {
+    const setMap = {};
+    forEach(armoire.all, item => {
+      // Gotta have one outlier
+      if (!item.set || item.set.startsWith('armoire-')) return;
+      if (setMap[item.set] === undefined) {
+        setMap[item.set] = 0;
+      }
+      setMap[item.set] += 1;
+    });
+    Object.keys(setMap).forEach(set => {
+      expect(setMap[set], set).to.be.at.least(2);
+    });
+  });
+});

test/content/eggs.test.js

@@ -5,29 +5,51 @@ import {
   expectValidTranslationString,
 } from '../helpers/content.helper';
 
-import * as eggs from '../../website/common/script/content/eggs';
+import eggs from '../../website/common/script/content/eggs';
 
 describe('eggs', () => {
-  describe('all', () => {
-    it('is a combination of drop and quest eggs', () => {
-      const dropNumber = Object.keys(eggs.drops).length;
-      const questNumber = Object.keys(eggs.quests).length;
-      const allNumber = Object.keys(eggs.all).length;
+  let clock;
 
-      expect(allNumber).to.be.greaterThan(0);
-      expect(allNumber).to.equal(dropNumber + questNumber);
-    });
+  afterEach(() => {
+    if (clock) {
+      clock.restore();
+    }
+  });
 
-    it('contains basic information about each egg', () => {
-      each(eggs.all, (egg, key) => {
-        expectValidTranslationString(egg.text);
-        expectValidTranslationString(egg.adjective);
-        expectValidTranslationString(egg.mountText);
-        expectValidTranslationString(egg.notes);
-        expect(egg.canBuy).to.be.a('function');
-        expect(egg.value).to.be.a('number');
-        expect(egg.key).to.equal(key);
+  const eggTypes = [
+    'drops',
+    'quests',
+  ];
+
+  eggTypes.forEach(eggType => {
+    describe(eggType, () => {
+      it('contains basic information about each egg', () => {
+        each(eggs[eggType], (egg, key) => {
+          expectValidTranslationString(egg.text);
+          expectValidTranslationString(egg.adjective);
+          expectValidTranslationString(egg.mountText);
+          expectValidTranslationString(egg.notes);
+          expect(egg.canBuy).to.be.a('function');
+          expect(egg.value).to.be.a('number');
+          expect(egg.key).to.equal(key);
+        });
       });
     });
   });
+
+  it('does not contain unreleased eggs', () => {
+    clock = sinon.useFakeTimers(new Date('2024-05-20'));
+    const questEggs = eggs.quests;
+    expect(questEggs.Giraffe).to.not.exist;
+  });
+
+  it('Releases eggs when appropriate without needing restarting', () => {
+    clock = sinon.useFakeTimers(new Date('2024-05-20'));
+    const mayEggs = eggs.quests;
+    clock.restore();
+    clock = sinon.useFakeTimers(new Date('2024-06-20'));
+    const juneEggs = eggs.quests;
+    expect(juneEggs.Giraffe).to.exist;
+    expect(Object.keys(mayEggs).length).to.equal(Object.keys(juneEggs).length - 1);
+  });
 });

test/content/events.test.js

@@ -0,0 +1,40 @@
+import { getRepeatingEvents } from '../../website/common/script/content/constants/events';
+
+describe('events', () => {
+  let clock;
+
+  afterEach(() => {
+    if (clock) {
+      clock.restore();
+    }
+  });
+
+  it('returns empty array when no events are active', () => {
+    clock = sinon.useFakeTimers(new Date('2024-01-06'));
+    const events = getRepeatingEvents();
+    expect(events).to.be.empty;
+  });
+
+  it('returns events when active', () => {
+    clock = sinon.useFakeTimers(new Date('2024-01-31'));
+    const events = getRepeatingEvents();
+    expect(events).to.have.length(1);
+    expect(events[0].key).to.equal('birthday');
+    expect(events[0].end).to.be.greaterThan(new Date());
+    expect(events[0].start).to.be.lessThan(new Date());
+  });
+
+  it('returns nye event at beginning of the year', () => {
+    clock = sinon.useFakeTimers(new Date('2025-01-01'));
+    const events = getRepeatingEvents();
+    expect(events).to.have.length(1);
+    expect(events[0].key).to.equal('nye');
+  });
+
+  it('returns nye event at end of the year', () => {
+    clock = sinon.useFakeTimers(new Date('2024-12-30'));
+    const events = getRepeatingEvents();
+    expect(events).to.have.length(1);
+    expect(events[0].key).to.equal('nye');
+  });
+});

test/content/food.test.js

@@ -0,0 +1,94 @@
+/* eslint-disable global-require */
+import {
+  each,
+} from 'lodash';
+import {
+  expectValidTranslationString,
+} from '../helpers/content.helper';
+import content from '../../website/common/script/content';
+
+describe('food', () => {
+  let clock;
+
+  afterEach(() => {
+    if (clock) {
+      clock.restore();
+    }
+    delete require.cache[require.resolve('../../website/common/script/content')];
+  });
+
+  describe('all', () => {
+    it('contains basic information about each food item', () => {
+      each(content.food, (foodItem, key) => {
+        if (foodItem.key === 'Saddle') {
+          expectValidTranslationString(foodItem.sellWarningNote);
+        } else {
+          expectValidTranslationString(foodItem.textA);
+          expectValidTranslationString(foodItem.textThe);
+          expect(foodItem.target).to.be.a('string');
+        }
+        expectValidTranslationString(foodItem.text);
+        expectValidTranslationString(foodItem.notes);
+        expect(foodItem.canBuy).to.be.a('function');
+        expect(foodItem.value).to.be.a('number');
+        expect(foodItem.key).to.equal(key);
+      });
+    });
+
+    it('sets canDrop for normal food if there is no food season', () => {
+      clock = sinon.useFakeTimers(new Date(2024, 5, 8));
+      const datedContent = require('../../website/common/script/content').default;
+      each(datedContent.food, foodItem => {
+        if (foodItem.key.indexOf('Cake') === -1 && foodItem.key.indexOf('Candy_') === -1 && foodItem.key.indexOf('Pie_') === -1 && foodItem.key !== 'Saddle') {
+          expect(foodItem.canDrop).to.equal(true);
+        } else {
+          expect(foodItem.canDrop).to.equal(false);
+        }
+      });
+    });
+
+    it('sets canDrop for candy if it is candy season', () => {
+      clock = sinon.useFakeTimers(new Date(2024, 9, 31));
+      const datedContent = require('../../website/common/script/content').default;
+      each(datedContent.food, foodItem => {
+        if (foodItem.key.indexOf('Candy_') !== -1) {
+          expect(foodItem.canDrop).to.equal(true);
+        } else {
+          expect(foodItem.canDrop).to.equal(false);
+        }
+      });
+    });
+
+    it('sets canDrop for cake if it is cake season', () => {
+      clock = sinon.useFakeTimers(new Date(2024, 0, 31));
+      const datedContent = require('../../website/common/script/content').default;
+      each(datedContent.food, foodItem => {
+        if (foodItem.key.indexOf('Cake_') !== -1) {
+          expect(foodItem.canDrop).to.equal(true);
+        } else {
+          expect(foodItem.canDrop).to.equal(false);
+        }
+      });
+    });
+
+    it('sets canDrop for pie if it is pie season', () => {
+      clock = sinon.useFakeTimers(new Date(2024, 2, 14));
+      const datedContent = require('../../website/common/script/content').default;
+      each(datedContent.food, foodItem => {
+        if (foodItem.key.indexOf('Pie_') !== -1) {
+          expect(foodItem.canDrop).to.equal(true);
+        } else {
+          expect(foodItem.canDrop).to.equal(false);
+        }
+      });
+    });
+  });
+
+  it('sets correct values for saddles', () => {
+    const saddle = content.food.Saddle;
+    expect(saddle.canBuy).to.be.a('function');
+    expect(saddle.value).to.equal(5);
+    expect(saddle.key).to.equal('Saddle');
+    expect(saddle.canDrop).to.equal(false);
+  });
+});

test/content/gear.test.js

@@ -4,6 +4,8 @@ import {
   expectValidTranslationString,
 } from '../helpers/content.helper';
 
+import { CLASSES } from '../../website/common/script/content/constants';
+
 import gearData from '../../website/common/script/content/gear';
 import * as backerGear from '../../website/common/script/content/gear/sets/special/special-backer';
 import * as contributorGear from '../../website/common/script/content/gear/sets/special/special-contributor';
@@ -17,35 +19,48 @@ describe('Gear', () => {
         context(`${klass} ${gearType}s`, () => {
           it('have a value of at least 0 for each stat', () => {
             each(items, gear => {
-              expect(gear.con).to.be.at.least(0);
-              expect(gear.int).to.be.at.least(0);
-              expect(gear.per).to.be.at.least(0);
-              expect(gear.str).to.be.at.least(0);
+              expect(gear.con, gear.key).to.be.at.least(0);
+              expect(gear.int, gear.key).to.be.at.least(0);
+              expect(gear.per, gear.key).to.be.at.least(0);
+              expect(gear.str, gear.key).to.be.at.least(0);
             });
           });
 
           it('have a purchase value of at least 0', () => {
             each(items, gear => {
-              expect(gear.value).to.be.at.least(0);
+              expect(gear.value, gear.key).to.be.at.least(0);
             });
           });
 
           it('has a canBuy function', () => {
             each(items, gear => {
-              expect(gear.canBuy).to.be.a('function');
+              expect(gear.canBuy, gear.key).to.be.a('function');
             });
           });
 
           it('have valid translation strings for text and notes', () => {
             each(items, gear => {
-              expectValidTranslationString(gear.text);
-              expectValidTranslationString(gear.notes);
+              expectValidTranslationString(gear.text, gear.key);
+              expectValidTranslationString(gear.notes, gear.key);
             });
           });
 
           it('has a set attribue', () => {
             each(items, gear => {
-              expect(gear.set).to.exist;
+              expect(gear.set, gear.key).to.exist;
+            });
+          });
+
+          it('has a valid value for klass or specialClass', () => {
+            const validClassValues = CLASSES + ['base', 'mystery', 'armoire'];
+            each(items, gear => {
+              const field = gear.klass === 'special' ? gear.specialClass : gear.klass;
+              if (gear.klass === 'special' && field === undefined) {
+                // some special gear doesn't have a klass
+                return;
+              }
+              expect(field, gear.key).to.exist;
+              expect(validClassValues, gear.key).to.include(field);
             });
           });
         });
@@ -53,6 +68,16 @@ describe('Gear', () => {
     });
   });
 
+  it('only assigns mage weapons twoHanded', () => {
+    each([allGear.armor.special, allGear.head.special, allGear.shield.special], gearType => {
+      each(gearType, gear => {
+        if (gear.specialClass === 'wizard') {
+          expect(gear.twoHanded, gear.key).to.not.eql(true);
+        }
+      });
+    });
+  });
+
   describe('backer gear', () => {
     let user;
 

test/content/hatching-potions.test.js

@@ -5,28 +5,50 @@ import {
   expectValidTranslationString,
 } from '../helpers/content.helper';
 
-import * as hatchingPotions from '../../website/common/script/content/hatching-potions';
+import hatchingPotions from '../../website/common/script/content/hatching-potions';
 
 describe('hatchingPotions', () => {
-  describe('all', () => {
-    it('is a combination of drop, premium, and wacky potions', () => {
-      const dropNumber = Object.keys(hatchingPotions.drops).length;
-      const premiumNumber = Object.keys(hatchingPotions.premium).length;
-      const wackyNumber = Object.keys(hatchingPotions.wacky).length;
-      const allNumber = Object.keys(hatchingPotions.all).length;
+  let clock;
 
-      expect(allNumber).to.be.greaterThan(0);
-      expect(allNumber).to.equal(dropNumber + premiumNumber + wackyNumber);
-    });
+  afterEach(() => {
+    if (clock) {
+      clock.restore();
+    }
+  });
 
-    it('contains basic information about each potion', () => {
-      each(hatchingPotions.all, (potion, key) => {
-        expectValidTranslationString(potion.text);
-        expectValidTranslationString(potion.notes);
-        expect(potion.canBuy).to.be.a('function');
-        expect(potion.value).to.be.a('number');
-        expect(potion.key).to.equal(key);
+  const potionTypes = [
+    'drops',
+    'quests',
+    'premium',
+    'wacky',
+  ];
+  potionTypes.forEach(potionType => {
+    describe(potionType, () => {
+      it('contains basic information about each potion', () => {
+        each(hatchingPotions.all, (potion, key) => {
+          expectValidTranslationString(potion.text);
+          expectValidTranslationString(potion.notes);
+          expect(potion.canBuy).to.be.a('function');
+          expect(potion.value).to.be.a('number');
+          expect(potion.key).to.equal(key);
+        });
       });
     });
   });
+
+  it('does not contain unreleased potions', () => {
+    clock = sinon.useFakeTimers(new Date('2024-05-20'));
+    const premiumPotions = hatchingPotions.premium;
+    expect(premiumPotions.Koi).to.not.exist;
+  });
+
+  it('Releases potions when appropriate without needing restarting', () => {
+    clock = sinon.useFakeTimers(new Date('2024-05-20'));
+    const mayPotions = hatchingPotions.premium;
+    clock.restore();
+    clock = sinon.useFakeTimers(new Date('2024-06-20'));
+    const junePotions = hatchingPotions.premium;
+    expect(junePotions.Koi).to.exist;
+    expect(Object.keys(mayPotions).length).to.equal(Object.keys(junePotions).length - 1);
+  });
 });