4.96.1

and Bailey

migrations/users/bulk-email.js

@@ -1,5 +1,5 @@
 /* eslint-disable no-console */
-import { sendTxn } from '../../../website/server/libs/email';
+import { sendTxn } from '../../website/server/libs/email';
 import { model as User } from '../../website/server/models/user';
 import moment from 'moment';
 import nconf from 'nconf';

migrations/users/full-stable.js

@@ -1,67 +1,24 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = 'full-stable';
 import each from 'lodash/each';
 import keys from 'lodash/keys';
 import content from '../../website/common/script/content/index';
-const migrationName = 'full-stable.js';
-const authorName = 'Sabe'; // in case script author needs to know when their ...
-const authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
+
+import { model as User } from '../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
 
 /*
  * Award users every extant pet and mount
  */
-const connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
 
-let monk = require('monk');
-let dbUsers = monk(connectionString).get('users', { castIds: false });
-
-function processUsers (lastId) {
-  // specify a query to limit the affected users (empty for all users):
-  let query = {
-    'profile.name': 'SabreCat',
-  };
-
-  if (lastId) {
-    query._id = {
-      $gt: lastId,
-    };
-  }
-
-  dbUsers.find(query, {
-    sort: {_id: 1},
-    limit: 250,
-    fields: [
-    ], // specify fields we are interested in to limit retrieved data (empty if we're not reading data):
-  })
-    .then(updateUsers)
-    .catch((err) => {
-      console.log(err);
-      return exiting(1, `ERROR! ${  err}`);
-    });
-}
-
-let progressCount = 1000;
-let count = 0;
-
-function updateUsers (users) {
-  if (!users || users.length === 0) {
-    console.warn('All appropriate users found and modified.');
-    displayData();
-    return;
-  }
-
-  let userPromises = users.map(updateUser);
-  let lastUser = users[users.length - 1];
-
-  return Promise.all(userPromises)
-    .then(() => {
-      processUsers(lastUser._id);
-    });
-}
-
-function updateUser (user) {
+async function updateUser (user) {
   count++;
-  let set = {
-    migration: migrationName,
-  };
+
+  const set = {};
+
+  set.migration = MIGRATION_NAME;
 
   each(keys(content.pets), (pet) => {
     set[`items.pets.${pet}`] = 5;
@@ -88,30 +45,40 @@ function updateUser (user) {
     set[`items.mounts.${mount}`] = true;
   });
 
-  dbUsers.update({_id: user._id}, {$set: set});
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
 
-  if (count % progressCount === 0) console.warn(`${count  } ${  user._id}`);
-  if (user._id === authorUuid) console.warn(`${authorName  } processed`);
+  return await User.update({_id: user._id}, {$set: set}).exec();
 }
 
-function displayData () {
-  console.warn(`\n${  count  } users processed\n`);
-  return exiting(0);
-}
+module.exports = async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'auth.local.username': 'olson22',
+  };
 
-function exiting (code, msg) {
-  code = code || 0; // 0 = success
-  if (code && !msg) {
-    msg = 'ERROR!';
-  }
-  if (msg) {
-    if (code) {
-      console.error(msg);
-    } else      {
-      console.log(msg);
+  const fields = {
+    _id: 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],
+      };
     }
-  }
-  process.exit(code);
-}
 
-module.exports = processUsers;
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

migrations/users/mystery-items.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-console */
-const MIGRATION_NAME = 'mystery_items_201902';
-const MYSTERY_ITEMS = ['eyewear_mystery_201902', 'shield_mystery_201902'];
+const MIGRATION_NAME = 'mystery_items_201904';
+const MYSTERY_ITEMS = ['armor_mystery_201904', 'head_mystery_201904'];
 import { model as User } from '../../website/server/models/user';
 import { model as UserNotification } from '../../website/server/models/userNotification';
 

migrations/users/pi-day.js

@@ -0,0 +1,73 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20190314_pi_day';
+import { v4 as uuid } from 'uuid';
+
+import { model as User } from '../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const inc = {
+    'items.food.Pie_Skeleton': 1,
+    'items.food.Pie_Base': 1,
+    'items.food.Pie_CottonCandyBlue': 1,
+    'items.food.Pie_CottonCandyPink': 1,
+    'items.food.Pie_Shade': 1,
+    'items.food.Pie_White': 1,
+    'items.food.Pie_Golden': 1,
+    'items.food.Pie_Zombie': 1,
+    'items.food.Pie_Desert': 1,
+    'items.food.Pie_Red': 1,
+  };
+  const set = {};
+
+  set.migration = MIGRATION_NAME;
+
+  set['items.gear.owned.head_special_piDay'] = false;
+  set['items.gear.owned.shield_special_piDay'] = false;
+  const push = [
+    {type: 'marketGear', path: 'gear.flat.head_special_piDay', _id: uuid()},
+    {type: 'marketGear', path: 'gear.flat.shield_special_piDay', _id: uuid()},
+  ];
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({_id: user._id}, {$inc: inc, $set: set, $push: {pinnedItems: {$each: push}}}).exec();
+}
+
+module.exports = async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'auth.timestamps.loggedin': {$gt: new Date('2019-02-15')},
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};

package.json

@@ -1,19 +1,19 @@
 {
   "name": "habitica",
   "description": "A habit tracker app which treats your goals like a Role Playing Game.",
-  "version": "4.86.1",
+  "version": "4.96.1",
   "main": "./website/server/index.js",
   "dependencies": {
-    "@google-cloud/trace-agent": "^3.5.2",
+    "@google-cloud/trace-agent": "^3.6.0",
     "@slack/client": "^3.8.1",
     "accepts": "^1.3.5",
     "amazon-payments": "^0.2.7",
     "amplitude": "^3.5.0",
-    "amplitude-js": "^4.6.0-beta.2",
+    "amplitude-js": "^5.0.0",
     "apidoc": "^0.17.5",
     "apn": "^2.2.0",
-    "autoprefixer": "^8.5.0",
-    "aws-sdk": "^2.400.0",
+    "autoprefixer": "^9.4.0",
+    "aws-sdk": "^2.432.0",
     "axios": "^0.18.0",
     "axios-progress-bar": "^1.2.0",
     "babel-core": "^6.26.3",
@@ -28,16 +28,16 @@
     "babel-preset-es2015": "^6.6.0",
     "babel-register": "^6.6.0",
     "babel-runtime": "^6.11.6",
-    "bcrypt": "^3.0.1",
+    "bcrypt": "^3.0.5",
     "body-parser": "^1.18.3",
     "bootstrap": "^4.1.1",
-    "bootstrap-vue": "^2.0.0-rc.13",
-    "compression": "^1.7.2",
-    "cookie-session": "^1.2.0",
+    "bootstrap-vue": "^2.0.0-rc.18",
+    "compression": "^1.7.4",
+    "cookie-session": "^1.3.3",
     "coupon-code": "^0.4.5",
     "cross-env": "^5.2.0",
     "css-loader": "^0.28.11",
-    "csv-stringify": "^4.3.1",
+    "csv-stringify": "^5.1.0",
     "cwait": "^1.1.1",
     "domain-middleware": "~0.1.0",
     "express": "^4.16.3",
@@ -52,10 +52,10 @@
     "gulp-nodemon": "^2.4.1",
     "gulp.spritesmith": "^6.9.0",
     "habitica-markdown": "^1.3.0",
-    "hellojs": "^1.15.1",
+    "hellojs": "^1.18.1",
     "html-webpack-plugin": "^3.2.0",
-    "image-size": "^0.6.2",
-    "in-app-purchase": "^1.10.2",
+    "image-size": "^0.7.0",
+    "in-app-purchase": "^1.11.3",
     "intro.js": "^2.9.3",
     "jquery": ">=3.0.0",
     "js2xmlparser": "^3.0.0",
@@ -64,13 +64,13 @@
     "method-override": "^3.0.0",
     "moment": "^2.22.1",
     "moment-recur": "^1.0.7",
-    "mongoose": "^5.4.11",
+    "mongoose": "^5.4.19",
     "morgan": "^1.7.0",
     "nconf": "^0.10.0",
     "node-gcm": "^1.0.2",
     "node-sass": "^4.9.0",
-    "nodemailer": "^5.0.0",
-    "ora": "^3.0.0",
+    "nodemailer": "^6.0.0",
+    "ora": "^3.2.0",
     "pageres": "^4.1.1",
     "passport": "^0.4.0",
     "passport-facebook": "^2.0.0",
@@ -85,12 +85,12 @@
     "sass-loader": "^7.0.3",
     "shelljs": "^0.8.2",
     "short-uuid": "^3.0.0",
-    "smartbanner.js": "^1.9.1",
+    "smartbanner.js": "^1.11.0",
     "stripe": "^5.9.0",
-    "superagent": "^4.0.0",
+    "superagent": "^5.0.2",
     "svg-inline-loader": "^0.8.0",
     "svg-url-loader": "^2.3.2",
-    "svgo": "^1.0.5",
+    "svgo": "^1.2.0",
     "svgo-loader": "^2.1.0",
     "universal-analytics": "^0.4.17",
     "update": "^0.7.4",
@@ -100,13 +100,13 @@
     "uuid": "^3.0.1",
     "validator": "^10.5.0",
     "vinyl-buffer": "^1.0.1",
-    "vue": "^2.6.4",
+    "vue": "^2.6.10",
     "vue-loader": "^14.2.2",
     "vue-mugen-scroll": "^0.2.1",
     "vue-router": "^3.0.0",
     "vue-style-loader": "^4.1.0",
-    "vue-template-compiler": "^2.6.4",
-    "vuedraggable": "^2.15.0",
+    "vue-template-compiler": "^2.6.10",
+    "vuedraggable": "^2.20.0",
     "vuejs-datepicker": "git://github.com/habitrpg/vuejs-datepicker.git#5d237615463a84a23dd6f3f77c6ab577d68593ec",
     "webpack": "^3.12.0",
     "webpack-merge": "^4.1.3",
@@ -154,7 +154,7 @@
     "chalk": "^2.4.1",
     "chromedriver": "^2.40.0",
     "connect-history-api-fallback": "^1.1.0",
-    "coveralls": "^3.0.1",
+    "coveralls": "^3.0.3",
     "cross-spawn": "^6.0.5",
     "eslint": "^4.19.1",
     "eslint-config-habitrpg": "^4.0.0",
@@ -166,7 +166,7 @@
     "expect.js": "^0.3.1",
     "http-proxy-middleware": "^0.19.0",
     "istanbul": "^1.1.0-alpha.1",
-    "karma": "^3.1.3",
+    "karma": "^4.0.1",
     "karma-babel-preprocessor": "^7.0.0",
     "karma-chai-plugins": "^0.9.0",
     "karma-chrome-launcher": "^2.2.0",
@@ -181,11 +181,11 @@
     "lcov-result-merger": "^3.0.0",
     "mocha": "^5.1.1",
     "monk": "^6.0.6",
-    "nightwatch": "^0.9.21",
-    "puppeteer": "^1.5.0",
+    "nightwatch": "^1.0.16",
+    "puppeteer": "^1.14.0",
     "require-again": "^2.0.0",
     "selenium-server": "^3.12.0",
-    "sinon": "^6.3.5",
+    "sinon": "^7.2.4",
     "sinon-chai": "^3.0.0",
     "sinon-stub-promise": "^4.0.0",
     "webpack-bundle-analyzer": "^2.12.0",

scripts/gdpr-delete-users.js

@@ -53,7 +53,7 @@ async function _deleteHabiticaData (user, email) {
 
   if (response) {
     console.log(`${response.status} ${response.statusText}`);
-    if (response.status === 200) console.log(`${user._id} removed. Last login: ${user.auth.timestamps.loggedin}`);
+    if (response.status === 200) console.log(`${user._id} (${email}) removed. Last login: ${user.auth.timestamps.loggedin}`);
   }
 }
 

test/api/unit/libs/analyticsService.test.js

@@ -335,14 +335,13 @@ describe('analyticsService', () => {
     let data, itemSpy;
 
     beforeEach(() => {
+      Visitor.prototype.event.yields();
+
       itemSpy = sandbox.stub().returnsThis();
 
-      Visitor.prototype.event.returns({
-        send: sandbox.stub(),
-      });
       Visitor.prototype.transaction.returns({
         item: itemSpy,
-        send: sandbox.stub().returnsThis(),
+        send: sandbox.stub().yields(),
       });
 
       data = {

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

@@ -0,0 +1,113 @@
+/* eslint-disable camelcase */
+import {
+  validateItemPath,
+  getDefaultOwnedGear,
+  castItemVal,
+} from '../../../../../website/server/libs/items/utils';
+
+describe('Items Utils', () => {
+  describe('getDefaultOwnedGear', () => {
+    it('clones the result object', () => {
+      const res1 = getDefaultOwnedGear();
+      res1.extraProperty = true;
+
+      const res2 = getDefaultOwnedGear();
+      expect(res2).not.to.have.property('extraProperty');
+    });
+  });
+
+  describe('validateItemPath', () => {
+    it('returns false if not an item path', () => {
+      expect(validateItemPath('notitems.gear.owned.item')).to.equal(false);
+    });
+
+    it('returns true if a valid schema path', () => {
+      expect(validateItemPath('items.gear.equipped.weapon')).to.equal(true);
+      expect(validateItemPath('items.currentPet')).to.equal(true);
+      expect(validateItemPath('items.special.snowball')).to.equal(true);
+    });
+
+    it('works with owned gear paths', () => {
+      expect(validateItemPath('items.gear.owned.head_armoire_crownOfHearts')).to.equal(true);
+      expect(validateItemPath('items.gear.owned.head_invalid')).to.equal(false);
+    });
+
+    it('works with pets paths', () => {
+      expect(validateItemPath('items.pets.Wolf-CottonCandyPink')).to.equal(true);
+      expect(validateItemPath('items.pets.Wolf-Invalid')).to.equal(false);
+    });
+
+    it('works with eggs paths', () => {
+      expect(validateItemPath('items.eggs.LionCub')).to.equal(true);
+      expect(validateItemPath('items.eggs.Armadillo')).to.equal(true);
+      expect(validateItemPath('items.eggs.NotAnArmadillo')).to.equal(false);
+    });
+
+    it('works with hatching potions paths', () => {
+      expect(validateItemPath('items.hatchingPotions.Base')).to.equal(true);
+      expect(validateItemPath('items.hatchingPotions.StarryNight')).to.equal(true);
+      expect(validateItemPath('items.hatchingPotions.Invalid')).to.equal(false);
+    });
+
+    it('works with food paths', () => {
+      expect(validateItemPath('items.food.Cake_Base')).to.equal(true);
+      expect(validateItemPath('items.food.Cake_Invalid')).to.equal(false);
+    });
+
+    it('works with mounts paths', () => {
+      expect(validateItemPath('items.mounts.Cactus-Base')).to.equal(true);
+      expect(validateItemPath('items.mounts.Aether-Invisible')).to.equal(true);
+      expect(validateItemPath('items.mounts.Aether-Invalid')).to.equal(false);
+    });
+
+    it('works with quests paths', () => {
+      expect(validateItemPath('items.quests.atom3')).to.equal(true);
+      expect(validateItemPath('items.quests.invalid')).to.equal(false);
+    });
+  });
+
+  describe('castItemVal', () => {
+    it('returns the item val untouched if not an item path', () => {
+      expect(castItemVal('notitems.gear.owned.item', 'a string')).to.equal('a string');
+    });
+
+    it('returns the item val untouched if an unsupported path', () => {
+      expect(castItemVal('items.gear.equipped.weapon', 'a string')).to.equal('a string');
+      expect(castItemVal('items.currentPet', 'a string')).to.equal('a string');
+      expect(castItemVal('items.special.snowball', 'a string')).to.equal('a string');
+    });
+
+    it('converts values for pets paths to numbers', () => {
+      expect(castItemVal('items.pets.Wolf-CottonCandyPink', '5')).to.equal(5);
+      expect(castItemVal('items.pets.Wolf-Invalid', '5')).to.equal(5);
+    });
+
+    it('converts values for eggs paths to numbers', () => {
+      expect(castItemVal('items.eggs.LionCub', '5')).to.equal(5);
+      expect(castItemVal('items.eggs.Armadillo', '5')).to.equal(5);
+      expect(castItemVal('items.eggs.NotAnArmadillo', '5')).to.equal(5);
+    });
+
+    it('converts values for hatching potions paths to numbers', () => {
+      expect(castItemVal('items.hatchingPotions.Base', '5')).to.equal(5);
+      expect(castItemVal('items.hatchingPotions.StarryNight', '5')).to.equal(5);
+      expect(castItemVal('items.hatchingPotions.Invalid', '5')).to.equal(5);
+    });
+
+    it('converts values for food paths to numbers', () => {
+      expect(castItemVal('items.food.Cake_Base', '5')).to.equal(5);
+      expect(castItemVal('items.food.Cake_Invalid', '5')).to.equal(5);
+    });
+
+    it('converts values for mounts paths to numbers', () => {
+      expect(castItemVal('items.mounts.Cactus-Base', '5')).to.equal(5);
+      expect(castItemVal('items.mounts.Aether-Invisible', '5')).to.equal(5);
+      expect(castItemVal('items.mounts.Aether-Invalid', '5')).to.equal(5);
+    });
+
+    it('converts values for quests paths to numbers', () => {
+      expect(castItemVal('items.quests.atom3', '5')).to.equal(5);
+      expect(castItemVal('items.quests.invalid', '5')).to.equal(5);
+    });
+  });
+});

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

@@ -56,11 +56,11 @@ describe('PUT /challenges/:challengeId', () => {
       tasksOrder: 'new order',
       official: true,
       shortName: 'new short name',
+      leader: member._id,
 
       // applied
       name: 'New Challenge Name',
       description: 'New challenge description.',
-      leader: member._id,
     });
 
     expect(res.prize).to.equal(0);
@@ -76,12 +76,12 @@ describe('PUT /challenges/:challengeId', () => {
     expect(res.shortName).not.to.equal('new short name');
 
     expect(res.leader).to.eql({
-      _id: member._id,
-      id: member._id,
-      profile: {name: member.profile.name},
+      _id: user._id,
+      id: user._id,
+      profile: {name: user.profile.name},
       auth: {
         local: {
-          username: member.auth.local.username,
+          username: user.auth.local.username,
         },
       },
       flags: {

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

@@ -67,4 +67,10 @@ describe('GET /heroes/:heroId', () => {
     expect(heroRes.auth.local).not.to.have.keys(['salt', 'hashed_password']);
     expect(heroRes.profile).to.have.all.keys(['name']);
   });
+
+  it('returns correct hero using search with difference case', async () => {
+    await generateUser({}, { username: 'TestUpperCaseName123' });
+    let heroRes = await user.get('/hall/heroes/TestuPPerCasEName123');
+    expect(heroRes.auth.local.username).to.equal('TestUpperCaseName123');
+  });
 });

test/api/v3/integration/inbox/GET-inbox_messages.test.js

@@ -27,8 +27,6 @@ describe('GET /inbox/messages', () => {
       toUserId: user.id,
       message: 'fourth',
     });
-
-    await user.sync();
   });
 
   it('returns the user inbox messages as an array of ordered messages (from most to least recent)', async () => {
@@ -45,4 +43,27 @@ describe('GET /inbox/messages', () => {
     expect(messages[2].text).to.equal('second');
     expect(messages[3].text).to.equal('first');
   });
+
+  it('returns four messages when using page-query ', async () => {
+    const promises = [];
+
+    for (let i = 0; i < 10; i++) {
+      promises.push(user.post('/members/send-private-message', {
+        toUserId: user.id,
+        message: 'fourth',
+      }));
+    }
+
+    await Promise.all(promises);
+
+    const messages = await user.get('/inbox/messages?page=1');
+
+    expect(messages.length).to.equal(4);
+  });
+
+  it('returns only the messages of one conversation', async () => {
+    const messages = await user.get(`/inbox/messages?conversation=${otherUser.id}`);
+
+    expect(messages.length).to.equal(3);
+  });
 });

test/api/v3/integration/payments/stripe/POST-payments_stripe_checkout.test.js

@@ -13,10 +13,10 @@ describe('payments - stripe - #checkout', () => {
   });
 
   it('verifies credentials', async () => {
-    await expect(user.post(endpoint, {id: 123})).to.eventually.be.rejected.and.eql({
+    await expect(user.post(endpoint, {id: 123})).to.eventually.be.rejected.and.include({
       code: 401,
       error: 'Error',
-      message: 'Invalid API Key provided: ****************************1111',
+      message: 'Invalid API Key provided: aaaabbbb********************1111',
     });
   });
 

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

@@ -4,6 +4,7 @@ import {
   generateUser,
 } from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';
+import { model as Group } from '../../../../../website/server/models/group';
 
 describe('POST /groups/:groupId/quests/cancel', () => {
   let questingGroup;
@@ -99,6 +100,10 @@ describe('POST /groups/:groupId/quests/cancel', () => {
   it('cancels a quest', async () => {
     await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
     await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
+    // partyMembers[1] hasn't accepted the invitation, because if he accepts, invitation phase ends.
+    // The cancel command can be done only in the invitation phase.
+
+    let stub = sandbox.spy(Group.prototype, 'sendChat');
 
     let res = await leader.post(`/groups/${questingGroup._id}/quests/cancel`);
 
@@ -135,5 +140,9 @@ describe('POST /groups/:groupId/quests/cancel', () => {
       },
       members: {},
     });
+    expect(Group.prototype.sendChat).to.be.calledOnce;
+    expect(Group.prototype.sendChat).to.be.calledWithMatch(/cancelled the party quest Wail of the Whale.`/);
+
+    stub.restore();
   });
 });

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

@@ -63,6 +63,38 @@ describe('Groups DELETE /tasks/:id', () => {
       });
   });
 
+  it('removes deleted taskʾs approval pending notifications from managers', async () => {
+    await user.post(`/groups/${guild._id}/add-manager`, {
+      managerId: member2._id,
+    });
+    await user.put(`/tasks/${task._id}/`, {
+      requiresApproval: true,
+    });
+    let memberTasks = await member.get('/tasks/user');
+    let syncedTask = find(memberTasks, findAssignedTask);
+    await expect(member.post(`/tasks/${syncedTask._id}/score/up`))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('taskApprovalHasBeenRequested'),
+      });
+
+    await user.sync();
+    await member2.sync();
+    expect(user.notifications.length).to.equal(2);
+    expect(user.notifications[1].type).to.equal('GROUP_TASK_APPROVAL');
+    expect(member2.notifications.length).to.equal(2);
+    expect(member2.notifications[1].type).to.equal('GROUP_TASK_APPROVAL');
+
+    await member2.del(`/tasks/${task._id}`);
+
+    await user.sync();
+    await member2.sync();
+
+    expect(user.notifications.length).to.equal(1);
+    expect(member2.notifications.length).to.equal(1);
+  });
+
   it('unlinks assigned user', async () => {
     await user.del(`/tasks/${task._id}`);
 

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

@@ -53,18 +53,29 @@ describe('POST /tasks/:id/approve/:userId', () => {
 
   it('approves an assigned user', async () => {
     await user.post(`/tasks/${task._id}/assign/${member._id}`);
-    await user.post(`/tasks/${task._id}/approve/${member._id}`);
 
     let memberTasks = await member.get('/tasks/user');
     let syncedTask = find(memberTasks, findAssignedTask);
 
+    await expect(member.post(`/tasks/${syncedTask._id}/score/up`))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('taskApprovalHasBeenRequested'),
+      });
+
+    await user.post(`/tasks/${task._id}/approve/${member._id}`);
+
     await member.sync();
 
-    expect(member.notifications.length).to.equal(2);
-    expect(member.notifications[0].type).to.equal('GROUP_TASK_APPROVED');
-    expect(member.notifications[0].data.message).to.equal(t('yourTaskHasBeenApproved', {taskText: task.text}));
-    expect(member.notifications[1].type).to.equal('SCORED_TASK');
+    expect(member.notifications.length).to.equal(3);
+    expect(member.notifications[1].type).to.equal('GROUP_TASK_APPROVED');
     expect(member.notifications[1].data.message).to.equal(t('yourTaskHasBeenApproved', {taskText: task.text}));
+    expect(member.notifications[2].type).to.equal('SCORED_TASK');
+    expect(member.notifications[2].data.message).to.equal(t('yourTaskHasBeenApproved', {taskText: task.text}));
+
+    memberTasks = await member.get('/tasks/user');
+    syncedTask = find(memberTasks, findAssignedTask);
 
     expect(syncedTask.group.approval.approved).to.be.true;
     expect(syncedTask.group.approval.approvingUser).to.equal(user._id);
@@ -77,18 +88,28 @@ describe('POST /tasks/:id/approve/:userId', () => {
     });
 
     await member2.post(`/tasks/${task._id}/assign/${member._id}`);
-    await member2.post(`/tasks/${task._id}/approve/${member._id}`);
 
     let memberTasks = await member.get('/tasks/user');
     let syncedTask = find(memberTasks, findAssignedTask);
 
+    await expect(member.post(`/tasks/${syncedTask._id}/score/up`))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('taskApprovalHasBeenRequested'),
+      });
+
+    await member2.post(`/tasks/${task._id}/approve/${member._id}`);
     await member.sync();
 
-    expect(member.notifications.length).to.equal(2);
-    expect(member.notifications[0].type).to.equal('GROUP_TASK_APPROVED');
-    expect(member.notifications[0].data.message).to.equal(t('yourTaskHasBeenApproved', {taskText: task.text}));
-    expect(member.notifications[1].type).to.equal('SCORED_TASK');
+    expect(member.notifications.length).to.equal(3);
+    expect(member.notifications[1].type).to.equal('GROUP_TASK_APPROVED');
     expect(member.notifications[1].data.message).to.equal(t('yourTaskHasBeenApproved', {taskText: task.text}));
+    expect(member.notifications[2].type).to.equal('SCORED_TASK');
+    expect(member.notifications[2].data.message).to.equal(t('yourTaskHasBeenApproved', {taskText: task.text}));
+
+    memberTasks = await member.get('/tasks/user');
+    syncedTask = find(memberTasks, findAssignedTask);
 
     expect(syncedTask.group.approval.approved).to.be.true;
     expect(syncedTask.group.approval.approvingUser).to.equal(member2._id);
@@ -132,6 +153,16 @@ describe('POST /tasks/:id/approve/:userId', () => {
     });
 
     await member2.post(`/tasks/${task._id}/assign/${member._id}`);
+
+    let memberTasks = await member.get('/tasks/user');
+    let syncedTask = find(memberTasks, findAssignedTask);
+    await expect(member.post(`/tasks/${syncedTask._id}/score/up`))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('taskApprovalHasBeenRequested'),
+      });
+
     await member2.post(`/tasks/${task._id}/approve/${member._id}`);
     await expect(user.post(`/tasks/${task._id}/approve/${member._id}`))
       .to.eventually.be.rejected.and.to.eql({
@@ -141,6 +172,17 @@ describe('POST /tasks/:id/approve/:userId', () => {
       });
   });
 
+  it('prevents approving a task if it is not waiting for approval', async () => {
+    await user.post(`/tasks/${task._id}/assign/${member._id}`);
+
+    await expect(user.post(`/tasks/${task._id}/approve/${member._id}`))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('taskApprovalWasNotRequested'),
+      });
+  });
+
   it('completes master task when single-completion task is approved', async () => {
     let sharedCompletionTask = await user.post(`/tasks/group/${guild._id}`, {
       text: 'shared completion todo',
@@ -151,6 +193,16 @@ describe('POST /tasks/:id/approve/:userId', () => {
 
     await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member._id}`);
     await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member2._id}`);
+
+    let memberTasks = await member.get('/tasks/user');
+    let syncedTask = find(memberTasks, findAssignedTask);
+    await expect(member.post(`/tasks/${syncedTask._id}/score/up`))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('taskApprovalHasBeenRequested'),
+      });
+
     await user.post(`/tasks/${sharedCompletionTask._id}/approve/${member._id}`);
 
     let groupTasks = await user.get(`/tasks/group/${guild._id}?type=completedTodos`);
@@ -172,6 +224,16 @@ describe('POST /tasks/:id/approve/:userId', () => {
 
     await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member._id}`);
     await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member2._id}`);
+
+    let memberTasks = await member.get('/tasks/user');
+    let syncedTask = find(memberTasks, findAssignedTask);
+    await expect(member.post(`/tasks/${syncedTask._id}/score/up`))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('taskApprovalHasBeenRequested'),
+      });
+
     await user.post(`/tasks/${sharedCompletionTask._id}/approve/${member._id}`);
 
     let member2Tasks = await member2.get('/tasks/user');
@@ -193,6 +255,16 @@ describe('POST /tasks/:id/approve/:userId', () => {
 
     await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member._id}`);
     await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member2._id}`);
+
+    let memberTasks = await member.get('/tasks/user');
+    let syncedTask = find(memberTasks, findAssignedTask);
+    await expect(member.post(`/tasks/${syncedTask._id}/score/up`))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('taskApprovalHasBeenRequested'),
+      });
+
     await user.post(`/tasks/${sharedCompletionTask._id}/approve/${member._id}`);
 
     let groupTasks = await user.get(`/tasks/group/${guild._id}`);
@@ -214,6 +286,25 @@ describe('POST /tasks/:id/approve/:userId', () => {
 
     await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member._id}`);
     await user.post(`/tasks/${sharedCompletionTask._id}/assign/${member2._id}`);
+
+    let memberTasks = await member.get('/tasks/user');
+    let syncedTask = find(memberTasks, findAssignedTask);
+    await expect(member.post(`/tasks/${syncedTask._id}/score/up`))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('taskApprovalHasBeenRequested'),
+      });
+
+    let member2Tasks = await member2.get('/tasks/user');
+    let member2SyncedTask = find(member2Tasks, findAssignedTask);
+    await expect(member2.post(`/tasks/${member2SyncedTask._id}/score/up`))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('taskApprovalHasBeenRequested'),
+      });
+
     await user.post(`/tasks/${sharedCompletionTask._id}/approve/${member._id}`);
     await user.post(`/tasks/${sharedCompletionTask._id}/approve/${member2._id}`);
 

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

@@ -51,7 +51,7 @@ describe('POST /tasks/:id/needs-work/:userId', () => {
       });
   });
 
-  it('marks as task as needing more work', async () => {
+  it('marks a task as needing more work', async () => {
     const initialNotifications = member.notifications.length;
 
     await user.post(`/tasks/${task._id}/assign/${member._id}`);
@@ -77,7 +77,7 @@ describe('POST /tasks/:id/needs-work/:userId', () => {
     expect(syncedTask.group.approval.requestedDate).to.equal(undefined);
 
     // Check that the notification is correct
-    expect(member.notifications.length).to.equal(initialNotifications + 1);
+    expect(member.notifications.length).to.equal(initialNotifications + 2);
     const notification = member.notifications[member.notifications.length - 1];
     expect(notification.type).to.equal('GROUP_TASK_NEEDS_WORK');
 
@@ -131,7 +131,7 @@ describe('POST /tasks/:id/needs-work/:userId', () => {
     expect(syncedTask.group.approval.requested).to.equal(false);
     expect(syncedTask.group.approval.requestedDate).to.equal(undefined);
 
-    expect(member.notifications.length).to.equal(initialNotifications + 1);
+    expect(member.notifications.length).to.equal(initialNotifications + 2);
     const notification = member.notifications[member.notifications.length - 1];
     expect(notification.type).to.equal('GROUP_TASK_NEEDS_WORK');
 
@@ -167,6 +167,17 @@ describe('POST /tasks/:id/needs-work/:userId', () => {
     });
 
     await member2.post(`/tasks/${task._id}/assign/${member._id}`);
+
+    let memberTasks = await member.get('/tasks/user');
+    let syncedTask = find(memberTasks, findAssignedTask);
+
+    await expect(member.post(`/tasks/${syncedTask._id}/score/up`))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('taskApprovalHasBeenRequested'),
+      });
+
     await member2.post(`/tasks/${task._id}/approve/${member._id}`);
     await expect(user.post(`/tasks/${task._id}/needs-work/${member._id}`))
       .to.eventually.be.rejected.and.to.eql({

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

@@ -129,6 +129,13 @@ describe('POST /tasks/:id/score/:direction', () => {
     let memberTasks = await member.get('/tasks/user');
     let syncedTask = find(memberTasks, findAssignedTask);
 
+    await expect(member.post(`/tasks/${syncedTask._id}/score/up`))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('taskApprovalHasBeenRequested'),
+      });
+
     await user.post(`/tasks/${task._id}/approve/${member._id}`);
 
     await member.post(`/tasks/${syncedTask._id}/score/up`);

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

@@ -113,6 +113,17 @@ describe('POST /tasks/:taskId/assign/:memberId', () => {
     expect(syncedTask).to.exist;
   });
 
+  it('sends a notification to assigned user', async () => {
+    await user.post(`/tasks/${task._id}/assign/${member._id}`);
+    await member.sync();
+
+    let groupTask = await user.get(`/tasks/group/${guild._id}`);
+
+    expect(member.notifications.length).to.equal(1);
+    expect(member.notifications[0].type).to.equal('GROUP_TASK_ASSIGNED');
+    expect(member.notifications[0].taskId).to.equal(groupTask._id);
+  });
+
   it('assigns a task to multiple users', async () => {
     await user.post(`/tasks/${task._id}/assign/${member._id}`);
     await user.post(`/tasks/${task._id}/assign/${member2._id}`);

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

@@ -86,6 +86,13 @@ describe('POST /tasks/:taskId/unassign/:memberId', () => {
     expect(syncedTask).to.not.exist;
   });
 
+  it('removes task assignment notification from unassigned user', async () => {
+    await user.post(`/tasks/${task._id}/unassign/${member._id}`);
+
+    await member.sync();
+    expect(member.notifications.length).to.equal(0);
+  });
+
   it('unassigns a user and only that user from a task', async () => {
     await user.post(`/tasks/${task._id}/assign/${member2._id}`);
 

test/api/v3/integration/user/auth/POST-login-local.test.js

@@ -110,4 +110,22 @@ describe('POST /user/auth/local/login', () => {
     let isValidPassword = await bcryptCompare(textPassword, user.auth.local.hashed_password);
     expect(isValidPassword).to.equal(true);
   });
+
+  it('user uses social authentication and has no password', async () => {
+    await user.unset({
+      'auth.local.hashed_password': 1,
+    });
+
+    await user.sync();
+    expect(user.auth.local.hashed_password).to.be.undefined;
+
+    await expect(api.post(endpoint, {
+      username: user.auth.local.username,
+      password: 'any-password',
+    })).to.eventually.be.rejected.and.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('invalidLoginCredentialsLong'),
+    });
+  });
 });

test/api/v4/inbox/GET-inbox-conversations.test.js

@@ -0,0 +1,44 @@
+import {
+  generateUser,
+} from '../../../helpers/api-integration/v4';
+
+describe('GET /inbox/conversations', () => {
+  let user;
+  let otherUser;
+  let thirdUser;
+
+  before(async () => {
+    [user, otherUser, thirdUser] = await Promise.all([generateUser(), generateUser(), generateUser()]);
+
+    await otherUser.post('/members/send-private-message', {
+      toUserId: user.id,
+      message: 'first',
+    });
+    await user.post('/members/send-private-message', {
+      toUserId: otherUser.id,
+      message: 'second',
+    });
+    await user.post('/members/send-private-message', {
+      toUserId: thirdUser.id,
+      message: 'third',
+    });
+    await otherUser.post('/members/send-private-message', {
+      toUserId: user.id,
+      message: 'fourth',
+    });
+
+    // message to yourself
+    await user.post('/members/send-private-message', {
+      toUserId: user.id,
+      message: 'fifth',
+    });
+  });
+
+  it('returns the conversations', async () => {
+    const result = await user.get('/inbox/conversations');
+
+    expect(result.length).to.be.equal(3);
+    expect(result[0].user).to.be.equal(user.profile.name);
+    expect(result[0].username).to.be.equal(user.auth.local.username);
+  });
+});

test/common/libs/inAppRewards.js

@@ -62,6 +62,18 @@ describe('inAppRewards', () => {
     expect(result[9].path).to.eql('potion');
   });
 
+  it('ignores null/undefined entries', () => {
+    user.pinnedItems = testPinnedItems;
+    user.pinnedItems.push(null);
+    user.pinnedItems.push(undefined);
+    user.pinnedItemsOrder = testPinnedItemsOrder;
+
+    let result = inAppRewards(user);
+
+    expect(result[2].path).to.eql('armoire');
+    expect(result[9].path).to.eql('potion');
+  });
+
   it('does not return seasonal items which have been unpinned', () => {
     if (officialPinnedItems.length === 0) {
       return; // if no seasonal items, this test is not applicable

test/common/ops/buy/buy.js

@@ -9,6 +9,7 @@ import {
 import i18n from '../../../../website/common/script/i18n';
 import content from '../../../../website/common/script/content/index';
 import errorMessage from '../../../../website/common/script/libs/errorMessage';
+import { defaultsDeep } from 'lodash';
 
 describe('shared.ops.buy', () => {
   let user;
@@ -16,6 +17,10 @@ describe('shared.ops.buy', () => {
 
   beforeEach(() => {
     user = generateUser({
+      stats: { gp: 200 },
+    });
+
+    defaultsDeep(user, {
       items: {
         gear: {
           owned: {
@@ -26,7 +31,6 @@ describe('shared.ops.buy', () => {
           },
         },
       },
-      stats: { gp: 200 },
     });
 
     sinon.stub(analytics, 'track');
@@ -138,4 +142,52 @@ describe('shared.ops.buy', () => {
     buy(user, {params: {key: 'potion'}, quantity: 2});
     expect(user.stats.hp).to.eql(50);
   });
+
+  it('errors if user supplies a non-numeric quantity', (done) => {
+    try {
+      buy(user, {
+        params: {
+          key: 'dilatoryDistress1',
+        },
+        type: 'quest',
+        quantity: 'bogle',
+      });
+    } catch (err) {
+      expect(err).to.be.an.instanceof(BadRequest);
+      expect(err.message).to.equal(errorMessage('invalidQuantity'));
+      done();
+    }
+  });
+
+  it('errors if user supplies a negative quantity', (done) => {
+    try {
+      buy(user, {
+        params: {
+          key: 'dilatoryDistress1',
+        },
+        type: 'quest',
+        quantity: -3,
+      });
+    } catch (err) {
+      expect(err).to.be.an.instanceof(BadRequest);
+      expect(err.message).to.equal(errorMessage('invalidQuantity'));
+      done();
+    }
+  });
+
+  it('errors if user supplies a decimal quantity', (done) => {
+    try {
+      buy(user, {
+        params: {
+          key: 'dilatoryDistress1',
+        },
+        type: 'quest',
+        quantity: 1.83,
+      });
+    } catch (err) {
+      expect(err).to.be.an.instanceof(BadRequest);
+      expect(err.message).to.equal(errorMessage('invalidQuantity'));
+      done();
+    }
+  });
 });

test/common/ops/buy/buyMarketGear.js

@@ -11,6 +11,7 @@ import {
 } from '../../../../website/common/script/libs/errors';
 import i18n from '../../../../website/common/script/i18n';
 import errorMessage from '../../../../website/common/script/libs/errorMessage';
+import { defaultsDeep } from 'lodash';
 
 function buyGear (user, req, analytics) {
   let buyOp = new BuyMarketGearOperation(user, req, analytics);
@@ -24,6 +25,10 @@ describe('shared.ops.buyMarketGear', () => {
 
   beforeEach(() => {
     user = generateUser({
+      stats: { gp: 200 },
+    });
+
+    defaultsDeep(user, {
       items: {
         gear: {
           owned: {
@@ -34,7 +39,6 @@ describe('shared.ops.buyMarketGear', () => {
           },
         },
       },
-      stats: { gp: 200 },
     });
 
     sinon.stub(shared, 'randomVal');

test/common/ops/buy/purchase.js

@@ -108,6 +108,47 @@ describe('shared.ops.purchase', () => {
         done();
       }
     });
+
+    it('returns error when user supplies a non-numeric quantity', (done) => {
+      let type = 'eggs';
+      let key = 'Wolf';
+
+      try {
+        purchase(user, {params: {type, key}, quantity: 'jamboree'}, analytics);
+      } catch (err) {
+        expect(err).to.be.an.instanceof(BadRequest);
+        expect(err.message).to.equal(i18n.t('invalidQuantity'));
+        done();
+      }
+    });
+
+    it('returns error when user supplies a negative quantity', (done) => {
+      let type = 'eggs';
+      let key = 'Wolf';
+      user.balance = 10;
+
+      try {
+        purchase(user, {params: {type, key}, quantity: -2}, analytics);
+      } catch (err) {
+        expect(err).to.be.an.instanceof(BadRequest);
+        expect(err.message).to.equal(i18n.t('invalidQuantity'));
+        done();
+      }
+    });
+
+    it('returns error when user supplies a decimal quantity', (done) => {
+      let type = 'eggs';
+      let key = 'Wolf';
+      user.balance = 10;
+
+      try {
+        purchase(user, {params: {type, key}, quantity: 2.9}, analytics);
+      } catch (err) {
+        expect(err).to.be.an.instanceof(BadRequest);
+        expect(err.message).to.equal(i18n.t('invalidQuantity'));
+        done();
+      }
+    });
   });
 
   context('successful purchase', () => {
@@ -168,7 +209,7 @@ describe('shared.ops.purchase', () => {
 
     it('purchases quest bundles', () => {
       let startingBalance = user.balance;
-      let clock = sandbox.useFakeTimers(moment('2017-05-20').valueOf());
+      let clock = sandbox.useFakeTimers(moment('2019-05-20').valueOf());
       let type = 'bundles';
       let key = 'featheredFriends';
       let price = 1.75;

test/common/ops/hatch.js

@@ -93,6 +93,22 @@ describe('shared.ops.hatch', () => {
           done();
         }
       });
+
+      it('does not allow hatching quest pet egg using wacky potion', (done) => {
+        user.items.eggs = {Bunny: 1};
+        user.items.hatchingPotions = {Veggie: 1};
+        user.items.pets = {};
+        try {
+          hatch(user, {params: {egg: 'Bunny', hatchingPotion: 'Veggie'}});
+        } catch (err) {
+          expect(err).to.be.an.instanceof(BadRequest);
+          expect(err.message).to.equal(i18n.t('messageInvalidEggPotionCombo'));
+          expect(user.items.pets).to.be.empty;
+          expect(user.items.eggs).to.eql({Bunny: 1});
+          expect(user.items.hatchingPotions).to.eql({Veggie: 1});
+          done();
+        }
+      });
     });
 
     context('successful hatching', () => {

test/common/ops/pinnedGearUtils.js

@@ -0,0 +1,18 @@
+import {
+  generateUser,
+} from '../../helpers/common.helper';
+import {addPinnedGear} from '../../../website/common/script/ops/pinnedGearUtils';
+
+describe('shared.ops.pinnedGearUtils.addPinnedGear', () => {
+  let user;
+
+  beforeEach(() => {
+    user = generateUser();
+  });
+
+  it('not adds an item with empty properties to pinnedItems', () => {
+    addPinnedGear(user, undefined, undefined);
+
+    expect(user.pinnedItems.length).to.be.eql(0);
+  });
+});

test/content/hatching-potions.test.js

@@ -9,13 +9,14 @@ import hatchingPotions from '../../website/common/script/content/hatching-potion
 
 describe('hatchingPotions', ()  => {
   describe('all', ()  => {
-    it('is a combination of drop and premium potions', () => {
+    it('is a combination of drop, premium, and wacky potions', () => {
       let dropNumber = Object.keys(hatchingPotions.drops).length;
       let premiumNumber = Object.keys(hatchingPotions.premium).length;
+      let wackyNumber = Object.keys(hatchingPotions.wacky).length;
       let allNumber = Object.keys(hatchingPotions.all).length;
 
       expect(allNumber).to.be.greaterThan(0);
-      expect(allNumber).to.equal(dropNumber + premiumNumber);
+      expect(allNumber).to.equal(dropNumber + premiumNumber + wackyNumber);
     });
 
     it('contains basic information about each potion', () => {

test/content/stable.test.js

@@ -47,6 +47,18 @@ describe('stable', ()  => {
     });
   });
 
+  describe('wackyPets', () => {
+    it('contains a pet for each wacky potion * each drop egg', () => {
+      let numberOfWackyPotions = Object.keys(potions.wacky).length;
+      let numberOfDropEggs = Object.keys(eggs.drops).length;
+      let numberOfWackyPets = Object.keys(stable.wackyPets).length;
+      let expectedTotal = numberOfWackyPotions * numberOfDropEggs;
+
+      expect(numberOfWackyPets).to.be.greaterThan(0);
+      expect(numberOfWackyPets).to.equal(expectedTotal);
+    });
+  });
+
   describe('specialPets', () => {
     it('each value is a valid translation string', () => {
       each(stable.specialPets, (pet) => {
@@ -107,10 +119,11 @@ describe('stable', ()  => {
       let questNumber = Object.keys(stable.questPets).length;
       let specialNumber = Object.keys(stable.specialPets).length;
       let premiumNumber = Object.keys(stable.premiumPets).length;
+      let wackyNumber = Object.keys(stable.wackyPets).length;
       let allNumber = Object.keys(stable.petInfo).length;
 
       expect(allNumber).to.be.greaterThan(0);
-      expect(allNumber).to.equal(dropNumber + questNumber + specialNumber + premiumNumber);
+      expect(allNumber).to.equal(dropNumber + questNumber + specialNumber + premiumNumber + wackyNumber);
     });
 
     it('contains basic information about each pet', () => {

test/helpers/api-integration/api-classes.js

@@ -4,6 +4,7 @@ import { requester } from './requester';
 import {
   getDocument as getDocumentFromMongo,
   updateDocument as updateDocumentInMongo,
+  unsetDocument as unsetDocumentInMongo,
 } from '../mongo';
 import {
   assign,
@@ -29,6 +30,18 @@ class ApiObject {
     return this;
   }
 
+  async unset (options) {
+    if (isEmpty(options)) {
+      return;
+    }
+
+    await unsetDocumentInMongo(this._docType, this, options);
+
+    _updateLocalParameters((this, options));
+
+    return this;
+  }
+
   async sync () {
     let updatedDoc = await getDocumentFromMongo(this._docType, this);
 

test/helpers/api-integration/v3/object-generators.js

@@ -13,10 +13,16 @@ import * as Tasks from '../../../../website/server/models/task';
 // parameter, such as the number of wolf eggs the user has,
 // , you can do so by passing in the full path as a string:
 // { 'items.eggs.Wolf': 10 }
-export async function generateUser (update = {}) {
-  let username = (Date.now() + generateUUID()).substring(0, 20);
-  let password = 'password';
-  let email = `${username}@example.com`;
+//
+// To manually set a username, email or password pass it in as
+// an object for the second parameter. Only overrides need to be
+// added. Items that don't exist will be autogenerated.
+// Example: generateUser({}, { username: 'TestName' }) adds user
+// with the 'TestName' username.
+export async function generateUser (update = {}, overrides = {}) {
+  let username = overrides.username || (Date.now() + generateUUID()).substring(0, 20);
+  let password = overrides.password || 'password';
+  let email = overrides.email || `${username}@example.com`;
 
   let user = await requester().post('/user/auth/local/register', {
     username,

test/helpers/common.helper.js

@@ -9,6 +9,7 @@ import {
 } from '../../website/server/models/task';
 export {translate} from './translate';
 
+
 export function generateUser (options = {}) {
   let user = new User(options).toObject();
 

test/helpers/mongo.js

@@ -98,6 +98,19 @@ export async function updateDocument (collectionName, doc, update) {
   });
 }
 
+// Unset a property in the database.
+// Useful for testing.
+export async function unsetDocument (collectionName, doc, update) {
+  let collection = mongoose.connection.db.collection(collectionName);
+
+  return new Promise((resolve) => {
+    collection.updateOne({ _id: doc._id }, { $unset: update }, (updateErr) => {
+      if (updateErr) throw new Error(`Error updating ${collectionName}: ${updateErr}`);
+      resolve();
+    });
+  });
+}
+
 export async function getDocument (collectionName, doc) {
   let collection = mongoose.connection.db.collection(collectionName);
 

website/client/app.vue

@@ -12,6 +12,8 @@ div
     banned-account-modal
     amazon-payments-modal(v-if='!isStaticPage')
     payments-success-modal
+    sub-cancel-modal-confirm(v-if='isUserLoaded')
+    sub-canceled-modal(v-if='isUserLoaded')
     snackbars
     router-view(v-if="!isUserLoggedIn || isStaticPage")
     template(v-else)
@@ -187,6 +189,8 @@ import notifications from 'client/mixins/notifications';
 import { setup as setupPayments } from 'client/libs/payments';
 import amazonPaymentsModal from 'client/components/payments/amazonModal';
 import paymentsSuccessModal from 'client/components/payments/successModal';
+import subCancelModalConfirm from 'client/components/payments/cancelModalConfirm';
+import subCanceledModal from 'client/components/payments/canceledModal';
 
 import spellsMixin from 'client/mixins/spells';
 import { CONSTANTS, getLocalSetting, removeLocalSetting } from 'client/libs/userlocalManager';
@@ -210,6 +214,8 @@ export default {
     amazonPaymentsModal,
     bannedAccountModal,
     paymentsSuccessModal,
+    subCancelModalConfirm,
+    subCanceledModal,
   },
   data () {
     return {

website/client/assets/css/sprites.css

@@ -10,6 +10,12 @@
   height: 219px;
 }
 
+.Pet_HatchingPotion_Veggie {
+  background: url("~assets/images/Pet_HatchingPotion_Veggie.gif") no-repeat;
+  width: 68px;
+  height: 68px;
+}
+
 .Gems {
   display:inline-block;
   margin-right:5px;

website/client/assets/css/sprites/spritesmith-largeSprites-0.css

@@ -1,42 +1,66 @@
-.promo_armoire_backgrounds_201903 {
+.promo_armoire_backgrounds_201905 {
   background-image: url('~assets/images/sprites/spritesmith-largeSprites-0.png');
-  background-position: 0px -220px;
+  background-position: 0px -786px;
   width: 423px;
   height: 147px;
 }
-.promo_mystery_201902 {
+.promo_bronze_quest {
   background-image: url('~assets/images/sprites/spritesmith-largeSprites-0.png');
-  background-position: -424px -220px;
-  width: 240px;
+  background-position: -499px 0px;
+  width: 360px;
+  height: 360px;
+}
+.promo_feathered_friends_bundle {
+  background-image: url('~assets/images/sprites/spritesmith-largeSprites-0.png');
+  background-position: 0px -638px;
+  width: 423px;
   height: 147px;
 }
-.promo_mythical_marvels_bundle {
+.promo_floral_sunshine_potions {
   background-image: url('~assets/images/sprites/spritesmith-largeSprites-0.png');
-  background-position: 0px -368px;
+  background-position: -424px -638px;
   width: 423px;
   height: 147px;
 }
+.promo_mystery_201904 {
+  background-image: url('~assets/images/sprites/spritesmith-largeSprites-0.png');
+  background-position: -860px -223px;
+  width: 282px;
+  height: 147px;
+}
 .promo_take_this {
   background-image: url('~assets/images/sprites/spritesmith-largeSprites-0.png');
-  background-position: -424px -368px;
+  background-position: -1068px -371px;
   width: 96px;
   height: 69px;
 }
-.promo_valentines_potions {
-  background-image: url('~assets/images/sprites/spritesmith-largeSprites-0.png');
-  background-position: 0px -516px;
-  width: 420px;
-  height: 147px;
-}
-.scene_achievement {
-  background-image: url('~assets/images/sprites/spritesmith-largeSprites-0.png');
-  background-position: -397px 0px;
-  width: 339px;
-  height: 210px;
-}
-.scene_cooking {
+.scene_gold {
   background-image: url('~assets/images/sprites/spritesmith-largeSprites-0.png');
   background-position: 0px 0px;
-  width: 396px;
-  height: 219px;
+  width: 498px;
+  height: 360px;
+}
+.scene_languages {
+  background-image: url('~assets/images/sprites/spritesmith-largeSprites-0.png');
+  background-position: -328px -361px;
+  width: 297px;
+  height: 261px;
+}
+.scene_rewards {
+  background-image: url('~assets/images/sprites/spritesmith-largeSprites-0.png');
+  background-position: -860px -371px;
+  width: 207px;
+  height: 180px;
+}
+.scene_spells {
+  background-image: url('~assets/images/sprites/spritesmith-largeSprites-0.png');
+  background-position: -860px 0px;
+  width: 312px;
+  height: 222px;
+}
+.scene_yesterdailies_repeatables {
+  background-image: url('~assets/images/sprites/spritesmith-largeSprites-0.png');
+  background-position: 0px -361px;
+  width: 327px;
+  height: 276px;
 }