fix(lint): leave out unused imports

This reverts commit 215e768e90.

.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

@@ -19,7 +19,8 @@ jobs:
       uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
-    - run: sudo apt-get -y install libkrb5-dev
+    - run: sudo apt update
+    - run: sudo apt -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
@@ -41,7 +42,8 @@ jobs:
       uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
-    - run: sudo apt-get -y install libkrb5-dev
+    - run: sudo apt update
+    - run: sudo apt -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
@@ -63,7 +65,8 @@ jobs:
       uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
-    - run: sudo apt-get -y install libkrb5-dev
+    - run: sudo apt update
+    - run: sudo apt -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
@@ -72,7 +75,7 @@ jobs:
         CI: true
         NODE_ENV: test
     - run: npm run test:sanity
-  
+
   common:
     runs-on: ubuntu-latest
     strategy:
@@ -86,7 +89,8 @@ jobs:
       uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
-    - run: sudo apt-get -y install libkrb5-dev
+    - run: sudo apt update
+    - run: sudo apt -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
@@ -108,7 +112,8 @@ jobs:
       uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
-    - run: sudo apt-get -y install libkrb5-dev
+    - run: sudo apt update
+    - run: sudo apt -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
@@ -117,13 +122,13 @@ jobs:
         CI: true
         NODE_ENV: test
     - run: npm run test:content
-  
+
   api-unit:
     runs-on: ubuntu-latest
     strategy:
       matrix:
         node-version: [21.x]
-        mongodb-version: [4.2]
+        mongodb-version: [7.0]
     steps:
     - uses: actions/checkout@v4
       with:
@@ -132,12 +137,15 @@ jobs:
       uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
+
     - name: Start MongoDB ${{ matrix.mongodb-version }} Replica Set
-      uses: supercharge/mongodb-github-action@1.3.0
+      uses: supercharge/mongodb-github-action@1.11.0
       with:
         mongodb-version: ${{ matrix.mongodb-version }}
         mongodb-replica-set: rs
-    - run: sudo apt-get -y install libkrb5-dev
+
+    - run: sudo apt update
+    - run: sudo apt -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
@@ -145,15 +153,19 @@ jobs:
       env:
         CI: true
         NODE_ENV: test
+
+    #- run: npm run mongo:dev -- -d
     - run: npm run test:api:unit
       env:
         REQUIRES_SERVER=true: true
+
+    #- run: npm run mongo:dev:down
   api-v3-integration:
     runs-on: ubuntu-latest
     strategy:
       matrix:
         node-version: [21.x]
-        mongodb-version: [4.2]
+        mongodb-version: [7.0]
     steps:
     - uses: actions/checkout@v4
       with:
@@ -163,11 +175,13 @@ jobs:
       with:
         node-version: ${{ matrix.node-version }}
     - name: Start MongoDB ${{ matrix.mongodb-version }} Replica Set
-      uses: supercharge/mongodb-github-action@1.3.0
+      uses: supercharge/mongodb-github-action@1.11.0
       with:
         mongodb-version: ${{ matrix.mongodb-version }}
         mongodb-replica-set: rs
-    - run: sudo apt-get -y install libkrb5-dev
+
+    - run: sudo apt update
+    - run: sudo apt -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
@@ -175,15 +189,20 @@ jobs:
       env:
         CI: true
         NODE_ENV: test
+
+    #- run: npm run mongo:dev -- -d
     - run: npm run test:api-v3:integration
       env:
         REQUIRES_SERVER=true: true
+
+    #- run: npm run mongo:dev:down
   api-v4-integration:
     runs-on: ubuntu-latest
     strategy:
       matrix:
         node-version: [21.x]
-        mongodb-version: [4.2]
+        mongodb-version: [7.0]
+
     steps:
     - uses: actions/checkout@v4
       with:
@@ -193,11 +212,13 @@ jobs:
       with:
         node-version: ${{ matrix.node-version }}
     - name: Start MongoDB ${{ matrix.mongodb-version }} Replica Set
-      uses: supercharge/mongodb-github-action@1.3.0
+      uses: supercharge/mongodb-github-action@1.11.0
       with:
         mongodb-version: ${{ matrix.mongodb-version }}
         mongodb-replica-set: rs
-    - run: sudo apt-get -y install libkrb5-dev
+
+    - run: sudo apt update
+    - run: sudo apt -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
@@ -205,10 +226,13 @@ jobs:
       env:
         CI: true
         NODE_ENV: test
+    #- run: npm run mongo:dev -- -d
     - run: npm run test:api-v4:integration
       env:
         REQUIRES_SERVER=true: true
 
+
+    #- run: npm run mongo:dev:down
   client-unit:
     runs-on: ubuntu-latest
     strategy:
@@ -222,7 +246,8 @@ jobs:
       uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
-    - run: sudo apt-get -y install libkrb5-dev
+    - run: sudo apt update
+    - run: sudo apt -y install libkrb5-dev
     - run: cp config.json.example config.json
     - name: npm install
       run: |
@@ -246,7 +271,8 @@ jobs:
       uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
-    - run: sudo apt-get -y install libkrb5-dev
+    - run: sudo apt update
+    - run: sudo apt -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
@@ -47,4 +47,5 @@ webpack.webstorm.config
 
 # mongodb replica set for local dev
 mongodb-*.tgz
-/mongodb-data
+/mongodb-data*
+/.nyc_output

.heroku/report_deploy.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+DEVELOPER="someone"
+if git rev-parse --git-dir > /dev/null 2>&1; then
+    DEVELOPERS=$(git log -5 --pretty=format:'%an')
+    IFS=$'\n'
+    DEVELOPER=""
+    for dev in $DEVELOPERS
+    do
+        if [ "$DEVELOPER" == "someone" ]; then
+            if [[ ${dev} != *"[bot]"* ]]; then
+                DEVELOPER=$dev
+                continue
+            fi
+            continue
+        fi
+    done
+fi
+
+PARTS=$(cut -d"." -f1 <<< $BASE_URL)
+SERVER_NAME=$(cut -d"/" -f3 <<< ${PARTS[0]})
+
+SERVER_NAME=":$SERVER_EMOJI: $SERVER_NAME"
+
+wget $SLACK_DEPLOY_URL --post-data="{\"server_name\": \"$SERVER_NAME\", \"developer\": \"$DEVELOPER\", \"base_url\": \"$BASE_URL\"}" -O /dev/null

Dockerfile-Dev

@@ -3,12 +3,13 @@ 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,14 +1,20 @@
-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 ![Build Status](https://github.com/HabitRPG/habitica/workflows/Test/badge.svg)
 ===============
 
-[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 Gold 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:
+**Want to contribute code to Habitica?** We're always looking for assistance on any issues in our repo with the "Help Wanted" label. The wiki pages below and the additional linked pages will tell you how to start contributing code and where you can 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.
-* [Setting up Habitica Locally](https://habitica.fandom.com/wiki/Setting_up_Habitica_Locally) - how to set up a local install of Habitica for development and testing on various platforms.
+* [Setting up Habitica Locally](https://github.com/HabitRPG/habitica/wiki/Setting-Up-Habitica-for-Local-Development) - how to set up a local install of Habitica for development and testing.
+
+**Interested in contributing to Habitica’s mobile apps?** Visit the links below for our mobile repositories.
+* **Android:** https://github.com/HabitRPG/habitica-android
+* **iOS:** https://github.com/HabitRPG/habitica-ios
 
 Habitica's code is licensed as described at https://github.com/HabitRPG/habitica/blob/develop/LICENSE
 
-**Found a bug?** Please report it to [admin email](mailto:admin@habitica.com) rather than creating an issue (an admin will advise you if a new issue is necessary; usually it is not).
+**Found a bug?** Please report it to [admin email](mailto:admin@habitica.com) rather than create an issue (an admin will advise you if a new issue is necessary; usually it is not).
 
-**Have any questions about Habitica or its community?** See the links in the [habitica.com](https://habitica.com) website's Help menu or drop in to [Guilds > Tavern Chat](https://habitica.com/groups/tavern) to ask questions or chat socially!
+**Creating a third-party tool?** Please review our [API Usage Guidelines](https://github.com/HabitRPG/habitica/wiki/API-Usage-Guidelines) to ensure that your tool is compliant and maintains the best experience for Habitica players.
+
+**Have any questions about Habitica or contributing?** See the links in the [Habitica](https://habitica.com) website's Help menu. There’s FAQ’s, guides, and the option to reach out to us with any further questions!

config.json.example

@@ -32,10 +32,12 @@
   "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",
+  "NODE_DB_URI": "mongodb://localhost:27017/habitica-dev?replicaSet=rs&directConnection=true&readPreference=secondary",
+  "TEST_DB_URI": "mongodb://localhost:27017/habitica-test?replicaSet=rs&directConnection=true&readPreference=secondary",
   "MONGODB_POOL_SIZE": "10",
+  "MONGODB_SOCKET_TIMEOUT": "20000",
   "NODE_ENV": "development",
   "PATH": "bin:node_modules/.bin:/usr/local/bin:/usr/bin:/bin",
   "PAYPAL_BILLING_PLANS_basic_12mo": "basic_12mo",
@@ -84,8 +86,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,https://habitica.com"
+  "TRUSTED_DOMAINS": "localhost,https://habitica.com",
+  "TIME_TRAVEL_ENABLED": "false",
+  "DEBUG_ENABLED": "false",
+  "CONTENT_SWITCHOVER_TIME_OFFSET": 8
 }

docker-compose.dev.yml

@@ -22,7 +22,8 @@ services:
       dockerfile: ./Dockerfile-Dev
     command: ["npm", "start"]
     depends_on:
-      - mongo
+      mongo:
+        condition: service_healthy
     environment:
       - NODE_DB_URI=mongodb://mongo/habitrpg
     networks:
@@ -33,7 +34,16 @@ services:
       - .:/usr/src/habitica
       - /usr/src/habitica/node_modules
   mongo:
-    image: mongo:3.6
+    image: mongo:7.0
+    restart: unless-stopped
+    command: ["--replSet", "rs", "--bind_ip_all", "--port", "27017"]
+    healthcheck:
+      test: echo "try { rs.status() } catch (err) { rs.initiate() }" | mongosh --port 27017 --quiet
+      interval: 10s
+      timeout: 30s
+      start_period: 0s
+      start_interval: 1s
+      retries: 30
     networks:
       - habitica
     ports:

docker-compose.mongo-local.yml

@@ -0,0 +1,37 @@
+# big thanks to https://pakisan.github.io/posts/docker-compose-mongodb-single-node-replica-set/ <3
+
+version: "3.9"
+networks:
+  mongodb-network:
+    name: "mongodb-network"
+    driver: bridge
+services:
+  mongodb:
+    image: "mongo:7.0"
+    container_name: "mongodb"
+    networks:
+      - mongodb-network
+    hostname: "mongodb"
+    ports:
+      - "27017:27017"
+    restart: "unless-stopped"
+    volumes:
+      - "./mongodb-data:/data/db"
+    entrypoint: [ "/usr/bin/mongod", "--bind_ip_all", "--replSet", "rs" ]
+  mongoinit:
+    image: "mongo:7.0"
+    container_name: "mongodb_replSet_initializer"
+    restart: "on-failure" # WITHOUT THIS, the initializer tries only once and fails
+    depends_on:
+      - mongodb
+    networks:
+      - mongodb-network
+
+    command: >
+      mongosh --host mongodb:27017 --eval "rs.initiate({
+       _id: \"rs\",
+       members: [
+         {_id: 0, host: \"mongodb\"}
+       ]
+      })"
+

docker-compose.yml

@@ -25,7 +25,7 @@ services:
       - mongo
 
   mongo:
-    image: mongo:3.6
+    image: mongo:7.0
     ports:
       - "27017:27017"
     networks:

gulp/gulp-build.js

@@ -5,8 +5,8 @@ import path from 'path';
 import babel from 'gulp-babel';
 import os from 'os';
 import fs from 'fs';
-import spawn from 'cross-spawn'; // eslint-disable-line import/no-extraneous-dependencies
-import clean from 'rimraf';
+/* import spawn from 'cross-spawn'; // eslint-disable-line import/no-extraneous-dependencies
+import clean from 'rimraf'; */
 
 gulp.task('build:babel:server', () => gulp.src('website/server/**/*.js')
   .pipe(babel())
@@ -51,7 +51,7 @@ gulp.task('build:prepare-mongo', async () => {
   console.log('MongoDB data folder is missing, setting up.'); // eslint-disable-line no-console
 
   // use run-rs without --keep, kill it as soon as the replica set starts
-  const runRsProcess = spawn('run-rs', ['-v', '4.1.1', '-l', 'ubuntu1804', '--dbpath', 'mongodb-data', '--number', '1', '--quiet']);
+  /* const runRsProcess = spawn('node', ['../scripts/start-local-mongo.mjs --build-db']);
 
   for await (const chunk of runRsProcess.stdout) {
     const stringChunk = chunk.toString();
@@ -79,6 +79,8 @@ gulp.task('build:prepare-mongo', async () => {
 
     throw new Error(`Error running run-rs: ${error}`);
   }
+
+   */
 });
 
 gulp.task('build:dev', gulp.series(

gulp/gulp-sprites.js

@@ -42,10 +42,41 @@ function cssVarMap (sprite) {
   }
 }
 
-function createSpritesStream (name, src) {
+function filterFile (file) {
+  if (file.relative.indexOf('Mount_Icon_') !== -1) {
+    return false;
+  }
+  if (file.path.indexOf('shop/') !== -1) {
+    return false;
+  }
+  if (file.path.indexOf('stable/eggs') !== -1) {
+    return false;
+  }
+  if (file.path.indexOf('stable/food') !== -1) {
+    return false;
+  }
+  if (file.path.indexOf('stable/potions') !== -1) {
+    return false;
+  }
+  if (file.relative.indexOf('shop_') === 0) {
+    return false;
+  }
+  if (file.relative.indexOf('icon_background') === 0) {
+    return false;
+  }
+  return true;
+}
+
+async function createSpritesStream (name, src) {
   const stream = mergeStream();
+  // need to import this way bc of weird dependency things
+  // eslint-disable-next-line global-require
+  const filter = require('gulp-filter');
+
+  const f = filter(filterFile);
 
   const spriteData = gulp.src(src)
+    .pipe(f)
     .pipe(spritesmith({
       imgName: `spritesmith-${name}.png`,
       cssName: `spritesmith-${name}.css`,
@@ -63,7 +94,7 @@ function createSpritesStream (name, src) {
   return stream;
 }
 
-gulp.task('sprites:main', () => {
+gulp.task('sprites:main', async () => {
   const mainSrc = sync('habitica-images/**/*.png');
   return createSpritesStream('main', mainSrc);
 });

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 */
@@ -59,6 +59,11 @@ gulp.task('test:prepare:mongo', cb => {
   const mongooseOptions = getDefaultConnectionOptions();
   const connectionUrl = getDevelopmentConnectionUrl(TEST_DB_URI);
 
+  console.info({
+    mongooseOptions,
+    connectionUrl,
+  });
+
   mongoose.connect(connectionUrl, mongooseOptions)
     .then(() => mongoose.connection.dropDatabase())
     .then(() => mongoose.connection.close()).then(() => {
@@ -148,7 +153,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 +161,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 +180,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
+  }
+};

migrations/archive/2024/2024_purge_invite_accepted.js

@@ -0,0 +1,47 @@
+/* eslint-disable no-console */
+import { model as User } from '../../../website/server/models/user';
+
+const MIGRATION_NAME = '2024_purge_invite_accepted';
+const progressCount = 1000;
+let count = 0;
+
+async function updateUsers (userIds) {
+  count += userIds.length;
+  if (count % progressCount === 0) console.warn(`${count} ${userIds[0]}`);
+
+  return await User.updateMany(
+    { _id: { $in: userIds } },
+    { $pull: { notifications: { type: 'GROUP_INVITE_ACCEPTED' } } },
+  ).exec();
+}
+
+export default async function processUsers () {
+  let query = {
+    migration: { $ne: MIGRATION_NAME },
+    'notifications.type': 'GROUP_INVITE_ACCEPTED',
+    'auth.timestamps.loggedin': { $gt: new Date('2024-06-25') },
+  };
+
+  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({ _id: 1 })
+      .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],
+      };
+    }
+
+    const userIds = users.map(user => user._id);
+
+    await updateUsers(userIds); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/users/naming-day.js

@@ -1,14 +1,12 @@
 /* eslint-disable no-console */
-const MIGRATION_NAME = '20230731_naming_day';
-import { v4 as uuid } from 'uuid';
-
-import { model as User } from '../../../website/server/models/user';
+import { model as User } from '../../website/server/models/user';
 
+const MIGRATION_NAME = '20240731_naming_day';
 const progressCount = 1000;
 let count = 0;
 
 async function updateUser (user) {
-  count++;
+  count += 1;
 
   let set;
   let push;
@@ -115,16 +113,16 @@ async function updateUser (user) {
   if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
 
   if (push) {
-    return await user.updateOne({ $set: set, $inc: inc, $push: push }).exec();
-  } else {
-    return await user.updateOne({ $set: set, $inc: inc }).exec();
+    return user.updateOne({ $set: set, $inc: inc, $push: push }).exec();
   }
+
+  return user.updateOne({ $set: set, $inc: inc }).exec();
 }
 
 export default async function processUsers () {
-  let query = {
+  const query = {
     migration: { $ne: MIGRATION_NAME },
-    'auth.timestamps.loggedin': { $gt: new Date('2023-07-01') },
+    'auth.timestamps.loggedin': { $gt: new Date('2024-07-01') },
   };
 
   const fields = {
@@ -136,7 +134,7 @@ export default async function processUsers () {
     const users = await User // eslint-disable-line no-await-in-loop
       .find(query)
       .limit(250)
-      .sort({_id: 1})
+      .sort({ _id: 1 })
       .select(fields)
       .exec();
 
@@ -152,4 +150,4 @@ export default async function processUsers () {
 
     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.22.3",
+  "version": "5.28.8",
   "main": "./website/server/index.js",
   "dependencies": {
     "@babel/core": "^7.22.10",
@@ -15,6 +15,7 @@
     "amplitude": "^6.0.0",
     "apidoc": "^0.54.0",
     "apple-auth": "^1.0.9",
+    "babel-preset-env": "^1.7.0",
     "bcrypt": "^5.1.1",
     "body-parser": "^1.20.2",
     "bootstrap": "^4.6.2",
@@ -27,13 +28,15 @@
     "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",
     "gulp-babel": "^8.0.0",
+    "gulp-filter": "^7.0.0",
     "gulp-imagemin": "^7.1.0",
     "gulp-nodemon": "^2.5.0",
     "gulp.spritesmith": "^6.13.0",
@@ -66,12 +69,14 @@
     "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",
     "useragent": "^2.1.9",
     "uuid": "^9.0.0",
     "validator": "^13.11.0",
+    "webpack-bundle-analyzer": "^4.10.2",
     "winston": "^3.10.0",
     "winston-loggly-bulk": "^3.3.0",
     "xml2js": "^0.6.2"
@@ -92,35 +97,38 @@
     "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",
     "client:unit": "cd website/client && npm run test:unit",
     "start": "gulp nodemon",
+    "start:simple": "node ./website/server/index.js",
     "debug": "gulp nodemon --inspect",
-    "mongo:dev": "run-rs -v 5.0.23 -l ubuntu1804 --keep --dbpath mongodb-data --number 1 --quiet",
+    "mongo:dev_": "node scripts/start-local-mongo.mjs",
+    "mongo:dev": "docker compose -f docker-compose.mongo-local.yml up",
+    "mongo:dev:down": "docker compose -f docker-compose.mongo-local.yml down",
+    "mongo:test": "node scripts/start-local-mongo.mjs --test-db",
     "postinstall": "git config --global url.\"https://\".insteadOf git:// && gulp build && cd website/client && npm install",
-    "apidoc": "gulp apidoc"
+    "apidoc": "gulp apidoc",
+    "heroku-postbuild": ".heroku/report_deploy.sh"
   },
   "devDependencies": {
-    "axios": "^1.4.0",
+    "axios": "^1.7.4",
     "chai": "^4.3.7",
     "chai-as-promised": "^7.1.1",
     "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",
+    "mongodb-memory-server": "^10.1.2",
     "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"
   }

scripts/start-local-mongo.mjs

@@ -0,0 +1,54 @@
+/* eslint-disable-file */
+import { MongoMemoryReplSet } from 'mongodb-memory-server';
+
+import { dirname } from 'node:path';
+import { existsSync, mkdirSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+const TEST_MODE = process.argv.includes('--test-db');
+const BUILD_MODE = process.argv.includes('--build-db');
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const pathSuffix = TEST_MODE ? '-test' : BUILD_MODE ? '-build' : '';
+
+const mongoDbPath = `${__dirname}/../mongodb-data`+pathSuffix;
+
+if (!existsSync(mongoDbPath)) {
+  mkdirSync(mongoDbPath);
+}
+
+(async () => {
+  // async code in where
+
+  // This will create an new instance of "MongoMemoryServer" and automatically start it
+  const mongod = await MongoMemoryReplSet.create({
+    replSet: {
+      count: 3,
+      dbName: TEST_MODE ? 'habitica-test' : 'habitica-dev',
+      dbPath: mongoDbPath,
+      name: 'rs',
+    },
+    instanceOpts: [
+      {
+        port: 27017,
+      },
+      {
+        port: 27018,
+      },
+      {
+        port: 27019,
+      },
+    ],
+    dispose: {
+      cleanup: !BUILD_MODE && !TEST_MODE,
+    }
+  });
+
+  const uri = mongod.getUri();
+
+  console.log(`MongoDB running at ${uri}`, mongod.state);
+
+  // Keep the Node.js process running
+  setInterval(() => {}, 1000);
+})();

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/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/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/rateLimiter.test.js

@@ -54,6 +54,7 @@ describe('rateLimiter middleware', () => {
 
   it('does not throw when there are available points', async () => {
     nconfGetStub.withArgs('RATE_LIMITER_ENABLED').returns('true');
+    nconfGetStub.withArgs('RATE_LIMITER_IP_COST').returns(1);
     const attachRateLimiter = requireAgain(pathToRateLimiter).default;
     await attachRateLimiter(req, res, next);
 
@@ -71,6 +72,7 @@ describe('rateLimiter middleware', () => {
 
   it('does not throw when an unknown error is thrown by the rate limiter', async () => {
     nconfGetStub.withArgs('RATE_LIMITER_ENABLED').returns('true');
+    nconfGetStub.withArgs('RATE_LIMITER_IP_COST').returns(1);
     sandbox.stub(logger, 'error');
     sandbox.stub(RateLimiterMemory.prototype, 'consume')
       .returns(Promise.reject(new Error('Unknown error.')));
@@ -87,8 +89,73 @@ 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');
+    nconfGetStub.withArgs('RATE_LIMITER_IP_COST').returns(1);
+    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);
+    nconfGetStub.withArgs('RATE_LIMITER_IP_COST').returns(1);
+    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('');
+    nconfGetStub.withArgs('RATE_LIMITER_IP_COST').returns(1);
+    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');
+    nconfGetStub.withArgs('RATE_LIMITER_IP_COST').returns(1);
     const attachRateLimiter = requireAgain(pathToRateLimiter).default;
 
     // call for 31 times
@@ -112,6 +179,7 @@ describe('rateLimiter middleware', () => {
 
   it('uses the user id if supplied or the ip address', async () => {
     nconfGetStub.withArgs('RATE_LIMITER_ENABLED').returns('true');
+    nconfGetStub.withArgs('RATE_LIMITER_IP_COST').returns(1);
     const attachRateLimiter = requireAgain(pathToRateLimiter).default;
 
     req.ip = 1;
@@ -138,4 +206,51 @@ describe('rateLimiter middleware', () => {
       'X-RateLimit-Reset': sinon.match(Date),
     });
   });
+
+  it('applies increased cost for registration calls with and without user id', async () => {
+    nconfGetStub.withArgs('RATE_LIMITER_ENABLED').returns('true');
+    nconfGetStub.withArgs('RATE_LIMITER_REGISTRATION_COST').returns(3);
+    const attachRateLimiter = requireAgain(pathToRateLimiter).default;
+    req.path = '/api/v4/user/auth/local/register';
+
+    req.ip = 1;
+    await attachRateLimiter(req, res, next);
+
+    req.headers['x-api-user'] = 'user-1';
+    await attachRateLimiter(req, res, next);
+    await attachRateLimiter(req, res, next);
+
+    // user id an ip are counted as separate sources
+    expect(res.set).to.have.been.calledWithMatch({
+      'X-RateLimit-Limit': 30,
+      'X-RateLimit-Remaining': 27, // 2 calls with user id
+      'X-RateLimit-Reset': sinon.match(Date),
+    });
+
+    req.headers['x-api-user'] = undefined;
+    await attachRateLimiter(req, res, next);
+    await attachRateLimiter(req, res, next);
+
+    expect(res.set).to.have.been.calledWithMatch({
+      'X-RateLimit-Limit': 30,
+      'X-RateLimit-Remaining': 24, // 3 calls with only ip
+      'X-RateLimit-Reset': sinon.match(Date),
+    });
+  });
+
+  it('applies increased cost for unauthenticated API calls', async () => {
+    nconfGetStub.withArgs('RATE_LIMITER_ENABLED').returns('true');
+    nconfGetStub.withArgs('RATE_LIMITER_IP_COST').returns(10);
+    const attachRateLimiter = requireAgain(pathToRateLimiter).default;
+
+    req.ip = 1;
+    await attachRateLimiter(req, res, next);
+    await attachRateLimiter(req, res, next);
+
+    expect(res.set).to.have.been.calledWithMatch({
+      'X-RateLimit-Limit': 30,
+      'X-RateLimit-Remaining': 10,
+      'X-RateLimit-Reset': sinon.match(Date),
+    });
+  });
 });

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/v3/integration/chat/GET-chat.test.js

@@ -3,6 +3,7 @@ import {
   createAndPopulateGroup,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
+import { model as Group } from '../../../../../website/server/models/group';
 
 describe('GET /groups/:groupId/chat', () => {
   let user;
@@ -37,4 +38,34 @@ describe('GET /groups/:groupId/chat', () => {
       });
     });
   });
+
+  context('public Guild', () => {
+    let group;
+    before(async () => {
+      ({ group } = await createAndPopulateGroup({
+        groupDetails: {
+          name: 'test group',
+          type: 'guild',
+          privacy: 'private',
+        },
+        members: 1,
+        upgradeToGroupPlan: true,
+        chat: [
+          'Hello',
+          'Welcome to the Guild',
+        ],
+      }));
+
+      // Creation API is shut down, we need to simulate an extant public group
+      await Group.updateOne({ _id: group._id }, { $set: { privacy: 'public' }, $unset: { 'purchased.plan': 1 } }).exec();
+    });
+
+    it('returns error if user attempts to fetch a sunset Guild', async () => {
+      await expect(user.get(`/groups/${group._id}/chat`)).to.eventually.be.rejected.and.eql({
+        code: 400,
+        error: 'BadRequest',
+        message: t('featureRetired'),
+      });
+    });
+  });
 });

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,8 +1,10 @@
 import { find } from 'lodash';
 import {
+  generateUser,
   createAndPopulateGroup,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
+import { model as Group } from '../../../../../website/server/models/group';
 
 describe('POST /chat/:chatId/like', () => {
   let user;
@@ -79,4 +81,49 @@ 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'),
+      });
+  });
+
+  it('does not like a message that belongs to a sunset public group', async () => {
+    const message = await anotherUser.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
+
+    // Creation API is shut down, we need to simulate an extant public group
+    await Group.updateOne({ _id: groupWithChat._id }, { $set: { privacy: 'public' }, $unset: { 'purchased.plan': 1 } }).exec();
+
+    await expect(user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`))
+      .to.eventually.be.rejected.and.eql({
+        code: 400,
+        error: 'BadRequest',
+        message: t('featureRetired'),
+      });
+  });
 });

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/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_boss-rage.test.js

@@ -0,0 +1,73 @@
+import nconf from 'nconf';
+import {
+  generateUser,
+  createAndPopulateGroup,
+} from '../../../../helpers/api-integration/v3';
+
+describe('POST /debug/boss-rage', () => {
+  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(() => {
+    nconfStub.restore();
+  });
+
+  it('errors if user is not in a party', async () => {
+    await expect(user.post('/debug/boss-rage'))
+      .to.eventually.be.rejected.and.deep.equal({
+        code: 400,
+        error: 'BadRequest',
+        message: 'User not in a party.',
+      });
+  });
+
+  it('returns error when not in production mode', async () => {
+    nconfStub.withArgs('DEBUG_ENABLED').returns(false);
+
+    await expect(user.post('/debug/boss-rage'))
+      .to.eventually.be.rejected.and.deep.equal({
+        code: 404,
+        error: 'NotFound',
+        message: 'Not found.',
+      });
+  });
+
+  context('user is in a party', async () => {
+    let party;
+
+    beforeEach(async () => {
+      const { group, groupLeader } = await createAndPopulateGroup({
+        groupDetails: {
+          name: 'Test Party',
+          type: 'party',
+        },
+        members: 2,
+      });
+      party = group;
+      user = groupLeader;
+    });
+
+    it('increases boss rage to 50', async () => {
+      await user.post('/debug/boss-rage');
+      await party.sync();
+      expect(party.quest.progress.rage).to.eql(50);
+    });
+
+    it('increases boss rage to 100', async () => {
+      await user.post('/debug/boss-rage');
+      await user.post('/debug/boss-rage');
+      await party.sync();
+      expect(party.quest.progress.rage).to.eql(100);
+    });
+  });
+});

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

@@ -0,0 +1,86 @@
+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);
+    const tomorrow = new Date(today.valueOf());
+    tomorrow.setDate(today.getDate() + 1);
+    expect(newResultDate.getDate()).to.eql(tomorrow.getDate());
+    expect(newResultDate.getMonth()).to.eql(tomorrow.getMonth());
+    expect(newResultDate.getFullYear()).to.eql(tomorrow.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);
+    const yesterday = new Date(today.valueOf());
+    yesterday.setDate(today.getDate() - 1);
+    expect(newResultDate.getDate()).to.eql(yesterday.getDate());
+    expect(newResultDate.getMonth()).to.eql(yesterday.getMonth());
+    expect(newResultDate.getFullYear()).to.eql(yesterday.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

@@ -85,22 +85,6 @@ describe('POST /group/:groupId/join', () => {
         await expect(user.get('/user')).to.eventually.have.nested.property('items.quests.basilist', 1);
       });
 
-      it('notifies inviting user that their invitation was accepted', async () => {
-        await invitedUser.post(`/groups/${guild._id}/join`);
-
-        const inviter = await user.get('/user');
-        const expectedData = {
-          headerText: t('invitationAcceptedHeader'),
-          bodyText: t('invitationAcceptedBody', {
-            username: invitedUser.auth.local.username,
-            groupName: guild.name,
-          }),
-        };
-
-        expect(inviter.notifications[1].type).to.eql('GROUP_INVITE_ACCEPTED');
-        expect(inviter.notifications[1].data).to.eql(expectedData);
-      });
-
       it('awards Joined Guild achievement', async () => {
         await invitedUser.post(`/groups/${guild._id}/join`);
 
@@ -155,29 +139,21 @@ describe('POST /group/:groupId/join', () => {
         await expect(invitedUser.get('/user')).to.eventually.have.nested.property('party._id', party._id);
       });
 
-      it('notifies inviting user that their invitation was accepted', async () => {
-        await invitedUser.post(`/groups/${party._id}/join`);
-
-        const inviter = await user.get('/user');
-
-        const expectedData = {
-          headerText: t('invitationAcceptedHeader'),
-          bodyText: t('invitationAcceptedBody', {
-            username: invitedUser.auth.local.username,
-            groupName: party.name,
-          }),
-        };
-
-        expect(inviter.notifications[0].type).to.eql('GROUP_INVITE_ACCEPTED');
-        expect(inviter.notifications[0].data).to.eql(expectedData);
-      });
-
       it('clears invitation from user when joining party', async () => {
         await invitedUser.post(`/groups/${party._id}/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/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

@@ -125,6 +125,90 @@ describe('POST /tasks/:id/score/:direction', () => {
         expect(body.finalLvl).to.eql(user.stats.lvl);
       });
     });
+
+    context('handles drops', async () => {
+      let randomStub;
+
+      afterEach(() => {
+        randomStub.restore();
+      });
+      it('gives user a drop', async () => {
+        user = await generateUser({
+          'stats.gp': 100,
+          'achievements.completedTask': true,
+          'items.eggs': {
+            Wolf: 1,
+          },
+        });
+        randomStub = sandbox.stub(Math, 'random').returns(0.1);
+        const task = await user.post('/tasks/user', {
+          text: 'test habit',
+          type: 'habit',
+        });
+
+        const res = await user.post(`/tasks/${task.id}/score/up`);
+        expect(res._tmp.drop).to.be.ok;
+      });
+
+      it('does not give a drop when non-sub drop cap is reached', async () => {
+        user = await generateUser({
+          'stats.gp': 100,
+          'achievements.completedTask': true,
+          'items.eggs': {
+            Wolf: 1,
+          },
+          'items.lastDrop.count': 5,
+        });
+        randomStub = sandbox.stub(Math, 'random').returns(0.1);
+        const task = await user.post('/tasks/user', {
+          text: 'test habit',
+          type: 'habit',
+        });
+
+        const res = await user.post(`/tasks/${task.id}/score/up`);
+        expect(res._tmp.drop).to.be.undefined;
+      });
+
+      it('gives a drop when subscriber is over regular cap but under subscriber cap', async () => {
+        user = await generateUser({
+          'stats.gp': 100,
+          'achievements.completedTask': true,
+          'items.eggs': {
+            Wolf: 1,
+          },
+          'items.lastDrop.count': 6,
+          'purchased.plan.customerId': '123',
+        });
+        randomStub = sandbox.stub(Math, 'random').returns(0.1);
+        const task = await user.post('/tasks/user', {
+          text: 'test habit',
+          type: 'habit',
+        });
+
+        const res = await user.post(`/tasks/${task.id}/score/up`);
+        expect(res._tmp.drop).to.be.ok;
+      });
+
+      it('does not give a drop when subscriber is at subscriber drop cap', async () => {
+        user = await generateUser({
+          'stats.gp': 100,
+          'achievements.completedTask': true,
+          'items.eggs': {
+            Wolf: 1,
+          },
+          'items.lastDrop.count': 10,
+          'purchased.plan.customerId': '123',
+        });
+        randomStub = sandbox.stub(Math, 'random').returns(0.1);
+        const task = await user.post('/tasks/user', {
+          text: 'test habit',
+          type: 'habit',
+        });
+
+        const res = await user.post(`/tasks/${task.id}/score/up`);
+        expect(res._tmp.drop).to.be.undefined;
+      });
+    });
   });
 
   context('todos', () => {

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

@@ -105,9 +105,9 @@ describe('POST /tasks/:taskId/assign/:memberId', () => {
 
     const groupTask = await user.get(`/tasks/group/${guild._id}`);
 
-    expect(member.notifications.length).to.equal(2);
-    expect(member.notifications[1].type).to.equal('GROUP_TASK_ASSIGNED');
-    expect(member.notifications[1].taskId).to.equal(groupTask._id);
+    const lastNotification = member.notifications[member.notifications.length - 1];
+    expect(lastNotification.type).to.equal('GROUP_TASK_ASSIGNED');
+    expect(lastNotification.taskId).to.equal(groupTask._id);
   });
 
   it('assigns a task to multiple users', async () => {

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

@@ -89,10 +89,12 @@ describe('POST /tasks/:taskId/unassign/:memberId', () => {
   });
 
   it('removes task assignment notification from unassigned user', async () => {
+    await member.sync();
+    const oldNotificationCount = member.notifications.length;
     await user.post(`/tasks/${task._id}/unassign/${member._id}`);
 
     await member.sync();
-    expect(member.notifications.length).to.equal(1); // mystery items
+    expect(member.notifications.length).to.equal(oldNotificationCount - 1);
   });
 
   it('unassigns a user and only that user from a task', async () => {

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

@@ -11,6 +11,7 @@ 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/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('fall');
+    });
+  });
 });

test/api/v4/user/GET-user.test.js

@@ -40,6 +40,24 @@ describe('GET /user', () => {
     expect(returnedUser.stats).to.not.exist;
   });
 
+  it('returns when ALWAYS_LOADED paths are requested', async () => {
+    const returnedUser = await user.get('/user?userFields=_id,notifications,preferences,auth,flags,permissions');
+
+    expect(returnedUser._id).to.equal(user._id);
+    expect(returnedUser.notifications).to.exist;
+    expect(returnedUser.preferences).to.exist;
+    expect(returnedUser.auth).to.exist;
+    expect(returnedUser.flags).to.exist;
+    expect(returnedUser.permissions).to.exist;
+  });
+
+  it('returns when subpaths paths are requested', async () => {
+    const returnedUser = await user.get('/user?userFields=auth.local.username');
+
+    expect(returnedUser._id).to.equal(user._id);
+    expect(returnedUser.auth.local.username).to.exist;
+  });
+
   it('does not return requested private properties', async () => {
     const returnedUser = await user.get('/user?userFields=apiToken,secret.text');
 

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,442 @@
+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-01T09:00:00.000Z'));
+        const potions = shared.shops.getMarketCategories(user).find(x => x.identifier === 'premiumHatchingPotions');
+        expect(potions.items.length).to.eql(3);
+      });
+
+      it('does not contain past scheduled premium hatching potions', async () => {
+        clock = sinon.useFakeTimers(new Date('2024-04-01T09:00:00.000Z'));
+        const potions = shared.shops.getMarketCategories(user).find(x => x.identifier === 'premiumHatchingPotions');
+        expect(potions.items.filter(x => x.key === 'Aquatic' || x.key === 'Celestial').length, 'Aquatic or Celestial found').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-01T09:00:00.000Z'));
+        const potions = shared.shops.getMarketCategories(user).find(x => x.identifier === 'premiumHatchingPotions');
+        expect(potions.items.length).to.eql(3);
+        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);
+    });
+
+    it('does not add an end date to steampunk gear', () => {
+      const categories = shopCategories.filter(cat => cat.identifier.startsWith('30'));
+      categories.forEach(category => {
+        expect(category.end).to.not.exist;
+        category.items.forEach(item => {
+          expect(item.end).to.not.exist;
+        });
+      });
+    });
+  });
+
+  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

@@ -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

@@ -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

@@ -15,6 +15,7 @@ import { errorMessage } from '../../../../website/common/script/libs/errorMessag
 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/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/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,50 @@ 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 event hatching potion', async () => {
+      clock.restore();
+      clock = sandbox.useFakeTimers(moment('2022-04-10').valueOf());
+      const type = 'hatchingPotions';
+      const key = 'Veggie';
+
+      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 +286,6 @@ describe('shared.ops.purchase', () => {
       expect(user.balance).to.equal(startingBalance - price);
 
       expect(pinnedGearUtils.removeItemByPath.notCalled).to.equal(true);
-      clock.restore();
     });
   });
 
@@ -257,5 +326,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/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-08'));
+    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(2);
+    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(2);
+    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, 15));
+      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);
+  });
 });

test/content/index.test.js

@@ -0,0 +1,154 @@
+import content from '../../website/common/script/content';
+
+describe('content index', () => {
+  let clock;
+
+  afterEach(() => {
+    if (clock) {
+      clock.restore();
+    }
+  });
+
+  it('Releases eggs when appropriate without needing restarting', () => {
+    clock = sinon.useFakeTimers(new Date('2024-06-20'));
+    const mayEggs = content.eggs;
+    expect(mayEggs.Chameleon).to.not.exist;
+    clock.restore();
+    clock = sinon.useFakeTimers(new Date('2024-07-20'));
+    const juneEggs = content.eggs;
+    expect(juneEggs.Chameleon).to.exist;
+    expect(Object.keys(mayEggs).length, '').to.equal(Object.keys(juneEggs).length - 1);
+  });
+
+  it('Releases hatching potions when appropriate without needing restarting', () => {
+    clock = sinon.useFakeTimers(new Date('2024-05-20'));
+    const mayHatchingPotions = content.hatchingPotions;
+    expect(mayHatchingPotions.Koi).to.not.exist;
+    clock.restore();
+    clock = sinon.useFakeTimers(new Date('2024-06-20'));
+    const juneHatchingPotions = content.hatchingPotions;
+    expect(juneHatchingPotions.Koi).to.exist;
+    expect(Object.keys(mayHatchingPotions).length, '').to.equal(Object.keys(juneHatchingPotions).length - 1);
+  });
+
+  it('Releases armoire gear when appropriate without needing restarting', () => {
+    clock = sinon.useFakeTimers(new Date('2024-06-20'));
+    const juneGear = content.gear.flat;
+    expect(juneGear.armor_armoire_corsairsCoatAndCape).to.not.exist;
+    clock.restore();
+    clock = sinon.useFakeTimers(new Date('2024-07-10'));
+    const julyGear = content.gear.flat;
+    expect(julyGear.armor_armoire_corsairsCoatAndCape).to.exist;
+    expect(Object.keys(juneGear).length, '').to.equal(Object.keys(julyGear).length - 3);
+  });
+
+  it('Releases pets when appropriate without needing restarting', () => {
+    clock = sinon.useFakeTimers(new Date('2024-06-20'));
+    const junePets = content.petInfo;
+    expect(junePets['Chameleon-Base']).to.not.exist;
+    clock.restore();
+    clock = sinon.useFakeTimers(new Date('2024-07-18'));
+    const julyPets = content.petInfo;
+    expect(julyPets['Chameleon-Base']).to.exist;
+    expect(Object.keys(junePets).length, '').to.equal(Object.keys(julyPets).length - 10);
+  });
+
+  it('Releases mounts when appropriate without needing restarting', () => {
+    clock = sinon.useFakeTimers(new Date('2024-06-20'));
+    const juneMounts = content.mountInfo;
+    expect(juneMounts['Chameleon-Base']).to.not.exist;
+    clock.restore();
+    clock = sinon.useFakeTimers(new Date('2024-07-18'));
+    const julyMounts = content.mountInfo;
+    expect(julyMounts['Chameleon-Base']).to.exist;
+    expect(Object.keys(juneMounts).length, '').to.equal(Object.keys(julyMounts).length - 10);
+  });
+
+  it('marks regular food as buyable and droppable without any events', () => {
+    clock = sinon.useFakeTimers(new Date('2024-06-20'));
+    const { food } = content;
+    Object.keys(food).forEach(key => {
+      if (key === 'Saddle') {
+        expect(food[key].canBuy(), `${key} canBuy`).to.be.true;
+        expect(food[key].canDrop, `${key} canDrop`).to.be.false;
+        return;
+      }
+      let expected = true;
+      if (key.startsWith('Cake_')) {
+        expected = false;
+      } else if (key.startsWith('Candy_')) {
+        expected = false;
+      } else if (key.startsWith('Pie_')) {
+        expected = false;
+      }
+      expect(food[key].canBuy(), `${key} canBuy`).to.equal(expected);
+      expect(food[key].canDrop, `${key} canDrop`).to.equal(expected);
+    });
+  });
+
+  it('marks candy as buyable and droppable during habitoween', () => {
+    clock = sinon.useFakeTimers(new Date('2024-10-31'));
+    const { food } = content;
+    Object.keys(food).forEach(key => {
+      if (key === 'Saddle') {
+        expect(food[key].canBuy(), `${key} canBuy`).to.be.true;
+        expect(food[key].canDrop, `${key} canDrop`).to.be.false;
+        return;
+      }
+      let expected = false;
+      if (key.startsWith('Cake_')) {
+        expected = false;
+      } else if (key.startsWith('Candy_')) {
+        expected = true;
+      } else if (key.startsWith('Pie_')) {
+        expected = false;
+      }
+      expect(food[key].canBuy(), `${key} canBuy`).to.equal(expected);
+      expect(food[key].canDrop, `${key} canDrop`).to.equal(expected);
+    });
+  });
+
+  it('marks cake as buyable and droppable during birthday', () => {
+    clock = sinon.useFakeTimers(new Date('2024-01-31'));
+    const { food } = content;
+    Object.keys(food).forEach(key => {
+      if (key === 'Saddle') {
+        expect(food[key].canBuy(), `${key} canBuy`).to.be.true;
+        expect(food[key].canDrop, `${key} canDrop`).to.be.false;
+        return;
+      }
+      let expected = false;
+      if (key.startsWith('Cake_')) {
+        expected = true;
+      } else if (key.startsWith('Candy_')) {
+        expected = false;
+      } else if (key.startsWith('Pie_')) {
+        expected = false;
+      }
+      expect(food[key].canBuy(), `${key} canBuy`).to.equal(expected);
+      expect(food[key].canDrop, `${key} canDrop`).to.equal(expected);
+    });
+  });
+
+  it('marks pie as buyable and droppable during pi day', () => {
+    clock = sinon.useFakeTimers(new Date('2024-03-15'));
+    const { food } = content;
+    Object.keys(food).forEach(key => {
+      if (key === 'Saddle') {
+        expect(food[key].canBuy(), `${key} canBuy`).to.be.true;
+        expect(food[key].canDrop, `${key} canDrop`).to.be.false;
+        return;
+      }
+      let expected = false;
+      if (key.startsWith('Cake_')) {
+        expected = false;
+      } else if (key.startsWith('Candy_')) {
+        expected = false;
+      } else if (key.startsWith('Pie_')) {
+        expected = true;
+      }
+      expect(food[key].canBuy(), `${key} canBuy`).to.equal(expected);
+      expect(food[key].canDrop, `${key} canDrop`).to.equal(expected);
+    });
+  });
+});

test/content/quests.test.js

@@ -0,0 +1,42 @@
+import {
+  each,
+} from 'lodash';
+import {
+  expectValidTranslationString,
+} from '../helpers/content.helper';
+
+import { quests } from '../../website/common/script/content/quests';
+
+describe('quests', () => {
+  let clock;
+
+  afterEach(() => {
+    if (clock) {
+      clock.restore();
+    }
+  });
+
+  it('contains basic information about each quest', () => {
+    each(quests, (quest, key) => {
+      expectValidTranslationString(quest.text);
+      expectValidTranslationString(quest.notes);
+      expectValidTranslationString(quest.completion);
+      expect(quest.key, key).to.equal(key);
+      expect(quest.category, key).to.be.a('string');
+      if (quest.boss) {
+        expectValidTranslationString(quest.boss.name);
+        expect(quest.boss.hp, key).to.be.a('number');
+        expect(quest.boss.str, key).to.be.a('number');
+      }
+      expect(quest.drop).to.be.an('object');
+      expect(quest.drop.gp, key).to.be.a('number');
+      expect(quest.drop.exp, key).to.be.a('number');
+      if (quest.drop.items) {
+        quest.drop.items.forEach(drop => {
+          expectValidTranslationString(drop.text);
+          expect(drop.type, key).to.exist;
+        });
+      }
+    });
+  });
+});

test/content/releaseDates.test.js

@@ -0,0 +1,82 @@
+import find from 'lodash/find';
+import maxBy from 'lodash/maxBy';
+import {
+  ARMOIRE_RELEASE_DATES,
+  EGGS_RELEASE_DATES,
+  HATCHING_POTIONS_RELEASE_DATES,
+} from '../../website/common/script/content/constants/releaseDates';
+import armoire from '../../website/common/script/content/gear/sets/armoire';
+import eggs from '../../website/common/script/content/eggs';
+import hatchingPotions from '../../website/common/script/content/hatching-potions';
+
+describe('releaseDates', () => {
+  let clock;
+
+  afterEach(() => {
+    if (clock) {
+      clock.restore();
+    }
+  });
+  describe('armoire', () => {
+    it('should only contain valid armoire names', () => {
+      const lastReleaseDate = maxBy(Object.values(ARMOIRE_RELEASE_DATES), value => new Date(`${value.year}-${value.month + 1}-20`));
+      clock = sinon.useFakeTimers(new Date(`${lastReleaseDate.year}-${lastReleaseDate.month + 1}-20`));
+      Object.keys(ARMOIRE_RELEASE_DATES).forEach(key => {
+        expect(find(armoire.all, { set: key }), `${key} is not a valid armoire set`).to.exist;
+      });
+    });
+
+    it('should contain a valid year and month', () => {
+      Object.keys(ARMOIRE_RELEASE_DATES).forEach(key => {
+        const date = ARMOIRE_RELEASE_DATES[key];
+        expect(date.year, `${key} year is not a valid year`).to.be.a('number');
+        expect(date.year).to.be.at.least(2023);
+        expect(date.month, `${key} month is not a valid month`).to.be.a('number');
+        expect(date.month).to.be.within(1, 12);
+        expect(date.day).to.not.exist;
+      });
+    });
+  });
+
+  describe('eggs', () => {
+    it('should only contain valid egg names', () => {
+      const lastReleaseDate = maxBy(Object.values(EGGS_RELEASE_DATES), value => new Date(`${value.year}-${value.month + 1}-${value.day}`));
+      clock = sinon.useFakeTimers(new Date(`${lastReleaseDate.year}-${lastReleaseDate.month + 1}-${lastReleaseDate.day}`));
+      Object.keys(EGGS_RELEASE_DATES).forEach(key => {
+        expect(eggs.all[key], `${key} is not a valid egg name`).to.exist;
+      });
+    });
+
+    it('should contain a valid year, month and date', () => {
+      Object.keys(EGGS_RELEASE_DATES).forEach(key => {
+        const date = EGGS_RELEASE_DATES[key];
+        expect(date.year, `${key} year is not a valid year`).to.be.a('number');
+        expect(date.year).to.be.at.least(2024);
+        expect(date.month, `${key} month is not a valid month`).to.be.a('number');
+        expect(date.month).to.be.within(1, 12);
+        expect(date.day, `${key} day is not a valid day`).to.be.a('number');
+      });
+    });
+  });
+
+  describe('hatchingPotions', () => {
+    it('should only contain valid potion names', () => {
+      const lastReleaseDate = maxBy(Object.values(HATCHING_POTIONS_RELEASE_DATES), value => new Date(`${value.year}-${value.month + 1}-${value.day}`));
+      clock = sinon.useFakeTimers(new Date(`${lastReleaseDate.year}-${lastReleaseDate.month + 1}-${lastReleaseDate.day}`));
+      Object.keys(HATCHING_POTIONS_RELEASE_DATES).forEach(key => {
+        expect(hatchingPotions.all[key], `${key} is not a valid potion name`).to.exist;
+      });
+    });
+
+    it('should contain a valid year, month and date', () => {
+      Object.keys(HATCHING_POTIONS_RELEASE_DATES).forEach(key => {
+        const date = HATCHING_POTIONS_RELEASE_DATES[key];
+        expect(date.year, `${key} year is not a valid year`).to.be.a('number');
+        expect(date.year).to.be.at.least(2024);
+        expect(date.month, `${key} month is not a valid month`).to.be.a('number');
+        expect(date.month).to.be.within(1, 12);
+        expect(date.day, `${key} day is not a valid day`).to.be.a('number');
+      });
+    });
+  });
+});

test/content/schedule.test.js

@@ -0,0 +1,332 @@
+// eslint-disable-next-line max-len
+import moment from 'moment';
+import nconf from 'nconf';
+import {
+  getAllScheduleMatchingGroups, clearCachedMatchers, MONTHLY_SCHEDULE, GALA_SCHEDULE,
+} from '../../website/common/script/content/constants/schedule';
+import QUEST_PETS from '../../website/common/script/content/quests/pets';
+import QUEST_HATCHINGPOTIONS from '../../website/common/script/content/quests/potions';
+import QUEST_BUNDLES from '../../website/common/script/content/bundles';
+import potions from '../../website/common/script/content/hatching-potions';
+import SPELLS from '../../website/common/script/content/spells';
+import QUEST_SEASONAL from '../../website/common/script/content/quests/seasonal';
+
+function validateMatcher (matcher, checkedDate) {
+  expect(matcher.end).to.be.a('date');
+  expect(matcher.end).to.be.greaterThan(checkedDate);
+}
+
+describe('Content Schedule', () => {
+  let switchoverTime;
+  let clock;
+
+  beforeEach(() => {
+    switchoverTime = nconf.get('CONTENT_SWITCHOVER_TIME_OFFSET') || 0;
+    clearCachedMatchers();
+  });
+
+  afterEach(() => {
+    if (clock) {
+      clock.restore();
+    }
+  });
+
+  it('assembles scheduled items on january 15th', () => {
+    const date = new Date('2024-01-15');
+    const matchers = getAllScheduleMatchingGroups(date);
+    for (const key in matchers) {
+      if (matchers[key]) {
+        validateMatcher(matchers[key], date);
+      }
+    }
+  });
+
+  it('assembles scheduled items on january 31th', () => {
+    const date = new Date('2024-01-31');
+    const matchers = getAllScheduleMatchingGroups(date);
+    for (const key in matchers) {
+      if (matchers[key]) {
+        validateMatcher(matchers[key], date);
+      }
+    }
+  });
+
+  it('assembles scheduled items on march 2nd', () => {
+    const date = new Date('2024-03-02');
+    const matchers = getAllScheduleMatchingGroups(date);
+    for (const key in matchers) {
+      if (matchers[key]) {
+        validateMatcher(matchers[key], date);
+      }
+    }
+  });
+
+  it('assembles scheduled items on march 22st', () => {
+    const date = new Date('2024-03-22');
+    const matchers = getAllScheduleMatchingGroups(date);
+    for (const key in matchers) {
+      if (matchers[key]) {
+        validateMatcher(matchers[key], date);
+      }
+    }
+  });
+
+  it('assembles scheduled items on october 7th', () => {
+    const date = new Date('2024-10-07');
+    const matchers = getAllScheduleMatchingGroups(date);
+    for (const key in matchers) {
+      if (matchers[key]) {
+        validateMatcher(matchers[key], date);
+      }
+    }
+  });
+  it('assembles scheduled items on november 1th', () => {
+    const date = new Date('2024-11-01');
+    const matchers = getAllScheduleMatchingGroups(date);
+    for (const key in matchers) {
+      if (matchers[key]) {
+        validateMatcher(matchers[key], date);
+      }
+    }
+  });
+
+  it('assembles scheduled items on december 20th', () => {
+    const date = new Date('2024-12-20');
+    const matchers = getAllScheduleMatchingGroups(date);
+    for (const key in matchers) {
+      if (matchers[key]) {
+        validateMatcher(matchers[key], date);
+      }
+    }
+  });
+
+  it('sets the end date if its in the same month', () => {
+    const date = new Date('2024-04-03');
+    const matchers = getAllScheduleMatchingGroups(date);
+    expect(matchers.backgrounds.end).to.eql(moment.utc(`2024-04-07T${String(switchoverTime).padStart(2, '0')}:00:00.000Z`).toDate());
+  });
+
+  it('sets the end date if its in the next day', () => {
+    const date = new Date('2024-05-06T14:00:00.000Z');
+    const matchers = getAllScheduleMatchingGroups(date);
+    expect(matchers.backgrounds.end).to.eql(moment.utc(`2024-05-07T${String(switchoverTime).padStart(2, '0')}:00:00.000Z`).toDate());
+  });
+
+  it('sets the end date if its on the release day before switchover', () => {
+    const date = new Date('2024-05-07T07:00:00.000+00:00');
+    const matchers = getAllScheduleMatchingGroups(date);
+    expect(matchers.backgrounds.end).to.eql(moment.utc(`2024-05-07T${String(switchoverTime).padStart(2, '0')}:00:00.000Z`).toDate());
+  });
+
+  it('sets the end date if its on the release day after switchover', () => {
+    const date = new Date('2024-05-07T09:00:00.000+00:00');
+    const matchers = getAllScheduleMatchingGroups(date);
+    expect(matchers.backgrounds.end).to.eql(moment.utc(`2024-06-07T${String(switchoverTime).padStart(2, '0')}:00:00.000Z`).toDate());
+  });
+
+  it('sets the end date if its next month', () => {
+    const date = new Date('2024-05-20T01:00:00.000Z');
+    const matchers = getAllScheduleMatchingGroups(date);
+    expect(matchers.backgrounds.end).to.eql(moment.utc(`2024-06-07T${String(switchoverTime).padStart(2, '0')}:00:00.000Z`).toDate());
+  });
+
+  it('sets the end date for a gala', () => {
+    const date = new Date('2024-05-20');
+    const matchers = getAllScheduleMatchingGroups(date);
+    expect(matchers.seasonalGear.end).to.eql(moment.utc(`2024-06-21T${String(switchoverTime).padStart(2, '0')}:00:00.000Z`).toDate());
+  });
+
+  it('sets the end date for a winter gala', () => {
+    const date = new Date('2024-12-22');
+    const matchers = getAllScheduleMatchingGroups(date);
+    expect(matchers.seasonalGear.end).to.eql(moment.utc(`2025-03-21T${String(switchoverTime).padStart(2, '0')}:00:00.000Z`).toDate());
+  });
+
+  it('uses correct date for first hours of the month', () => {
+    // if the date is checked before CONTENT_SWITCHOVER_TIME_OFFSET,
+    // it should be considered the previous month
+    const date = new Date('2024-05-01T02:00:00.000Z');
+    const matchers = getAllScheduleMatchingGroups(date);
+    expect(matchers.petQuests.items).to.contain('snake');
+    expect(matchers.petQuests.items).to.not.contain('horse');
+    expect(matchers.timeTravelers.match('202304'), '202304').to.be.true;
+    expect(matchers.timeTravelers.match('202404'), '202404').to.be.false;
+    expect(matchers.timeTravelers.match('202305'), '202305').to.be.false;
+  });
+
+  it('uses correct date after switchover time', () => {
+    // if the date is checked after CONTENT_SWITCHOVER_TIME_OFFSET,
+    // it should be considered the current
+    const date = new Date('2024-05-01T09:00:00.000Z');
+    const matchers = getAllScheduleMatchingGroups(date);
+    expect(matchers.petQuests.items).to.contain('snake');
+    expect(matchers.petQuests.items).to.not.contain('horse');
+    expect(matchers.timeTravelers.match('202304'), '202304').to.be.false;
+    expect(matchers.timeTravelers.match('202305'), '202305').to.be.true;
+    expect(matchers.timeTravelers.match('202405'), '202405').to.be.false;
+  });
+
+  it('uses UTC timezone', () => {
+    // if the date is checked after CONTENT_SWITCHOVER_TIME_OFFSET,
+    // it should be considered the current
+    clock = sinon.useFakeTimers(new Date('2024-05-01T05:00:00.000-04:00'));
+    const matchers = getAllScheduleMatchingGroups();
+    expect(matchers.petQuests.items).to.contain('snake');
+    expect(matchers.petQuests.items).to.not.contain('horse');
+    expect(matchers.timeTravelers.match('202304'), '202304').to.be.false;
+    expect(matchers.timeTravelers.match('202305'), '202305').to.be.true;
+    expect(matchers.timeTravelers.match('202405'), '202405').to.be.false;
+  });
+
+  it('contains content for repeating events', () => {
+    const date = new Date('2024-04-15');
+    const matchers = getAllScheduleMatchingGroups(date);
+    expect(matchers.premiumHatchingPotions).to.exist;
+    expect(matchers.premiumHatchingPotions.items.length).to.equal(5);
+    expect(matchers.premiumHatchingPotions.items.indexOf('Veggie')).to.not.equal(-1);
+    expect(matchers.premiumHatchingPotions.items.indexOf('Porcelain')).to.not.equal(-1);
+  });
+
+  describe('only contains valid keys for', () => {
+    it('pet quests', () => {
+      const petKeys = Object.keys(QUEST_PETS);
+      Object.keys(MONTHLY_SCHEDULE).forEach(key => {
+        const petQuests = MONTHLY_SCHEDULE[key][14].find(item => item.type === 'petQuests');
+        for (const petQuest of petQuests.items) {
+          expect(petQuest).to.be.a('string');
+          expect(petKeys).to.include(petQuest);
+        }
+      });
+    });
+
+    it('hatchingpotion quests', () => {
+      const potionKeys = Object.keys(QUEST_HATCHINGPOTIONS);
+      Object.keys(MONTHLY_SCHEDULE).forEach(key => {
+        const potionQuests = MONTHLY_SCHEDULE[key][14].find(item => item.type === 'hatchingPotionQuests');
+        for (const potionQuest of potionQuests.items) {
+          expect(potionQuest).to.be.a('string');
+          expect(potionKeys).to.include(potionQuest);
+        }
+      });
+    });
+
+    it('bundles', () => {
+      const bundleKeys = Object.keys(QUEST_BUNDLES);
+      Object.keys(MONTHLY_SCHEDULE).forEach(key => {
+        const bundles = MONTHLY_SCHEDULE[key][14].find(item => item.type === 'bundles');
+        for (const bundle of bundles.items) {
+          expect(bundle).to.be.a('string');
+          expect(bundleKeys).to.include(bundle);
+        }
+      });
+    });
+
+    it('premium hatching potions', () => {
+      const potionKeys = Object.keys(potions.premium);
+      Object.keys(MONTHLY_SCHEDULE).forEach(key => {
+        const monthlyPotions = MONTHLY_SCHEDULE[key][21].find(item => item.type === 'premiumHatchingPotions');
+        for (const potion of monthlyPotions.items) {
+          expect(potion).to.be.a('string');
+          expect(potionKeys).to.include(potion);
+        }
+      });
+    });
+
+    it('seasonal quests', () => {
+      const questKeys = Object.keys(QUEST_SEASONAL);
+      Object.keys(GALA_SCHEDULE).forEach(key => {
+        const quests = GALA_SCHEDULE[key].matchers.find(item => item.type === 'seasonalQuests');
+        for (const quest of quests.items) {
+          expect(quest).to.be.a('string');
+          expect(questKeys).to.include(quest);
+        }
+      });
+    });
+
+    it('seasonal spells', () => {
+      const spellKeys = Object.keys(SPELLS.special);
+      Object.keys(GALA_SCHEDULE).forEach(key => {
+        const petQuests = GALA_SCHEDULE[key].matchers.find(item => item.type === 'seasonalSpells');
+        for (const petQuest of petQuests.items) {
+          expect(petQuest).to.be.a('string');
+          expect(spellKeys).to.include(petQuest);
+        }
+      });
+    });
+  });
+
+  describe('backgrounds matcher', () => {
+    it('allows background matching the month for new backgrounds', () => {
+      const date = new Date('2024-07-08');
+      const matcher = getAllScheduleMatchingGroups(date).backgrounds;
+      expect(matcher.match('backgroundkey072024')).to.be.true;
+    });
+
+    it('disallows background in the future', () => {
+      const date = new Date('2024-07-08');
+      const matcher = getAllScheduleMatchingGroups(date).backgrounds;
+      expect(matcher.match('backgroundkey072025')).to.be.false;
+    });
+
+    it('disallows background for the inverse month for new backgrounds', () => {
+      const date = new Date('2024-07-08');
+      const matcher = getAllScheduleMatchingGroups(date).backgrounds;
+      expect(matcher.match('backgroundkey012024')).to.be.false;
+    });
+
+    it('allows background for the inverse month for old backgrounds', () => {
+      const date = new Date('2024-08-08');
+      const matcher = getAllScheduleMatchingGroups(date).backgrounds;
+      expect(matcher.match('backgroundkey022023')).to.be.true;
+      expect(matcher.match('backgroundkey022021')).to.be.true;
+    });
+
+    it('allows background even yeared backgrounds in first half of year', () => {
+      const date = new Date('2025-02-08');
+      const matcher = getAllScheduleMatchingGroups(date).backgrounds;
+      expect(matcher.match('backgroundkey022024')).to.be.true;
+      expect(matcher.match('backgroundkey082022')).to.be.true;
+    });
+
+    it('allows background odd yeared backgrounds in second half of year', () => {
+      const date = new Date('2024-08-08');
+      const matcher = getAllScheduleMatchingGroups(date).backgrounds;
+      expect(matcher.match('backgroundkey022023')).to.be.true;
+      expect(matcher.match('backgroundkey082021')).to.be.true;
+    });
+  });
+
+  describe('timeTravelers matcher', () => {
+    it('allows sets matching the month', () => {
+      const date = new Date('2024-07-08');
+      const matcher = getAllScheduleMatchingGroups(date).timeTravelers;
+      expect(matcher.match('202307'), '202307').to.be.true;
+      expect(matcher.match('202207'), '202207').to.be.true;
+    });
+
+    it('disallows sets not matching the month', () => {
+      const date = new Date('2024-07-08');
+      const matcher = getAllScheduleMatchingGroups(date).timeTravelers;
+      expect(matcher.match('202306'), '202306').to.be.false;
+      expect(matcher.match('202402'), '202402').to.be.false;
+    });
+
+    it('disallows sets from current month', () => {
+      const date = new Date('2024-07-08');
+      const matcher = getAllScheduleMatchingGroups(date).timeTravelers;
+      expect(matcher.match('202407'), '202407').to.be.false;
+    });
+
+    it('disallows sets from the future', () => {
+      const date = new Date('2024-07-08');
+      const matcher = getAllScheduleMatchingGroups(date).timeTravelers;
+      expect(matcher.match('202507'), '202507').to.be.false;
+    });
+
+    it('matches sets released in the earlier half of the year', () => {
+      const date = new Date('2024-07-08');
+      const matcher = getAllScheduleMatchingGroups(date).timeTravelers;
+      expect(matcher.match('202401'), '202401').to.be.true;
+    });
+  });
+});

test/content/shop-featuredItems.test.js

@@ -0,0 +1,52 @@
+import Sinon from 'sinon';
+import featuredItems from '../../website/common/script/content/shop-featuredItems';
+
+describe('Shop Featured Items', () => {
+  let clock;
+
+  afterEach(() => {
+    if (clock !== undefined) {
+      clock.restore();
+      clock = undefined;
+    }
+  });
+
+  describe('Market', () => {
+    it('contains armoire', () => {
+      const items = featuredItems.market();
+      expect(_.find(items, item => item.path === 'armoire')).to.exist;
+    });
+
+    it('contains the current premium hatching potions', () => {
+      clock = Sinon.useFakeTimers(new Date('2024-04-08'));
+      const items = featuredItems.market();
+      expect(_.find(items, item => item.path === 'premiumHatchingPotions.Porcelain')).to.exist;
+    });
+
+    it('is featuring 4 items', () => {
+      clock = Sinon.useFakeTimers(new Date('2024-02-08'));
+      const items = featuredItems.market();
+      expect(items.length).to.eql(4);
+    });
+  });
+
+  describe('Quest Shop', () => {
+    it('contains bundle', () => {
+      clock = Sinon.useFakeTimers(new Date('2024-03-08'));
+      const items = featuredItems.quests();
+      expect(_.find(items, item => item.path === 'quests.pinkMarble')).to.exist;
+    });
+
+    it('contains pet quests', () => {
+      clock = Sinon.useFakeTimers(new Date('2024-04-08'));
+      const items = featuredItems.quests();
+      expect(_.find(items, item => item.path === 'quests.frog')).to.exist;
+    });
+
+    it('is featuring 3 items', () => {
+      clock = Sinon.useFakeTimers(new Date('2024-02-08'));
+      const items = featuredItems.quests();
+      expect(items.length).to.eql(3);
+    });
+  });
+});

test/content/spells.test.js

@@ -0,0 +1,63 @@
+import {
+  generateUser,
+} from '../helpers/common.helper';
+import spells from '../../website/common/script/content/spells';
+import {
+  expectValidTranslationString,
+} from '../helpers/content.helper';
+import { TRANSFORMATION_DEBUFFS_LIST } from '../../website/common/script/constants';
+
+// TODO complete the test suite...
+
+describe('shared.ops.spells', () => {
+  let user;
+  let target;
+
+  beforeEach(() => {
+    user = generateUser();
+    target = generateUser();
+  });
+
+  it('all spells have required properties', () => {
+    for (const category of Object.values(spells)) {
+      for (const spell of Object.values(category)) {
+        expectValidTranslationString(spell.text, spell.key);
+        expectValidTranslationString(spell.notes);
+        expect(spell.target, spell.key).to.be.oneOf(['self', 'party', 'task', 'tasks', 'user']);
+      }
+    }
+  });
+
+  it('all special spells have a working cast method', async () => {
+    for (const s of Object.values(spells.special)) {
+      user.items.special[s.key] = 1;
+      s.cast(user, target, { language: 'en' });
+    }
+  });
+
+  it('all debuff spells cost 5 gold', () => {
+    for (const s of Object.values(spells.special)) {
+      if (s.purchaseType === 'debuffPotion') {
+        user.stats.gp = 5;
+        s.cast(user);
+        expect(user.stats.gp).to.equal(0);
+      }
+    }
+  });
+
+  it('all debuff spells remove the buff', () => {
+    const debuffMapping = {};
+    Object.keys(TRANSFORMATION_DEBUFFS_LIST).forEach(key => {
+      debuffMapping[TRANSFORMATION_DEBUFFS_LIST[key]] = key;
+    });
+    for (const s of Object.values(spells.special)) {
+      if (s.purchaseType === 'debuffPotion') {
+        user.stats.gp = 5;
+        user.stats.buffs[debuffMapping[s.key]] = true;
+        expect(user.stats.buffs[debuffMapping[s.key]]).to.equal(true);
+        s.cast(user);
+        expect(user.stats.buffs[debuffMapping[s.key]]).to.equal(false);
+      }
+    }
+  });
+});

test/content/stable.test.js

@@ -6,12 +6,21 @@ import {
 } from '../helpers/content.helper';
 import t from '../../website/common/script/content/translation';
 
-import * as stable from '../../website/common/script/content/stable';
-import * as eggs from '../../website/common/script/content/eggs';
-import * as potions from '../../website/common/script/content/hatching-potions';
+import stable from '../../website/common/script/content/stable';
+import eggs from '../../website/common/script/content/eggs';
+import potions from '../../website/common/script/content/hatching-potions';
 
 describe('stable', () => {
   describe('dropPets', () => {
+    let clock;
+    beforeEach(() => {
+      clock = sinon.useFakeTimers(new Date('2020-05-20'));
+    });
+
+    afterEach(() => {
+      clock.restore();
+    });
+
     it('contains a pet for each drop potion * each drop egg', () => {
       const numberOfDropPotions = Object.keys(potions.drops).length;
       const numberOfDropEggs = Object.keys(eggs.drops).length;

test/content/time-travelers.test.js

@@ -6,23 +6,105 @@ import timeTravelers from '../../website/common/script/content/time-travelers';
 
 describe('time-travelers store', () => {
   let user;
+  let date;
   beforeEach(() => {
     user = generateUser();
   });
 
-  it('removes owned sets from the time travelers store', () => {
-    user.items.gear.owned.head_mystery_201602 = true; // eslint-disable-line camelcase
-    expect(timeTravelers.timeTravelerStore(user)['201602']).to.not.exist;
-    expect(timeTravelers.timeTravelerStore(user)['201603']).to.exist;
+  describe('on january 15th', () => {
+    beforeEach(() => {
+      date = new Date('2024-01-15');
+    });
+    it('returns the correct gear', () => {
+      const items = timeTravelers.timeTravelerStore(user, date);
+      for (const [key] of Object.entries(items)) {
+        if (key.startsWith('20')) {
+          expect(key).to.match(/20[0-9]{2}(01|07)/);
+        }
+      }
+    });
+    it('removes owned sets from the time travelers store', () => {
+      user.items.gear.owned.head_mystery_201601 = true; // eslint-disable-line camelcase
+      const items = timeTravelers.timeTravelerStore(user, date);
+      expect(items['201601']).to.not.exist;
+      expect(items['201801']).to.exist;
+      expect(items['202207']).to.exist;
+    });
+
+    it('removes unopened mystery item sets from the time travelers store', () => {
+      user.purchased = {
+        plan: {
+          mysteryItems: ['head_mystery_201601'],
+        },
+      };
+      const items = timeTravelers.timeTravelerStore(user, date);
+      expect(items['201601']).to.not.exist;
+      expect(items['201607']).to.exist;
+    });
   });
 
-  it('removes unopened mystery item sets from the time travelers store', () => {
-    user.purchased = {
-      plan: {
-        mysteryItems: ['head_mystery_201602'],
-      },
-    };
-    expect(timeTravelers.timeTravelerStore(user)['201602']).to.not.exist;
-    expect(timeTravelers.timeTravelerStore(user)['201603']).to.exist;
+  describe('on may 1st', () => {
+    beforeEach(() => {
+      date = new Date('2024-05-01T09:00:00.000Z');
+    });
+    it('returns the correct gear', () => {
+      const items = timeTravelers.timeTravelerStore(user, date);
+      for (const [key] of Object.entries(items)) {
+        if (key.startsWith('20')) {
+          expect(key).to.match(/20[0-9]{2}(05|11)/);
+        }
+      }
+    });
+    it('removes owned sets from the time travelers store', () => {
+      user.items.gear.owned.head_mystery_201705 = true; // eslint-disable-line camelcase
+      const items = timeTravelers.timeTravelerStore(user, date);
+      expect(items['201705']).to.not.exist;
+      expect(items['201805']).to.exist;
+      expect(items['202211']).to.exist;
+    });
+
+    it('removes unopened mystery item sets from the time travelers store', () => {
+      user.purchased = {
+        plan: {
+          mysteryItems: ['head_mystery_201705'],
+        },
+      };
+      const items = timeTravelers.timeTravelerStore(user, date);
+      expect(items['201705']).to.not.exist;
+      expect(items['201611']).to.exist;
+    });
+  });
+
+  describe('on october 21st', () => {
+    beforeEach(() => {
+      date = new Date('2024-10-21');
+    });
+    it('returns the correct gear', () => {
+      const items = timeTravelers.timeTravelerStore(user, date);
+      for (const [key] of Object.entries(items)) {
+        if (key.startsWith('20')) {
+          expect(key).to.match(/20[0-9]{2}(10|04)/);
+        }
+      }
+    });
+    it('removes owned sets from the time travelers store', () => {
+      user.items.gear.owned.head_mystery_201810 = true; // eslint-disable-line camelcase
+      user.items.gear.owned.armor_mystery_201810 = true; // eslint-disable-line camelcase
+      const items = timeTravelers.timeTravelerStore(user, date);
+      expect(items['201810']).to.not.exist;
+      expect(items['201910']).to.exist;
+      expect(items['202204']).to.exist;
+    });
+
+    it('removes unopened mystery item sets from the time travelers store', () => {
+      user.purchased = {
+        plan: {
+          mysteryItems: ['armor_mystery_201710'],
+        },
+      };
+      const items = timeTravelers.timeTravelerStore(user, date);
+      expect(items['201710']).to.not.exist;
+      expect(items['201604']).to.exist;
+    });
   });
 });

test/helpers/api-unit.helper.js

@@ -40,6 +40,7 @@ export function generateRes (options = {}) {
     redirect: sandbox.stub(),
     render: sandbox.stub(),
     send: sandbox.stub(),
+    sendFile: sandbox.stub(),
     sendStatus: sandbox.stub().returnsThis(),
     set: sandbox.stub(),
     status: sandbox.stub().returnsThis(),
@@ -59,7 +60,17 @@ export function generateReq (options = {}) {
     header (header) {
       return this.headers[header];
     },
+    listeners: {},
     session: {},
+    on (key, func) {
+      if (!this.listeners[key]) {
+        this.listeners[key] = [];
+      }
+      this.listeners[key].push(func);
+    },
+    end () {
+      this.listeners.close.forEach(func => func());
+    },
   };
 
   const req = defaultsDeep(options, defaultReq);

test/helpers/content.helper.js

@@ -7,13 +7,13 @@ i18n.translations = translations;
 export const STRING_ERROR_MSG = /^Error processing the string ".*". Please see Help > Report a Bug.$/;
 export const STRING_DOES_NOT_EXIST_MSG = /^String '.*' not found.$/;
 
-export function expectValidTranslationString (attribute) {
-  expect(attribute).to.be.a('function');
+export function expectValidTranslationString (attribute, contextKey) {
+  expect(attribute, contextKey).to.be.a('function');
 
   const translatedString = attribute();
 
-  expect(translatedString.trim()).to.not.be.empty;
-  expect(translatedString).to.not.contain('function func(lang)');
-  expect(translatedString).to.not.eql(STRING_ERROR_MSG);
-  expect(translatedString).to.not.match(STRING_DOES_NOT_EXIST_MSG);
+  expect(translatedString.trim(), contextKey).to.not.be.empty;
+  expect(translatedString, contextKey).to.not.contain('function func(lang)');
+  expect(translatedString, contextKey).to.not.eql(STRING_ERROR_MSG);
+  expect(translatedString, contextKey).to.not.match(STRING_DOES_NOT_EXIST_MSG);
 }

test/helpers/mongo.js

@@ -21,6 +21,7 @@ export async function getProperty (collectionName, id, path) {
 // Specifically helpful for the GET /groups tests,
 // resets the db to an empty state and creates a tavern document
 export async function resetHabiticaDB () {
+  console.info('Resetting Habitica DB');
   const groups = mongoose.connection.db.collection('groups');
   const users = mongoose.connection.db.collection('users');
   return mongoose.connection.dropDatabase()

website/client/package.json

@@ -18,30 +18,30 @@
     "@vue/cli-service": "^5.0.8",
     "@vue/test-utils": "1.0.0-beta.29",
     "amplitude-js": "^8.21.3",
-    "axios": "^0.27.2",
+    "assert": "^2.1.0",
+    "axios": "^0.28.0",
     "axios-progress-bar": "^1.2.0",
     "babel-eslint": "^10.1.0",
     "bootstrap": "^4.6.0",
     "bootstrap-vue": "^2.23.1",
-    "chai": "^4.3.7",
     "core-js": "^3.33.1",
-    "dompurify": "^3.0.3",
     "eslint": "7.32.0",
     "eslint-config-habitrpg": "6.2.0",
     "eslint-plugin-mocha": "5.3.0",
     "eslint-plugin-vue": "7.20.0",
     "habitica-markdown": "^3.0.0",
     "hellojs": "^1.20.0",
-    "inspectpack": "^4.7.1",
     "intro.js": "^7.2.0",
     "jquery": "^3.7.1",
     "lodash": "^4.17.21",
     "moment": "^2.29.4",
+    "moment-locales-webpack-plugin": "^1.2.0",
     "nconf": "^0.12.1",
     "sass": "^1.63.4",
-    "sass-loader": "^8.0.2",
-    "smartbanner.js": "^1.19.3",
+    "sass-loader": "^14.1.1",
+    "sinon": "^17.0.1",
     "stopword": "^2.0.8",
+    "timers-browserify": "^2.0.12",
     "uuid": "^9.0.1",
     "validator": "^13.9.0",
     "vue": "^2.7.10",
@@ -51,10 +51,14 @@
     "vue-template-babel-compiler": "^2.0.0",
     "vue-template-compiler": "^2.7.10",
     "vuedraggable": "^2.24.3",
-    "vuejs-datepicker": "git://github.com/habitrpg/vuejs-datepicker.git#153d339e4dbebb73733658aeda1d5b7fcc55b0a0",
-    "webpack": "^5.89.0"
+    "vuejs-datepicker": "git://github.com/habitrpg/vuejs-datepicker.git#153d339e4dbebb73733658aeda1d5b7fcc55b0a0"
   },
   "devDependencies": {
-    "@babel/plugin-proposal-optional-chaining": "^7.21.0"
+    "@babel/plugin-proposal-optional-chaining": "^7.21.0",
+    "babel-plugin-lodash": "^3.3.4",
+    "chai": "^5.1.0",
+    "inspectpack": "^4.7.1",
+    "terser-webpack-plugin": "^5.3.10",
+    "webpack": "^5.94.0"
   }
 }

website/client/public/index.html

@@ -7,18 +7,6 @@
     <title>Habitica - Gamify Your Life</title>
     <meta name="description" content="Habitica is a free habit and productivity app that treats your real life like a game. Habitica can help you achieve your goals to become healthy and happy.">
     <meta name="keywords" content="Habits,Goals,Todo,Gamification,Health,Fitness,School,Work">
-    <meta name="smartbanner:title" content="Habitica">
-    <meta name="smartbanner:author" content="HabitRPG, Inc.">
-    <meta name="smartbanner:price" content="FREE">
-    <meta name="smartbanner:price-suffix-apple" content=" - On the App Store">
-    <meta name="smartbanner:price-suffix-google" content=" - In Google Play">
-    <meta name="smartbanner:icon-apple" content="/static/presskit/Logo/iOS.png">
-    <meta name="smartbanner:icon-google" content="/static/presskit/Logo/Android.png">
-    <meta name="smartbanner:button" content="VIEW">
-    <meta name="smartbanner:button-url-apple" content="https://itunes.apple.com/us/app/habitica-gamified-taskmanager/id994882113">
-    <meta name="smartbanner:button-url-google" content="https://play.google.com/store/apps/details?id=com.habitrpg.android.habitica">
-    <meta name="smartbanner:enabled-platforms" content="android,ios">
-    <meta name="smartbanner:hide-ttl" content="2592000000">
     <link href="https://fonts.googleapis.com/css?family=Roboto+Condensed:400,400i,700,700i|Roboto:400,400i,700,700i" rel="stylesheet">
     <link rel="shortcut icon" sizes="48x48" href="/static/icons/favicon.ico">
     <link rel="shortcut icon" sizes="192x192" href="/static/icons/favicon_192x192.png">
@@ -27,8 +15,15 @@
   </head>
   <body>
     <div id="loading-screen">
-      <svg width="32" height="32" viewBox="0 0 32 32" xmlns="http://www.w3.org/2000/svg">
-      <path fill-rule="evenodd" clip-rule="evenodd" d="M31.62 28.86c-.32-.706-1.057-1.048-1.538-.706-.48.341-1.147.393-1.78.24-.633-.153-.753-1.604-.616-3.278.136-1.673.363-2.318.506-2.925.162-.61.877-.562.962-.084.086.479.582.479 1.307-.391.724-.87.617-3.409-.218-5.474-.836-2.065.326-1.865.664-1.66.337.205.544-.102.462-1.28-.082-1.178-1.166-2.098-2.039-2.663-.873-.564-1.936-1.186-1.911-2.697.025-1.511 2.08-1.464 2.358-1.439.279.025.815-.093.506-1.663-.31-1.57-1.43-1.869-2.133-1.826-.703.042-1.177.428-2.17.053-.995-.376-1.655-.23-2.58-.023-.926.206-2.138.776-3.646 1.183-.795.219-1.064.274-1.93.288-.532.008-.755.653-.043 1.444.563.643 1.839.814 2.606.707.494-.07.608.258.563.74a8.013 8.013 0 0 0-.01 1.795c.08.6.18 1.62-.103 2.286-.14.326-.545.677-.98.653-.565-.034-1.022-.7-1.414-1.49-.825-1.662-1.793-2.014-5.404-3.535-3.248-1.367-5.007-3.5-6.096-4.874-.969-1.217-1.939-.756-1.85.342.07.852.592 3.604 1.912 5.257 1.623 2.525 4.128 3.67 7.013 3.895.755.06 1.226.208 1.29.553.095.735-.622 1.244-1.959 1.09-1.336-.157-1.907.087-1.641.848.85 1.79 2.809 1.869 3.623 1.942.275.05 1.246 0 1.764.143.605.166.735 1.005-.14 1.459-1.558.76-2.237 1.391-3.025 2.83-.595 1.13-1.108 3.022-.574 5.745.513 2.648-3.337 2.733-5 2.357-.716-.151-1.47-1.512.287-2.65 1.421-.922 1.708-1.49 1.645-2.657-.074-1.36-.824-1.458-.822-2.64v-2.82a.435.435 0 0 0-.435-.435H7.698a.435.435 0 0 1-.435-.434v-1.7a.435.435 0 0 0-.435-.435H5.501a.435.435 0 0 1-.435-.435v-1.524a.435.435 0 0 0-.435-.435H3.015a.435.435 0 0 1-.435-.435v-1.603a.435.435 0 0 0-.435-.434H.435a.435.435 0 0 0-.435.434v1.705c0 .24.195.435.435.435h1.62c.24 0 .435.195.435.435v6.076c0 .241.195.435.435.435h1.71c.241 0 .436.196.436.435v1.988c0 .24.195.434.435.434h2.402c.734-.052.862.934.854 1.286-.016.803-.923 1.06-1.352 1.395-1.145.884-2.031 1.783-1.513 3.512l.013.036c.945 2.007 3.542 1.8 5.183 1.8h10.326c.584 0 1.184.135 1.046-.545-.136-.68-.425-1.61-1.265-1.61-.84 0-.703.467-1.524.228-.821-.238-.822-1.348.411-3.279 1.276-1.649 3.46-1.524 4.781-.358 1.32 1.166.93 3.191.653 4.354-.158.82.218 1.224.669 1.213h5.242c.806-.014.647-.556.185-1.614h.003z" fill="#fff"/>
+      <svg width="80" height="80" viewBox="0 0 80 80" xmlns="http://www.w3.org/2000/svg">
+        <path
+        xmlns="http://www.w3.org/2000/svg"
+        fill-rule="evenodd"
+        clip-rule="evenodd"
+        d="M79.05 72.15c-.8-1.766-2.643-2.62-3.845-1.766-1.201.855-2.867.985-4.448.602-1.584-.385-1.885-4.01-1.543-8.195.342-4.184.909-5.795 1.267-7.314.404-1.524 2.191-1.404 2.405-.209.215 1.196 1.454 1.196 3.266-.979 1.811-2.175 1.543-8.52-.546-13.684-2.088-5.163.817-4.661 1.66-4.149.844.513 1.362-.255 1.156-3.2-.204-2.945-2.916-5.247-5.096-6.657-2.184-1.41-4.842-2.967-4.78-6.745.063-3.777 5.2-3.658 5.897-3.596.697.063 2.037-.233 1.264-4.157-.773-3.924-3.575-4.673-5.332-4.567-1.758.106-2.943 1.071-5.427.133-2.484-.938-4.136-.572-6.45-.057-2.313.515-5.343 1.94-9.112 2.959-1.989.545-2.661.683-4.828.718-1.33.02-1.885 1.633-.106 3.61 1.408 1.608 4.597 2.036 6.515 1.768 1.236-.174 1.521.645 1.407 1.85a20.023 20.023 0 0 0-.024 4.488c.198 1.5.45 4.051-.258 5.713-.35.817-1.361 1.693-2.449 1.633-1.413-.084-2.555-1.75-3.537-3.726-2.06-4.152-4.48-5.033-13.509-8.835-8.12-3.417-12.516-8.749-15.24-12.185-2.421-3.042-4.846-1.89-4.626.855.179 2.128 1.48 9.008 4.781 13.141 4.058 6.314 10.32 9.177 17.534 9.739 1.885.149 3.065.52 3.225 1.383.236 1.835-1.557 3.11-4.898 2.722-3.341-.39-4.768.22-4.103 2.121 2.123 4.477 7.021 4.672 9.058 4.857.686.122 3.114 0 4.41.355 1.51.418 1.836 2.514-.353 3.648-3.892 1.903-5.59 3.479-7.561 7.075-1.486 2.826-2.77 7.555-1.435 14.365 1.283 6.62-8.342 6.83-12.497 5.89-1.793-.377-3.675-3.778.716-6.625 3.553-2.305 4.269-3.724 4.111-6.642-.184-3.4-2.058-3.644-2.053-6.598v-7.05c0-.602-.488-1.088-1.087-1.088h-3.334a1.087 1.087 0 0 1-1.087-1.087v-4.25c0-.602-.488-1.087-1.088-1.087h-3.317a1.087 1.087 0 0 1-1.087-1.088v-3.81c0-.602-.489-1.087-1.088-1.087h-4.04a1.087 1.087 0 0 1-1.089-1.088V26.25c0-.602-.488-1.088-1.087-1.088H1.088C.485 25.161 0 25.65 0 26.25v4.26c0 .602.488 1.087 1.088 1.087h4.049c.602 0 1.087.489 1.087 1.088v15.192c0 .602.489 1.087 1.088 1.087h4.277c.602 0 1.088.489 1.088 1.088v4.968c0 .602.488 1.087 1.087 1.087h6.005c1.836-.13 2.156 2.335 2.137 3.214-.04 2.007-2.308 2.652-3.382 3.487-2.861 2.21-5.077 4.459-3.78 8.781l.032.09c2.362 5.017 8.855 4.499 12.956 4.499h25.817c1.459 0 2.959.339 2.614-1.362-.342-1.7-1.063-4.024-3.162-4.024-2.1 0-1.758 1.166-3.81.57-2.054-.597-2.057-3.371 1.027-8.198 3.19-4.122 8.652-3.81 11.952-.895 3.301 2.915 2.325 7.978 1.633 10.885-.396 2.048.545 3.06 1.67 3.032H78.58c2.015-.035 1.62-1.391.464-4.035h.008z"
+        fill="#fff"
+      >
+      </path>
     </svg>
     </div>