4.2.0

2017-10-04 18:35:05 -05:00
8585 changed files with 138244 additions and 59153 deletions
@@ -0,0 +1,3 @@
+{
+  "directory": "website/client-old/bower_components"
+}
@@ -20,7 +20,11 @@ container_commands:
    command: "touch /tmp/.babel.json"
  02_ownBabel:
    command: "chmod a+rw /tmp/.babel.json"
-  03_installGulp:
+  03_installBower:
+    command: "$NODE_HOME/bin/npm install -g bower"
+  04_installGulp:
    command: "$NODE_HOME/bin/npm install -g gulp"
-  04_runGulp:
+  05_runBower:
+    command: "$NODE_HOME/lib/node_modules/bower/bin/bower --config.interactive=false --allow-root install -f"
+  06_runGulp:
    command: "$NODE_HOME/lib/node_modules/gulp/bin/gulp.js build"
@@ -6,9 +6,6 @@ website/transpiled-babel/
 website/common/transpiled-babel/
 dist/
 dist-client/
-apidoc_build/
-content_cache/
-node_modules/

 # Not linted
 website/client-old/
@@ -19,3 +16,5 @@ migrations/*
 scripts/*
 website/common/browserify.js
 Gruntfile.js
+gulpfile.js
+gulp
@@ -4,7 +4,7 @@

 # Pull Request

-[Please see these instructions for adding a pull request](http://habitica.wikia.com/wiki/Using_Your_Local_Install_to_Modify_Habitica%27s_Website_and_API)
+[Please see these instructions for adding a pull request](http://habitica.wikia.com/wiki/Using_Habitica_Git#Pull_Request)

 # Requesting a feature

@@ -6,7 +6,7 @@

 [//]: # (For more guidelines see https://github.com/HabitRPG/habitica/issues/2760)

-[//]: # (Fill out relevant information - UUID is found from the Habitia website at User Icon > Settings > API)
+[//]: # (Fill out relevant information - UUID is found in Settings -> API)
 ### General Info
  * UUID: 
  * Browser: 
@@ -1,4 +1,4 @@
-[//]: # (Note: See http://habitica.wikia.com/wiki/Using_Your_Local_Install_to_Modify_Habitica%27s_Website_and_API for more info)
+[//]: # (Note: See http://habitica.wikia.com/wiki/Using_Habitica_Git#Pull_Request for more info)

 [//]: # (Put Issue # or URL here, if applicable. This will automatically close the issue if your PR is merged in)
 Fixes put_issue_url_here
@@ -8,7 +8,7 @@ Fixes put_issue_url_here



-[//]: # (Put User ID in here - found on the Habitica website at User Icon > Settings > API)
+[//]: # (Put User ID in here - found in Settings -> API)

 ----
 UUID: 
@@ -2,14 +2,11 @@
 website/client-old/gen
 website/client-old/common
 website/client-old/apidoc
-website/build
 website/client-old/js/habitrpg-shared.js*
 website/client-old/css/habitrpg-shared.css
 website/transpiled-babel/
 website/common/transpiled-babel/
 node_modules
-content_cache
-apidoc_build
 *.swp
 .idea*
 config.json
@@ -34,4 +34,5 @@ env:
    - TEST="test:sanity"
    - TEST="test:content" COVERAGE=true
    - TEST="test:common" COVERAGE=true
+    - TEST="client:unit" COVERAGE=true
    - TEST="apidoc"
@@ -4,7 +4,7 @@ FROM node:boron
 # The used solution is suggested here https://github.com/npm/npm/issues/16807#issuecomment-313591975
 RUN yarn global add npm@5
 # Install global packages
-RUN npm install -g gulp mocha
+RUN npm install -g gulp grunt-cli bower mocha

 # Clone Habitica repo and install dependencies
 RUN mkdir -p /usr/src/habitrpg
@@ -12,6 +12,7 @@ WORKDIR /usr/src/habitrpg
 RUN git clone https://github.com/HabitRPG/habitica.git /usr/src/habitrpg
 RUN cp config.json.example config.json
 RUN npm install
+RUN bower install --allow-root

 # Create Build dir
 RUN mkdir -p ./website/build
@@ -1,27 +1,17 @@
 FROM node:boron

-ENV ADMIN_EMAIL admin@habitica.com
-ENV AMAZON_PAYMENTS_CLIENT_ID amzn1.application-oa2-client.68ed9e6904ef438fbc1bf86bf494056e
-ENV AMAZON_PAYMENTS_SELLER_ID AMQ3SB4SG5E91
-ENV AMPLITUDE_KEY e8d4c24b3d6ef3ee73eeba715023dd43
-ENV BASE_URL https://habitica.com
-ENV FACEBOOK_KEY 128307497299777
-ENV GA_ID UA-33510635-1
-ENV GOOGLE_CLIENT_ID 1035232791481-32vtplgnjnd1aufv3mcu1lthf31795fq.apps.googleusercontent.com
-ENV NODE_ENV production
-ENV STRIPE_PUB_KEY pk_85fQ0yMECHNfHTSsZoxZXlPSwSNfA
-
 # Upgrade NPM to v5 (Yarn is needed because of this bug https://github.com/npm/npm/issues/16807)
 # The used solution is suggested here https://github.com/npm/npm/issues/16807#issuecomment-313591975
 RUN yarn global add npm@5
 # Install global packages
-RUN npm install -g gulp mocha
+RUN npm install -g gulp grunt-cli bower mocha

 # Clone Habitica repo and install dependencies
 RUN mkdir -p /usr/src/habitrpg
 WORKDIR /usr/src/habitrpg
-RUN git clone --branch v4.16.0 https://github.com/HabitRPG/habitica.git /usr/src/habitrpg
+RUN git clone --branch v4.0.3 https://github.com/HabitRPG/habitica.git /usr/src/habitrpg
 RUN npm install
+RUN bower install --allow-root
 RUN gulp build:prod --force

 # Create Build dir
@@ -0,0 +1,142 @@
+/*global module:false*/
+require('babel-register');
+var _ = require('lodash');
+module.exports = function(grunt) {
+
+  // Project configuration.
+  grunt.initConfig({
+    pkg: grunt.file.readJSON('package.json'),
+
+    karma: {
+      unit: {
+        configFile: 'test/client-old/spec/karma.conf.js'
+      },
+      continuous: {
+        configFile: 'test/client-old/spec/karma.conf.js',
+        singleRun: true,
+        autoWatch: false
+      }
+    },
+
+    clean: {
+      build: ['website/build']
+    },
+
+    cssmin: {
+      dist: {
+        options: {
+          report: 'gzip'
+        },
+        files:{
+          "website/client-old/css/habitrpg-shared.css": [
+            "website/assets/sprites/dist/spritesmith*.css",
+            "website/assets/sprites/css/backer.css",
+            "website/assets/sprites/css/Mounts.css",
+            "website/assets/sprites/css/index.css"
+          ]
+        }
+      }
+    },
+
+    stylus: {
+      build: {
+        options: {
+          compress: false, // AFTER
+          'include css': true,
+          paths: ['website/client-old']
+        },
+        files: {
+          'website/build/app.css': ['website/client-old/css/index.styl'],
+          'website/build/static.css': ['website/client-old/css/static.styl']
+        }
+      }
+    },
+
+    copy: {
+      build: {
+        files: [
+          {expand: true, cwd: 'website/client-old/', src: 'favicon.ico', dest: 'website/build/'},
+          {expand: true, cwd: 'website/client-old/', src: 'favicon_192x192.png', dest: 'website/build/'},
+          {expand: true, cwd: 'website/assets/sprites/dist/', src: 'spritesmith*.png', dest: 'website/build/static/sprites'},
+          {expand: true, cwd: 'website/assets/sprites/', src: 'backer-only/*.gif', dest: 'website/build/'},
+          {expand: true, cwd: 'website/assets/sprites/', src: 'npc_ian.gif', dest: 'website/build/'},
+          {expand: true, cwd: 'website/assets/sprites/', src: 'quest_*.gif', dest: 'website/build/'},
+          {expand: true, cwd: 'website/client-old/', src: 'bower_components/bootstrap/dist/fonts/*', dest: 'website/build/'}
+        ]
+      }
+    },
+
+    // UPDATE IT WHEN YOU ADD SOME FILES NOT ALREADY MATCHED!
+    hashres: {
+      build: {
+        options: {
+          fileNameFormat: '${name}-${hash}.${ext}'
+        },
+        src: [
+          'website/build/*.js',
+          'website/build/*.css',
+          'website/build/favicon.ico',
+          'website/build/favicon_192x192.png',
+          'website/build/*.png',
+          'website/build/static/sprites/*.png',
+          'website/build/*.gif',
+          'website/build/bower_components/bootstrap/dist/fonts/*'
+        ],
+        dest: 'website/build/*.css'
+      }
+    }
+  });
+
+  //Load build files from client-old/manifest.json
+  grunt.registerTask('loadManifestFiles', 'Load all build files from client-old/manifest.json', function(){
+    var files = grunt.file.readJSON('./website/client-old/manifest.json');
+    var uglify = {};
+    var cssmin = {};
+
+    _.each(files, function(val, key){
+
+      var js = uglify['website/build/' + key + '.js'] = [];
+
+      _.each(files[key].js, function(val){
+        var path = "./";
+        if( val.indexOf('common/') == -1)
+          path = './website/client-old/';
+        js.push(path + val);
+      });
+
+      var css = cssmin['website/build/' + key + '.css'] = [];
+
+      _.each(files[key].css, function(val){
+        var path = "./";
+        if( val.indexOf('common/') == -1) {
+          path = (val == 'app.css' || val == 'static.css') ?  './website/build/' : './website/client-old/';
+        }
+        css.push(path + val)
+      });
+
+    });
+
+    grunt.config.set('uglify.build.files', uglify);
+    grunt.config.set('uglify.build.options', {compress: false});
+
+    grunt.config.set('cssmin.build.files', cssmin);
+    // Rewrite urls to relative path
+    grunt.config.set('cssmin.build.options', {'target': 'website/client-old/css/whatever-css.css'});
+  });
+
+  // Register tasks.
+  grunt.registerTask('build:prod', ['loadManifestFiles', 'clean:build', 'uglify', 'stylus', 'cssmin', 'copy:build', 'hashres']);
+  grunt.registerTask('build:dev', ['cssmin', 'stylus']);
+  grunt.registerTask('build:test', ['build:dev']);
+
+  // Load tasks
+  grunt.loadNpmTasks('grunt-contrib-uglify');
+  grunt.loadNpmTasks('grunt-contrib-clean');
+  grunt.loadNpmTasks('grunt-contrib-stylus');
+  grunt.loadNpmTasks('grunt-contrib-cssmin');
+  grunt.loadNpmTasks('grunt-contrib-copy');
+  grunt.loadNpmTasks('grunt-contrib-watch');
+  grunt.loadNpmTasks('grunt-hashres');
+  if (process.env.NODE_ENV !== 'production') grunt.loadNpmTasks('grunt-karma');
+
+};
@@ -0,0 +1,56 @@
+{
+  "name": "HabitRPG",
+  "version": "0.1.1",
+  "homepage": "https://github.com/lefnire/habitrpg",
+  "authors": [
+    "Tyler Renelle <tylerrenelle@gmail.com>"
+  ],
+  "private": true,
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "website/client-old/bower_components",
+    "test",
+    "tests"
+  ],
+  "dependencies": {
+    "Angular-At-Directive": "snicker/Angular-At-Directive#c27bae207aa06d1e",
+    "angular": "1.3.9",
+    "angular-bootstrap": "0.13.0",
+    "angular-filter": "0.5.1",
+    "angular-loading-bar": "0.6.0",
+    "angular-resource": "1.3.9",
+    "angular-sanitize": "1.3.9",
+    "angular-ui": "0.4.0",
+    "angular-ui-router": "0.2.13",
+    "angular-ui-select2": "angular-ui/ui-select2#afa6589a54cb72815f",
+    "angular-ui-utils": "0.1.0",
+    "bootstrap": "3.1.0",
+    "bootstrap-growl": "ifightcrime/bootstrap-growl#162daa41cd1155f",
+    "bootstrap-tour": "0.10.1",
+    "css-social-buttons": "samcollins/css-social-buttons#v1.1.1 ",
+    "github-buttons": "mdo/github-buttons#v3.0.0",
+    "hello": "1.14.1",
+    "jquery": "2.1.0",
+    "jquery-colorbox": "1.4.36",
+    "jquery-ui": "1.10.3",
+    "jquery.cookie": "1.4.0",
+    "js-emoji": "snicker/js-emoji#f25d8a303f",
+    "ngInfiniteScroll": "1.1.0",
+    "pnotify": "1.3.1",
+    "sticky": "1.0.3",
+    "swagger-ui": "wordnik/swagger-ui#v2.0.24",
+    "smart-app-banner": "78ef9c0679723b25be1a0ae04f7b4aef7cbced4f",
+    "habitica-markdown": "1.2.2",
+    "pusher-js-auth": "^2.0.0",
+    "pusher-websocket-iso": "pusher#^3.2.0",
+    "taggle": "^1.11.1"
+  },
+  "devDependencies": {
+    "angular-mocks": "1.3.9"
+  },
+  "resolutions": {
+    "angular": "1.3.9",
+    "jquery": ">=1.9.0"
+  }
+}
@@ -71,7 +71,6 @@
    },
    "IAP_GOOGLE_KEYDIR": "/path/to/google/public/key/dir/",
    "LOGGLY_TOKEN": "token",
-    "LOGGLY_CLIENT_TOKEN": "token",
    "LOGGLY_ACCOUNT": "account",
    "PUSH_CONFIGS": {
        "GCM_SERVER_API_KEY": "",
@@ -0,0 +1,10 @@
+{
+  "root": true,
+  "env": {
+    "node": true,
+  },
+  "extends": [
+    "habitrpg/server",
+    "habitrpg/babel"
+  ],
+}
@@ -2,7 +2,7 @@ import gulp from 'gulp';
 import clean from 'rimraf';
 import apidoc from 'apidoc';

-const APIDOC_DEST_PATH = './apidoc_build';
+const APIDOC_DEST_PATH = './website/build/apidoc';
 const APIDOC_SRC_PATH = './website/server';
 gulp.task('apidoc:clean', (done) => {
  clean(APIDOC_DEST_PATH, done);
@@ -22,5 +22,5 @@ gulp.task('apidoc', ['apidoc:clean'], (done) => {
 });

 gulp.task('apidoc:watch', ['apidoc'], () => {
-  return gulp.watch(`${APIDOC_SRC_PATH}/**/*.js`, ['apidoc']);
+  return gulp.watch(APIDOC_SRC_PATH + '/**/*.js', ['apidoc']);
 });
@@ -0,0 +1,31 @@
+import gulp from 'gulp';
+import browserify from 'browserify';
+import source from 'vinyl-source-stream';
+import buffer from 'vinyl-buffer';
+import uglify from 'gulp-uglify';
+import sourcemaps from 'gulp-sourcemaps';
+import babel from 'babelify';
+
+gulp.task('browserify', function () {
+  let bundler = browserify({
+    entries: './website/common/browserify.js',
+    debug: true,
+    transform: [[babel, { compact: false }]],
+  });
+
+  return bundler.bundle()
+    .pipe(source('habitrpg-shared.js'))
+    .pipe(buffer())
+    .pipe(sourcemaps.init({loadMaps: true}))
+    .pipe(uglify())
+    .on('error', function (err) {
+      console.error(err);
+      this.emit('end');
+    })
+    .pipe(sourcemaps.write('./'))
+    .pipe(gulp.dest('./website/client-old/js/'));
+});
+
+gulp.task('browserify:watch', () => {
+  gulp.watch('./website/common/script/**/*.js', ['browserify']);
+});
@@ -0,0 +1,36 @@
+import gulp from 'gulp';
+import fs from 'fs';
+
+// Copy Bootstrap 4 config variables from /website /node_modules so we can check
+// them into Git
+
+const BOOSTRAP_NEW_CONFIG_PATH = 'website/client/assets/scss/bootstrap_config.scss';
+const BOOTSTRAP_ORIGINAL_CONFIG_PATH = 'node_modules/bootstrap/scss/_custom.scss';
+
+// https://stackoverflow.com/a/14387791/969528
+function copyFile(source, target, cb) {
+  let cbCalled = false;
+
+  function done(err) {
+    if (!cbCalled) {
+      cb(err);
+      cbCalled = true;
+    }
+  }
+
+  let rd = fs.createReadStream(source);
+  rd.on('error', done);
+  let wr = fs.createWriteStream(target);
+  wr.on('error', done);
+  wr.on('close', () => done());
+  rd.pipe(wr);
+}
+
+gulp.task('bootstrap', (done) => {
+  // use new config
+  copyFile(
+    BOOSTRAP_NEW_CONFIG_PATH,
+    BOOTSTRAP_ORIGINAL_CONFIG_PATH,
+    done,
+  );
+});
@@ -1,10 +1,14 @@
 import gulp from 'gulp';
+import runSequence from 'run-sequence';
 import babel from 'gulp-babel';
 import webpackProductionBuild from '../webpack/build';
+require('gulp-grunt')(gulp);

 gulp.task('build', () => {
-  if (process.env.NODE_ENV === 'production') { // eslint-disable-line no-process-env
+  if (process.env.NODE_ENV === 'production') {
    gulp.start('build:prod');
+  } else {
+    gulp.start('build:dev');
  }
 });

@@ -23,15 +27,25 @@ gulp.task('build:common', () => {
 gulp.task('build:server', ['build:src', 'build:common']);

 // Client Production Build
-gulp.task('build:client', (done) => {
+gulp.task('build:client', ['bootstrap'], (done) => {
  webpackProductionBuild((err, output) => {
    if (err) return done(err);
-    console.log(output); // eslint-disable-line no-console
+    console.log(output);
  });
 });

+gulp.task('build:dev', ['browserify', 'prepare:staticNewStuff'], (done) => {
+  gulp.start('grunt-build:dev', done);
+});
+
+gulp.task('build:dev:watch', ['build:dev'], () => {
+  gulp.watch(['website/client-old/**/*.styl', 'website/common/script/*']);
+});
+
 gulp.task('build:prod', [
-  'build:server',
+  'browserify', 
+  'build:server', 
+  'prepare:staticNewStuff', 
  'build:client',
  'apidoc',
 ]);
@@ -7,11 +7,10 @@ import gulp     from 'gulp';

 // Add additional properties to the repl's context
 let improveRepl = (context) => {
+
  // Let "exit" and "quit" terminate the console
  ['exit', 'quit'].forEach((term) => {
-    Object.defineProperty(context, term, { get () {
-      process.exit();
-    }});
+    Object.defineProperty(context, term, { get () { process.exit(); }});
  });

  // "clear" clears the screen
@@ -19,12 +18,12 @@ let improveRepl = (context) => {
    process.stdout.write('\u001B[2J\u001B[0;0f');
  }});

-  context.Challenge = require('../website/server/models/challenge').model; // eslint-disable-line global-require
-  context.Group     = require('../website/server/models/group').model; // eslint-disable-line global-require
-  context.User      = require('../website/server/models/user').model; // eslint-disable-line global-require
+  context.Challenge = require('../website/server/models/challenge').model;
+  context.Group     = require('../website/server/models/group').model;
+  context.User      = require('../website/server/models/user').model;

-  const isProd = nconf.get('NODE_ENV') === 'production';
-  const mongooseOptions = !isProd ? {} : {
+  var isProd = nconf.get('NODE_ENV') === 'production';
+  var mongooseOptions = !isProd ? {} : {
    replset: { socketOptions: { keepAlive: 1, connectTimeoutMS: 30000 } },
    server: { socketOptions: { keepAlive: 1, connectTimeoutMS: 30000 } },
  };
@@ -32,15 +31,16 @@ let improveRepl = (context) => {
    mongoose.connect(
      nconf.get('NODE_DB_URI'),
      mongooseOptions,
-      (err) => {
+      function (err) {
        if (err) throw err;
        logger.info('Connected with Mongoose');
      }
    )
  );
+
 };

-gulp.task('console', () => {
+gulp.task('console', (cb) => {
  improveRepl(repl.start({
    prompt: 'Habitica > ',
  }).context);
@@ -0,0 +1,10 @@
+import gulp from 'gulp';
+import jade from 'jade';
+import {writeFileSync} from 'fs';
+
+gulp.task('prepare:staticNewStuff', () => {
+  writeFileSync(
+    './website/client-old/new-stuff.html',
+    jade.compileFile('./website/views/shared/new-stuff.jade')()
+  );
+});
@@ -10,39 +10,82 @@ import {each} from 'lodash';

 // https://github.com/Ensighten/grunt-spritesmith/issues/67#issuecomment-34786248
 const MAX_SPRITESHEET_SIZE = 1024 * 1024 * 3;
+const DIST_PATH = 'website/assets/sprites/dist/';

-const IMG_DIST_PATH = 'website/client/assets/images/sprites/';
-const CSS_DIST_PATH = 'website/client/assets/css/sprites/';
+const IMG_DIST_PATH_NEW_CLIENT = 'website/static/sprites/';
+const CSS_DIST_PATH_NEW_CLIENT = 'website/client/assets/css/sprites/';

-function checkForSpecialTreatment (name) {
-  let regex = /^hair|skin|beard|mustach|shirt|flower|^headAccessory_special_\w+Ears|^eyewear_special_\w+TopFrame/;
-  return name.match(regex) || name === 'head_0';
-}
+gulp.task('sprites:compile', ['sprites:clean', 'sprites:main', 'sprites:largeSprites', 'sprites:checkCompiledDimensions']);

-function calculateImgDimensions (img, addPadding) {
-  let dims = sizeOf(img);
+gulp.task('sprites:main', () => {
+  let mainSrc = sync('website/assets/sprites/spritesmith/**/*.png');
+  return createSpritesStream('main', mainSrc);
+});

-  let requiresSpecialTreatment = checkForSpecialTreatment(img);
-  if (requiresSpecialTreatment) {
-    let newWidth = dims.width < 90 ? 90 : dims.width;
-    let newHeight = dims.height < 90 ? 90 : dims.height;
-    dims = {
-      width: newWidth,
-      height: newHeight,
-    };
+gulp.task('sprites:largeSprites', () => {
+  let largeSrc = sync('website/assets/sprites/spritesmith_large/**/*.png');
+  return createSpritesStream('largeSprites', largeSrc);
+});
+
+gulp.task('sprites:clean', (done) => {
+  clean(`{${DIST_PATH}spritesmith*,${IMG_DIST_PATH_NEW_CLIENT}spritesmith*,${CSS_DIST_PATH_NEW_CLIENT}spritesmith*}`, done);
+});
+
+gulp.task('sprites:checkCompiledDimensions', ['sprites:main', 'sprites:largeSprites'], () => {
+  console.log('Verifiying that images do not exceed max dimensions');
+
+  let numberOfSheetsThatAreTooBig = 0;
+
+  let distSpritesheets = sync(`${DIST_PATH}*.png`);
+
+  each(distSpritesheets, (img, index) => {
+    let spriteSize = calculateImgDimensions(img);
+
+    if (spriteSize > MAX_SPRITESHEET_SIZE) {
+      numberOfSheetsThatAreTooBig++;
+      let name = basename(img, '.png');
+      console.error(`WARNING: ${name} might be too big - ${spriteSize} > ${MAX_SPRITESHEET_SIZE}`);
+    }
+  });
+
+  if (numberOfSheetsThatAreTooBig > 0) {
+    console.error(`${numberOfSheetsThatAreTooBig} sheets might too big for mobile Safari to be able to handle them, but there is a margin of error in these calculations so it is probably okay. Mention this to an admin so they can test a staging site on mobile Safari after your PR is merged.`); // https://github.com/HabitRPG/habitica/pull/6683#issuecomment-185462180
+  } else {
+    console.log('All images are within the correct dimensions');
  }
+});

-  let padding = 0;
+function createSpritesStream (name, src) {
+  let spritesheetSliceIndicies = calculateSpritesheetsSrcIndicies(src);
+  let stream = mergeStream();

-  if (addPadding) {
-    padding = dims.width * 8 + dims.height * 8;
-  }
+  each(spritesheetSliceIndicies, (start, index) => {
+    let slicedSrc = src.slice(start, spritesheetSliceIndicies[index + 1]);

-  if (!dims.width || !dims.height) console.error('MISSING DIMENSIONS:', dims); // eslint-disable-line no-console
+    let spriteData = gulp.src(slicedSrc)
+      .pipe(spritesmith({
+        imgName: `spritesmith-${name}-${index}.png`,
+        cssName: `spritesmith-${name}-${index}.css`,
+        algorithm: 'binary-tree',
+        padding: 1,
+        cssTemplate: 'website/assets/sprites/css/css.template.handlebars',
+        cssVarMap: cssVarMap,
+      }));

-  let totalPixelSize = dims.width * dims.height + padding;
+    let imgStream = spriteData.img
+      .pipe(imagemin())
+      .pipe(gulp.dest(IMG_DIST_PATH_NEW_CLIENT))
+      .pipe(gulp.dest(DIST_PATH));

-  return totalPixelSize;
+    let cssStream = spriteData.css
+      .pipe(gulp.dest(CSS_DIST_PATH_NEW_CLIENT))
+      .pipe(gulp.dest(DIST_PATH));
+
+    stream.add(imgStream);
+    stream.add(cssStream);
+  });
+
+  return stream;
 }

 function calculateSpritesheetsSrcIndicies (src) {
@@ -62,6 +105,37 @@ function calculateSpritesheetsSrcIndicies (src) {
  return slices;
 }

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

 let pkg = require('../package.json');

+gulp.task('run:dev', ['nodemon', 'build:dev:watch']);
+
 gulp.task('nodemon', () => {
  nodemon({
    script: pkg.main,
@@ -1,12 +1,21 @@
 import {
  pipe,
+  awaitPort,
+  kill,
+  runMochaTests,
 }  from './taskHelper';
+import { server as karma }        from 'karma';
 import mongoose                   from 'mongoose';
 import { exec }                   from 'child_process';
+import psTree                     from 'ps-tree';
 import gulp                       from 'gulp';
+import Bluebird                   from 'bluebird';
 import runSequence                from 'run-sequence';
 import os                         from 'os';
 import nconf                      from 'nconf';
+import fs from 'fs';
+
+const i18n = require('../website/server/libs/i18n');

 // TODO rewrite

@@ -15,23 +24,25 @@ let server;

 const TEST_DB_URI       = nconf.get('TEST_DB_URI');

+const API_V3_TEST_COMMAND = 'npm run test:api-v3';
 const SANITY_TEST_COMMAND = 'npm run test:sanity';
 const COMMON_TEST_COMMAND = 'npm run test:common';
 const CONTENT_TEST_COMMAND = 'npm run test:content';
 const CONTENT_OPTIONS = {maxBuffer: 1024 * 500};
+const KARMA_TEST_COMMAND = 'npm run test:karma';

 /* Helper methods for reporting test summary */
 let testResults = [];
 let testCount = (stdout, regexp) => {
  let match = stdout.match(regexp);
-  return parseInt(match && match[1] || 0, 10);
+  return parseInt(match && match[1] || 0);
 };

 let testBin = (string, additionalEnvVariables = '') => {
  if (os.platform() === 'win32') {
-    if (additionalEnvVariables !== '') {
+    if (additionalEnvVariables != '') {
      additionalEnvVariables = additionalEnvVariables.split(' ').join('&&set ');
-      additionalEnvVariables = `set ${additionalEnvVariables}&&`;
+      additionalEnvVariables = 'set ' + additionalEnvVariables + '&&';
    }
    return `set NODE_ENV=test&&${additionalEnvVariables}${string}`;
  } else {
@@ -39,9 +50,9 @@ let testBin = (string, additionalEnvVariables = '') => {
  }
 };

-gulp.task('test:nodemon', () => {
-  process.env.PORT = TEST_SERVER_PORT; // eslint-disable-line no-process-env
-  process.env.NODE_DB_URI = TEST_DB_URI; // eslint-disable-line no-process-env
+gulp.task('test:nodemon', (done) => {
+  process.env.PORT = TEST_SERVER_PORT;
+  process.env.NODE_DB_URI = TEST_DB_URI;

  runSequence('nodemon');
 });
@@ -58,27 +69,37 @@ gulp.task('test:prepare:mongo', (cb) => {
 gulp.task('test:prepare:server', ['test:prepare:mongo'], () => {
  if (!server) {
    server = exec(testBin('node ./website/server/index.js', `NODE_DB_URI=${TEST_DB_URI} PORT=${TEST_SERVER_PORT}`), (error, stdout, stderr) => {
-      if (error) {
-        throw new Error(`Problem with the server: ${error}`);
-      }
-      if (stderr) {
-        console.error(stderr); // eslint-disable-line no-console
-      }
+      if (error) { throw `Problem with the server: ${error}`; }
+      if (stderr) { console.error(stderr); }
    });
  }
 });

-gulp.task('test:prepare:build', ['build']);
+gulp.task('test:prepare:translations', (cb) => {
+  fs.writeFile(
+    'test/client-old/spec/mocks/translations.js',
+     `if(!window.env) window.env = {};
+window.env.translations = ${JSON.stringify(i18n.translations['en'])};`, cb);
+
+});
+
+gulp.task('test:prepare:build', ['build', 'test:prepare:translations']);
+// exec(testBin('grunt build:test'), cb);
+
+gulp.task('test:prepare:webdriver', (cb) => {
+  exec('npm run test:prepare:webdriver', cb);
+});

 gulp.task('test:prepare', [
  'test:prepare:build',
  'test:prepare:mongo',
+  'test:prepare:webdriver',
 ]);

 gulp.task('test:sanity', (cb) => {
  let runner = exec(
    testBin(SANITY_TEST_COMMAND),
-    (err) => {
+    (err, stdout, stderr) => {
      if (err) {
        process.exit(1);
      }
@@ -91,7 +112,7 @@ gulp.task('test:sanity', (cb) => {
 gulp.task('test:common', ['test:prepare:build'], (cb) => {
  let runner = exec(
    testBin(COMMON_TEST_COMMAND),
-    (err) => {
+    (err, stdout, stderr) => {
      if (err) {
        process.exit(1);
      }
@@ -112,7 +133,7 @@ gulp.task('test:common:watch', ['test:common:clean'], () => {
 gulp.task('test:common:safe', ['test:prepare:build'], (cb) => {
  let runner = exec(
    testBin(COMMON_TEST_COMMAND),
-    (err, stdout) => { // eslint-disable-line handle-callback-err
+    (err, stdout, stderr) => {
      testResults.push({
        suite: 'Common Specs\t',
        pass: testCount(stdout, /(\d+) passing/),
@@ -129,7 +150,7 @@ gulp.task('test:content', ['test:prepare:build'], (cb) => {
  let runner = exec(
    testBin(CONTENT_TEST_COMMAND),
    CONTENT_OPTIONS,
-    (err) => {
+    (err, stdout, stderr) => {
      if (err) {
        process.exit(1);
      }
@@ -151,7 +172,7 @@ gulp.task('test:content:safe', ['test:prepare:build'], (cb) => {
  let runner = exec(
    testBin(CONTENT_TEST_COMMAND),
    CONTENT_OPTIONS,
-    (err, stdout) => {  // eslint-disable-line handle-callback-err
+    (err, stdout, stderr) => {
      testResults.push({
        suite: 'Content Specs\t',
        pass: testCount(stdout, /(\d+) passing/),
@@ -164,10 +185,103 @@ gulp.task('test:content:safe', ['test:prepare:build'], (cb) => {
  pipe(runner);
 });

+gulp.task('test:karma', ['test:prepare:build'], (cb) => {
+  let runner = exec(
+    testBin(KARMA_TEST_COMMAND),
+    (err, stdout) => {
+      if (err) {
+        process.exit(1);
+      }
+      cb();
+    }
+  );
+  pipe(runner);
+});
+
+gulp.task('test:karma:watch', ['test:prepare:build'], (cb) => {
+  let runner = exec(
+    testBin(`${KARMA_TEST_COMMAND}:watch`),
+    (err, stdout) => {
+      cb(err);
+    }
+  );
+  pipe(runner);
+});
+
+gulp.task('test:karma:safe', ['test:prepare:build'], (cb) => {
+  let runner = exec(
+    testBin(KARMA_TEST_COMMAND),
+    (err, stdout) => {
+      testResults.push({
+        suite: 'Karma Specs\t',
+        pass: testCount(stdout, /(\d+) tests? completed/),
+        fail: testCount(stdout, /(\d+) tests? failed/),
+        pend: testCount(stdout, /(\d+) tests? skipped/),
+      });
+      cb();
+    }
+  );
+  pipe(runner);
+});
+
+gulp.task('test:e2e', ['test:prepare', 'test:prepare:server'], (cb) => {
+  let support = [
+    'Xvfb :99 -screen 0 1024x768x24 -extension RANDR',
+    testBin('npm run test:e2e:webdriver', 'DISPLAY=:99'),
+  ].map(exec);
+  support.push(server);
+
+  Bluebird.all([
+    awaitPort(TEST_SERVER_PORT),
+    awaitPort(4444),
+  ]).then(() => {
+    let runner = exec(
+      'npm run test:e2e',
+      (err, stdout, stderr) => {
+        support.forEach(kill);
+        if (err) {
+          process.exit(1);
+        }
+        cb();
+      }
+    );
+    pipe(runner);
+  });
+});
+
+gulp.task('test:e2e:safe', ['test:prepare', 'test:prepare:server'], (cb) => {
+  let support = [
+    'Xvfb :99 -screen 0 1024x768x24 -extension RANDR',
+    'npm run test:e2e:webdriver',
+  ].map(exec);
+
+  Bluebird.all([
+    awaitPort(TEST_SERVER_PORT),
+    awaitPort(4444),
+  ]).then(() => {
+    let runner = exec(
+      'npm run test:e2e',
+      (err, stdout, stderr) => {
+        let match = stdout.match(/(\d+) tests?.*(\d) failures?/);
+
+        testResults.push({
+          suite: 'End-to-End Specs\t',
+          pass: testCount(stdout, /(\d+) passing/),
+          fail: testCount(stdout, /(\d+) failing/),
+          pend: testCount(stdout, /(\d+) pending/),
+        });
+        support.forEach(kill);
+        cb();
+      }
+    );
+    pipe(runner);
+  });
+});
+
 gulp.task('test:api-v3:unit', (done) => {
  let runner = exec(
    testBin('node_modules/.bin/istanbul cover --dir coverage/api-v3-unit --report lcovonly node_modules/mocha/bin/_mocha -- test/api/v3/unit --recursive --require ./test/helpers/start-server'),
-    (err) => {
+    (err, stdout, stderr) => {
      if (err) {
        process.exit(1);
      }
@@ -186,7 +300,7 @@ gulp.task('test:api-v3:integration', (done) => {
  let runner = exec(
    testBin('node_modules/.bin/istanbul cover --dir coverage/api-v3-integration --report lcovonly node_modules/mocha/bin/_mocha -- test/api/v3/integration --recursive --require ./test/helpers/start-server'),
    {maxBuffer: 500 * 1024},
-    (err) => {
+    (err, stdout, stderr) => {
      if (err) {
        process.exit(1);
      }
@@ -206,7 +320,7 @@ gulp.task('test:api-v3:integration:separate-server', (done) => {
  let runner = exec(
    testBin('mocha test/api/v3/integration --recursive --require ./test/helpers/start-server', 'LOAD_SERVER=0'),
    {maxBuffer: 500 * 1024},
-    (err) => done(err)
+    (err, stdout, stderr) => done(err)
  );

  pipe(runner);
@@ -217,6 +331,7 @@ gulp.task('test', (done) => {
    'test:sanity',
    'test:content',
    'test:common',
+    'test:karma',
    'test:api-v3:unit',
    'test:api-v3:integration',
    done
@@ -1,5 +1,6 @@
 import fs       from 'fs';
 import _        from 'lodash';
+import nconf    from 'nconf';
 import gulp     from 'gulp';
 import { postToSlack, conf } from './taskHelper';

@@ -11,82 +12,8 @@ const SLACK_CONFIG = {

 const LOCALES = './website/common/locales/';
 const ENGLISH_LOCALE = `${LOCALES}en/`;
-
-
-function getArrayOfLanguages () {
-  let languages = fs.readdirSync(LOCALES);
-  languages.shift(); // Remove README.md from array of languages
-
-  return languages;
-}
-
 const ALL_LANGUAGES = getArrayOfLanguages();

-function stripOutNonJsonFiles (collection) {
-  let onlyJson = _.filter(collection, (file) => {
-    return file.match(/[a-zA-Z]*\.json/);
-  });
-
-  return onlyJson;
-}
-
-function eachTranslationFile (languages, cb) {
-  let jsonFiles = stripOutNonJsonFiles(fs.readdirSync(ENGLISH_LOCALE));
-
-  _.each(languages, (lang) => {
-    _.each(jsonFiles, (filename) => {
-      let parsedTranslationFile;
-      try {
-        const translationFile = fs.readFileSync(`${LOCALES}${lang}/${filename}`);
-        parsedTranslationFile = JSON.parse(translationFile);
-      } catch (err) {
-        return cb(err);
-      }
-
-      let englishFile = fs.readFileSync(ENGLISH_LOCALE + filename);
-      let parsedEnglishFile = JSON.parse(englishFile);
-
-      cb(null, lang, filename, parsedEnglishFile, parsedTranslationFile);
-    });
-  });
-}
-
-function eachTranslationString (languages, cb) {
-  eachTranslationFile(languages, (error, language, filename, englishJSON, translationJSON) => {
-    if (error) return;
-    _.each(englishJSON, (string, key) => {
-      const translationString = translationJSON[key];
-      cb(language, filename, key, string, translationString);
-    });
-  });
-}
-
-function formatMessageForPosting (msg, items) {
-  let body = `*Warning:* ${msg}`;
-  body += '\n\n```\n';
-  body += items.join('\n');
-  body += '\n```';
-
-  return body;
-}
-
-function getStringsWith (json, interpolationRegex) {
-  let strings = {};
-
-  _.each(json, (fileName) => {
-    const rawFile = fs.readFileSync(ENGLISH_LOCALE + fileName);
-    const parsedJson = JSON.parse(rawFile);
-
-    strings[fileName] = {};
-    _.each(parsedJson, (value, key) => {
-      const match = value.match(interpolationRegex);
-      if (match) strings[fileName][key] = match;
-    });
-  });
-
-  return strings;
-}
-
 const malformedStringExceptions = {
  messageDropFood: true,
  armoireFood: true,
@@ -96,6 +23,7 @@ const malformedStringExceptions = {
 gulp.task('transifex', ['transifex:missingFiles', 'transifex:missingStrings', 'transifex:malformedStrings']);

 gulp.task('transifex:missingFiles', () => {
+
  let missingStrings = [];

  eachTranslationFile(ALL_LANGUAGES, (error) => {
@@ -112,6 +40,7 @@ gulp.task('transifex:missingFiles', () => {
 });

 gulp.task('transifex:missingStrings', () => {
+
  let missingStrings = [];

  eachTranslationString(ALL_LANGUAGES, (language, filename, key, englishString, translationString) => {
@@ -129,6 +58,7 @@ gulp.task('transifex:missingStrings', () => {
 });

 gulp.task('transifex:malformedStrings', () => {
+
  let jsonFiles = stripOutNonJsonFiles(fs.readdirSync(ENGLISH_LOCALE));
  let interpolationRegex = /<%= [a-zA-Z]* %>/g;
  let stringsToLookFor = getStringsWith(jsonFiles, interpolationRegex);
@@ -136,23 +66,25 @@ gulp.task('transifex:malformedStrings', () => {
  let stringsWithMalformedInterpolations = [];
  let stringsWithIncorrectNumberOfInterpolations = [];

-  _.each(ALL_LANGUAGES, (lang) => {
-    _.each(stringsToLookFor, (strings, filename) => {
-      let translationFile = fs.readFileSync(`${LOCALES}${lang}/${filename}`);
+  let count = 0;
+  _.each(ALL_LANGUAGES, function (lang) {
+
+    _.each(stringsToLookFor, function (strings, file) {
+      let translationFile = fs.readFileSync(LOCALES + lang + '/' + file);
      let parsedTranslationFile = JSON.parse(translationFile);

-      _.each(strings, (value, key) => { // eslint-disable-line max-nested-callbacks
+      _.each(strings, function (value, key) {
        let translationString = parsedTranslationFile[key];
        if (!translationString) return;

-        let englishOccurences = stringsToLookFor[filename][key];
+        let englishOccurences = stringsToLookFor[file][key];
        let translationOccurences = translationString.match(interpolationRegex);

        if (!translationOccurences) {
-          let malformedString = `${lang} - ${filename} - ${key} - ${translationString}`;
+          let malformedString = `${lang} - ${file} - ${key} - ${translationString}`;
          stringsWithMalformedInterpolations.push(malformedString);
        } else if (englishOccurences.length !== translationOccurences.length && !malformedStringExceptions[key]) {
-          let missingInterpolationString = `${lang} - ${filename} - ${key} - ${translationString}`;
+          let missingInterpolationString = `${lang} - ${file} - ${key} - ${translationString}`;
          stringsWithIncorrectNumberOfInterpolations.push(missingInterpolationString);
        }
      });
@@ -171,3 +103,74 @@ gulp.task('transifex:malformedStrings', () => {
    postToSlack(formattedMessage, SLACK_CONFIG);
  }
 });
+
+function getArrayOfLanguages () {
+  let languages = fs.readdirSync(LOCALES);
+  languages.shift(); // Remove README.md from array of languages
+
+  return languages;
+}
+
+function eachTranslationFile (languages, cb) {
+  let jsonFiles = stripOutNonJsonFiles(fs.readdirSync(ENGLISH_LOCALE));
+
+  _.each(languages, (lang) => {
+    _.each(jsonFiles, (filename) => {
+      try {
+        var translationFile = fs.readFileSync(LOCALES + lang + '/' + filename);
+        var parsedTranslationFile = JSON.parse(translationFile);
+      } catch (err) {
+        return cb(err);
+      }
+
+      let englishFile = fs.readFileSync(ENGLISH_LOCALE + filename);
+      let parsedEnglishFile = JSON.parse(englishFile);
+
+      cb(null, lang, filename, parsedEnglishFile, parsedTranslationFile);
+    });
+  });
+}
+
+function eachTranslationString (languages, cb) {
+  eachTranslationFile(languages, (error, language, filename, englishJSON, translationJSON) => {
+    if (error) return;
+    _.each(englishJSON, (string, key) => {
+      var translationString = translationJSON[key];
+      cb(language, filename, key, string, translationString);
+    });
+  });
+}
+
+function formatMessageForPosting (msg, items) {
+  let body = `*Warning:* ${msg}`;
+  body += '\n\n```\n';
+  body += items.join('\n');
+  body += '\n```';
+
+  return body;
+}
+
+function getStringsWith (json, interpolationRegex) {
+  var strings = {};
+
+  _.each(json, function (file_name) {
+    var raw_file = fs.readFileSync(ENGLISH_LOCALE + file_name);
+    var parsed_json = JSON.parse(raw_file);
+
+    strings[file_name] = {};
+    _.each(parsed_json, function (value, key) {
+      var match = value.match(interpolationRegex);
+      if (match) strings[file_name][key] = match;
+    });
+  });
+
+  return strings;
+}
+
+function stripOutNonJsonFiles (collection) {
+  let onlyJson = _.filter(collection, (file) => {
+    return file.match(/[a-zA-Z]*\.json/);
+  });
+
+  return onlyJson;
+}
@@ -12,7 +12,7 @@ import { resolve }                from 'path';
 * Get access to configruable values
 */
 nconf.argv().env().file({ file: 'config.json' });
-export const conf = nconf;
+export var conf = nconf;

 /*
 * Kill a child process and any sub-children that process may have spawned.
@@ -26,12 +26,11 @@ export function kill (proc) {
        pids.forEach(kill); return;
      }
      try {
-        exec(/^win/.test(process.platform) ?
-          `taskkill /PID ${pid} /T /F` :
-          `kill -9 ${pid}`);
-      } catch (e) {
-        console.log(e); // eslint-disable-line no-console
+        exec(/^win/.test(process.platform)
+          ? `taskkill /PID ${pid} /T /F`
+          : `kill -9 ${pid}`);
      }
+      catch (e) { console.log(e); }
    });
  };

@@ -45,25 +44,21 @@ export function kill (proc) {
 * before failing.
 */
 export function awaitPort (port, max = 60) {
-  return new Bluebird((rej, res) => {
-    let socket;
-    let timeout;
-    let interval;
+  return new Bluebird((reject, resolve) => {
+    let socket, timeout, interval;

    timeout = setTimeout(() => {
      clearInterval(interval);
-      rej(`Timed out after ${max} seconds`);
+      reject(`Timed out after ${max} seconds`);
    }, max * 1000);

    interval = setInterval(() => {
-      socket = net.connect({port}, () => {
+      socket = net.connect({port: port}, () => {
        clearInterval(interval);
        clearTimeout(timeout);
        socket.destroy();
-        res();
-      }).on('error', () => {
-        socket.destroy();
-      });
+        resolve();
+      }).on('error', () => { socket.destroy; });
    }, 1000);
  });
 }
@@ -72,12 +67,8 @@ export function awaitPort (port, max = 60) {
 * Pipe the child's stdin and stderr to the parent process.
 */
 export function pipe (child) {
-  child.stdout.on('data', (data) => {
-    process.stdout.write(data);
-  });
-  child.stderr.on('data', (data) => {
-    process.stderr.write(data);
-  });
+  child.stdout.on('data', (data) => { process.stdout.write(data); });
+  child.stderr.on('data', (data) => { process.stderr.write(data); });
 }

 /*
@@ -87,8 +78,8 @@ export function postToSlack (msg, config = {}) {
  let slackUrl = nconf.get('SLACK_URL');

  if (!slackUrl) {
-    console.error('No slack post url specified. Your message was:'); // eslint-disable-line no-console
-    console.log(msg); // eslint-disable-line no-console
+    console.error('No slack post url specified. Your message was:');
+    console.log(msg);

    return;
  }
@@ -98,15 +89,15 @@ export function postToSlack (msg, config = {}) {
      channel: `#${config.channel || '#general'}`,
      username: config.username || 'gulp task',
      text: msg,
-      icon_emoji: `:${config.emoji || 'gulp'}:`, // eslint-disable-line camelcase
+      icon_emoji: `:${config.emoji || 'gulp'}:`,
    })
-    .end((err) => {
-      if (err) console.error('Unable to post to slack', err); // eslint-disable-line no-console
+    .end((err, res) => {
+      if (err) console.error('Unable to post to slack', err);
    });
 }

 export function runMochaTests (files, server, cb) {
-  require('../test/helpers/globals.helper'); // eslint-disable-line global-require
+  require('../test/helpers/globals.helper');

  let mocha = new Mocha({reporter: 'spec'});
  let tests = glob(files);
@@ -117,7 +108,7 @@ export function runMochaTests (files, server, cb) {
  });

  mocha.run((numberOfFailures) => {
-    if (!process.env.RUN_INTEGRATION_TEST_FOREVER) { // eslint-disable-line no-process-env
+    if (!process.env.RUN_INTEGRATION_TEST_FOREVER) {
      if (server) kill(server);
      process.exit(numberOfFailures);
    }
@@ -8,10 +8,13 @@

 require('babel-register');

-if (process.env.NODE_ENV === 'production') { // eslint-disable-line no-process-env
-  require('./gulp/gulp-apidoc'); // eslint-disable-line global-require
-  require('./gulp/gulp-build'); // eslint-disable-line global-require
+if (process.env.NODE_ENV === 'production') {
+  require('./gulp/gulp-apidoc');
+  require('./gulp/gulp-newstuff');
+  require('./gulp/gulp-build');
+  require('./gulp/gulp-babelify');
+  require('./gulp/gulp-bootstrap');
 } else {
-  require('glob').sync('./gulp/gulp-*').forEach(require); // eslint-disable-line global-require
-  require('gulp').task('default', ['test']); // eslint-disable-line global-require
+  require('glob').sync('./gulp/gulp-*').forEach(require);
+  require('gulp').task('default', ['test']);
 }
@@ -16,7 +16,7 @@ var migrationName = '20140831_increase_gems_for_previous_contributions';
 * https://github.com/HabitRPG/habitrpg/issues/3933
 * Increase Number of Gems for Contributors
 * author: Alys (d904bd62-da08-416b-a816-ba797c9ee265)
- *
+ * 
 * Increase everyone's gems per their contribution level.
 * Originally they were given 2 gems per tier.
 * Now they are given 3 gems per tier for tiers 1,2,3
@@ -70,7 +70,7 @@ dbUsers.findEach(query, fields, function(err, user) {
    var extraGems = tier; // tiers 1,2,3
    if (tier > 3)  { extraGems = 3 + (tier - 3) * 2; }
    if (tier == 8) { extraGems = 11; }
-    var extraBalance = extraGems / 4;
+    extraBalance = extraGems / 4;
    set['balance'] = user.balance + extraBalance;

    // Capture current state of user:
@@ -39,7 +39,7 @@ function findUsers(gt){
      console.log('User: ', countUsers, user._id);

      var update = {
-        $set: {}
+        $set: {};
      };

      if(user.auth && user.auth.local) {
@@ -60,4 +60,4 @@ function findUsers(gt){
  });
 };

-findUsers();
+findUsers();
@@ -1,111 +0,0 @@
-var migrationName = '20171030_jackolanterns.js';
-var authorName = 'Sabe'; // in case script author needs to know when their ...
-var authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; //... own data is done
-
-/*
- * Award the Jack-O'-Lantern ladder:
- * Ghost Jack-O-Lantern Mount to owners of Ghost Jack-O-Lantern Pet
- * Ghost Jack-O-Lantern Pet to owners of Jack-O-Lantern Mount
- * Jack-O-Lantern Mount to owners of Jack-O-Lantern Pet
- * Jack-O-Lantern Pet to everyone else
- */
-
-var monk = require('monk');
-var connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
-var dbUsers = monk(connectionString).get('users', { castIds: false });
-
-function processUsers(lastId) {
-  // specify a query to limit the affected users (empty for all users):
-  var query = {
-    'migration':{$ne:migrationName},
-  };
-
-  if (lastId) {
-    query._id = {
-      $gt: lastId
-    }
-  }
-
-  dbUsers.find(query, {
-    sort: {_id: 1},
-    limit: 250,
-    fields: [
-      'items.pets',
-      'items.mounts',
-    ] // specify fields we are interested in to limit retrieved data (empty if we're not reading data):
-  })
-  .then(updateUsers)
-  .catch(function (err) {
-    console.log(err);
-    return exiting(1, 'ERROR! ' + err);
-  });
-}
-
-var progressCount = 1000;
-var count = 0;
-
-function updateUsers (users) {
-  if (!users || users.length === 0) {
-    console.warn('All appropriate users found and modified.');
-    displayData();
-    return;
-  }
-
-  var userPromises = users.map(updateUser);
-  var lastUser = users[users.length - 1];
-
-  return Promise.all(userPromises)
-  .then(function () {
-    processUsers(lastUser._id);
-  });
-}
-
-function updateUser (user) {
-  count++;
-
-  var set = {};
-  var inc = {
-    'items.food.Candy_Skeleton': 1,
-    'items.food.Candy_Base': 1,
-    'items.food.Candy_CottonCandyBlue': 1,
-    'items.food.Candy_CottonCandyPink': 1,
-    'items.food.Candy_Shade': 1,
-    'items.food.Candy_White': 1,
-    'items.food.Candy_Golden': 1,
-    'items.food.Candy_Zombie': 1,
-    'items.food.Candy_Desert': 1,
-    'items.food.Candy_Red': 1,
-  };
-
-  if (user && user.items && user.items.pets && user.items.pets['JackOLantern-Ghost']) {
-    set = {'migration':migrationName, 'items.mounts.JackOLantern-Ghost': true};
-  } else if (user && user.items && user.items.mounts && user.items.mounts['JackOLantern-Base']) {
-    set = {'migration':migrationName, 'items.pets.JackOLantern-Ghost': 5};
-  } else if (user && user.items && user.items.pets && user.items.pets['JackOLantern-Base']) {
-    set = {'migration':migrationName, 'items.mounts.JackOLantern-Base': true};
-  } else {
-    set = {'migration':migrationName, 'items.pets.JackOLantern-Base': 5};
-  }
-
-  dbUsers.update({_id: user._id}, {$set:set, $inc:inc});
-
-  if (count % progressCount == 0) console.warn(count + ' ' + user._id);
-  if (user._id == authorUuid) console.warn(authorName + ' processed');
-}
-
-function displayData() {
-  console.warn('\n' + count + ' users processed\n');
-  return exiting(0);
-}
-
-function exiting(code, msg) {
-  code = code || 0; // 0 = success
-  if (code && !msg) { msg = 'ERROR!'; }
-  if (msg) {
-    if (code) { console.error(msg); }
-    else      { console.log(  msg); }
-  }
-  process.exit(code);
-}
-
-module.exports = processUsers;
@@ -1,128 +0,0 @@
-var migrationName = '20171117_turkey_ladder.js';
-var authorName = 'Sabe'; // in case script author needs to know when their ...
-var authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; //... own data is done
-
-/*
- * Award the Turkey Day ladder:
- * Grant Turkey Costume to those who have the Gilded Turkey mount
- * Grant Gilded Turkey mount to those who have the Gilded Turkey pet
- * Grant Gilded Turkey pet to those who have the Base Turkey mount
- * Grant Base Turkey mount to those who have the Base Turkey pet
- * Grant Base Turkey pet to those who have none of the above yet
- */
-
-var monk = require('monk');
-var connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
-var dbUsers = monk(connectionString).get('users', { castIds: false });
-
-function processUsers(lastId) {
-  // specify a query to limit the affected users (empty for all users):
-  var query = {
-    'migration':{$ne:migrationName},
-    'auth.timestamps.loggedin':{$gt:new Date('2017-11-01')},
-  };
-
-  if (lastId) {
-    query._id = {
-      $gt: lastId
-    }
-  }
-
-  dbUsers.find(query, {
-    sort: {_id: 1},
-    limit: 250,
-    fields: [
-      'items.pets',
-      'items.mounts',
-    ] // specify fields we are interested in to limit retrieved data (empty if we're not reading data):
-  })
-  .then(updateUsers)
-  .catch(function (err) {
-    console.log(err);
-    return exiting(1, 'ERROR! ' + err);
-  });
-}
-
-var progressCount = 1000;
-var count = 0;
-
-function updateUsers (users) {
-  if (!users || users.length === 0) {
-    console.warn('All appropriate users found and modified.');
-    displayData();
-    return;
-  }
-
-  var userPromises = users.map(updateUser);
-  var lastUser = users[users.length - 1];
-
-  return Promise.all(userPromises)
-  .then(function () {
-    processUsers(lastUser._id);
-  });
-}
-
-function updateUser (user) {
-  count++;
-
-  var set = {};
-
-  if (user && user.items && user.items.mounts && user.items.mounts['Turkey-Gilded']) {
-    set = {
-      migration: migrationName,
-      'items.gear.owned.head_special_turkeyHelmBase': false,
-      'items.gear.owned.armor_special_turkeyArmorBase': false,
-      'items.gear.owned.back_special_turkeyTailBase': false,
-    };
-    var push = [
-      {
-        type: 'marketGear',
-        path: 'gear.flat.head_special_turkeyHelmBase',
-        _id: monk.id(),
-      },
-      {
-        type: 'marketGear',
-        path: 'gear.flat.armor_special_turkeyArmorBase',
-        _id: monk.id(),
-      },
-      {
-        type: 'marketGear',
-        path: 'gear.flat.back_special_turkeyTailBase',
-        _id: monk.id(),
-      },
-    ];
-  } else if (user && user.items && user.items.pets && user.items.pets['Turkey-Gilded']) {
-    set = {'migration':migrationName, 'items.mounts.Turkey-Gilded':true};
-  } else if (user && user.items && user.items.mounts && user.items.mounts['Turkey-Base']) {
-    set = {'migration':migrationName, 'items.pets.Turkey-Gilded':5};
-  } else if (user && user.items && user.items.pets && user.items.pets['Turkey-Base']) {
-    set = {'migration':migrationName, 'items.mounts.Turkey-Base':true};
-  } else {
-    set = {'migration':migrationName, 'items.pets.Turkey-Base':5};
-  }
-
-  dbUsers.update({_id: user._id}, {$set: set});
-  if (push) {
-    dbUsers.update({_id: user._id}, {$push: {pinnedItems: {$each: push}}});
-  }
-
-  if (count % progressCount == 0) console.warn(count + ' ' + user._id);
-  if (user._id == authorUuid) console.warn(authorName + ' processed');
-}
-
-function displayData() {
-  console.warn('\n' + count + ' users processed\n');
-  return exiting(0);
-}
-
-function exiting(code, msg) {
-  code = code || 0; // 0 = success
-  if (code && !msg) { msg = 'ERROR!'; }
-  if (msg) {
-    if (code) { console.error(msg); }
-    else      { console.log(  msg); }
-  }
-  process.exit(code);
-}
-
-module.exports = processUsers;
@@ -17,12 +17,8 @@ function setUpServer () {
 setUpServer();

 // Replace this with your migration
-const processUsers = require('./users/achievement-restore');
+var processUsers = require('./groups/update-groups-with-group-plans');
 processUsers()
-  .then(() => {
-    process.exit();
-  })
  .catch(function (err) {
-    console.log(err);
-    process.exit();
-  });
+      console.log(err)
+  })
@@ -2,7 +2,7 @@ var _id = '';
 var update = {
  $addToSet: {
    'purchased.plan.mysteryItems':{
-      $each:['armor_mystery_201712','head_mystery_201712']
+      $each:['shield_mystery_201709','back_mystery_201709']
    }
  }
 };
@@ -65,29 +65,19 @@ function updateUser (user) {
    set = {'migration':migrationName};
  } else if (typeof user.items.gear.owned.body_special_takeThis !== 'undefined') {
    set = {'migration':migrationName, 'items.gear.owned.back_special_takeThis':false};
-    var push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.back_special_takeThis', '_id': monk.id()}};
  } else if (typeof user.items.gear.owned.head_special_takeThis !== 'undefined') {
    set = {'migration':migrationName, 'items.gear.owned.body_special_takeThis':false};
-    var push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.body_special_takeThis', '_id': monk.id()}};
  } else if (typeof user.items.gear.owned.armor_special_takeThis !== 'undefined') {
    set = {'migration':migrationName, 'items.gear.owned.head_special_takeThis':false};
-    var push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.head_special_takeThis', '_id': monk.id()}};
  } else if (typeof user.items.gear.owned.weapon_special_takeThis !== 'undefined') {
    set = {'migration':migrationName, 'items.gear.owned.armor_special_takeThis':false};
-    var push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_takeThis', '_id': monk.id()}};
  } else if (typeof user.items.gear.owned.shield_special_takeThis !== 'undefined') {
    set = {'migration':migrationName, 'items.gear.owned.weapon_special_takeThis':false};
-    var push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.weapon_special_takeThis', '_id': monk.id()}};
  } else {
    set = {'migration':migrationName, 'items.gear.owned.shield_special_takeThis':false};
-    var push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.shield_special_takeThis', '_id': monk.id()}};
  }

-  if (push) {
-    dbUsers.update({_id: user._id}, {$set: set, $push: push});
-  } else {
-    dbUsers.update({_id: user._id}, {$set: set});
-  }
+  dbUsers.update({_id: user._id}, {$set:set});

  if (count % progressCount == 0) console.warn(count + ' ' + user._id);
  if (user._id == authorUuid) console.warn(authorName + ' processed');
@@ -1,88 +0,0 @@
-var migrationName = 'tasks-set-everyX';
-var authorName = ''; // in case script author needs to know when their ...
-var authorUuid = ''; //... own data is done
-
-/*
- * Iterates over all tasks and sets invalid everyX values (less than 0 or more than 9999 or not an int) field to 0
- */
-
-var monk = require('monk');
-var connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
-var dbTasks = monk(connectionString).get('tasks', { castIds: false });
-
-function processTasks(lastId) {
-  // specify a query to limit the affected tasks (empty for all tasks):
-  var query = {
-    type: "daily",
-    everyX: {
-      $not: {
-        $gte: 0,
-        $lte: 9999,
-        $type: "int",
-      }
-    },
-  };
-
-  if (lastId) {
-    query._id = {
-      $gt: lastId
-    }
-  }
-
-  dbTasks.find(query, {
-    sort: {_id: 1},
-    limit: 250,
-    fields: [],
-  })
-  .then(updateTasks)
-  .catch(function (err) {
-    console.log(err);
-    return exiting(1, 'ERROR! ' + err);
-  });
-}
-
-var progressCount = 1000;
-var count = 0;
-
-function updateTasks (tasks) {
-  if (!tasks || tasks.length === 0) {
-    console.warn('All appropriate tasks found and modified.');
-    displayData();
-    return;
-  }
-
-  var taskPromises = tasks.map(updatetask);
-  var lasttask = tasks[tasks.length - 1];
-
-  return Promise.all(taskPromises)
-  .then(function () {
-    processTasks(lasttask._id);
-  });
-}
-
-function updatetask (task) {
-  count++;
-  var set = {'everyX': 0};
-
-  dbTasks.update({_id: task._id}, {$set:set});
-
-  if (count % progressCount == 0) console.warn(count + ' ' + task._id);
-  if (task._id == authorUuid) console.warn(authorName + ' processed');
-}
-
-function displayData() {
-  console.warn('\n' + count + ' tasks processed\n');
-  return exiting(0);
-}
-
-function exiting(code, msg) {
-  code = code || 0; // 0 = success
-  if (code && !msg) { msg = 'ERROR!'; }
-  if (msg) {
-    if (code) { console.error(msg); }
-    else      { console.log(  msg); }
-  }
-  process.exit(code);
-}
-
-module.exports = processTasks;
@@ -1,38 +0,0 @@
-var migrationName = 'AccountTransfer';
-var authorName = 'TheHollidayInn'; // in case script author needs to know when their ...
-var authorUuid = ''; //... own data is done
-
-/*
- * This migraition will copy user data from prod to test
- */
-
-const monk = require('monk');
-const connectionString = '';
-const Users = monk(connectionString).get('users', { castIds: false });
-
-import uniq from 'lodash/uniq';
-import Bluebird from 'bluebird';
-
-
-module.exports = async function accountTransfer () {
-  const fromAccountId = '';
-  const toAccountId = '';
-
-  const fromAccount = await Users.findOne({_id: fromAccountId});
-  const toAccount = await Users.findOne({_id: toAccountId});
-
-  const newMounts = Object.assign({}, fromAccount.items.mounts, toAccount.items.mounts);
-  const newPets = Object.assign({}, fromAccount.items.pets, toAccount.items.pets);
-  const newBackgrounds = Object.assign({}, fromAccount.purchased.background, toAccount.purchased.background);
-
-  await Users.update({_id: toAccountId}, {
-    $set: {
-      'items.pets': newPets,
-      'items.mounts': newMounts,
-      'purchased.background': newBackgrounds,
-    },
-  })
-  .then((result) => {
-    console.log(result);
-  });
-};
@@ -1,93 +0,0 @@
-const migrationName = 'AchievementRestore';
-const authorName = 'TheHollidayInn'; // in case script author needs to know when their ...
-const authorUuid = ''; //... own data is done
-
-/*
- * This migraition will copy user data from prod to test
- */
-import Bluebird from 'bluebird';
-
-const monk = require('monk');
-const connectionString = 'mongodb://localhost/new-habit';
-const Users = monk(connectionString).get('users', { castIds: false });
-
-const monkOld = require('monk');
-const oldConnectionSting = 'mongodb://localhost/old-habit';
-const UsersOld = monk(oldConnectionSting).get('users', { castIds: false });
-
-function getAchievementUpdate (newUser, oldUser) {
-  const oldAchievements = oldUser.achievements;
-  const newAchievements = newUser.achievements;
-
-  let achievementsUpdate = Object.assign({}, newAchievements);
-
-  // ultimateGearSets
-  if (!achievementsUpdate.ultimateGearSets && oldAchievements.ultimateGearSets) {
-    achievementsUpdate.ultimateGearSets = oldAchievements.ultimateGearSets;
-  } else if (oldAchievements.ultimateGearSets) {
-    for (let index in oldAchievements.ultimateGearSets) {
-      if (oldAchievements.ultimateGearSets[index]) achievementsUpdate.ultimateGearSets[index] = true;
-    }
-  }
-
-  // challenges
-  if (!newAchievements.challenges) newAchievements.challenges = [];
-  if (!oldAchievements.challenges) oldAchievements.challenges = [];
-  achievementsUpdate.challenges = newAchievements.challenges.concat(oldAchievements.challenges);
-
-  // Quests
-  if (!achievementsUpdate.quests) achievementsUpdate.quests = {};
-  for (let index in oldAchievements.quests) {
-    if (!achievementsUpdate.quests[index]) {
-      achievementsUpdate.quests[index] = oldAchievements.quests[index];
-    } else {
-      achievementsUpdate.quests[index] += oldAchievements.quests[index];
-    }
-  }
-
-  // Rebirth level
-  if (achievementsUpdate.rebirthLevel) {
-    achievementsUpdate.rebirthLevel = Math.max(achievementsUpdate.rebirthLevel, oldAchievements.rebirthLevel);
-  } else if (oldAchievements.rebirthLevel) {
-    achievementsUpdate.rebirthLevel = oldAchievements.rebirthLevel;
-  }
-
-  //All others
-  const indexsToIgnore = ['ultimateGearSets', 'challenges', 'quests', 'rebirthLevel'];
-  for (let index in oldAchievements) {
-    if (indexsToIgnore.indexOf(index) !== -1) continue;
-
-    if (!achievementsUpdate[index])  {
-      achievementsUpdate[index] = oldAchievements[index];
-      continue;
-    }
-
-    if (Number.isInteger(oldAchievements[index])) {
-      achievementsUpdate[index] += oldAchievements[index];
-    } else {
-      if (oldAchievements[index] === true) achievementsUpdate[index] = true;
-    }
-  }
-
-  return achievementsUpdate;
-}
-
-module.exports = async function achievementRestore () {
-  const userIds = [
-  ];
-
-  for (let index in userIds) {
-    const userId = userIds[index];
-    const oldUser = await UsersOld.findOne({_id: userId}, 'achievements');
-    const newUser = await Users.findOne({_id: userId}, 'achievements');
-    const achievementUpdate = getAchievementUpdate(newUser, oldUser);
-    await Users.update(
-      {_id: userId},
-      {
-        $set: {
-          'achievements': achievementUpdate,
-        },
-      });
-    console.log(`Updated ${userId}`);
-  }
-};
@@ -1,7 +1,7 @@
 {
  "name": "habitica",
  "description": "A habit tracker app which treats your goals like a Role Playing Game.",
-  "version": "4.16.2",
+  "version": "4.2.0",
  "main": "./website/server/index.js",
  "dependencies": {
    "@slack/client": "^3.8.1",
@@ -31,8 +31,9 @@
    "bcrypt": "^1.0.2",
    "bluebird": "^3.3.5",
    "body-parser": "^1.15.0",
-    "bootstrap": "4.0.0-beta.2",
-    "bootstrap-vue": "^1.0.2",
+    "bootstrap": "4.0.0-alpha.6",
+    "bootstrap-vue": "^1.0.0-beta.6",
+    "bower": "~1.3.12",
    "browserify": "~12.0.1",
    "compression": "^1.6.1",
    "connect-ratelimit": "0.0.7",
@@ -52,8 +53,18 @@
    "file-loader": "^0.10.0",
    "glob": "^4.3.5",
    "got": "^6.1.1",
+    "grunt": "~0.4.1",
+    "grunt-cli": "~0.1.9",
+    "grunt-contrib-clean": "~0.6.0",
+    "grunt-contrib-copy": "~0.6.0",
+    "grunt-contrib-cssmin": "~0.10.0",
+    "grunt-contrib-stylus": "~0.20.0",
+    "grunt-contrib-uglify": "~0.6.0",
+    "grunt-contrib-watch": "~0.6.1",
+    "grunt-hashres": "git://github.com/habitrpg/grunt-hashres#dc85db6d3002e29e1b7c5ee186b80d708d2f0e0b",
    "gulp": "^3.9.0",
    "gulp-babel": "^6.1.2",
+    "gulp-grunt": "^0.5.2",
    "gulp-imagemin": "^2.4.0",
    "gulp-nodemon": "^2.0.4",
    "gulp-sourcemaps": "^1.6.0",
@@ -116,14 +127,13 @@
    "validator": "^4.9.0",
    "vinyl-buffer": "^1.0.0",
    "vinyl-source-stream": "^1.1.0",
-    "vue": "^2.5.2",
-    "vue-loader": "^13.3.0",
+    "vue": "^2.1.0",
+    "vue-loader": "^11.0.0",
    "vue-mugen-scroll": "^0.2.1",
-    "vue-router": "^3.0.0",
+    "vue-router": "^2.0.0-rc.5",
    "vue-style-loader": "^3.0.0",
-    "vue-template-compiler": "^2.5.2",
-    "vuedraggable": "^2.15.0",
-    "vuejs-datepicker": "git://github.com/habitrpg/vuejs-datepicker#825a866b6a9c52dd8c588a3e8b900880875ce914",
+    "vue-template-compiler": "^2.1.10",
+    "vuejs-datepicker": "git://github.com/habitrpg/vuejs-datepicker#45e607a7bccf4e3e089761b3b7b33e3f2c5dc21f",
    "webpack": "^2.2.1",
    "webpack-merge": "^4.0.0",
    "winston": "^2.1.0",
@@ -137,7 +147,7 @@
  },
  "scripts": {
    "lint": "eslint --ext .js,.vue .",
-    "test": "npm run lint && gulp test && gulp apidoc",
+    "test": "npm run lint && gulp test && npm run client:unit && gulp apidoc",
    "test:build": "gulp test:prepare:build",
    "test:api-v3": "gulp test:api-v3",
    "test:api-v3:unit": "gulp test:api-v3:unit",
@@ -146,16 +156,21 @@
    "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:karma": "karma start test/client-old/spec/karma.conf.js --single-run",
+    "test:karma:watch": "karma start test/client-old/spec/karma.conf.js",
+    "test:prepare:webdriver": "webdriver-manager update",
+    "test:e2e:webdriver": "webdriver-manager start",
+    "test:e2e": "protractor test/client-old/e2e/protractor.conf.js",
    "test:nodemon": "gulp test:nodemon",
    "coverage": "COVERAGE=true mocha --require register-handlers.js --reporter html-cov > coverage.html; open coverage.html",
    "sprites": "gulp sprites:compile",
-    "client:dev": "node webpack/dev-server.js",
+    "client:dev": "gulp bootstrap && node webpack/dev-server.js",
    "client:build": "gulp build:client",
    "client:unit": "cross-env NODE_ENV=test karma start test/client/unit/karma.conf.js --single-run",
    "client:unit:watch": "cross-env NODE_ENV=test karma start test/client/unit/karma.conf.js",
    "client:e2e": "node test/client/e2e/runner.js",
    "client:test": "npm run client:unit && npm run client:e2e",
-    "start": "gulp nodemon",
+    "start": "gulp run:dev",
    "postinstall": "gulp build",
    "apidoc": "gulp apidoc"
  },
@@ -179,6 +194,7 @@
    "event-stream": "^3.2.2",
    "eventsource-polyfill": "^0.9.6",
    "expect.js": "~0.2.0",
+    "grunt-karma": "~0.12.1",
    "http-proxy-middleware": "^0.17.0",
    "inject-loader": "^3.0.0-beta4",
    "istanbul": "^1.1.0-alpha.1",
@@ -64,11 +64,11 @@ describe('GET /challenges/:challengeId/export/csv', () => {
    let sortedMembers = _.sortBy([members[0], members[1], members[2], groupLeader], '_id');
    let splitRes = res.split('\n');

-    expect(splitRes[0]).to.equal('UUID,name,Task,Value,Notes,Streak,Task,Value,Notes,Streak');
-    expect(splitRes[1]).to.equal(`${sortedMembers[0]._id},${sortedMembers[0].profile.name},habit:Task 1,0,,0,todo:Task 2,0,,0`);
-    expect(splitRes[2]).to.equal(`${sortedMembers[1]._id},${sortedMembers[1].profile.name},habit:Task 1,0,,0,todo:Task 2,0,,0`);
-    expect(splitRes[3]).to.equal(`${sortedMembers[2]._id},${sortedMembers[2].profile.name},habit:Task 1,0,,0,todo:Task 2,0,,0`);
-    expect(splitRes[4]).to.equal(`${sortedMembers[3]._id},${sortedMembers[3].profile.name},habit:Task 1,0,,0,todo:Task 2,0,,0`);
+    expect(splitRes[0]).to.equal('UUID,name,Task,Value,Notes,Task,Value,Notes');
+    expect(splitRes[1]).to.equal(`${sortedMembers[0]._id},${sortedMembers[0].profile.name},habit:Task 1,0,,todo:Task 2,0,`);
+    expect(splitRes[2]).to.equal(`${sortedMembers[1]._id},${sortedMembers[1].profile.name},habit:Task 1,0,,todo:Task 2,0,`);
+    expect(splitRes[3]).to.equal(`${sortedMembers[2]._id},${sortedMembers[2].profile.name},habit:Task 1,0,,todo:Task 2,0,`);
+    expect(splitRes[4]).to.equal(`${sortedMembers[3]._id},${sortedMembers[3].profile.name},habit:Task 1,0,,todo:Task 2,0,`);
    expect(splitRes[5]).to.equal('');
  });
 });
@@ -142,22 +142,4 @@ describe('GET /challenges/:challengeId/members', () => {
    let resIds = res.concat(res2).map(member => member._id);
    expect(resIds).to.eql(expectedIds.sort());
  });
-
-  it('supports using req.query.search to get search members', async () => {
-    let group = await generateGroup(user, {type: 'party', name: generateUUID()});
-    let challenge = await generateChallenge(user, group);
-
-    let usersToGenerate = [];
-    for (let i = 0; i < 3; i++) {
-      usersToGenerate.push(generateUser({challenges: [challenge._id]}));
-    }
-    let generatedUsers = await Promise.all(usersToGenerate);
-    let profileNames = generatedUsers.map(generatedUser => generatedUser.profile.name);
-
-    let firstProfileName = profileNames[0];
-    let nameToSearch = firstProfileName.substring(0, 4);
-
-    let response = await user.get(`/challenges/${challenge._id}/members?search=${nameToSearch}`);
-    expect(response[0].profile.name).to.eql(firstProfileName);
-  });
 });
@@ -4,7 +4,6 @@ import {
  createAndPopulateGroup,
  translate as t,
 } from '../../../../helpers/api-v3-integration.helper';
-import { TAVERN_ID } from '../../../../../website/common/script/constants';

 describe('GET challenges/groups/:groupId', () => {
  context('Public Guild', () => {
@@ -182,123 +181,4 @@ describe('GET challenges/groups/:groupId', () => {
      expect(foundChallengeIndex).to.eql(1);
    });
  });
-
-  context('Party', () => {
-    let party, user, nonMember, challenge, challenge2;
-
-    before(async () => {
-      let { group, groupLeader } = await createAndPopulateGroup({
-        groupDetails: {
-          name: 'TestParty',
-          type: 'party',
-        },
-      });
-
-      party = group;
-      user = groupLeader;
-
-      nonMember = await generateUser();
-
-      challenge = await generateChallenge(user, group);
-      challenge2 = await generateChallenge(user, group);
-    });
-
-    it('should prevent non-member from seeing challenges', async () => {
-      await expect(nonMember.get(`/challenges/groups/${party._id}`))
-        .to.eventually.be.rejected.and.eql({
-          code: 404,
-          error: 'NotFound',
-          message: t('groupNotFound'),
-        });
-    });
-
-    it('should return group challenges for member with populated leader', async () => {
-      let challenges = await user.get(`/challenges/groups/${party._id}`);
-
-      let foundChallenge1 = _.find(challenges, { _id: challenge._id });
-      expect(foundChallenge1).to.exist;
-      expect(foundChallenge1.leader).to.eql({
-        _id: party.leader._id,
-        id: party.leader._id,
-        profile: {name: user.profile.name},
-      });
-      let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
-      expect(foundChallenge2).to.exist;
-      expect(foundChallenge2.leader).to.eql({
-        _id: party.leader._id,
-        id: party.leader._id,
-        profile: {name: user.profile.name},
-      });
-    });
-
-    it('should return group challenges for member using ID "party"', async () => {
-      let challenges = await user.get('/challenges/groups/party');
-
-      let foundChallenge1 = _.find(challenges, { _id: challenge._id });
-      expect(foundChallenge1).to.exist;
-      expect(foundChallenge1.leader).to.eql({
-        _id: party.leader._id,
-        id: party.leader._id,
-        profile: {name: user.profile.name},
-      });
-      let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
-      expect(foundChallenge2).to.exist;
-      expect(foundChallenge2.leader).to.eql({
-        _id: party.leader._id,
-        id: party.leader._id,
-        profile: {name: user.profile.name},
-      });
-    });
-  });
-
-  context('Tavern', () => {
-    let tavern, user, challenge, challenge2;
-
-    before(async () => {
-      user = await generateUser();
-      await user.update({balance: 0.5});
-      tavern = await user.get(`/groups/${TAVERN_ID}`);
-
-      challenge = await generateChallenge(user, tavern, {prize: 1});
-      challenge2 = await generateChallenge(user, tavern, {prize: 1});
-    });
-
-    it('should return tavern challenges with populated leader', async () => {
-      let challenges = await user.get(`/challenges/groups/${TAVERN_ID}`);
-
-      let foundChallenge1 = _.find(challenges, { _id: challenge._id });
-      expect(foundChallenge1).to.exist;
-      expect(foundChallenge1.leader).to.eql({
-        _id: user._id,
-        id: user._id,
-        profile: {name: user.profile.name},
-      });
-      let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
-      expect(foundChallenge2).to.exist;
-      expect(foundChallenge2.leader).to.eql({
-        _id: user._id,
-        id: user._id,
-        profile: {name: user.profile.name},
-      });
-    });
-
-    it('should return tavern challenges using ID "habitrpg', async () => {
-      let challenges = await user.get('/challenges/groups/habitrpg');
-
-      let foundChallenge1 = _.find(challenges, { _id: challenge._id });
-      expect(foundChallenge1).to.exist;
-      expect(foundChallenge1.leader).to.eql({
-        _id: user._id,
-        id: user._id,
-        profile: {name: user.profile.name},
-      });
-      let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
-      expect(foundChallenge2).to.exist;
-      expect(foundChallenge2.leader).to.eql({
-        _id: user._id,
-        id: user._id,
-        profile: {name: user.profile.name},
-      });
-    });
-  });
 });
@@ -1,6 +1,5 @@
 import {
  createAndPopulateGroup,
-  generateUser,
  translate as t,
  sleep,
  server,
@@ -13,7 +12,6 @@ import {
 import { v4 as generateUUID } from 'uuid';
 import { getMatchesByWordArray, removePunctuationFromString } from '../../../../../website/server/libs/stringUtils';
 import bannedWords from '../../../../../website/server/libs/bannedWords';
-import guildsAllowingBannedWords from '../../../../../website/server/libs/guildsAllowingBannedWords';
 import * as email from '../../../../../website/server/libs/email';
 import { IncomingWebhook } from '@slack/client';
 import nconf from 'nconf';
@@ -98,24 +96,6 @@ describe('POST /chat', () => {
        });
    });

-    it('returns an error when chat message contains a banned word in a public guild', async () => {
-      let { group, members } = await createAndPopulateGroup({
-        groupDetails: {
-          name: 'public guild',
-          type: 'guild',
-          privacy: 'public',
-        },
-        members: 1,
-      });
-
-      await expect(members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage}))
-        .to.eventually.be.rejected.and.eql({
-          code: 400,
-          error: 'BadRequest',
-          message: bannedWordErrorMessage,
-        });
-    });
-
    it('errors when word is part of a phrase', async () => {
      let wordInPhrase = `phrase ${testBannedWordMessage} end`;
      await expect(user.post('/groups/habitrpg/chat', { message: wordInPhrase}))
@@ -181,7 +161,7 @@ describe('POST /chat', () => {
      expect(message.message.id).to.exist;
    });

-    it('does not error when sending a chat message containing a banned word to a public guild in which banned words are allowed', async () => {
+    it('does not error when sending a chat message containing a banned word to a public guild', async () => {
      let { group, members } = await createAndPopulateGroup({
        groupDetails: {
          name: 'public guild',
@@ -191,8 +171,6 @@ describe('POST /chat', () => {
        members: 1,
      });

-      guildsAllowingBannedWords[group._id] = true;
-
      let message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage});

      expect(message.message.id).to.exist;
@@ -364,24 +342,6 @@ describe('POST /chat', () => {
    expect(message.message.id).to.exist;
  });

-  it('adds backer info to chat', async () => {
-    const backerInfo = {
-      npc: 'Town Crier',
-      tier: 800,
-      tokensApplied: true,
-    };
-    const backer = await generateUser({
-      backer: backerInfo,
-    });
-
-    const message = await backer.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
-    const messageBackerInfo = message.message.backer;
-
-    expect(messageBackerInfo.npc).to.equal(backerInfo.npc);
-    expect(messageBackerInfo.tier).to.equal(backerInfo.tier);
-    expect(messageBackerInfo.tokensApplied).to.equal(backerInfo.tokensApplied);
-  });
-
  it('sends group chat received webhooks', async () => {
    let userUuid = generateUUID();
    let memberUuid = generateUUID();
@@ -3,7 +3,6 @@ import {
  generateUser,
  translate as t,
 } from '../../../../helpers/api-v3-integration.helper';
-import config from '../../../../../config.json';
 import { v4 as generateUUID } from 'uuid';

 describe('POST /groups/:id/chat/:id/clearflags', () => {
@@ -75,7 +74,7 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
      expect(messages[0].flagCount).to.eql(0);
    });

-    it('can\'t flag a system message', async () => {
+    it('can unflag a system message', async () => {
      let { group, members } = await createAndPopulateGroup({
        groupDetails: {
          type: 'party',
@@ -96,15 +95,13 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
      await member.post('/user/class/cast/mpheal');

      let [skillMsg] = await member.get(`/groups/${group.id}/chat`);
-      await expect(member.post(`/groups/${group._id}/chat/${skillMsg.id}/flag`))
-        .to.eventually.be.rejected.and.eql({
-          code: 400,
-          error: 'BadRequest',
-          message: t('messageCannotFlagSystemMessages', {communityManagerEmail: config.EMAILS.COMMUNITY_MANAGER_EMAIL}),
-        });
-      // let messages = await members[0].get(`/groups/${group._id}/chat`);
-      // expect(messages[0].id).to.eql(skillMsg.id);
-      // expect(messages[0].flagCount).to.eql(0);
+
+      await member.post(`/groups/${group._id}/chat/${skillMsg.id}/flag`);
+      await admin.post(`/groups/${group._id}/chat/${skillMsg.id}/clearflags`);
+
+      let messages = await members[0].get(`/groups/${group._id}/chat`);
+      expect(messages[0].id).to.eql(skillMsg.id);
+      expect(messages[0].flagCount).to.eql(0);
    });
  });

@@ -1,8 +1,8 @@
 import {
  generateUser,
+  translate as t,
  resetHabiticaDB,
 } from '../../../../helpers/api-v3-integration.helper';
-import apiMessages from '../../../../../website/server/libs/apiMessages';

 describe('GET /coupons/', () => {
  let user;
@@ -19,7 +19,7 @@ describe('GET /coupons/', () => {
    await expect(user.get('/coupons')).to.eventually.be.rejected.and.eql({
      code: 401,
      error: 'NotAuthorized',
-      message: apiMessages('noSudoAccess'),
+      message: t('noSudoAccess'),
    });
  });

@@ -4,7 +4,6 @@ import {
  resetHabiticaDB,
 } from '../../../../helpers/api-v3-integration.helper';
 import couponCode from 'coupon-code';
-import apiMessages from '../../../../../website/server/libs/apiMessages';

 describe('POST /coupons/generate/:event', () => {
  let user;
@@ -26,7 +25,7 @@ describe('POST /coupons/generate/:event', () => {
    await expect(user.post('/coupons/generate/aaa')).to.eventually.be.rejected.and.eql({
      code: 401,
      error: 'NotAuthorized',
-      message: apiMessages('noSudoAccess'),
+      message: t('noSudoAccess'),
    });
  });

@@ -4,7 +4,7 @@ import {
 } from '../../../../helpers/api-v3-integration.helper';
 import { v4 as generateUUID } from 'uuid';

-xdescribe('GET /export/avatar-:memberId.html', () => {
+describe('GET /export/avatar-:memberId.html', () => {
  let user;

  before(async () => {
@@ -161,19 +161,4 @@ describe('GET /groups/:groupId/members', () => {
    let resIds = res.concat(res2).map(member => member._id);
    expect(resIds).to.eql(expectedIds.sort());
  });
-
-  it('searches members', async () => {
-    let group = await generateGroup(user, {type: 'party', name: generateUUID()});
-
-    let usersToGenerate = [];
-    for (let i = 0; i < 2; i++) {
-      usersToGenerate.push(generateUser({party: {_id: group._id}}));
-    }
-    const usersCreated = await Promise.all(usersToGenerate);
-    const userToSearch = usersCreated[0].profile.name;
-
-    let res = await user.get(`/groups/party/members?search=${userToSearch}`);
-    expect(res.length).to.equal(1);
-    expect(res[0].profile.name).to.equal(userToSearch);
-  });
 });
@@ -10,8 +10,6 @@ import { v4 as generateUUID } from 'uuid';
 import {
  each,
 } from 'lodash';
-import { model as User } from '../../../../../website/server/models/user';
-import * as payments from '../../../../../website/server/libs/payments';

 describe('POST /groups/:groupId/leave', () => {
  let typesOfGroups = {
@@ -266,45 +264,4 @@ describe('POST /groups/:groupId/leave', () => {
      expect(userWithNonExistentParty.party).to.eql({});
    });
  });
-
-  context('Leaving a group plan', () => {
-    it('cancels the free subscription', async () => {
-      // Create group
-      let { group, groupLeader, members } = await createAndPopulateGroup({
-        groupDetails: {
-          name: 'Test Private Guild',
-          type: 'guild',
-        },
-        members: 1,
-      });
-
-      let leader = groupLeader;
-      let member = members[0];
-      let userWithFreePlan = await User.findById(leader._id).exec();
-
-      // Create subscription
-      let paymentData = {
-        user: userWithFreePlan,
-        groupId: group._id,
-        sub: {
-          key: 'basic_3mo',
-        },
-        customerId: 'customer-id',
-        paymentMethod: 'Payment Method',
-        headers: {
-          'x-client': 'habitica-web',
-          'user-agent': '',
-        },
-      };
-      await payments.createSubscription(paymentData);
-      await member.sync();
-      expect(member.purchased.plan.planId).to.equal('group_plan_auto');
-      expect(member.purchased.plan.dateTerminated).to.not.exist;
-
-      // Leave
-      await member.post(`/groups/${group._id}/leave`);
-      await member.sync();
-      expect(member.purchased.plan.dateTerminated).to.exist;
-    });
-  });
 });
@@ -118,56 +118,4 @@ describe('POST /members/send-private-message', () => {
    expect(sendersMessageInReceiversInbox).to.exist;
    expect(sendersMessageInSendersInbox).to.exist;
  });
-
-  it('allows admin to send when sender has blocked the admin', async () => {
-    userToSendMessage = await generateUser({
-      'contributor.admin': 1,
-    });
-    const receiver = await generateUser({'inbox.blocks': [userToSendMessage._id]});
-
-    await userToSendMessage.post('/members/send-private-message', {
-      message: messageToSend,
-      toUserId: receiver._id,
-    });
-
-    const updatedReceiver = await receiver.get('/user');
-    const updatedSender = await userToSendMessage.get('/user');
-
-    const sendersMessageInReceiversInbox = _.find(updatedReceiver.inbox.messages, (message) => {
-      return message.uuid === userToSendMessage._id && message.text === messageToSend;
-    });
-
-    const sendersMessageInSendersInbox = _.find(updatedSender.inbox.messages, (message) => {
-      return message.uuid === receiver._id && message.text === messageToSend;
-    });
-
-    expect(sendersMessageInReceiversInbox).to.exist;
-    expect(sendersMessageInSendersInbox).to.exist;
-  });
-
-  it('allows admin to send when to user has opted out of messaging', async () => {
-    userToSendMessage = await generateUser({
-      'contributor.admin': 1,
-    });
-    const receiver = await generateUser({'inbox.optOut': true});
-
-    await userToSendMessage.post('/members/send-private-message', {
-      message: messageToSend,
-      toUserId: receiver._id,
-    });
-
-    const updatedReceiver = await receiver.get('/user');
-    const updatedSender = await userToSendMessage.get('/user');
-
-    const sendersMessageInReceiversInbox = _.find(updatedReceiver.inbox.messages, (message) => {
-      return message.uuid === userToSendMessage._id && message.text === messageToSend;
-    });
-
-    const sendersMessageInSendersInbox = _.find(updatedSender.inbox.messages, (message) => {
-      return message.uuid === receiver._id && message.text === messageToSend;
-    });
-
-    expect(sendersMessageInReceiversInbox).to.exist;
-    expect(sendersMessageInSendersInbox).to.exist;
-  });
 });
@@ -13,44 +13,14 @@ describe('POST /notifications/:notificationId/read', () => {

  it('errors when notification is not found', async () => {
    let dummyId = generateUUID();
-
-    await expect(user.post(`/notifications/${dummyId}/read`)).to.eventually.be.rejected.and.eql({
-      code: 404,
-      error: 'NotFound',
-      message: t('messageNotificationNotFound'),
-    });
+    await expect(user.post(`/notifications/${dummyId}/read`))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('messageNotificationNotFound'),
+      });
  });

-  it('removes a notification', async () => {
-    expect(user.notifications.length).to.equal(0);
-
-    const id = generateUUID();
-    const id2 = generateUUID();
-
-    await user.update({
-      notifications: [{
-        id,
-        type: 'DROPS_ENABLED',
-        data: {},
-      }, {
-        id: id2,
-        type: 'LOGIN_INCENTIVE',
-        data: {},
-      }],
-    });
-
-    await user.sync();
-    expect(user.notifications.length).to.equal(2);
-
-    const res = await user.post(`/notifications/${id}/read`);
-    expect(res).to.deep.equal([{
-      id: id2,
-      type: 'LOGIN_INCENTIVE',
-      data: {},
-    }]);
-
-    await user.sync();
-    expect(user.notifications.length).to.equal(1);
-    expect(user.notifications[0].id).to.equal(id2);
+  xit('removes a notification', async () => {
  });
 });
@@ -1,66 +0,0 @@
-import {
-  generateUser,
-  translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
-import { v4 as generateUUID } from 'uuid';
-
-describe('POST /notifications/:notificationId/read', () => {
-  let user;
-
-  before(async () => {
-    user = await generateUser();
-  });
-
-  it('errors when notification is not found', async () => {
-    let dummyId = generateUUID();
-
-    await expect(user.post('/notifications/read', {
-      notificationIds: [dummyId],
-    })).to.eventually.be.rejected.and.eql({
-      code: 404,
-      error: 'NotFound',
-      message: t('messageNotificationNotFound'),
-    });
-  });
-
-  it('removes multiple notifications', async () => {
-    expect(user.notifications.length).to.equal(0);
-
-    const id = generateUUID();
-    const id2 = generateUUID();
-    const id3 = generateUUID();
-
-    await user.update({
-      notifications: [{
-        id,
-        type: 'DROPS_ENABLED',
-        data: {},
-      }, {
-        id: id2,
-        type: 'LOGIN_INCENTIVE',
-        data: {},
-      }, {
-        id: id3,
-        type: 'CRON',
-        data: {},
-      }],
-    });
-
-    await user.sync();
-    expect(user.notifications.length).to.equal(3);
-
-    const res = await user.post('/notifications/read', {
-      notificationIds: [id, id3],
-    });
-
-    expect(res).to.deep.equal([{
-      id: id2,
-      type: 'LOGIN_INCENTIVE',
-      data: {},
-    }]);
-
-    await user.sync();
-    expect(user.notifications.length).to.equal(1);
-    expect(user.notifications[0].id).to.equal(id2);
-  });
-});
@@ -141,16 +141,6 @@ describe('DELETE /tasks/:id', () => {
      });
    });

-    it('removes a task from user.tasksOrder', async () => {
-      let task = await user.post('/tasks/user', {
-        text: 'test habit',
-        type: 'habit',
-      });
-
-      await user.del(`/tasks/${task._id}`);
-      await user.sync();
-
-      expect(user.tasksOrder.habits.indexOf(task._id)).to.eql(-1);
-    });
+    it('removes a task from user.tasksOrder'); // TODO
  });
 });
@@ -130,7 +130,6 @@ describe('POST /tasks/:id/score/:direction', () => {
    });

    it('uncompletes todo when direction is down', async () => {
-      await user.post(`/tasks/${todo._id}/score/up`);
      await user.post(`/tasks/${todo._id}/score/down`);
      let updatedTask = await user.get(`/tasks/${todo._id}`);

@@ -138,23 +137,9 @@ describe('POST /tasks/:id/score/:direction', () => {
      expect(updatedTask.dateCompleted).to.be.a('undefined');
    });

-    it('doesn\'t let a todo be completed twice', async () => {
-      await user.post(`/tasks/${todo._id}/score/up`);
-      await expect(user.post(`/tasks/${todo._id}/score/up`))
-      .to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('sessionOutdated'),
-      });
-    });
+    it('scores up todo even if it is already completed'); // Yes?

-    it('doesn\'t let a todo be uncompleted twice', async () => {
-      await expect(user.post(`/tasks/${todo._id}/score/down`)).to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('sessionOutdated'),
-      });
-    });
+    it('scores down todo even if it is already uncompleted'); // Yes?

    context('user stats when direction is up', () => {
      let updatedUser;
@@ -178,25 +163,23 @@ describe('POST /tasks/:id/score/:direction', () => {
    });

    context('user stats when direction is down', () => {
-      let updatedUser, initialUser;
+      let updatedUser;

      beforeEach(async () => {
-        await user.post(`/tasks/${todo._id}/score/up`);
-        initialUser = await user.get('/user');
        await user.post(`/tasks/${todo._id}/score/down`);
        updatedUser = await user.get('/user');
      });

      it('decreases user\'s mp', () => {
-        expect(updatedUser.stats.mp).to.be.lessThan(initialUser.stats.mp);
+        expect(updatedUser.stats.mp).to.be.lessThan(user.stats.mp);
      });

      it('decreases user\'s exp', () => {
-        expect(updatedUser.stats.exp).to.be.lessThan(initialUser.stats.exp);
+        expect(updatedUser.stats.exp).to.be.lessThan(user.stats.exp);
      });

      it('decreases user\'s gold', () => {
-        expect(updatedUser.stats.gp).to.be.lessThan(initialUser.stats.gp);
+        expect(updatedUser.stats.gp).to.be.lessThan(user.stats.gp);
      });
    });
  });
@@ -219,7 +202,6 @@ describe('POST /tasks/:id/score/:direction', () => {
    });

    it('uncompletes daily when direction is down', async () => {
-      await user.post(`/tasks/${daily._id}/score/up`);
      await user.post(`/tasks/${daily._id}/score/down`);
      let task = await user.get(`/tasks/${daily._id}`);

@@ -240,22 +222,9 @@ describe('POST /tasks/:id/score/:direction', () => {
      expect(task.nextDue.length).to.eql(6);
    });

-    it('doesn\'t let a daily be completed twice', async () => {
-      await user.post(`/tasks/${daily._id}/score/up`);
-      await expect(user.post(`/tasks/${daily._id}/score/up`)).to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('sessionOutdated'),
-      });
-    });
+    it('scores up daily even if it is already completed'); // Yes?

-    it('doesn\'t let a daily be uncompleted twice', async () => {
-      await expect(user.post(`/tasks/${daily._id}/score/down`)).to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('sessionOutdated'),
-      });
-    });
+    it('scores down daily even if it is already uncompleted'); // Yes?

    context('user stats when direction is up', () => {
      let updatedUser;
@@ -279,25 +248,23 @@ describe('POST /tasks/:id/score/:direction', () => {
    });

    context('user stats when direction is down', () => {
-      let updatedUser, initialUser;
+      let updatedUser;

      beforeEach(async () => {
-        await user.post(`/tasks/${daily._id}/score/up`);
-        initialUser = await user.get('/user');
        await user.post(`/tasks/${daily._id}/score/down`);
        updatedUser = await user.get('/user');
      });

      it('decreases user\'s mp', () => {
-        expect(updatedUser.stats.mp).to.be.lessThan(initialUser.stats.mp);
+        expect(updatedUser.stats.mp).to.be.lessThan(user.stats.mp);
      });

      it('decreases user\'s exp', () => {
-        expect(updatedUser.stats.exp).to.be.lessThan(initialUser.stats.exp);
+        expect(updatedUser.stats.exp).to.be.lessThan(user.stats.exp);
      });

      it('decreases user\'s gold', () => {
-        expect(updatedUser.stats.gp).to.be.lessThan(initialUser.stats.gp);
+        expect(updatedUser.stats.gp).to.be.lessThan(user.stats.gp);
      });
    });
  });
@@ -40,13 +40,9 @@ describe('POST /tasks/:taskId/move/to/:position', () => {

    let taskToMove = tasks[1];
    expect(taskToMove.text).to.equal('habit 2');
-
    let newOrder = await user.post(`/tasks/${tasks[1]._id}/move/to/3`);
-    await user.sync();
-
    expect(newOrder[3]).to.equal(taskToMove._id);
    expect(newOrder.length).to.equal(5);
-    expect(user.tasksOrder.habits).to.eql(newOrder);
  });

  it('can move task to new position using alias', async () => {
@@ -302,17 +302,6 @@ describe('POST /tasks/user', () => {

      expect(task.alias).to.eql('a_alias012');
    });
-
-    // This is a special case for iOS requests
-    it('will round a priority (difficulty)', async () => {
-      let task = await user.post('/tasks/user', {
-        text: 'test habit',
-        type: 'habit',
-        priority: 0.10000000000005,
-      });
-
-      expect(task.priority).to.eql(0.1);
-    });
  });

  context('habits', () => {
@@ -639,43 +628,6 @@ describe('POST /tasks/user', () => {
      });
    });

-    it('returns an error if everyX is a non int', async () => {
-      await expect(user.post('/tasks/user', {
-        text: 'test daily',
-        type: 'daily',
-        everyX: 2.5,
-      })).to.eventually.be.rejected.and.eql({
-        code: 400,
-        error: 'BadRequest',
-        message: 'daily validation failed',
-      });
-    });
-
-    it('returns an error if everyX is negative', async () => {
-      await expect(user.post('/tasks/user', {
-        text: 'test daily',
-        type: 'daily',
-        everyX: -1,
-      })).to.eventually.be.rejected.and.eql({
-        code: 400,
-        error: 'BadRequest',
-        message: 'daily validation failed',
-      });
-    });
-
-    it('returns an error if everyX is above 9999', async () => {
-      await expect(user.post('/tasks/user', {
-        text: 'test daily',
-        type: 'daily',
-        everyX: 10000,
-      })).to.eventually.be.rejected.and.eql({
-        code: 400,
-        error: 'BadRequest',
-        message: 'daily validation failed',
-      });
-    });
-
-
    it('can create checklists', async () => {
      let task = await user.post('/tasks/user', {
        text: 'test daily',
@@ -82,13 +82,6 @@ describe('POST /tasks/:id/score/:direction', () => {
    });

    it('should update the history', async () => {
-      let newCron = new Date(2015, 11, 20);
-
-      await user.post('/debug/set-cron', {
-        lastCron: newCron,
-      });
-
-      await user.post('/cron');
      await user.post(`/tasks/${usersChallengeTaskId}/score/up`);

      let tasks = await user.get(`/tasks/challenge/${challenge._id}`);
@@ -41,9 +41,8 @@ describe('POST /tasks/:id/score/:direction', () => {

    let memberTasks = await member.get('/tasks/user');
    let syncedTask = find(memberTasks, findAssignedTask);
-    const direction = 'up';

-    await expect(member.post(`/tasks/${syncedTask._id}/score/${direction}`))
+    await expect(member.post(`/tasks/${syncedTask._id}/score/up`))
      .to.eventually.be.rejected.and.to.eql({
        code: 401,
        error: 'NotAuthorized',
@@ -59,7 +58,6 @@ describe('POST /tasks/:id/score/:direction', () => {
      user: member.auth.local.username,
      taskName: updatedTask.text,
      taskId: updatedTask._id,
-      direction,
    }, 'cs')); // This test only works if we have the notification translated
    expect(user.notifications[1].data.groupId).to.equal(guild._id);

@@ -73,9 +71,8 @@ describe('POST /tasks/:id/score/:direction', () => {
    });
    let memberTasks = await member.get('/tasks/user');
    let syncedTask = find(memberTasks, findAssignedTask);
-    const direction = 'up';

-    await expect(member.post(`/tasks/${syncedTask._id}/score/${direction}`))
+    await expect(member.post(`/tasks/${syncedTask._id}/score/up`))
      .to.eventually.be.rejected.and.to.eql({
        code: 401,
        error: 'NotAuthorized',
@@ -91,7 +88,6 @@ describe('POST /tasks/:id/score/:direction', () => {
      user: member.auth.local.username,
      taskName: updatedTask.text,
      taskId: updatedTask._id,
-      direction,
    }));
    expect(user.notifications[1].data.groupId).to.equal(guild._id);

@@ -101,7 +97,6 @@ describe('POST /tasks/:id/score/:direction', () => {
      user: member.auth.local.username,
      taskName: updatedTask.text,
      taskId: updatedTask._id,
-      direction,
    }));
    expect(member2.notifications[0].data.groupId).to.equal(guild._id);
  });
@@ -75,6 +75,15 @@ describe('POST /tasks/:taskId/unassign/:memberId', () => {
      });
  });

+  it('returns error when non leader tries to create a task', async () => {
+    await expect(member.post(`/tasks/${task._id}/unassign/${member._id}`))
+      .to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('onlyGroupLeaderCanEditTasks'),
+      });
+  });
+
  it('unassigns a user from a task', async () => {
    await user.post(`/tasks/${task._id}/unassign/${member._id}`);

@@ -120,26 +129,4 @@ describe('POST /tasks/:taskId/unassign/:memberId', () => {
    expect(groupTask[0].group.assignedUsers).to.not.contain(member._id);
    expect(syncedTask).to.not.exist;
  });
-
-  it('allows a user to unassign themselves', async () => {
-    await member.post(`/tasks/${task._id}/unassign/${member._id}`);
-
-    let groupTask = await user.get(`/tasks/group/${guild._id}`);
-    let memberTasks = await member.get('/tasks/user');
-    let syncedTask = find(memberTasks, findAssignedTask);
-
-    expect(groupTask[0].group.assignedUsers).to.not.contain(member._id);
-    expect(syncedTask).to.not.exist;
-  });
-
-  // @TODO: Which do we want? The user to unassign themselves or not. This test was in
-  // here, but then we had a request to allow to unaissgn.
-  xit('returns error when non leader tries to unassign their a task', async () => {
-    await expect(member.post(`/tasks/${task._id}/unassign/${member._id}`))
-      .to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('onlyGroupLeaderCanEditTasks'),
-      });
-  });
 });
@@ -308,7 +308,7 @@ describe('DELETE /user', () => {
      })).to.eventually.be.rejected.and.eql({
        code: 401,
        error: 'NotAuthorized',
-        message: t('incorrectDeletePhrase', {magicWord: 'DELETE'}),
+        message: t('incorrectDeletePhrase'),
      });
    });

@@ -27,13 +27,4 @@ describe('GET /user', () => {
    expect(returnedUser.auth.local.salt).to.not.exist;
    expect(returnedUser.apiToken).to.not.exist;
  });
-
-  it('returns only user properties requested', async () => {
-    let returnedUser = await user.get('/user?userFields=achievements,items.mounts');
-
-    expect(returnedUser._id).to.equal(user._id);
-    expect(returnedUser.achievements).to.exist;
-    expect(returnedUser.items.mounts).to.exist;
-    expect(returnedUser.stats).to.not.exist;
-  });
 });
@@ -1,7 +1,7 @@
 import {
  generateUser,
  translate as t,
-} from '../../../../../helpers/api-integration/v3';
+} from '../../../../helpers/api-integration/v3';

 describe('POST /user/allocate', () => {
  let user;
@@ -1,6 +1,6 @@
 import {
  generateUser,
-} from '../../../../../helpers/api-integration/v3';
+} from '../../../../helpers/api-integration/v3';

 describe('POST /user/allocate-now', () => {
  // More tests in common code unit tests
@@ -3,8 +3,8 @@
 import {
  generateUser,
  translate as t,
-} from '../../../../../helpers/api-integration/v3';
-import shared from '../../../../../../website/common/script';
+} from '../../../../helpers/api-integration/v3';
+import shared from '../../../../../website/common/script';

 let content = shared.content;

@@ -82,19 +82,4 @@ describe('POST /user/buy/:key', () => {
      itemText: item.text(),
    }));
  });
-
-  it('allows for bulk purchases', async () => {
-    await user.update({
-      'stats.gp': 400,
-      'stats.hp': 20,
-    });
-
-    let potion = content.potion;
-    let res = await user.post('/user/buy/potion', {quantity: 2});
-    await user.sync();
-
-    expect(user.stats.hp).to.equal(50);
-    expect(res.data).to.eql(user.stats);
-    expect(res.message).to.equal(t('messageBought', {itemText: potion.text()}));
-  });
 });
@@ -1,7 +1,7 @@
 import {
  generateUser,
  translate as t,
-} from '../../../../../helpers/api-integration/v3';
+} from '../../../../helpers/api-integration/v3';

 describe('POST /user/buy-armoire', () => {
  let user;
@@ -0,0 +1,36 @@
+/* eslint-disable camelcase */
+
+import {
+  generateUser,
+  translate as t,
+} from '../../../../helpers/api-integration/v3';
+
+describe('POST /user/buy-gear/:key', () => {
+  let user;
+
+  beforeEach(async () => {
+    user = await generateUser({
+      'stats.gp': 400,
+    });
+  });
+
+  // More tests in common code unit tests
+
+  it('returns an error if the item is not found', async () => {
+    await expect(user.post('/user/buy-gear/notExisting'))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('itemNotFound', {key: 'notExisting'}),
+      });
+  });
+
+  it('buys a piece of gear', async () => {
+    let key = 'armor_warrior_1';
+
+    await user.post(`/user/buy-gear/${key}`);
+    await user.sync();
+
+    expect(user.items.gear.owned.armor_warrior_1).to.eql(true);
+  });
+});
@@ -1,8 +1,8 @@
 import {
  generateUser,
  translate as t,
-} from '../../../../../helpers/api-integration/v3';
-import shared from '../../../../../../website/common/script';
+} from '../../../../helpers/api-integration/v3';
+import shared from '../../../../../website/common/script';

 let content = shared.content;

@@ -1,7 +1,7 @@
 import {
  generateUser,
  translate as t,
-} from '../../../../../helpers/api-integration/v3';
+} from '../../../../helpers/api-integration/v3';

 describe('POST /user/buy-mystery-set/:key', () => {
  let user;
@@ -1,8 +1,8 @@
 import {
  generateUser,
  translate as t,
-} from '../../../../../helpers/api-integration/v3';
-import shared from '../../../../../../website/common/script';
+} from '../../../../helpers/api-integration/v3';
+import shared from '../../../../../website/common/script';

 let content = shared.content;

@@ -1,8 +1,8 @@
 import {
  generateUser,
  translate as t,
-} from '../../../../../helpers/api-integration/v3';
-import shared from '../../../../../../website/common/script';
+} from '../../../../helpers/api-integration/v3';
+import shared from '../../../../../website/common/script';

 let content = shared.content;

@@ -98,24 +98,4 @@ describe('POST /user/purchase/:type/:key', () => {
    await members[0].sync();
    expect(members[0].balance).to.equal(oldBalance);
  });
-
-  describe('bulk purchasing', () => {
-    it('purchases a gem item', async () => {
-      await user.post(`/user/purchase/${type}/${key}`, {quantity: 2});
-      await user.sync();
-
-      expect(user.items[type][key]).to.equal(2);
-    });
-
-    it('can convert gold to gems if subscribed', async () => {
-      let oldBalance = user.balance;
-      await user.update({
-        'purchased.plan.customerId': 'group-plan',
-        'stats.gp': 1000,
-      });
-      await user.post('/user/purchase/gems/gem', {quantity: 2});
-      await user.sync();
-      expect(user.balance).to.equal(oldBalance + 0.50);
-    });
-  });
 });
@@ -1,56 +0,0 @@
-/* eslint-disable camelcase */
-
-import {
-  generateUser,
-  translate as t,
-} from '../../../../../helpers/api-integration/v3';
-
-describe('POST /user/buy-gear/:key', () => {
-  let user;
-
-  beforeEach(async () => {
-    user = await generateUser({
-      'stats.gp': 400,
-    });
-  });
-
-  // More tests in common code unit tests
-
-  it('returns an error if the item is not found', async () => {
-    await expect(user.post('/user/buy-gear/notExisting'))
-      .to.eventually.be.rejected.and.eql({
-        code: 404,
-        error: 'NotFound',
-        message: t('itemNotFound', {key: 'notExisting'}),
-      });
-  });
-
-  it('buys the first level weapon gear', async () => {
-    let key = 'weapon_warrior_0';
-
-    await user.post(`/user/buy-gear/${key}`);
-    await user.sync();
-
-    expect(user.items.gear.owned[key]).to.eql(true);
-  });
-
-  it('buys the first level armor gear', async () => {
-    let key = 'armor_warrior_1';
-
-    await user.post(`/user/buy-gear/${key}`);
-    await user.sync();
-
-    expect(user.items.gear.owned[key]).to.eql(true);
-  });
-
-  it('tries to buy subsequent, level gear', async () => {
-    let key = 'armor_warrior_2';
-
-    return expect(user.post(`/user/buy-gear/${key}`))
-      .to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: 'You need to purchase a lower level gear before this one.',
-      });
-  });
-});
@@ -1,40 +0,0 @@
-import {
-  generateUser,
-  translate as t,
-} from '../../../../../helpers/api-integration/v3';
-
-describe('POST /user/allocate-bulk', () => {
-  let user;
-  const statsUpdate = {
-    stats: {
-      con: 1,
-      str: 2,
-    },
-  };
-
-  beforeEach(async () => {
-    user = await generateUser();
-  });
-
-  // More tests in common code unit tests
-
-  it('returns an error if user does not have enough points', async () => {
-    await expect(user.post('/user/allocate-bulk', statsUpdate))
-      .to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('notEnoughAttrPoints'),
-      });
-  });
-
-  it('allocates attribute points', async () => {
-    await user.update({'stats.points': 3});
-
-    await user.post('/user/allocate-bulk', statsUpdate);
-    await user.sync();
-
-    expect(user.stats.con).to.equal(1);
-    expect(user.stats.str).to.equal(2);
-    expect(user.stats.points).to.equal(0);
-  });
-});
@@ -0,0 +1,739 @@
+import moment from 'moment';
+import cc from 'coupon-code';
+import uuid from 'uuid';
+
+import {
+  generateGroup,
+} from '../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../website/server/models/user';
+import { model as Group } from '../../../../../website/server/models/group';
+import { model as Coupon } from '../../../../../website/server/models/coupon';
+import amzLib from '../../../../../website/server/libs/amazonPayments';
+import payments from '../../../../../website/server/libs/payments';
+import common from '../../../../../website/common';
+
+const i18n = common.i18n;
+
+describe('Amazon Payments', () => {
+  let subKey = 'basic_3mo';
+
+  describe('checkout', () => {
+    let user, orderReferenceId, headers;
+    let setOrderReferenceDetailsSpy;
+    let confirmOrderReferenceSpy;
+    let authorizeSpy;
+    let closeOrderReferenceSpy;
+
+    let paymentBuyGemsStub;
+    let paymentCreateSubscritionStub;
+    let amount = 5;
+
+    function expectAmazonStubs () {
+      expect(setOrderReferenceDetailsSpy).to.be.calledOnce;
+      expect(setOrderReferenceDetailsSpy).to.be.calledWith({
+        AmazonOrderReferenceId: orderReferenceId,
+        OrderReferenceAttributes: {
+          OrderTotal: {
+            CurrencyCode: amzLib.constants.CURRENCY_CODE,
+            Amount: amount,
+          },
+          SellerNote: amzLib.constants.SELLER_NOTE,
+          SellerOrderAttributes: {
+            SellerOrderId: common.uuid(),
+            StoreName: amzLib.constants.STORE_NAME,
+          },
+        },
+      });
+
+      expect(confirmOrderReferenceSpy).to.be.calledOnce;
+      expect(confirmOrderReferenceSpy).to.be.calledWith({ AmazonOrderReferenceId: orderReferenceId });
+
+      expect(authorizeSpy).to.be.calledOnce;
+      expect(authorizeSpy).to.be.calledWith({
+        AmazonOrderReferenceId: orderReferenceId,
+        AuthorizationReferenceId: common.uuid().substring(0, 32),
+        AuthorizationAmount: {
+          CurrencyCode: amzLib.constants.CURRENCY_CODE,
+          Amount: amount,
+        },
+        SellerAuthorizationNote: amzLib.constants.SELLER_NOTE,
+        TransactionTimeout: 0,
+        CaptureNow: true,
+      });
+
+      expect(closeOrderReferenceSpy).to.be.calledOnce;
+      expect(closeOrderReferenceSpy).to.be.calledWith({ AmazonOrderReferenceId: orderReferenceId });
+    }
+
+    beforeEach(function () {
+      user = new User();
+      headers = {};
+      orderReferenceId = 'orderReferenceId';
+
+      setOrderReferenceDetailsSpy = sinon.stub(amzLib, 'setOrderReferenceDetails');
+      setOrderReferenceDetailsSpy.returnsPromise().resolves({});
+
+      confirmOrderReferenceSpy = sinon.stub(amzLib, 'confirmOrderReference');
+      confirmOrderReferenceSpy.returnsPromise().resolves({});
+
+      authorizeSpy = sinon.stub(amzLib, 'authorize');
+      authorizeSpy.returnsPromise().resolves({});
+
+      closeOrderReferenceSpy = sinon.stub(amzLib, 'closeOrderReference');
+      closeOrderReferenceSpy.returnsPromise().resolves({});
+
+      paymentBuyGemsStub = sinon.stub(payments, 'buyGems');
+      paymentBuyGemsStub.returnsPromise().resolves({});
+
+      paymentCreateSubscritionStub = sinon.stub(payments, 'createSubscription');
+      paymentCreateSubscritionStub.returnsPromise().resolves({});
+
+      sinon.stub(common, 'uuid').returns('uuid-generated');
+    });
+
+    afterEach(function () {
+      amzLib.setOrderReferenceDetails.restore();
+      amzLib.confirmOrderReference.restore();
+      amzLib.authorize.restore();
+      amzLib.closeOrderReference.restore();
+      payments.buyGems.restore();
+      payments.createSubscription.restore();
+      common.uuid.restore();
+    });
+
+    it('should purchase gems', async () => {
+      sinon.stub(user, 'canGetGems').returnsPromise().resolves(true);
+      await amzLib.checkout({user, orderReferenceId, headers});
+
+      expect(paymentBuyGemsStub).to.be.calledOnce;
+      expect(paymentBuyGemsStub).to.be.calledWith({
+        user,
+        paymentMethod: amzLib.constants.PAYMENT_METHOD,
+        headers,
+      });
+      expectAmazonStubs();
+      expect(user.canGetGems).to.be.calledOnce;
+      user.canGetGems.restore();
+    });
+
+    it('should error if gem amount is too low', async () => {
+      let receivingUser = new User();
+      receivingUser.save();
+      let gift = {
+        type: 'gems',
+        gems: {
+          amount: 0,
+          uuid: receivingUser._id,
+        },
+      };
+
+      await expect(amzLib.checkout({gift, user, orderReferenceId, headers}))
+      .to.eventually.be.rejected.and.to.eql({
+        httpCode: 400,
+        message: 'Amount must be at least 1.',
+        name: 'BadRequest',
+      });
+    });
+
+    it('should error if user cannot get gems gems', async () => {
+      sinon.stub(user, 'canGetGems').returnsPromise().resolves(false);
+      await expect(amzLib.checkout({user, orderReferenceId, headers})).to.eventually.be.rejected.and.to.eql({
+        httpCode: 401,
+        message: i18n.t('groupPolicyCannotGetGems'),
+        name: 'NotAuthorized',
+      });
+      user.canGetGems.restore();
+    });
+
+    it('should gift gems', async () => {
+      let receivingUser = new User();
+      await receivingUser.save();
+      let gift = {
+        type: 'gems',
+        uuid: receivingUser._id,
+        gems: {
+          amount: 16,
+        },
+      };
+      amount = 16 / 4;
+      await amzLib.checkout({gift, user, orderReferenceId, headers});
+
+      expect(paymentBuyGemsStub).to.be.calledOnce;
+      expect(paymentBuyGemsStub).to.be.calledWith({
+        user,
+        paymentMethod: amzLib.constants.PAYMENT_METHOD_GIFT,
+        headers,
+        gift,
+      });
+      expectAmazonStubs();
+    });
+
+    it('should gift a subscription', async () => {
+      let receivingUser = new User();
+      receivingUser.save();
+      let gift = {
+        type: 'subscription',
+        subscription: {
+          key: subKey,
+          uuid: receivingUser._id,
+        },
+      };
+      amount = common.content.subscriptionBlocks[subKey].price;
+
+      await amzLib.checkout({user, orderReferenceId, headers, gift});
+
+      gift.member = receivingUser;
+      expect(paymentCreateSubscritionStub).to.be.calledOnce;
+      expect(paymentCreateSubscritionStub).to.be.calledWith({
+        user,
+        paymentMethod: amzLib.constants.PAYMENT_METHOD_GIFT,
+        headers,
+        gift,
+      });
+      expectAmazonStubs();
+    });
+  });
+
+  describe('subscribe', () => {
+    let user, group, amount, billingAgreementId, sub, coupon, groupId, headers;
+    let amazonSetBillingAgreementDetailsSpy;
+    let amazonConfirmBillingAgreementSpy;
+    let amazongAuthorizeOnBillingAgreementSpy;
+    let createSubSpy;
+
+    beforeEach(async () => {
+      user = new User();
+      user.profile.name = 'sender';
+      user.purchased.plan.customerId = 'customer-id';
+      user.purchased.plan.planId = subKey;
+      user.purchased.plan.lastBillingDate = new Date();
+
+      group = generateGroup({
+        name: 'test group',
+        type: 'guild',
+        privacy: 'public',
+        leader: user._id,
+      });
+      group.purchased.plan.customerId = 'customer-id';
+      group.purchased.plan.planId = subKey;
+      await group.save();
+
+      amount = common.content.subscriptionBlocks[subKey].price;
+      billingAgreementId = 'billingAgreementId';
+      sub = {
+        key: subKey,
+        price: amount,
+      };
+      groupId = group._id;
+      headers = {};
+
+      amazonSetBillingAgreementDetailsSpy = sinon.stub(amzLib, 'setBillingAgreementDetails');
+      amazonSetBillingAgreementDetailsSpy.returnsPromise().resolves({});
+
+      amazonConfirmBillingAgreementSpy = sinon.stub(amzLib, 'confirmBillingAgreement');
+      amazonConfirmBillingAgreementSpy.returnsPromise().resolves({});
+
+      amazongAuthorizeOnBillingAgreementSpy = sinon.stub(amzLib, 'authorizeOnBillingAgreement');
+      amazongAuthorizeOnBillingAgreementSpy.returnsPromise().resolves({});
+
+      createSubSpy = sinon.stub(payments, 'createSubscription');
+      createSubSpy.returnsPromise().resolves({});
+
+      sinon.stub(common, 'uuid').returns('uuid-generated');
+    });
+
+    afterEach(function () {
+      amzLib.setBillingAgreementDetails.restore();
+      amzLib.confirmBillingAgreement.restore();
+      amzLib.authorizeOnBillingAgreement.restore();
+      payments.createSubscription.restore();
+      common.uuid.restore();
+    });
+
+    it('should throw an error if we are missing a subscription', async () => {
+      await expect(amzLib.subscribe({
+        billingAgreementId,
+        coupon,
+        user,
+        groupId,
+        headers,
+      }))
+      .to.eventually.be.rejected.and.to.eql({
+        httpCode: 400,
+        name: 'BadRequest',
+        message: i18n.t('missingSubscriptionCode'),
+      });
+    });
+
+    it('should throw an error if we are missing a billingAgreementId', async () => {
+      await expect(amzLib.subscribe({
+        sub,
+        coupon,
+        user,
+        groupId,
+        headers,
+      }))
+      .to.eventually.be.rejected.and.to.eql({
+        httpCode: 400,
+        name: 'BadRequest',
+        message: 'Missing req.body.billingAgreementId',
+      });
+    });
+
+    it('should throw an error when coupon code is missing', async () => {
+      sub.discount = 40;
+
+      await expect(amzLib.subscribe({
+        billingAgreementId,
+        sub,
+        coupon,
+        user,
+        groupId,
+        headers,
+      }))
+      .to.eventually.be.rejected.and.to.eql({
+        httpCode: 400,
+        name: 'BadRequest',
+        message: i18n.t('couponCodeRequired'),
+      });
+    });
+
+    it('should throw an error when coupon code is invalid', async () => {
+      sub.discount = 40;
+      sub.key = 'google_6mo';
+      coupon = 'example-coupon';
+
+      let couponModel = new Coupon();
+      couponModel.event = 'google_6mo';
+      await couponModel.save();
+
+      sinon.stub(cc, 'validate').returns('invalid');
+
+      await expect(amzLib.subscribe({
+        billingAgreementId,
+        sub,
+        coupon,
+        user,
+        groupId,
+        headers,
+      }))
+      .to.eventually.be.rejected.and.to.eql({
+        httpCode: 401,
+        name: 'NotAuthorized',
+        message: i18n.t('invalidCoupon'),
+      });
+      cc.validate.restore();
+    });
+
+    it('subscribes with amazon with a coupon', async () => {
+      sub.discount = 40;
+      sub.key = 'google_6mo';
+      coupon = 'example-coupon';
+
+      let couponModel = new Coupon();
+      couponModel.event = 'google_6mo';
+      let updatedCouponModel = await couponModel.save();
+
+      sinon.stub(cc, 'validate').returns(updatedCouponModel._id);
+
+      await amzLib.subscribe({
+        billingAgreementId,
+        sub,
+        coupon,
+        user,
+        groupId,
+        headers,
+      });
+
+      expect(createSubSpy).to.be.calledOnce;
+      expect(createSubSpy).to.be.calledWith({
+        user,
+        customerId: billingAgreementId,
+        paymentMethod: amzLib.constants.PAYMENT_METHOD,
+        sub,
+        headers,
+        groupId,
+      });
+
+      cc.validate.restore();
+    });
+
+    it('subscribes with amazon', async () => {
+      await amzLib.subscribe({
+        billingAgreementId,
+        sub,
+        coupon,
+        user,
+        groupId,
+        headers,
+      });
+
+      expect(amazonSetBillingAgreementDetailsSpy).to.be.calledOnce;
+      expect(amazonSetBillingAgreementDetailsSpy).to.be.calledWith({
+        AmazonBillingAgreementId: billingAgreementId,
+        BillingAgreementAttributes: {
+          SellerNote: amzLib.constants.SELLER_NOTE_SUBSCRIPTION,
+          SellerBillingAgreementAttributes: {
+            SellerBillingAgreementId: common.uuid(),
+            StoreName: amzLib.constants.STORE_NAME,
+            CustomInformation: amzLib.constants.SELLER_NOTE_SUBSCRIPTION,
+          },
+        },
+      });
+
+      expect(amazonConfirmBillingAgreementSpy).to.be.calledOnce;
+      expect(amazonConfirmBillingAgreementSpy).to.be.calledWith({
+        AmazonBillingAgreementId: billingAgreementId,
+      });
+
+      expect(amazongAuthorizeOnBillingAgreementSpy).to.be.calledOnce;
+      expect(amazongAuthorizeOnBillingAgreementSpy).to.be.calledWith({
+        AmazonBillingAgreementId: billingAgreementId,
+        AuthorizationReferenceId: common.uuid().substring(0, 32),
+        AuthorizationAmount: {
+          CurrencyCode: amzLib.constants.CURRENCY_CODE,
+          Amount: amount,
+        },
+        SellerAuthorizationNote: amzLib.constants.SELLER_NOTE_ATHORIZATION_SUBSCRIPTION,
+        TransactionTimeout: 0,
+        CaptureNow: true,
+        SellerNote: amzLib.constants.SELLER_NOTE_ATHORIZATION_SUBSCRIPTION,
+        SellerOrderAttributes: {
+          SellerOrderId: common.uuid(),
+          StoreName: amzLib.constants.STORE_NAME,
+        },
+      });
+
+      expect(createSubSpy).to.be.calledOnce;
+      expect(createSubSpy).to.be.calledWith({
+        user,
+        customerId: billingAgreementId,
+        paymentMethod: amzLib.constants.PAYMENT_METHOD,
+        sub,
+        headers,
+        groupId,
+      });
+    });
+
+    it('subscribes with amazon with price to existing users', async () => {
+      user = new User();
+      user.guilds.push(groupId);
+      await user.save();
+      group.memberCount = 2;
+      await group.save();
+      sub.key = 'group_monthly';
+      sub.price = 9;
+      amount = 12;
+
+      await amzLib.subscribe({
+        billingAgreementId,
+        sub,
+        coupon,
+        user,
+        groupId,
+        headers,
+      });
+
+      expect(amazonSetBillingAgreementDetailsSpy).to.be.calledOnce;
+      expect(amazonSetBillingAgreementDetailsSpy).to.be.calledWith({
+        AmazonBillingAgreementId: billingAgreementId,
+        BillingAgreementAttributes: {
+          SellerNote: amzLib.constants.SELLER_NOTE_SUBSCRIPTION,
+          SellerBillingAgreementAttributes: {
+            SellerBillingAgreementId: common.uuid(),
+            StoreName: amzLib.constants.STORE_NAME,
+            CustomInformation: amzLib.constants.SELLER_NOTE_SUBSCRIPTION,
+          },
+        },
+      });
+
+      expect(amazonConfirmBillingAgreementSpy).to.be.calledOnce;
+      expect(amazonConfirmBillingAgreementSpy).to.be.calledWith({
+        AmazonBillingAgreementId: billingAgreementId,
+      });
+
+      expect(amazongAuthorizeOnBillingAgreementSpy).to.be.calledOnce;
+      expect(amazongAuthorizeOnBillingAgreementSpy).to.be.calledWith({
+        AmazonBillingAgreementId: billingAgreementId,
+        AuthorizationReferenceId: common.uuid().substring(0, 32),
+        AuthorizationAmount: {
+          CurrencyCode: amzLib.constants.CURRENCY_CODE,
+          Amount: amount,
+        },
+        SellerAuthorizationNote: amzLib.constants.SELLER_NOTE_ATHORIZATION_SUBSCRIPTION,
+        TransactionTimeout: 0,
+        CaptureNow: true,
+        SellerNote: amzLib.constants.SELLER_NOTE_ATHORIZATION_SUBSCRIPTION,
+        SellerOrderAttributes: {
+          SellerOrderId: common.uuid(),
+          StoreName: amzLib.constants.STORE_NAME,
+        },
+      });
+
+      expect(createSubSpy).to.be.calledOnce;
+      expect(createSubSpy).to.be.calledWith({
+        user,
+        customerId: billingAgreementId,
+        paymentMethod: amzLib.constants.PAYMENT_METHOD,
+        sub,
+        headers,
+        groupId,
+      });
+    });
+  });
+
+  describe('cancelSubscription', () => {
+    let user, group, headers, billingAgreementId, subscriptionBlock, subscriptionLength;
+    let getBillingAgreementDetailsSpy;
+    let paymentCancelSubscriptionSpy;
+
+    function expectAmazonStubs () {
+      expect(getBillingAgreementDetailsSpy).to.be.calledOnce;
+      expect(getBillingAgreementDetailsSpy).to.be.calledWith({
+        AmazonBillingAgreementId: billingAgreementId,
+      });
+    }
+
+    beforeEach(async () => {
+      user = new User();
+      user.profile.name = 'sender';
+      user.purchased.plan.customerId = 'customer-id';
+      user.purchased.plan.planId = subKey;
+      user.purchased.plan.lastBillingDate = new Date();
+
+      group = generateGroup({
+        name: 'test group',
+        type: 'guild',
+        privacy: 'public',
+        leader: user._id,
+      });
+      group.purchased.plan.customerId = 'customer-id';
+      group.purchased.plan.planId = subKey;
+      group.purchased.plan.lastBillingDate = new Date();
+      await group.save();
+
+      subscriptionBlock = common.content.subscriptionBlocks[subKey];
+      subscriptionLength = subscriptionBlock.months * 30;
+
+      headers = {};
+
+      getBillingAgreementDetailsSpy = sinon.stub(amzLib, 'getBillingAgreementDetails');
+      getBillingAgreementDetailsSpy.returnsPromise().resolves({
+        BillingAgreementDetails: {
+          BillingAgreementStatus: {State: 'Closed'},
+        },
+      });
+
+      paymentCancelSubscriptionSpy = sinon.stub(payments, 'cancelSubscription');
+      paymentCancelSubscriptionSpy.returnsPromise().resolves({});
+    });
+
+    afterEach(function () {
+      amzLib.getBillingAgreementDetails.restore();
+      payments.cancelSubscription.restore();
+    });
+
+    it('should throw an error if we are missing a subscription', async () => {
+      user.purchased.plan.customerId = undefined;
+
+      await expect(amzLib.cancelSubscription({user}))
+        .to.eventually.be.rejected.and.to.eql({
+          httpCode: 401,
+          name: 'NotAuthorized',
+          message: i18n.t('missingSubscription'),
+        });
+    });
+
+    it('should cancel a user subscription', async () => {
+      billingAgreementId = user.purchased.plan.customerId;
+
+      await amzLib.cancelSubscription({user, headers});
+
+      expect(paymentCancelSubscriptionSpy).to.be.calledOnce;
+      expect(paymentCancelSubscriptionSpy).to.be.calledWith({
+        user,
+        groupId: undefined,
+        nextBill: moment(user.purchased.plan.lastBillingDate).add({ days: subscriptionLength }),
+        paymentMethod: amzLib.constants.PAYMENT_METHOD,
+        headers,
+        cancellationReason: undefined,
+      });
+      expectAmazonStubs();
+    });
+
+    it('should close a user subscription if amazon not closed', async () => {
+      amzLib.getBillingAgreementDetails.restore();
+      getBillingAgreementDetailsSpy = sinon.stub(amzLib, 'getBillingAgreementDetails')
+        .returnsPromise()
+        .resolves({
+          BillingAgreementDetails: {
+            BillingAgreementStatus: {State: 'Open'},
+          },
+        });
+      let closeBillingAgreementSpy = sinon.stub(amzLib, 'closeBillingAgreement').returnsPromise().resolves({});
+      billingAgreementId = user.purchased.plan.customerId;
+
+      await amzLib.cancelSubscription({user, headers});
+
+      expectAmazonStubs();
+      expect(closeBillingAgreementSpy).to.be.calledOnce;
+      expect(closeBillingAgreementSpy).to.be.calledWith({
+        AmazonBillingAgreementId: billingAgreementId,
+      });
+      expect(paymentCancelSubscriptionSpy).to.be.calledOnce;
+      expect(paymentCancelSubscriptionSpy).to.be.calledWith({
+        user,
+        groupId: undefined,
+        nextBill: moment(user.purchased.plan.lastBillingDate).add({ days: subscriptionLength }),
+        paymentMethod: amzLib.constants.PAYMENT_METHOD,
+        headers,
+        cancellationReason: undefined,
+      });
+      amzLib.closeBillingAgreement.restore();
+    });
+
+    it('should throw an error if group is not found', async () => {
+      await expect(amzLib.cancelSubscription({user, groupId: 'fake-id'}))
+        .to.eventually.be.rejected.and.to.eql({
+          httpCode: 404,
+          name: 'NotFound',
+          message: i18n.t('groupNotFound'),
+        });
+    });
+
+    it('should throw an error if user is not group leader', async () => {
+      let nonLeader = new User();
+      nonLeader.guilds.push(group._id);
+      await nonLeader.save();
+
+      await expect(amzLib.cancelSubscription({user: nonLeader, groupId: group._id}))
+        .to.eventually.be.rejected.and.to.eql({
+          httpCode: 401,
+          name: 'NotAuthorized',
+          message: i18n.t('onlyGroupLeaderCanManageSubscription'),
+        });
+    });
+
+    it('should cancel a group subscription', async () => {
+      billingAgreementId = group.purchased.plan.customerId;
+
+      await amzLib.cancelSubscription({user, groupId: group._id, headers});
+
+      expect(paymentCancelSubscriptionSpy).to.be.calledOnce;
+      expect(paymentCancelSubscriptionSpy).to.be.calledWith({
+        user,
+        groupId: group._id,
+        nextBill: moment(group.purchased.plan.lastBillingDate).add({ days: subscriptionLength }),
+        paymentMethod: amzLib.constants.PAYMENT_METHOD,
+        headers,
+        cancellationReason: undefined,
+      });
+      expectAmazonStubs();
+    });
+
+    it('should close a group subscription if amazon not closed', async () => {
+      amzLib.getBillingAgreementDetails.restore();
+      getBillingAgreementDetailsSpy = sinon.stub(amzLib, 'getBillingAgreementDetails')
+        .returnsPromise()
+        .resolves({
+          BillingAgreementDetails: {
+            BillingAgreementStatus: {State: 'Open'},
+          },
+        });
+      let closeBillingAgreementSpy = sinon.stub(amzLib, 'closeBillingAgreement').returnsPromise().resolves({});
+      billingAgreementId = group.purchased.plan.customerId;
+
+      await amzLib.cancelSubscription({user, groupId: group._id, headers});
+
+      expectAmazonStubs();
+      expect(closeBillingAgreementSpy).to.be.calledOnce;
+      expect(closeBillingAgreementSpy).to.be.calledWith({
+        AmazonBillingAgreementId: billingAgreementId,
+      });
+      expect(paymentCancelSubscriptionSpy).to.be.calledOnce;
+      expect(paymentCancelSubscriptionSpy).to.be.calledWith({
+        user,
+        groupId: group._id,
+        nextBill: moment(group.purchased.plan.lastBillingDate).add({ days: subscriptionLength }),
+        paymentMethod: amzLib.constants.PAYMENT_METHOD,
+        headers,
+        cancellationReason: undefined,
+      });
+      amzLib.closeBillingAgreement.restore();
+    });
+  });
+
+  describe('#upgradeGroupPlan', () => {
+    let spy, data, user, group, uuidString;
+
+    beforeEach(async function () {
+      user = new User();
+      user.profile.name = 'sender';
+
+      data = {
+        user,
+        sub: {
+          key: 'basic_3mo', // @TODO: Validate that this is group
+        },
+        customerId: 'customer-id',
+        paymentMethod: 'Payment Method',
+        headers: {
+          'x-client': 'habitica-web',
+          'user-agent': '',
+        },
+      };
+
+      group = generateGroup({
+        name: 'test group',
+        type: 'guild',
+        privacy: 'public',
+        leader: user._id,
+      });
+      await group.save();
+
+      spy = sinon.stub(amzLib, 'authorizeOnBillingAgreement');
+      spy.returnsPromise().resolves([]);
+
+      uuidString = 'uuid-v4';
+      sinon.stub(uuid, 'v4').returns(uuidString);
+
+      data.groupId = group._id;
+      data.sub.quantity = 3;
+    });
+
+    afterEach(function () {
+      sinon.restore(amzLib.authorizeOnBillingAgreement);
+      uuid.v4.restore();
+    });
+
+    it('charges for a new member', async () => {
+      data.paymentMethod = amzLib.constants.PAYMENT_METHOD;
+      await payments.createSubscription(data);
+
+      let updatedGroup = await Group.findById(group._id).exec();
+
+      updatedGroup.memberCount += 1;
+      await updatedGroup.save();
+
+      await amzLib.chargeForAdditionalGroupMember(updatedGroup);
+
+      expect(spy.calledOnce).to.be.true;
+      expect(spy).to.be.calledWith({
+        AmazonBillingAgreementId: updatedGroup.purchased.plan.customerId,
+        AuthorizationReferenceId: uuidString.substring(0, 32),
+        AuthorizationAmount: {
+          CurrencyCode: amzLib.constants.CURRENCY_CODE,
+          Amount: 3,
+        },
+        SellerAuthorizationNote: amzLib.constants.SELLER_NOTE_GROUP_NEW_MEMBER,
+        TransactionTimeout: 0,
+        CaptureNow: true,
+        SellerNote: amzLib.constants.SELLER_NOTE_GROUP_NEW_MEMBER,
+        SellerOrderAttributes: {
+          SellerOrderId: uuidString,
+          StoreName: amzLib.constants.STORE_NAME,
+        },
+      });
+    });
+  });
+});
@@ -0,0 +1,31 @@
+import {
+  getManifestFiles,
+} from '../../../../../website/server/libs/buildManifest';
+
+describe('Build Manifest', () => {
+  describe('getManifestFiles', () => {
+    it('returns an html string', () => {
+      let htmlCode = getManifestFiles('app');
+
+      expect(htmlCode.startsWith('<script') || htmlCode.startsWith('<link')).to.be.true;
+    });
+
+    it('can return only js files', () => {
+      let htmlCode = getManifestFiles('app', 'js');
+
+      expect(htmlCode.indexOf('<link') === -1).to.be.true;
+    });
+
+    it('can return only css files', () => {
+      let htmlCode = getManifestFiles('app', 'css');
+
+      expect(htmlCode.indexOf('<script') === -1).to.be.true;
+    });
+
+    it('throws an error in case the page does not exist', () => {
+      expect(() => {
+        getManifestFiles('strange name here');
+      }).to.throw(Error);
+    });
+  });
+});
@@ -365,72 +365,6 @@ describe('cron', () => {

      expect(user.history.todos).to.be.lengthOf(1);
    });
-
-    it('should remove completed todos from users taskOrder list', () => {
-      tasksByType.todos = [];
-      user.tasksOrder.todos = [];
-      let todo = {
-        text: 'test todo',
-        type: 'todo',
-        value: 0,
-      };
-
-      let task = new Tasks.todo(Tasks.Task.sanitize(todo)); // eslint-disable-line new-cap
-      tasksByType.todos.push(task);
-      task = new Tasks.todo(Tasks.Task.sanitize(todo)); // eslint-disable-line new-cap
-      tasksByType.todos.push(task);
-      tasksByType.todos[0].completed = true;
-
-      user.tasksOrder.todos = tasksByType.todos.map(taskTodo => {
-        return taskTodo._id;
-      });
-      // Since ideally tasksByType should not contain completed todos, fake ids should be filtered too
-      user.tasksOrder.todos.push('00000000-0000-0000-0000-000000000000');
-
-      expect(tasksByType.todos).to.be.lengthOf(2);
-      expect(user.tasksOrder.todos).to.be.lengthOf(3);
-
-      cron({user, tasksByType, daysMissed, analytics});
-
-      // user.tasksOrder.todos should be filtered while tasks by type remains unchanged
-      expect(tasksByType.todos).to.be.lengthOf(2);
-      expect(user.tasksOrder.todos).to.be.lengthOf(1);
-    });
-
-    it('should preserve todos order in task list', () => {
-      tasksByType.todos = [];
-      user.tasksOrder.todos = [];
-      let todo = {
-        text: 'test todo',
-        type: 'todo',
-        value: 0,
-      };
-
-      let task = new Tasks.todo(Tasks.Task.sanitize(todo)); // eslint-disable-line new-cap
-      tasksByType.todos.push(task);
-      task = new Tasks.todo(Tasks.Task.sanitize(todo)); // eslint-disable-line new-cap
-      tasksByType.todos.push(task);
-      task = new Tasks.todo(Tasks.Task.sanitize(todo)); // eslint-disable-line new-cap
-      tasksByType.todos.push(task);
-
-      // Set up user.tasksOrder list in a specific order
-      user.tasksOrder.todos = tasksByType.todos.map(todoTask => {
-        return todoTask._id;
-      }).reverse();
-      let original = user.tasksOrder.todos; // Preserve the original order
-
-      cron({user, tasksByType, daysMissed, analytics});
-
-      let listsAreEqual = true;
-      user.tasksOrder.todos.forEach((taskId, index) => {
-        if (original[index]._id !== taskId) {
-          listsAreEqual = false;
-        }
-      });
-
-      expect(listsAreEqual);
-      expect(user.tasksOrder.todos).to.be.lengthOf(original.length);
-    });
  });

  describe('dailys', () => {
@@ -191,7 +191,7 @@ describe('payments/index', () => {
        await api.createSubscription(data);
        let msg = '\`Hello recipient, sender has sent you 3 months of subscription!\`';

-        expect(user.sendMessage).to.be.calledTwice;
+        expect(user.sendMessage).to.be.calledOnce;
        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: msg, senderMsg: msg });
      });

@@ -229,77 +229,6 @@ describe('payments/index', () => {
          },
        });
      });
-
-      context('Winter 2017-18 Gift-1-Get-1 Promotion', async () => {
-        it('creates a gift subscription for purchaser and recipient if none exist', async () => {
-          await api.createSubscription(data);
-
-          expect(user.items.pets['Jackalope-RoyalPurple']).to.eql(5);
-          expect(user.purchased.plan.customerId).to.eql('Gift');
-          expect(user.purchased.plan.dateTerminated).to.exist;
-          expect(user.purchased.plan.dateUpdated).to.exist;
-          expect(user.purchased.plan.dateCreated).to.exist;
-
-          expect(recipient.items.pets['Jackalope-RoyalPurple']).to.eql(5);
-          expect(recipient.purchased.plan.customerId).to.eql('Gift');
-          expect(recipient.purchased.plan.dateTerminated).to.exist;
-          expect(recipient.purchased.plan.dateUpdated).to.exist;
-          expect(recipient.purchased.plan.dateCreated).to.exist;
-        });
-
-        it('adds extraMonths to existing subscription for purchaser and creates a gift subscription for recipient without sub', async () => {
-          user.purchased.plan = plan;
-
-          expect(user.purchased.plan.extraMonths).to.eql(0);
-
-          await api.createSubscription(data);
-
-          expect(user.purchased.plan.extraMonths).to.eql(3);
-
-          expect(recipient.items.pets['Jackalope-RoyalPurple']).to.eql(5);
-          expect(recipient.purchased.plan.customerId).to.eql('Gift');
-          expect(recipient.purchased.plan.dateTerminated).to.exist;
-          expect(recipient.purchased.plan.dateUpdated).to.exist;
-          expect(recipient.purchased.plan.dateCreated).to.exist;
-        });
-
-        it('adds extraMonths to existing subscription for recipient and creates a gift subscription for purchaser without sub', async () => {
-          recipient.purchased.plan = plan;
-
-          expect(recipient.purchased.plan.extraMonths).to.eql(0);
-
-          await api.createSubscription(data);
-
-          expect(recipient.purchased.plan.extraMonths).to.eql(3);
-
-          expect(user.items.pets['Jackalope-RoyalPurple']).to.eql(5);
-          expect(user.purchased.plan.customerId).to.eql('Gift');
-          expect(user.purchased.plan.dateTerminated).to.exist;
-          expect(user.purchased.plan.dateUpdated).to.exist;
-          expect(user.purchased.plan.dateCreated).to.exist;
-        });
-
-        it('adds extraMonths to existing subscriptions for purchaser and recipient', async () => {
-          user.purchased.plan = plan;
-          recipient.purchased.plan = plan;
-
-          expect(user.purchased.plan.extraMonths).to.eql(0);
-          expect(recipient.purchased.plan.extraMonths).to.eql(0);
-
-          await api.createSubscription(data);
-
-          expect(user.purchased.plan.extraMonths).to.eql(3);
-          expect(recipient.purchased.plan.extraMonths).to.eql(3);
-        });
-
-        it('sends a private message about the promotion', async () => {
-          await api.createSubscription(data);
-          let msg = '\`Hello sender, you received 3 months of subscription as part of our holiday gift-giving promotion!\`';
-
-          expect(user.sendMessage).to.be.calledTwice;
-          expect(user.sendMessage).to.be.calledWith(user, { senderMsg: msg });
-        });
-      });
    });

    context('Purchasing a subscription for self', () => {
@@ -1,180 +0,0 @@
-import moment from 'moment';
-
-import {
-  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import amzLib from '../../../../../../../website/server/libs/amazonPayments';
-import payments from '../../../../../../../website/server/libs/payments';
-import common from '../../../../../../../website/common';
-import { createNonLeaderGroupMember } from '../paymentHelpers';
-
-const i18n = common.i18n;
-
-describe('Amazon Payments - Cancel Subscription', () => {
-  const subKey = 'basic_3mo';
-
-  let user, group, headers, billingAgreementId, subscriptionBlock, subscriptionLength;
-  let getBillingAgreementDetailsSpy;
-  let paymentCancelSubscriptionSpy;
-
-  function expectAmazonStubs () {
-    expect(getBillingAgreementDetailsSpy).to.be.calledOnce;
-    expect(getBillingAgreementDetailsSpy).to.be.calledWith({
-      AmazonBillingAgreementId: billingAgreementId,
-    });
-  }
-
-  function expectAmazonCancelSubscriptionSpy (groupId, lastBillingDate) {
-    expect(paymentCancelSubscriptionSpy).to.be.calledWith({
-      user,
-      groupId,
-      nextBill: moment(lastBillingDate).add({ days: subscriptionLength }),
-      paymentMethod: amzLib.constants.PAYMENT_METHOD,
-      headers,
-      cancellationReason: undefined,
-    });
-  }
-
-  function expectAmazonCancelUserSubscriptionSpy () {
-    expect(paymentCancelSubscriptionSpy).to.be.calledOnce;
-    expectAmazonCancelSubscriptionSpy(undefined, user.purchased.plan.lastBillingDate);
-  }
-
-  function expectAmazonCancelGroupSubscriptionSpy (groupId) {
-    expect(paymentCancelSubscriptionSpy).to.be.calledOnce;
-    expectAmazonCancelSubscriptionSpy(groupId, group.purchased.plan.lastBillingDate);
-  }
-
-  function expectBillingAggreementDetailSpy () {
-    getBillingAgreementDetailsSpy = sinon.stub(amzLib, 'getBillingAgreementDetails')
-      .returnsPromise()
-      .resolves({
-        BillingAgreementDetails: {
-          BillingAgreementStatus: {State: 'Open'},
-        },
-      });
-  }
-
-  beforeEach(async () => {
-    user = new User();
-    user.profile.name = 'sender';
-    user.purchased.plan.customerId = 'customer-id';
-    user.purchased.plan.planId = subKey;
-    user.purchased.plan.lastBillingDate = new Date();
-
-    group = generateGroup({
-      name: 'test group',
-      type: 'guild',
-      privacy: 'public',
-      leader: user._id,
-    });
-    group.purchased.plan.customerId = 'customer-id';
-    group.purchased.plan.planId = subKey;
-    group.purchased.plan.lastBillingDate = new Date();
-    await group.save();
-
-    subscriptionBlock = common.content.subscriptionBlocks[subKey];
-    subscriptionLength = subscriptionBlock.months * 30;
-
-    headers = {};
-
-    getBillingAgreementDetailsSpy = sinon.stub(amzLib, 'getBillingAgreementDetails');
-    getBillingAgreementDetailsSpy.returnsPromise().resolves({
-      BillingAgreementDetails: {
-        BillingAgreementStatus: {State: 'Closed'},
-      },
-    });
-
-    paymentCancelSubscriptionSpy = sinon.stub(payments, 'cancelSubscription');
-    paymentCancelSubscriptionSpy.returnsPromise().resolves({});
-  });
-
-  afterEach(function () {
-    amzLib.getBillingAgreementDetails.restore();
-    payments.cancelSubscription.restore();
-  });
-
-  it('should throw an error if we are missing a subscription', async () => {
-    user.purchased.plan.customerId = undefined;
-
-    await expect(amzLib.cancelSubscription({user}))
-      .to.eventually.be.rejected.and.to.eql({
-        httpCode: 401,
-        name: 'NotAuthorized',
-        message: i18n.t('missingSubscription'),
-      });
-  });
-
-  it('should cancel a user subscription', async () => {
-    billingAgreementId = user.purchased.plan.customerId;
-
-    await amzLib.cancelSubscription({user, headers});
-
-    expectAmazonCancelUserSubscriptionSpy();
-    expectAmazonStubs();
-  });
-
-  it('should close a user subscription if amazon not closed', async () => {
-    amzLib.getBillingAgreementDetails.restore();
-    expectBillingAggreementDetailSpy();
-    let closeBillingAgreementSpy = sinon.stub(amzLib, 'closeBillingAgreement').returnsPromise().resolves({});
-    billingAgreementId = user.purchased.plan.customerId;
-
-    await amzLib.cancelSubscription({user, headers});
-
-    expectAmazonStubs();
-    expect(closeBillingAgreementSpy).to.be.calledOnce;
-    expect(closeBillingAgreementSpy).to.be.calledWith({
-      AmazonBillingAgreementId: billingAgreementId,
-    });
-    expectAmazonCancelUserSubscriptionSpy();
-    amzLib.closeBillingAgreement.restore();
-  });
-
-  it('should throw an error if group is not found', async () => {
-    await expect(amzLib.cancelSubscription({user, groupId: 'fake-id'}))
-      .to.eventually.be.rejected.and.to.eql({
-        httpCode: 404,
-        name: 'NotFound',
-        message: i18n.t('groupNotFound'),
-      });
-  });
-
-  it('should throw an error if user is not group leader', async () => {
-    let nonLeader = await createNonLeaderGroupMember(group);
-
-    await expect(amzLib.cancelSubscription({user: nonLeader, groupId: group._id}))
-      .to.eventually.be.rejected.and.to.eql({
-        httpCode: 401,
-        name: 'NotAuthorized',
-        message: i18n.t('onlyGroupLeaderCanManageSubscription'),
-      });
-  });
-
-  it('should cancel a group subscription', async () => {
-    billingAgreementId = group.purchased.plan.customerId;
-
-    await amzLib.cancelSubscription({user, groupId: group._id, headers});
-
-    expectAmazonCancelGroupSubscriptionSpy(group._id);
-    expectAmazonStubs();
-  });
-
-  it('should close a group subscription if amazon not closed', async () => {
-    amzLib.getBillingAgreementDetails.restore();
-    expectBillingAggreementDetailSpy();
-    let closeBillingAgreementSpy = sinon.stub(amzLib, 'closeBillingAgreement').returnsPromise().resolves({});
-    billingAgreementId = group.purchased.plan.customerId;
-
-    await amzLib.cancelSubscription({user, groupId: group._id, headers});
-
-    expectAmazonStubs();
-    expect(closeBillingAgreementSpy).to.be.calledOnce;
-    expect(closeBillingAgreementSpy).to.be.calledWith({
-      AmazonBillingAgreementId: billingAgreementId,
-    });
-    expectAmazonCancelGroupSubscriptionSpy(group._id);
-    amzLib.closeBillingAgreement.restore();
-  });
-});
@@ -1,193 +0,0 @@
-import { model as User } from '../../../../../../../website/server/models/user';
-import amzLib from '../../../../../../../website/server/libs/amazonPayments';
-import payments from '../../../../../../../website/server/libs/payments';
-import common from '../../../../../../../website/common';
-
-const i18n = common.i18n;
-
-describe('Amazon Payments - Checkout', () => {
-  const subKey = 'basic_3mo';
-  let user, orderReferenceId, headers;
-  let setOrderReferenceDetailsSpy;
-  let confirmOrderReferenceSpy;
-  let authorizeSpy;
-  let closeOrderReferenceSpy;
-
-  let paymentBuyGemsStub;
-  let paymentCreateSubscritionStub;
-  let amount = 5;
-
-  function expectOrderReferenceSpy () {
-    expect(setOrderReferenceDetailsSpy).to.be.calledOnce;
-    expect(setOrderReferenceDetailsSpy).to.be.calledWith({
-      AmazonOrderReferenceId: orderReferenceId,
-      OrderReferenceAttributes: {
-        OrderTotal: {
-          CurrencyCode: amzLib.constants.CURRENCY_CODE,
-          Amount: amount,
-        },
-        SellerNote: amzLib.constants.SELLER_NOTE,
-        SellerOrderAttributes: {
-          SellerOrderId: common.uuid(),
-          StoreName: amzLib.constants.STORE_NAME,
-        },
-      },
-    });
-  }
-
-  function expectAuthorizeSpy () {
-    expect(authorizeSpy).to.be.calledOnce;
-    expect(authorizeSpy).to.be.calledWith({
-      AmazonOrderReferenceId: orderReferenceId,
-      AuthorizationReferenceId: common.uuid().substring(0, 32),
-      AuthorizationAmount: {
-        CurrencyCode: amzLib.constants.CURRENCY_CODE,
-        Amount: amount,
-      },
-      SellerAuthorizationNote: amzLib.constants.SELLER_NOTE,
-      TransactionTimeout: 0,
-      CaptureNow: true,
-    });
-  }
-
-  function expectAmazonStubs () {
-    expectOrderReferenceSpy();
-
-    expect(confirmOrderReferenceSpy).to.be.calledOnce;
-    expect(confirmOrderReferenceSpy).to.be.calledWith({ AmazonOrderReferenceId: orderReferenceId });
-
-    expectAuthorizeSpy();
-
-    expect(closeOrderReferenceSpy).to.be.calledOnce;
-    expect(closeOrderReferenceSpy).to.be.calledWith({ AmazonOrderReferenceId: orderReferenceId });
-  }
-
-  beforeEach(function () {
-    user = new User();
-    headers = {};
-    orderReferenceId = 'orderReferenceId';
-
-    setOrderReferenceDetailsSpy = sinon.stub(amzLib, 'setOrderReferenceDetails');
-    setOrderReferenceDetailsSpy.returnsPromise().resolves({});
-
-    confirmOrderReferenceSpy = sinon.stub(amzLib, 'confirmOrderReference');
-    confirmOrderReferenceSpy.returnsPromise().resolves({});
-
-    authorizeSpy = sinon.stub(amzLib, 'authorize');
-    authorizeSpy.returnsPromise().resolves({});
-
-    closeOrderReferenceSpy = sinon.stub(amzLib, 'closeOrderReference');
-    closeOrderReferenceSpy.returnsPromise().resolves({});
-
-    paymentBuyGemsStub = sinon.stub(payments, 'buyGems');
-    paymentBuyGemsStub.returnsPromise().resolves({});
-
-    paymentCreateSubscritionStub = sinon.stub(payments, 'createSubscription');
-    paymentCreateSubscritionStub.returnsPromise().resolves({});
-
-    sinon.stub(common, 'uuid').returns('uuid-generated');
-  });
-
-  afterEach(function () {
-    amzLib.setOrderReferenceDetails.restore();
-    amzLib.confirmOrderReference.restore();
-    amzLib.authorize.restore();
-    amzLib.closeOrderReference.restore();
-    payments.buyGems.restore();
-    payments.createSubscription.restore();
-    common.uuid.restore();
-  });
-
-  function expectBuyGemsStub (paymentMethod, gift) {
-    expect(paymentBuyGemsStub).to.be.calledOnce;
-
-    let expectedArgs = {
-      user,
-      paymentMethod,
-      headers,
-    };
-    if (gift) expectedArgs.gift = gift;
-    expect(paymentBuyGemsStub).to.be.calledWith(expectedArgs);
-  }
-
-  it('should purchase gems', async () => {
-    sinon.stub(user, 'canGetGems').returnsPromise().resolves(true);
-    await amzLib.checkout({user, orderReferenceId, headers});
-
-    expectBuyGemsStub(amzLib.constants.PAYMENT_METHOD);
-    expectAmazonStubs();
-    expect(user.canGetGems).to.be.calledOnce;
-    user.canGetGems.restore();
-  });
-
-  it('should error if gem amount is too low', async () => {
-    let receivingUser = new User();
-    receivingUser.save();
-    let gift = {
-      type: 'gems',
-      gems: {
-        amount: 0,
-        uuid: receivingUser._id,
-      },
-    };
-
-    await expect(amzLib.checkout({gift, user, orderReferenceId, headers}))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 400,
-      message: 'Amount must be at least 1.',
-      name: 'BadRequest',
-    });
-  });
-
-  it('should error if user cannot get gems gems', async () => {
-    sinon.stub(user, 'canGetGems').returnsPromise().resolves(false);
-    await expect(amzLib.checkout({user, orderReferenceId, headers})).to.eventually.be.rejected.and.to.eql({
-      httpCode: 401,
-      message: i18n.t('groupPolicyCannotGetGems'),
-      name: 'NotAuthorized',
-    });
-    user.canGetGems.restore();
-  });
-
-  it('should gift gems', async () => {
-    let receivingUser = new User();
-    await receivingUser.save();
-    let gift = {
-      type: 'gems',
-      uuid: receivingUser._id,
-      gems: {
-        amount: 16,
-      },
-    };
-    amount = 16 / 4;
-    await amzLib.checkout({gift, user, orderReferenceId, headers});
-
-    expectBuyGemsStub(amzLib.constants.PAYMENT_METHOD_GIFT, gift);
-    expectAmazonStubs();
-  });
-
-  it('should gift a subscription', async () => {
-    let receivingUser = new User();
-    receivingUser.save();
-    let gift = {
-      type: 'subscription',
-      subscription: {
-        key: subKey,
-        uuid: receivingUser._id,
-      },
-    };
-    amount = common.content.subscriptionBlocks[subKey].price;
-
-    await amzLib.checkout({user, orderReferenceId, headers, gift});
-
-    gift.member = receivingUser;
-    expect(paymentCreateSubscritionStub).to.be.calledOnce;
-    expect(paymentCreateSubscritionStub).to.be.calledWith({
-      user,
-      paymentMethod: amzLib.constants.PAYMENT_METHOD_GIFT,
-      headers,
-      gift,
-    });
-    expectAmazonStubs();
-  });
-});
@@ -1,267 +0,0 @@
-import cc from 'coupon-code';
-
-import {
-  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Coupon } from '../../../../../../../website/server/models/coupon';
-import amzLib from '../../../../../../../website/server/libs/amazonPayments';
-import payments from '../../../../../../../website/server/libs/payments';
-import common from '../../../../../../../website/common';
-
-const i18n = common.i18n;
-
-describe('Amazon Payments - Subscribe', () => {
-  const subKey = 'basic_3mo';
-  let user, group, amount, billingAgreementId, sub, coupon, groupId, headers;
-  let amazonSetBillingAgreementDetailsSpy;
-  let amazonConfirmBillingAgreementSpy;
-  let amazonAuthorizeOnBillingAgreementSpy;
-  let createSubSpy;
-
-  beforeEach(async () => {
-    user = new User();
-    user.profile.name = 'sender';
-    user.purchased.plan.customerId = 'customer-id';
-    user.purchased.plan.planId = subKey;
-    user.purchased.plan.lastBillingDate = new Date();
-
-    group = generateGroup({
-      name: 'test group',
-      type: 'guild',
-      privacy: 'public',
-      leader: user._id,
-    });
-    group.purchased.plan.customerId = 'customer-id';
-    group.purchased.plan.planId = subKey;
-    await group.save();
-
-    amount = common.content.subscriptionBlocks[subKey].price;
-    billingAgreementId = 'billingAgreementId';
-    sub = {
-      key: subKey,
-      price: amount,
-    };
-    groupId = group._id;
-    headers = {};
-
-    amazonSetBillingAgreementDetailsSpy = sinon.stub(amzLib, 'setBillingAgreementDetails');
-    amazonSetBillingAgreementDetailsSpy.returnsPromise().resolves({});
-
-    amazonConfirmBillingAgreementSpy = sinon.stub(amzLib, 'confirmBillingAgreement');
-    amazonConfirmBillingAgreementSpy.returnsPromise().resolves({});
-
-    amazonAuthorizeOnBillingAgreementSpy = sinon.stub(amzLib, 'authorizeOnBillingAgreement');
-    amazonAuthorizeOnBillingAgreementSpy.returnsPromise().resolves({});
-
-    createSubSpy = sinon.stub(payments, 'createSubscription');
-    createSubSpy.returnsPromise().resolves({});
-
-    sinon.stub(common, 'uuid').returns('uuid-generated');
-  });
-
-  afterEach(function () {
-    amzLib.setBillingAgreementDetails.restore();
-    amzLib.confirmBillingAgreement.restore();
-    amzLib.authorizeOnBillingAgreement.restore();
-    payments.createSubscription.restore();
-    common.uuid.restore();
-  });
-
-  function expectAmazonAuthorizeBillingAgreementSpy () {
-    expect(amazonAuthorizeOnBillingAgreementSpy).to.be.calledOnce;
-    expect(amazonAuthorizeOnBillingAgreementSpy).to.be.calledWith({
-      AmazonBillingAgreementId: billingAgreementId,
-      AuthorizationReferenceId: common.uuid().substring(0, 32),
-      AuthorizationAmount: {
-        CurrencyCode: amzLib.constants.CURRENCY_CODE,
-        Amount: amount,
-      },
-      SellerAuthorizationNote: amzLib.constants.SELLER_NOTE_ATHORIZATION_SUBSCRIPTION,
-      TransactionTimeout: 0,
-      CaptureNow: true,
-      SellerNote: amzLib.constants.SELLER_NOTE_ATHORIZATION_SUBSCRIPTION,
-      SellerOrderAttributes: {
-        SellerOrderId: common.uuid(),
-        StoreName: amzLib.constants.STORE_NAME,
-      },
-    });
-  }
-
-  function expectAmazonSetBillingAgreementDetailsSpy () {
-    expect(amazonSetBillingAgreementDetailsSpy).to.be.calledOnce;
-    expect(amazonSetBillingAgreementDetailsSpy).to.be.calledWith({
-      AmazonBillingAgreementId: billingAgreementId,
-      BillingAgreementAttributes: {
-        SellerNote: amzLib.constants.SELLER_NOTE_SUBSCRIPTION,
-        SellerBillingAgreementAttributes: {
-          SellerBillingAgreementId: common.uuid(),
-          StoreName: amzLib.constants.STORE_NAME,
-          CustomInformation: amzLib.constants.SELLER_NOTE_SUBSCRIPTION,
-        },
-      },
-    });
-  }
-
-  function expectCreateSpy () {
-    expect(createSubSpy).to.be.calledOnce;
-    expect(createSubSpy).to.be.calledWith({
-      user,
-      customerId: billingAgreementId,
-      paymentMethod: amzLib.constants.PAYMENT_METHOD,
-      sub,
-      headers,
-      groupId,
-    });
-  }
-
-  it('should throw an error if we are missing a subscription', async () => {
-    await expect(amzLib.subscribe({
-      billingAgreementId,
-      coupon,
-      user,
-      groupId,
-      headers,
-    }))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 400,
-      name: 'BadRequest',
-      message: i18n.t('missingSubscriptionCode'),
-    });
-  });
-
-  it('should throw an error if we are missing a billingAgreementId', async () => {
-    await expect(amzLib.subscribe({
-      sub,
-      coupon,
-      user,
-      groupId,
-      headers,
-    }))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 400,
-      name: 'BadRequest',
-      message: 'Missing req.body.billingAgreementId',
-    });
-  });
-
-  it('should throw an error when coupon code is missing', async () => {
-    sub.discount = 40;
-
-    await expect(amzLib.subscribe({
-      billingAgreementId,
-      sub,
-      coupon,
-      user,
-      groupId,
-      headers,
-    }))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 400,
-      name: 'BadRequest',
-      message: i18n.t('couponCodeRequired'),
-    });
-  });
-
-  it('should throw an error when coupon code is invalid', async () => {
-    sub.discount = 40;
-    sub.key = 'google_6mo';
-    coupon = 'example-coupon';
-
-    let couponModel = new Coupon();
-    couponModel.event = 'google_6mo';
-    await couponModel.save();
-
-    sinon.stub(cc, 'validate').returns('invalid');
-
-    await expect(amzLib.subscribe({
-      billingAgreementId,
-      sub,
-      coupon,
-      user,
-      groupId,
-      headers,
-    }))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 401,
-      name: 'NotAuthorized',
-      message: i18n.t('invalidCoupon'),
-    });
-    cc.validate.restore();
-  });
-
-  it('subscribes with amazon with a coupon', async () => {
-    sub.discount = 40;
-    sub.key = 'google_6mo';
-    coupon = 'example-coupon';
-
-    let couponModel = new Coupon();
-    couponModel.event = 'google_6mo';
-    let updatedCouponModel = await couponModel.save();
-
-    sinon.stub(cc, 'validate').returns(updatedCouponModel._id);
-
-    await amzLib.subscribe({
-      billingAgreementId,
-      sub,
-      coupon,
-      user,
-      groupId,
-      headers,
-    });
-
-    expectCreateSpy();
-
-    cc.validate.restore();
-  });
-
-  it('subscribes with amazon', async () => {
-    await amzLib.subscribe({
-      billingAgreementId,
-      sub,
-      coupon,
-      user,
-      groupId,
-      headers,
-    });
-
-    expectAmazonSetBillingAgreementDetailsSpy();
-
-    expect(amazonConfirmBillingAgreementSpy).to.be.calledOnce;
-    expect(amazonConfirmBillingAgreementSpy).to.be.calledWith({
-      AmazonBillingAgreementId: billingAgreementId,
-    });
-
-    expectAmazonAuthorizeBillingAgreementSpy();
-
-    expectCreateSpy();
-  });
-
-  it('subscribes with amazon with price to existing users', async () => {
-    user = new User();
-    user.guilds.push(groupId);
-    await user.save();
-    group.memberCount = 2;
-    await group.save();
-    sub.key = 'group_monthly';
-    sub.price = 9;
-    amount = 12;
-
-    await amzLib.subscribe({
-      billingAgreementId,
-      sub,
-      coupon,
-      user,
-      groupId,
-      headers,
-    });
-
-    expectAmazonSetBillingAgreementDetailsSpy();
-    expect(amazonConfirmBillingAgreementSpy).to.be.calledOnce;
-    expect(amazonConfirmBillingAgreementSpy).to.be.calledWith({
-      AmazonBillingAgreementId: billingAgreementId,
-    });
-    expectAmazonAuthorizeBillingAgreementSpy();
-    expectCreateSpy();
-  });
-});
@@ -1,83 +0,0 @@
-import uuid from 'uuid';
-
-import {
-  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Group } from '../../../../../../../website/server/models/group';
-import amzLib from '../../../../../../../website/server/libs/amazonPayments';
-import payments from '../../../../../../../website/server/libs/payments';
-
-describe('#upgradeGroupPlan', () => {
-  let spy, data, user, group, uuidString;
-
-  beforeEach(async function () {
-    user = new User();
-    user.profile.name = 'sender';
-
-    data = {
-      user,
-      sub: {
-        key: 'basic_3mo', // @TODO: Validate that this is group
-      },
-      customerId: 'customer-id',
-      paymentMethod: 'Payment Method',
-      headers: {
-        'x-client': 'habitica-web',
-        'user-agent': '',
-      },
-    };
-
-    group = generateGroup({
-      name: 'test group',
-      type: 'guild',
-      privacy: 'public',
-      leader: user._id,
-    });
-    await group.save();
-
-    spy = sinon.stub(amzLib, 'authorizeOnBillingAgreement');
-    spy.returnsPromise().resolves([]);
-
-    uuidString = 'uuid-v4';
-    sinon.stub(uuid, 'v4').returns(uuidString);
-
-    data.groupId = group._id;
-    data.sub.quantity = 3;
-  });
-
-  afterEach(function () {
-    sinon.restore(amzLib.authorizeOnBillingAgreement);
-    uuid.v4.restore();
-  });
-
-  it('charges for a new member', async () => {
-    data.paymentMethod = amzLib.constants.PAYMENT_METHOD;
-    await payments.createSubscription(data);
-
-    let updatedGroup = await Group.findById(group._id).exec();
-
-    updatedGroup.memberCount += 1;
-    await updatedGroup.save();
-
-    await amzLib.chargeForAdditionalGroupMember(updatedGroup);
-
-    expect(spy.calledOnce).to.be.true;
-    expect(spy).to.be.calledWith({
-      AmazonBillingAgreementId: updatedGroup.purchased.plan.customerId,
-      AuthorizationReferenceId: uuidString.substring(0, 32),
-      AuthorizationAmount: {
-        CurrencyCode: amzLib.constants.CURRENCY_CODE,
-        Amount: 3,
-      },
-      SellerAuthorizationNote: amzLib.constants.SELLER_NOTE_GROUP_NEW_MEMBER,
-      TransactionTimeout: 0,
-      CaptureNow: true,
-      SellerNote: amzLib.constants.SELLER_NOTE_GROUP_NEW_MEMBER,
-      SellerOrderAttributes: {
-        SellerOrderId: uuidString,
-        StoreName: amzLib.constants.STORE_NAME,
-      },
-    });
-  });
-});
@@ -475,7 +475,7 @@ describe('Purchasing a group plan for group', () => {

    let updatedUser = await User.findById(recipient._id).exec();

-    expect(updatedUser.purchased.plan.extraMonths).to.within(3, 5);
+    expect(updatedUser.purchased.plan.extraMonths).to.within(3, 4);
  });

  it('adds months to members with existing recurring subscription (Paypal)', async () => {
@@ -1,7 +0,0 @@
-import { model as User } from '../../../../../../website/server/models/user';
-
-export async function createNonLeaderGroupMember (group) {
-  let nonLeader = new User();
-  nonLeader.guilds.push(group._id);
-  return await nonLeader.save();
-}
@@ -1,87 +0,0 @@
-/* eslint-disable camelcase */
-import payments from '../../../../../../../website/server/libs/payments';
-import paypalPayments from '../../../../../../../website/server/libs/paypalPayments';
-import { model as User } from '../../../../../../../website/server/models/user';
-
-describe('checkout success', () => {
-  const subKey = 'basic_3mo';
-  let user, gift, customerId, paymentId;
-  let paypalPaymentExecuteStub, paymentBuyGemsStub, paymentsCreateSubscritionStub;
-
-  beforeEach(() => {
-    user = new User();
-    customerId = 'customerId-test';
-    paymentId = 'paymentId-test';
-
-    paypalPaymentExecuteStub = sinon.stub(paypalPayments, 'paypalPaymentExecute').returnsPromise().resolves({});
-    paymentBuyGemsStub = sinon.stub(payments, 'buyGems').returnsPromise().resolves({});
-    paymentsCreateSubscritionStub = sinon.stub(payments, 'createSubscription').returnsPromise().resolves({});
-  });
-
-  afterEach(() => {
-    paypalPayments.paypalPaymentExecute.restore();
-    payments.buyGems.restore();
-    payments.createSubscription.restore();
-  });
-
-  it('purchases gems', async () => {
-    await paypalPayments.checkoutSuccess({user, gift, paymentId, customerId});
-
-    expect(paypalPaymentExecuteStub).to.be.calledOnce;
-    expect(paypalPaymentExecuteStub).to.be.calledWith(paymentId, { payer_id: customerId });
-    expect(paymentBuyGemsStub).to.be.calledOnce;
-    expect(paymentBuyGemsStub).to.be.calledWith({
-      user,
-      customerId,
-      paymentMethod: 'Paypal',
-    });
-  });
-
-  it('gifts gems', async () => {
-    let receivingUser = new User();
-    await receivingUser.save();
-    gift = {
-      type: 'gems',
-      gems: {
-        amount: 16,
-        uuid: receivingUser._id,
-      },
-    };
-
-    await paypalPayments.checkoutSuccess({user, gift, paymentId, customerId});
-
-    expect(paypalPaymentExecuteStub).to.be.calledOnce;
-    expect(paypalPaymentExecuteStub).to.be.calledWith(paymentId, { payer_id: customerId });
-    expect(paymentBuyGemsStub).to.be.calledOnce;
-    expect(paymentBuyGemsStub).to.be.calledWith({
-      user,
-      customerId,
-      paymentMethod: 'PayPal (Gift)',
-      gift,
-    });
-  });
-
-  it('gifts subscription', async () => {
-    let receivingUser = new User();
-    await receivingUser.save();
-    gift = {
-      type: 'subscription',
-      subscription: {
-        key: subKey,
-        uuid: receivingUser._id,
-      },
-    };
-
-    await paypalPayments.checkoutSuccess({user, gift, paymentId, customerId});
-
-    expect(paypalPaymentExecuteStub).to.be.calledOnce;
-    expect(paypalPaymentExecuteStub).to.be.calledWith(paymentId, { payer_id: customerId });
-    expect(paymentsCreateSubscritionStub).to.be.calledOnce;
-    expect(paymentsCreateSubscritionStub).to.be.calledWith({
-      user,
-      customerId,
-      paymentMethod: 'PayPal (Gift)',
-      gift,
-    });
-  });
-});
@@ -1,127 +0,0 @@
-/* eslint-disable camelcase */
-import nconf from 'nconf';
-
-import paypalPayments from '../../../../../../../website/server/libs/paypalPayments';
-import { model as User } from '../../../../../../../website/server/models/user';
-import common from '../../../../../../../website/common';
-
-const BASE_URL = nconf.get('BASE_URL');
-const i18n = common.i18n;
-
-describe('checkout', () => {
-  const subKey = 'basic_3mo';
-  let paypalPaymentCreateStub;
-  let approvalHerf;
-
-  function getPaypalCreateOptions (description, amount) {
-    return {
-      intent: 'sale',
-      payer: { payment_method: 'Paypal' },
-      redirect_urls: {
-        return_url: `${BASE_URL}/paypal/checkout/success`,
-        cancel_url: `${BASE_URL}`,
-      },
-      transactions: [{
-        item_list: {
-          items: [{
-            name: description,
-            price: amount,
-            currency: 'USD',
-            quantity: 1,
-          }],
-        },
-        amount: {
-          currency: 'USD',
-          total: amount,
-        },
-        description,
-      }],
-    };
-  }
-
-  beforeEach(() => {
-    approvalHerf = 'approval_href';
-    paypalPaymentCreateStub = sinon.stub(paypalPayments, 'paypalPaymentCreate')
-      .returnsPromise().resolves({
-        links: [{ rel: 'approval_url', href: approvalHerf }],
-      });
-  });
-
-  afterEach(() => {
-    paypalPayments.paypalPaymentCreate.restore();
-  });
-
-  it('creates a link for gem purchases', async () => {
-    let link = await paypalPayments.checkout({user: new User()});
-
-    expect(paypalPaymentCreateStub).to.be.calledOnce;
-    expect(paypalPaymentCreateStub).to.be.calledWith(getPaypalCreateOptions('Habitica Gems', 5.00));
-    expect(link).to.eql(approvalHerf);
-  });
-
-  it('should error if gem amount is too low', async () => {
-    let receivingUser = new User();
-    receivingUser.save();
-    let gift = {
-      type: 'gems',
-      gems: {
-        amount: 0,
-        uuid: receivingUser._id,
-      },
-    };
-
-    await expect(paypalPayments.checkout({gift}))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 400,
-      message: 'Amount must be at least 1.',
-      name: 'BadRequest',
-    });
-  });
-
-  it('should error if the user cannot get gems', async () => {
-    let user = new User();
-    sinon.stub(user, 'canGetGems').returnsPromise().resolves(false);
-
-    await expect(paypalPayments.checkout({user})).to.eventually.be.rejected.and.to.eql({
-      httpCode: 401,
-      message: i18n.t('groupPolicyCannotGetGems'),
-      name: 'NotAuthorized',
-    });
-  });
-
-  it('creates a link for gifting gems', async () => {
-    let receivingUser = new User();
-    await receivingUser.save();
-    let gift = {
-      type: 'gems',
-      uuid: receivingUser._id,
-      gems: {
-        amount: 16,
-      },
-    };
-
-    let link = await paypalPayments.checkout({gift});
-
-    expect(paypalPaymentCreateStub).to.be.calledOnce;
-    expect(paypalPaymentCreateStub).to.be.calledWith(getPaypalCreateOptions('Habitica Gems (Gift)', '4.00'));
-    expect(link).to.eql(approvalHerf);
-  });
-
-  it('creates a link for gifting a subscription', async () => {
-    let receivingUser = new User();
-    receivingUser.save();
-    let gift = {
-      type: 'subscription',
-      subscription: {
-        key: subKey,
-        uuid: receivingUser._id,
-      },
-    };
-
-    let link = await paypalPayments.checkout({gift});
-
-    expect(paypalPaymentCreateStub).to.be.calledOnce;
-    expect(paypalPaymentCreateStub).to.be.calledWith(getPaypalCreateOptions('mo. Habitica Subscription (Gift)', '15.00'));
-    expect(link).to.eql(approvalHerf);
-  });
-});
@@ -1,66 +0,0 @@
-/* eslint-disable camelcase */
-import payments from '../../../../../../../website/server/libs/payments';
-import paypalPayments from '../../../../../../../website/server/libs/paypalPayments';
-import {
-  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-
-describe('ipn', () => {
-  const subKey = 'basic_3mo';
-  let user, group, txn_type, userPaymentId, groupPaymentId;
-  let ipnVerifyAsyncStub, paymentCancelSubscriptionSpy;
-
-  beforeEach(async () => {
-    txn_type = 'recurring_payment_profile_cancel';
-    userPaymentId = 'userPaymentId-test';
-    groupPaymentId = 'groupPaymentId-test';
-
-    user = new User();
-    user.profile.name = 'sender';
-    user.purchased.plan.customerId = userPaymentId;
-    user.purchased.plan.planId = subKey;
-    user.purchased.plan.lastBillingDate = new Date();
-    await user.save();
-
-    group = generateGroup({
-      name: 'test group',
-      type: 'guild',
-      privacy: 'public',
-      leader: user._id,
-    });
-    group.purchased.plan.customerId = groupPaymentId;
-    group.purchased.plan.planId = subKey;
-    group.purchased.plan.lastBillingDate = new Date();
-    await group.save();
-
-    ipnVerifyAsyncStub = sinon.stub(paypalPayments, 'ipnVerifyAsync').returnsPromise().resolves({});
-    paymentCancelSubscriptionSpy = sinon.stub(payments, 'cancelSubscription').returnsPromise().resolves({});
-  });
-
-  afterEach(function () {
-    paypalPayments.ipnVerifyAsync.restore();
-    payments.cancelSubscription.restore();
-  });
-
-  it('should cancel a user subscription', async () => {
-    await paypalPayments.ipn({txn_type, recurring_payment_id: userPaymentId});
-
-    expect(ipnVerifyAsyncStub).to.be.calledOnce;
-    expect(ipnVerifyAsyncStub).to.be.calledWith({txn_type, recurring_payment_id: userPaymentId});
-
-    expect(paymentCancelSubscriptionSpy).to.be.calledOnce;
-    expect(paymentCancelSubscriptionSpy.args[0][0].user._id).to.eql(user._id);
-    expect(paymentCancelSubscriptionSpy.args[0][0].paymentMethod).to.eql('Paypal');
-  });
-
-  it('should cancel a group subscription', async () => {
-    await paypalPayments.ipn({txn_type, recurring_payment_id: groupPaymentId});
-
-    expect(ipnVerifyAsyncStub).to.be.calledOnce;
-    expect(ipnVerifyAsyncStub).to.be.calledWith({txn_type, recurring_payment_id: groupPaymentId});
-
-    expect(paymentCancelSubscriptionSpy).to.be.calledOnce;
-    expect(paymentCancelSubscriptionSpy).to.be.calledWith({ groupId: group._id, paymentMethod: 'Paypal' });
-  });
-});
@@ -1,124 +0,0 @@
-/* eslint-disable camelcase */
-import payments from '../../../../../../../website/server/libs/payments';
-import paypalPayments from '../../../../../../../website/server/libs/paypalPayments';
-import {
-  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import common from '../../../../../../../website/common';
-import { createNonLeaderGroupMember } from '../paymentHelpers';
-
-const i18n = common.i18n;
-
-describe('subscribeCancel', () => {
-  const subKey = 'basic_3mo';
-  let user, group, groupId, customerId, groupCustomerId, nextBillingDate;
-  let paymentCancelSubscriptionSpy, paypalBillingAgreementCancelStub, paypalBillingAgreementGetStub;
-
-  beforeEach(async () => {
-    customerId = 'customer-id';
-    groupCustomerId = 'groupCustomerId-test';
-
-    user = new User();
-    user.profile.name = 'sender';
-    user.purchased.plan.customerId = customerId;
-    user.purchased.plan.planId = subKey;
-    user.purchased.plan.lastBillingDate = new Date();
-
-    group = generateGroup({
-      name: 'test group',
-      type: 'guild',
-      privacy: 'public',
-      leader: user._id,
-    });
-    group.purchased.plan.customerId = groupCustomerId;
-    group.purchased.plan.planId = subKey;
-    group.purchased.plan.lastBillingDate = new Date();
-    await group.save();
-
-    nextBillingDate = new Date();
-
-    paypalBillingAgreementCancelStub = sinon.stub(paypalPayments, 'paypalBillingAgreementCancel').returnsPromise().resolves({});
-    paypalBillingAgreementGetStub = sinon.stub(paypalPayments, 'paypalBillingAgreementGet')
-      .returnsPromise().resolves({
-        agreement_details: {
-          next_billing_date: nextBillingDate,
-          cycles_completed: 1,
-        },
-      });
-    paymentCancelSubscriptionSpy = sinon.stub(payments, 'cancelSubscription').returnsPromise().resolves({});
-  });
-
-  afterEach(function () {
-    paypalPayments.paypalBillingAgreementGet.restore();
-    paypalPayments.paypalBillingAgreementCancel.restore();
-    payments.cancelSubscription.restore();
-  });
-
-  it('should throw an error if we are missing a subscription', async () => {
-    user.purchased.plan.customerId = undefined;
-
-    await expect(paypalPayments.subscribeCancel({user}))
-      .to.eventually.be.rejected.and.to.eql({
-        httpCode: 401,
-        name: 'NotAuthorized',
-        message: i18n.t('missingSubscription'),
-      });
-  });
-
-  it('should throw an error if group is not found', async () => {
-    await expect(paypalPayments.subscribeCancel({user, groupId: 'fake-id'}))
-      .to.eventually.be.rejected.and.to.eql({
-        httpCode: 404,
-        name: 'NotFound',
-        message: i18n.t('groupNotFound'),
-      });
-  });
-
-  it('should throw an error if user is not group leader', async () => {
-    let nonLeader = await createNonLeaderGroupMember(group);
-
-    await expect(paypalPayments.subscribeCancel({user: nonLeader, groupId: group._id}))
-      .to.eventually.be.rejected.and.to.eql({
-        httpCode: 401,
-        name: 'NotAuthorized',
-        message: i18n.t('onlyGroupLeaderCanManageSubscription'),
-      });
-  });
-
-  it('should cancel a user subscription', async () => {
-    await paypalPayments.subscribeCancel({user});
-
-    expect(paypalBillingAgreementGetStub).to.be.calledOnce;
-    expect(paypalBillingAgreementGetStub).to.be.calledWith(customerId);
-    expect(paypalBillingAgreementCancelStub).to.be.calledOnce;
-    expect(paypalBillingAgreementCancelStub).to.be.calledWith(customerId, { note: i18n.t('cancelingSubscription') });
-
-    expect(paymentCancelSubscriptionSpy).to.be.calledOnce;
-    expect(paymentCancelSubscriptionSpy).to.be.calledWith({
-      user,
-      groupId,
-      paymentMethod: 'Paypal',
-      nextBill: nextBillingDate,
-      cancellationReason: undefined,
-    });
-  });
-
-  it('should cancel a group subscription', async () => {
-    await paypalPayments.subscribeCancel({user, groupId: group._id});
-
-    expect(paypalBillingAgreementGetStub).to.be.calledOnce;
-    expect(paypalBillingAgreementGetStub).to.be.calledWith(groupCustomerId);
-    expect(paypalBillingAgreementCancelStub).to.be.calledOnce;
-    expect(paypalBillingAgreementCancelStub).to.be.calledWith(groupCustomerId, { note: i18n.t('cancelingSubscription') });
-
-    expect(paymentCancelSubscriptionSpy).to.be.calledOnce;
-    expect(paymentCancelSubscriptionSpy).to.be.calledWith({
-      user,
-      groupId: group._id,
-      paymentMethod: 'Paypal',
-      nextBill: nextBillingDate,
-      cancellationReason: undefined,
-    });
-  });
-});
@@ -1,77 +0,0 @@
-/* eslint-disable camelcase */
-import payments from '../../../../../../../website/server/libs/payments';
-import paypalPayments from '../../../../../../../website/server/libs/paypalPayments';
-import {
-  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import common from '../../../../../../../website/common';
-
-describe('subscribeSuccess', () => {
-  const subKey = 'basic_3mo';
-  let user, group, block, groupId, token, headers, customerId;
-  let paypalBillingAgreementExecuteStub, paymentsCreateSubscritionStub;
-
-  beforeEach(async () => {
-    user = new User();
-
-    group = generateGroup({
-      name: 'test group',
-      type: 'guild',
-      privacy: 'public',
-      leader: user._id,
-    });
-
-    token = 'test-token';
-    headers = {};
-    block = common.content.subscriptionBlocks[subKey];
-    customerId = 'test-customerId';
-
-    paypalBillingAgreementExecuteStub = sinon.stub(paypalPayments, 'paypalBillingAgreementExecute')
-      .returnsPromise({}).resolves({
-        id: customerId,
-      });
-    paymentsCreateSubscritionStub = sinon.stub(payments, 'createSubscription').returnsPromise().resolves({});
-  });
-
-  afterEach(() => {
-    paypalPayments.paypalBillingAgreementExecute.restore();
-    payments.createSubscription.restore();
-  });
-
-  it('creates a user subscription', async () => {
-    await paypalPayments.subscribeSuccess({user, block, groupId, token, headers});
-
-    expect(paypalBillingAgreementExecuteStub).to.be.calledOnce;
-    expect(paypalBillingAgreementExecuteStub).to.be.calledWith(token, {});
-
-    expect(paymentsCreateSubscritionStub).to.be.calledOnce;
-    expect(paymentsCreateSubscritionStub).to.be.calledWith({
-      user,
-      groupId,
-      customerId,
-      paymentMethod: 'Paypal',
-      sub: block,
-      headers,
-    });
-  });
-
-  it('create a group subscription', async () => {
-    groupId = group._id;
-
-    await paypalPayments.subscribeSuccess({user, block, groupId, token, headers});
-
-    expect(paypalBillingAgreementExecuteStub).to.be.calledOnce;
-    expect(paypalBillingAgreementExecuteStub).to.be.calledWith(token, {});
-
-    expect(paymentsCreateSubscritionStub).to.be.calledOnce;
-    expect(paymentsCreateSubscritionStub).to.be.calledWith({
-      user,
-      groupId,
-      customerId,
-      paymentMethod: 'Paypal',
-      sub: block,
-      headers,
-    });
-  });
-});
@@ -1,112 +0,0 @@
-/* eslint-disable camelcase */
-import moment from 'moment';
-import cc from 'coupon-code';
-
-import paypalPayments from '../../../../../../../website/server/libs/paypalPayments';
-import { model as Coupon } from '../../../../../../../website/server/models/coupon';
-import common from '../../../../../../../website/common';
-
-const i18n = common.i18n;
-
-describe('subscribe', () => {
-  const subKey = 'basic_3mo';
-  let coupon, sub, approvalHerf;
-  let paypalBillingAgreementCreateStub;
-
-  beforeEach(() => {
-    approvalHerf = 'approvalHerf-test';
-    sub = Object.assign({}, common.content.subscriptionBlocks[subKey]);
-
-    paypalBillingAgreementCreateStub = sinon.stub(paypalPayments, 'paypalBillingAgreementCreate')
-      .returnsPromise().resolves({
-        links: [{ rel: 'approval_url', href: approvalHerf }],
-      });
-  });
-
-  afterEach(() => {
-    paypalPayments.paypalBillingAgreementCreate.restore();
-  });
-
-  it('should throw an error when coupon code is missing', async () => {
-    sub.discount = 40;
-
-    await expect(paypalPayments.subscribe({sub, coupon}))
-      .to.eventually.be.rejected.and.to.eql({
-        httpCode: 400,
-        name: 'BadRequest',
-        message: i18n.t('couponCodeRequired'),
-      });
-  });
-
-  it('should throw an error when coupon code is invalid', async () => {
-    sub.discount = 40;
-    sub.key = 'google_6mo';
-    coupon = 'example-coupon';
-
-    let couponModel = new Coupon();
-    couponModel.event = 'google_6mo';
-    await couponModel.save();
-
-    sinon.stub(cc, 'validate').returns('invalid');
-
-    await expect(paypalPayments.subscribe({sub, coupon}))
-      .to.eventually.be.rejected.and.to.eql({
-        httpCode: 401,
-        name: 'NotAuthorized',
-        message: i18n.t('invalidCoupon'),
-      });
-    cc.validate.restore();
-  });
-
-  it('subscribes with amazon with a coupon', async () => {
-    sub.discount = 40;
-    sub.key = 'google_6mo';
-    coupon = 'example-coupon';
-
-    let couponModel = new Coupon();
-    couponModel.event = 'google_6mo';
-    let updatedCouponModel = await couponModel.save();
-
-    sinon.stub(cc, 'validate').returns(updatedCouponModel._id);
-
-    let link = await paypalPayments.subscribe({sub, coupon});
-
-    expect(link).to.eql(approvalHerf);
-    expect(paypalBillingAgreementCreateStub).to.be.calledOnce;
-    let billingPlanTitle = `Habitica Subscription ($${sub.price} every ${sub.months} months, recurring)`;
-    expect(paypalBillingAgreementCreateStub).to.be.calledWith({
-      name: billingPlanTitle,
-      description: billingPlanTitle,
-      start_date: moment().add({ minutes: 5 }).format(),
-      plan: {
-        id: sub.paypalKey,
-      },
-      payer: {
-        payment_method: 'Paypal',
-      },
-    });
-
-    cc.validate.restore();
-  });
-
-  it('creates a link for a subscription', async () => {
-    delete sub.discount;
-
-    let link = await paypalPayments.subscribe({sub, coupon});
-
-    expect(link).to.eql(approvalHerf);
-    expect(paypalBillingAgreementCreateStub).to.be.calledOnce;
-    let billingPlanTitle = `Habitica Subscription ($${sub.price} every ${sub.months} months, recurring)`;
-    expect(paypalBillingAgreementCreateStub).to.be.calledWith({
-      name: billingPlanTitle,
-      description: billingPlanTitle,
-      start_date: moment().add({ minutes: 5 }).format(),
-      plan: {
-        id: sub.paypalKey,
-      },
-      payer: {
-        payment_method: 'Paypal',
-      },
-    });
-  });
-});
@@ -1,143 +0,0 @@
-import stripeModule from 'stripe';
-
-import {
-  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import stripePayments from '../../../../../../../website/server/libs/stripePayments';
-import payments from '../../../../../../../website/server/libs/payments';
-import common from '../../../../../../../website/common';
-
-const i18n = common.i18n;
-
-describe('cancel subscription', () => {
-  const subKey = 'basic_3mo';
-  const stripe = stripeModule('test');
-  let user, groupId, group;
-
-  beforeEach(async () => {
-    user = new User();
-    user.profile.name = 'sender';
-    user.purchased.plan.customerId = 'customer-id';
-    user.purchased.plan.planId = subKey;
-    user.purchased.plan.lastBillingDate = new Date();
-
-    group = generateGroup({
-      name: 'test group',
-      type: 'guild',
-      privacy: 'public',
-      leader: user._id,
-    });
-    group.purchased.plan.customerId = 'customer-id';
-    group.purchased.plan.planId = subKey;
-    await group.save();
-
-    groupId = group._id;
-  });
-
-  it('throws an error if there is no customer id', async () => {
-    user.purchased.plan.customerId = undefined;
-
-    await expect(stripePayments.cancelSubscription({
-      user,
-      groupId: undefined,
-    }))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 401,
-      name: 'NotAuthorized',
-      message: i18n.t('missingSubscription'),
-    });
-  });
-
-  it('throws an error if the group is not found', async () => {
-    await expect(stripePayments.cancelSubscription({
-      user,
-      groupId: 'fake-group',
-    }))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 404,
-      name: 'NotFound',
-      message: i18n.t('groupNotFound'),
-    });
-  });
-
-  it('throws an error if user is not the group leader', async () => {
-    let nonLeader = new User();
-    nonLeader.guilds.push(groupId);
-    await nonLeader.save();
-
-    await expect(stripePayments.cancelSubscription({
-      user: nonLeader,
-      groupId,
-    }))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 401,
-      name: 'NotAuthorized',
-      message: i18n.t('onlyGroupLeaderCanManageSubscription'),
-    });
-  });
-
-  describe('success', () => {
-    let stripeDeleteCustomerStub, paymentsCancelSubStub, stripeRetrieveStub, subscriptionId, currentPeriodEndTimeStamp;
-
-    beforeEach(() => {
-      subscriptionId = 'subId';
-      stripeDeleteCustomerStub = sinon.stub(stripe.customers, 'del').returnsPromise().resolves({});
-      paymentsCancelSubStub = sinon.stub(payments, 'cancelSubscription').returnsPromise().resolves({});
-
-      currentPeriodEndTimeStamp = (new Date()).getTime();
-      stripeRetrieveStub = sinon.stub(stripe.customers, 'retrieve')
-        .returnsPromise().resolves({
-          subscriptions: {
-            data: [{id: subscriptionId, current_period_end: currentPeriodEndTimeStamp}], // eslint-disable-line camelcase
-          },
-        });
-    });
-
-    afterEach(() => {
-      stripe.customers.del.restore();
-      stripe.customers.retrieve.restore();
-      payments.cancelSubscription.restore();
-    });
-
-    it('cancels a user subscription', async () => {
-      await stripePayments.cancelSubscription({
-        user,
-        groupId: undefined,
-      }, stripe);
-
-      expect(stripeDeleteCustomerStub).to.be.calledOnce;
-      expect(stripeDeleteCustomerStub).to.be.calledWith(user.purchased.plan.customerId);
-      expect(stripeRetrieveStub).to.be.calledOnce;
-      expect(stripeRetrieveStub).to.be.calledWith(user.purchased.plan.customerId);
-      expect(paymentsCancelSubStub).to.be.calledOnce;
-      expect(paymentsCancelSubStub).to.be.calledWith({
-        user,
-        groupId: undefined,
-        nextBill: currentPeriodEndTimeStamp * 1000, // timestamp in seconds
-        paymentMethod: 'Stripe',
-        cancellationReason: undefined,
-      });
-    });
-
-    it('cancels a group subscription', async () => {
-      await stripePayments.cancelSubscription({
-        user,
-        groupId,
-      }, stripe);
-
-      expect(stripeDeleteCustomerStub).to.be.calledOnce;
-      expect(stripeDeleteCustomerStub).to.be.calledWith(group.purchased.plan.customerId);
-      expect(stripeRetrieveStub).to.be.calledOnce;
-      expect(stripeRetrieveStub).to.be.calledWith(user.purchased.plan.customerId);
-      expect(paymentsCancelSubStub).to.be.calledOnce;
-      expect(paymentsCancelSubStub).to.be.calledWith({
-        user,
-        groupId,
-        nextBill: currentPeriodEndTimeStamp * 1000, // timestamp in seconds
-        paymentMethod: 'Stripe',
-        cancellationReason: undefined,
-      });
-    });
-  });
-});
@@ -1,307 +0,0 @@
-import stripeModule from 'stripe';
-import cc from 'coupon-code';
-
-import {
-  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Coupon } from '../../../../../../../website/server/models/coupon';
-import stripePayments from '../../../../../../../website/server/libs/stripePayments';
-import payments from '../../../../../../../website/server/libs/payments';
-import common from '../../../../../../../website/common';
-
-const i18n = common.i18n;
-
-describe('checkout with subscription', () => {
-  const subKey = 'basic_3mo';
-  const stripe = stripeModule('test');
-  let user, group, data, gift, sub, groupId, email, headers, coupon, customerIdResponse, subscriptionId, token;
-  let spy;
-  let stripeCreateCustomerSpy;
-  let stripePaymentsCreateSubSpy;
-
-  beforeEach(async () => {
-    user = new User();
-    user.profile.name = 'sender';
-    user.purchased.plan.customerId = 'customer-id';
-    user.purchased.plan.planId = subKey;
-    user.purchased.plan.lastBillingDate = new Date();
-
-    group = generateGroup({
-      name: 'test group',
-      type: 'guild',
-      privacy: 'public',
-      leader: user._id,
-    });
-    group.purchased.plan.customerId = 'customer-id';
-    group.purchased.plan.planId = subKey;
-    await group.save();
-
-    sub = {
-      key: 'basic_3mo',
-    };
-
-    data = {
-      user,
-      sub,
-      customerId: 'customer-id',
-      paymentMethod: 'Payment Method',
-    };
-
-    email = 'example@example.com';
-    customerIdResponse = 'test-id';
-    subscriptionId = 'test-sub-id';
-    token = 'test-token';
-
-    spy = sinon.stub(stripe.subscriptions, 'update');
-    spy.returnsPromise().resolves;
-
-    stripeCreateCustomerSpy = sinon.stub(stripe.customers, 'create');
-    let stripCustomerResponse = {
-      id: customerIdResponse,
-      subscriptions: {
-        data: [{id: subscriptionId}],
-      },
-    };
-    stripeCreateCustomerSpy.returnsPromise().resolves(stripCustomerResponse);
-
-    stripePaymentsCreateSubSpy = sinon.stub(payments, 'createSubscription');
-    stripePaymentsCreateSubSpy.returnsPromise().resolves({});
-
-    data.groupId = group._id;
-    data.sub.quantity = 3;
-  });
-
-  afterEach(function () {
-    sinon.restore(stripe.subscriptions.update);
-    stripe.customers.create.restore();
-    payments.createSubscription.restore();
-  });
-
-  it('should throw an error if we are missing a token', async () => {
-    await expect(stripePayments.checkout({
-      user,
-      gift,
-      sub,
-      groupId,
-      email,
-      headers,
-      coupon,
-    }))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 400,
-      name: 'BadRequest',
-      message: 'Missing req.body.id',
-    });
-  });
-
-  it('should throw an error when coupon code is missing', async () => {
-    sub.discount = 40;
-
-    await expect(stripePayments.checkout({
-      token,
-      user,
-      gift,
-      sub,
-      groupId,
-      email,
-      headers,
-      coupon,
-    }))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 400,
-      name: 'BadRequest',
-      message: i18n.t('couponCodeRequired'),
-    });
-  });
-
-  it('should throw an error when coupon code is invalid', async () => {
-    sub.discount = 40;
-    sub.key = 'google_6mo';
-    coupon = 'example-coupon';
-
-    let couponModel = new Coupon();
-    couponModel.event = 'google_6mo';
-    await couponModel.save();
-
-    sinon.stub(cc, 'validate').returns('invalid');
-
-    await expect(stripePayments.checkout({
-      token,
-      user,
-      gift,
-      sub,
-      groupId,
-      email,
-      headers,
-      coupon,
-    }))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 400,
-      name: 'BadRequest',
-      message: i18n.t('invalidCoupon'),
-    });
-    cc.validate.restore();
-  });
-
-  it('subscribes with amazon with a coupon', async () => {
-    sub.discount = 40;
-    sub.key = 'google_6mo';
-    coupon = 'example-coupon';
-
-    let couponModel = new Coupon();
-    couponModel.event = 'google_6mo';
-    let updatedCouponModel = await couponModel.save();
-
-    sinon.stub(cc, 'validate').returns(updatedCouponModel._id);
-
-    await stripePayments.checkout({
-      token,
-      user,
-      gift,
-      sub,
-      groupId,
-      email,
-      headers,
-      coupon,
-    }, stripe);
-
-    expect(stripeCreateCustomerSpy).to.be.calledOnce;
-    expect(stripeCreateCustomerSpy).to.be.calledWith({
-      email,
-      metadata: { uuid: user._id },
-      card: token,
-      plan: sub.key,
-    });
-
-    expect(stripePaymentsCreateSubSpy).to.be.calledOnce;
-    expect(stripePaymentsCreateSubSpy).to.be.calledWith({
-      user,
-      customerId: customerIdResponse,
-      paymentMethod: 'Stripe',
-      sub,
-      headers,
-      groupId: undefined,
-      subscriptionId: undefined,
-    });
-
-    cc.validate.restore();
-  });
-
-  it('subscribes a user', async () => {
-    sub = data.sub;
-
-    await stripePayments.checkout({
-      token,
-      user,
-      gift,
-      sub,
-      groupId,
-      email,
-      headers,
-      coupon,
-    }, stripe);
-
-    expect(stripeCreateCustomerSpy).to.be.calledOnce;
-    expect(stripeCreateCustomerSpy).to.be.calledWith({
-      email,
-      metadata: { uuid: user._id },
-      card: token,
-      plan: sub.key,
-    });
-
-    expect(stripePaymentsCreateSubSpy).to.be.calledOnce;
-    expect(stripePaymentsCreateSubSpy).to.be.calledWith({
-      user,
-      customerId: customerIdResponse,
-      paymentMethod: 'Stripe',
-      sub,
-      headers,
-      groupId: undefined,
-      subscriptionId: undefined,
-    });
-  });
-
-  it('subscribes a group', async () => {
-    token = 'test-token';
-    sub = data.sub;
-    groupId = group._id;
-    email = 'test@test.com';
-    headers = {};
-
-    await stripePayments.checkout({
-      token,
-      user,
-      gift,
-      sub,
-      groupId,
-      email,
-      headers,
-      coupon,
-    }, stripe);
-
-    expect(stripeCreateCustomerSpy).to.be.calledOnce;
-    expect(stripeCreateCustomerSpy).to.be.calledWith({
-      email,
-      metadata: { uuid: user._id },
-      card: token,
-      plan: sub.key,
-      quantity: 3,
-    });
-
-    expect(stripePaymentsCreateSubSpy).to.be.calledOnce;
-    expect(stripePaymentsCreateSubSpy).to.be.calledWith({
-      user,
-      customerId: customerIdResponse,
-      paymentMethod: 'Stripe',
-      sub,
-      headers,
-      groupId,
-      subscriptionId,
-    });
-  });
-
-  it('subscribes a group with the correct number of group members', async () => {
-    token = 'test-token';
-    sub = data.sub;
-    groupId = group._id;
-    email = 'test@test.com';
-    headers = {};
-    user = new User();
-    user.guilds.push(groupId);
-    await user.save();
-    group.memberCount = 2;
-    await group.save();
-
-    await stripePayments.checkout({
-      token,
-      user,
-      gift,
-      sub,
-      groupId,
-      email,
-      headers,
-      coupon,
-    }, stripe);
-
-    expect(stripeCreateCustomerSpy).to.be.calledOnce;
-    expect(stripeCreateCustomerSpy).to.be.calledWith({
-      email,
-      metadata: { uuid: user._id },
-      card: token,
-      plan: sub.key,
-      quantity: 4,
-    });
-
-    expect(stripePaymentsCreateSubSpy).to.be.calledOnce;
-    expect(stripePaymentsCreateSubSpy).to.be.calledWith({
-      user,
-      customerId: customerIdResponse,
-      paymentMethod: 'Stripe',
-      sub,
-      headers,
-      groupId,
-      subscriptionId,
-    });
-  });
-});
@@ -1,193 +0,0 @@
-import stripeModule from 'stripe';
-
-import { model as User } from '../../../../../../../website/server/models/user';
-import stripePayments from '../../../../../../../website/server/libs/stripePayments';
-import payments from '../../../../../../../website/server/libs/payments';
-import common from '../../../../../../../website/common';
-
-const i18n = common.i18n;
-
-describe('checkout', () => {
-  const subKey = 'basic_3mo';
-  const stripe = stripeModule('test');
-  let stripeChargeStub, paymentBuyGemsStub, paymentCreateSubscritionStub;
-  let user, gift, groupId, email, headers, coupon, customerIdResponse, token;
-
-  beforeEach(() => {
-    user = new User();
-    user.profile.name = 'sender';
-    user.purchased.plan.customerId = 'customer-id';
-    user.purchased.plan.planId = subKey;
-    user.purchased.plan.lastBillingDate = new Date();
-
-    token = 'test-token';
-
-    customerIdResponse = 'example-customerIdResponse';
-    let stripCustomerResponse = {
-      id: customerIdResponse,
-    };
-    stripeChargeStub = sinon.stub(stripe.charges, 'create').returnsPromise().resolves(stripCustomerResponse);
-    paymentBuyGemsStub = sinon.stub(payments, 'buyGems').returnsPromise().resolves({});
-    paymentCreateSubscritionStub = sinon.stub(payments, 'createSubscription').returnsPromise().resolves({});
-  });
-
-  afterEach(() => {
-    stripe.charges.create.restore();
-    payments.buyGems.restore();
-    payments.createSubscription.restore();
-  });
-
-  it('should error if gem amount is too low', async () => {
-    let receivingUser = new User();
-    receivingUser.save();
-    gift = {
-      type: 'gems',
-      gems: {
-        amount: 0,
-        uuid: receivingUser._id,
-      },
-    };
-
-    await expect(stripePayments.checkout({
-      token,
-      user,
-      gift,
-      groupId,
-      email,
-      headers,
-      coupon,
-    }, stripe))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 400,
-      message: 'Amount must be at least 1.',
-      name: 'BadRequest',
-    });
-  });
-
-
-  it('should error if user cannot get gems', async () => {
-    gift = undefined;
-    sinon.stub(user, 'canGetGems').returnsPromise().resolves(false);
-
-    await expect(stripePayments.checkout({
-      token,
-      user,
-      gift,
-      groupId,
-      email,
-      headers,
-      coupon,
-    }, stripe)).to.eventually.be.rejected.and.to.eql({
-      httpCode: 401,
-      message: i18n.t('groupPolicyCannotGetGems'),
-      name: 'NotAuthorized',
-    });
-  });
-
-  it('should purchase gems', async () => {
-    gift = undefined;
-    sinon.stub(user, 'canGetGems').returnsPromise().resolves(true);
-
-    await stripePayments.checkout({
-      token,
-      user,
-      gift,
-      groupId,
-      email,
-      headers,
-      coupon,
-    }, stripe);
-
-    expect(stripeChargeStub).to.be.calledOnce;
-    expect(stripeChargeStub).to.be.calledWith({
-      amount: 500,
-      currency: 'usd',
-      card: token,
-    });
-
-    expect(paymentBuyGemsStub).to.be.calledOnce;
-    expect(paymentBuyGemsStub).to.be.calledWith({
-      user,
-      customerId: customerIdResponse,
-      paymentMethod: 'Stripe',
-      gift,
-    });
-    expect(user.canGetGems).to.be.calledOnce;
-    user.canGetGems.restore();
-  });
-
-  it('should gift gems', async () => {
-    let receivingUser = new User();
-    await receivingUser.save();
-    gift = {
-      type: 'gems',
-      uuid: receivingUser._id,
-      gems: {
-        amount: 16,
-      },
-    };
-
-    await stripePayments.checkout({
-      token,
-      user,
-      gift,
-      groupId,
-      email,
-      headers,
-      coupon,
-    }, stripe);
-
-    expect(stripeChargeStub).to.be.calledOnce;
-    expect(stripeChargeStub).to.be.calledWith({
-      amount: '400',
-      currency: 'usd',
-      card: token,
-    });
-
-    expect(paymentBuyGemsStub).to.be.calledOnce;
-    expect(paymentBuyGemsStub).to.be.calledWith({
-      user,
-      customerId: customerIdResponse,
-      paymentMethod: 'Gift',
-      gift,
-    });
-  });
-
-  it('should gift a subscription', async () => {
-    let receivingUser = new User();
-    receivingUser.save();
-    gift = {
-      type: 'subscription',
-      subscription: {
-        key: subKey,
-        uuid: receivingUser._id,
-      },
-    };
-
-    await stripePayments.checkout({
-      token,
-      user,
-      gift,
-      groupId,
-      email,
-      headers,
-      coupon,
-    }, stripe);
-
-    gift.member = receivingUser;
-    expect(stripeChargeStub).to.be.calledOnce;
-    expect(stripeChargeStub).to.be.calledWith({
-      amount: '1500',
-      currency: 'usd',
-      card: token,
-    });
-
-    expect(paymentCreateSubscritionStub).to.be.calledOnce;
-    expect(paymentCreateSubscritionStub).to.be.calledWith({
-      user,
-      customerId: customerIdResponse,
-      paymentMethod: 'Gift',
-      gift,
-    });
-  });
-});
@@ -1,147 +0,0 @@
-import stripeModule from 'stripe';
-
-import {
-  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import stripePayments from '../../../../../../../website/server/libs/stripePayments';
-import common from '../../../../../../../website/common';
-
-const i18n = common.i18n;
-
-describe('edit subscription', () => {
-  const subKey = 'basic_3mo';
-  const stripe = stripeModule('test');
-  let user, groupId, group, token;
-
-  beforeEach(async () => {
-    user = new User();
-    user.profile.name = 'sender';
-    user.purchased.plan.customerId = 'customer-id';
-    user.purchased.plan.planId = subKey;
-    user.purchased.plan.lastBillingDate = new Date();
-
-    group = generateGroup({
-      name: 'test group',
-      type: 'guild',
-      privacy: 'public',
-      leader: user._id,
-    });
-    group.purchased.plan.customerId = 'customer-id';
-    group.purchased.plan.planId = subKey;
-    await group.save();
-
-    groupId = group._id;
-
-    token = 'test-token';
-  });
-
-  it('throws an error if there is no customer id', async () => {
-    user.purchased.plan.customerId = undefined;
-
-    await expect(stripePayments.editSubscription({
-      user,
-      groupId: undefined,
-    }))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 401,
-      name: 'NotAuthorized',
-      message: i18n.t('missingSubscription'),
-    });
-  });
-
-  it('throws an error if a token is not provided', async () => {
-    await expect(stripePayments.editSubscription({
-      user,
-      groupId: undefined,
-    }))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 400,
-      name: 'BadRequest',
-      message: 'Missing req.body.id',
-    });
-  });
-
-  it('throws an error if the group is not found', async () => {
-    await expect(stripePayments.editSubscription({
-      token,
-      user,
-      groupId: 'fake-group',
-    }))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 404,
-      name: 'NotFound',
-      message: i18n.t('groupNotFound'),
-    });
-  });
-
-  it('throws an error if user is not the group leader', async () => {
-    let nonLeader = new User();
-    nonLeader.guilds.push(groupId);
-    await nonLeader.save();
-
-    await expect(stripePayments.editSubscription({
-      token,
-      user: nonLeader,
-      groupId,
-    }))
-    .to.eventually.be.rejected.and.to.eql({
-      httpCode: 401,
-      name: 'NotAuthorized',
-      message: i18n.t('onlyGroupLeaderCanManageSubscription'),
-    });
-  });
-
-  describe('success', () => {
-    let stripeListSubscriptionStub, stripeUpdateSubscriptionStub, subscriptionId;
-
-    beforeEach(() => {
-      subscriptionId = 'subId';
-      stripeListSubscriptionStub = sinon.stub(stripe.customers, 'listSubscriptions')
-        .returnsPromise().resolves({
-          data: [{id: subscriptionId}],
-        });
-
-      stripeUpdateSubscriptionStub = sinon.stub(stripe.customers, 'updateSubscription').returnsPromise().resolves({});
-    });
-
-    afterEach(() => {
-      stripe.customers.listSubscriptions.restore();
-      stripe.customers.updateSubscription.restore();
-    });
-
-    it('edits a user subscription', async () => {
-      await stripePayments.editSubscription({
-        token,
-        user,
-        groupId: undefined,
-      }, stripe);
-
-      expect(stripeListSubscriptionStub).to.be.calledOnce;
-      expect(stripeListSubscriptionStub).to.be.calledWith(user.purchased.plan.customerId);
-      expect(stripeUpdateSubscriptionStub).to.be.calledOnce;
-      expect(stripeUpdateSubscriptionStub).to.be.calledWith(
-        user.purchased.plan.customerId,
-        subscriptionId,
-        { card: token }
-      );
-    });
-
-    it('edits a group subscription', async () => {
-      await stripePayments.editSubscription({
-        token,
-        user,
-        groupId,
-      }, stripe);
-
-      expect(stripeListSubscriptionStub).to.be.calledOnce;
-      expect(stripeListSubscriptionStub).to.be.calledWith(group.purchased.plan.customerId);
-      expect(stripeUpdateSubscriptionStub).to.be.calledOnce;
-      expect(stripeUpdateSubscriptionStub).to.be.calledWith(
-        group.purchased.plan.customerId,
-        subscriptionId,
-        { card: token }
-      );
-    });
-  });
-});
@@ -1,257 +0,0 @@
-import stripeModule from 'stripe';
-
-import {
-  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import stripePayments from '../../../../../../../website/server/libs/stripePayments';
-import payments from '../../../../../../../website/server/libs/payments';
-import common from '../../../../../../../website/common';
-import logger from '../../../../../../../website/server/libs/logger';
-import { v4 as uuid } from 'uuid';
-import moment from 'moment';
-
-const i18n = common.i18n;
-
-describe('Stripe - Webhooks', () => {
-  const stripe = stripeModule('test');
-
-  describe('all events', () => {
-    const eventType = 'account.updated';
-    const event = {id: 123};
-    const eventRetrieved = {type: eventType};
-
-    beforeEach(() => {
-      sinon.stub(stripe.events, 'retrieve').returnsPromise().resolves(eventRetrieved);
-      sinon.stub(logger, 'error');
-    });
-
-    afterEach(() => {
-      stripe.events.retrieve.restore();
-      logger.error.restore();
-    });
-
-    it('logs an error if an unsupported webhook event is passed', async () => {
-      const error = new Error(`Missing handler for Stripe webhook ${eventType}`);
-      await stripePayments.handleWebhooks({requestBody: event}, stripe);
-      expect(logger.error).to.have.been.called.once;
-      expect(logger.error).to.have.been.calledWith(error, {event: eventRetrieved});
-    });
-
-    it('retrieves and validates the event from Stripe', async () => {
-      await stripePayments.handleWebhooks({requestBody: event}, stripe);
-      expect(stripe.events.retrieve).to.have.been.called.once;
-      expect(stripe.events.retrieve).to.have.been.calledWith(event.id);
-    });
-  });
-
-  describe('customer.subscription.deleted', () => {
-    const eventType = 'customer.subscription.deleted';
-
-    beforeEach(() => {
-      sinon.stub(stripe.customers, 'del').returnsPromise().resolves({});
-      sinon.stub(payments, 'cancelSubscription').returnsPromise().resolves({});
-    });
-
-    afterEach(() => {
-      stripe.customers.del.restore();
-      payments.cancelSubscription.restore();
-    });
-
-    it('does not do anything if event.request is null (subscription cancelled manually)', async () => {
-      sinon.stub(stripe.events, 'retrieve').returnsPromise().resolves({
-        id: 123,
-        type: eventType,
-        request: 123,
-      });
-
-      await stripePayments.handleWebhooks({requestBody: {}}, stripe);
-
-      expect(stripe.events.retrieve).to.have.been.called.once;
-      expect(stripe.customers.del).to.not.have.been.called;
-      expect(payments.cancelSubscription).to.not.have.been.called;
-      stripe.events.retrieve.restore();
-    });
-
-    describe('user subscription', () => {
-      it('throws an error if the user is not found', async () => {
-        const customerId = 456;
-        sinon.stub(stripe.events, 'retrieve').returnsPromise().resolves({
-          id: 123,
-          type: eventType,
-          data: {
-            object: {
-              plan: {
-                id: 'basic_earned',
-              },
-              customer: customerId,
-            },
-          },
-          request: null,
-        });
-
-        await expect(stripePayments.handleWebhooks({requestBody: {}}, stripe)).to.eventually.be.rejectedWith({
-          message: i18n.t('userNotFound'),
-          httpCode: 404,
-          name: 'NotFound',
-        });
-
-        expect(stripe.customers.del).to.not.have.been.called;
-        expect(payments.cancelSubscription).to.not.have.been.called;
-
-        stripe.events.retrieve.restore();
-      });
-
-      it('deletes the customer on Stripe and calls payments.cancelSubscription', async () => {
-        const customerId = '456';
-
-        let subscriber = new User();
-        subscriber.purchased.plan.customerId = customerId;
-        subscriber.purchased.plan.paymentMethod = 'Stripe';
-        await subscriber.save();
-
-        sinon.stub(stripe.events, 'retrieve').returnsPromise().resolves({
-          id: 123,
-          type: eventType,
-          data: {
-            object: {
-              plan: {
-                id: 'basic_earned',
-              },
-              customer: customerId,
-            },
-          },
-          request: null,
-        });
-
-        await stripePayments.handleWebhooks({requestBody: {}}, stripe);
-
-        expect(stripe.customers.del).to.have.been.calledOnce;
-        expect(stripe.customers.del).to.have.been.calledWith(customerId);
-        expect(payments.cancelSubscription).to.have.been.calledOnce;
-
-        let cancelSubscriptionOpts = payments.cancelSubscription.lastCall.args[0];
-        expect(cancelSubscriptionOpts.user._id).to.equal(subscriber._id);
-        expect(cancelSubscriptionOpts.paymentMethod).to.equal('Stripe');
-        expect(Math.round(moment(cancelSubscriptionOpts.nextBill).diff(new Date(), 'days', true))).to.equal(3);
-        expect(cancelSubscriptionOpts.groupId).to.be.undefined;
-
-        stripe.events.retrieve.restore();
-      });
-    });
-
-    describe('group plan subscription', () => {
-      it('throws an error if the group is not found', async () => {
-        const customerId = 456;
-        sinon.stub(stripe.events, 'retrieve').returnsPromise().resolves({
-          id: 123,
-          type: eventType,
-          data: {
-            object: {
-              plan: {
-                id: 'group_monthly',
-              },
-              customer: customerId,
-            },
-          },
-          request: null,
-        });
-
-        await expect(stripePayments.handleWebhooks({requestBody: {}}, stripe)).to.eventually.be.rejectedWith({
-          message: i18n.t('groupNotFound'),
-          httpCode: 404,
-          name: 'NotFound',
-        });
-
-        expect(stripe.customers.del).to.not.have.been.called;
-        expect(payments.cancelSubscription).to.not.have.been.called;
-
-        stripe.events.retrieve.restore();
-      });
-
-      it('throws an error if the group leader is not found', async () => {
-        const customerId = 456;
-
-        let subscriber = generateGroup({
-          name: 'test group',
-          type: 'guild',
-          privacy: 'public',
-          leader: uuid(),
-        });
-        subscriber.purchased.plan.customerId = customerId;
-        subscriber.purchased.plan.paymentMethod = 'Stripe';
-        await subscriber.save();
-
-        sinon.stub(stripe.events, 'retrieve').returnsPromise().resolves({
-          id: 123,
-          type: eventType,
-          data: {
-            object: {
-              plan: {
-                id: 'group_monthly',
-              },
-              customer: customerId,
-            },
-          },
-          request: null,
-        });
-
-        await expect(stripePayments.handleWebhooks({requestBody: {}}, stripe)).to.eventually.be.rejectedWith({
-          message: i18n.t('userNotFound'),
-          httpCode: 404,
-          name: 'NotFound',
-        });
-
-        expect(stripe.customers.del).to.not.have.been.called;
-        expect(payments.cancelSubscription).to.not.have.been.called;
-
-        stripe.events.retrieve.restore();
-      });
-
-      it('deletes the customer on Stripe and calls payments.cancelSubscription', async () => {
-        const customerId = '456';
-
-        let leader = new User();
-        await leader.save();
-
-        let subscriber = generateGroup({
-          name: 'test group',
-          type: 'guild',
-          privacy: 'public',
-          leader: leader._id,
-        });
-        subscriber.purchased.plan.customerId = customerId;
-        subscriber.purchased.plan.paymentMethod = 'Stripe';
-        await subscriber.save();
-
-        sinon.stub(stripe.events, 'retrieve').returnsPromise().resolves({
-          id: 123,
-          type: eventType,
-          data: {
-            object: {
-              plan: {
-                id: 'group_monthly',
-              },
-              customer: customerId,
-            },
-          },
-          request: null,
-        });
-
-        await stripePayments.handleWebhooks({requestBody: {}}, stripe);
-
-        expect(stripe.customers.del).to.have.been.calledOnce;
-        expect(stripe.customers.del).to.have.been.calledWith(customerId);
-        expect(payments.cancelSubscription).to.have.been.calledOnce;
-
-        let cancelSubscriptionOpts = payments.cancelSubscription.lastCall.args[0];
-        expect(cancelSubscriptionOpts.user._id).to.equal(leader._id);
-        expect(cancelSubscriptionOpts.paymentMethod).to.equal('Stripe');
-        expect(Math.round(moment(cancelSubscriptionOpts.nextBill).diff(new Date(), 'days', true))).to.equal(3);
-        expect(cancelSubscriptionOpts.groupId).to.equal(subscriber._id);
-
-        stripe.events.retrieve.restore();
-      });
-    });
-  });
-});
@@ -1,66 +0,0 @@
-import stripeModule from 'stripe';
-
-import {
-  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Group } from '../../../../../../../website/server/models/group';
-import stripePayments from '../../../../../../../website/server/libs/stripePayments';
-import payments from '../../../../../../../website/server/libs/payments';
-
-describe('Stripe - Upgrade Group Plan', () => {
-  const stripe = stripeModule('test');
-  let spy, data, user, group;
-
-  beforeEach(async function () {
-    user = new User();
-    user.profile.name = 'sender';
-
-    data = {
-      user,
-      sub: {
-        key: 'basic_3mo', // @TODO: Validate that this is group
-      },
-      customerId: 'customer-id',
-      paymentMethod: 'Payment Method',
-      headers: {
-        'x-client': 'habitica-web',
-        'user-agent': '',
-      },
-    };
-
-    group = generateGroup({
-      name: 'test group',
-      type: 'guild',
-      privacy: 'public',
-      leader: user._id,
-    });
-    await group.save();
-
-    spy = sinon.stub(stripe.subscriptions, 'update');
-    spy.returnsPromise().resolves([]);
-    data.groupId = group._id;
-    data.sub.quantity = 3;
-    stripePayments.setStripeApi(stripe);
-  });
-
-  afterEach(function () {
-    sinon.restore(stripe.subscriptions.update);
-  });
-
-  it('updates a group plan quantity', async () => {
-    data.paymentMethod = 'Stripe';
-    await payments.createSubscription(data);
-
-    let updatedGroup = await Group.findById(group._id).exec();
-    expect(updatedGroup.purchased.plan.quantity).to.eql(3);
-
-    updatedGroup.memberCount += 1;
-    await updatedGroup.save();
-
-    await stripePayments.chargeForAdditionalGroupMember(updatedGroup);
-
-    expect(spy.calledOnce).to.be.true;
-    expect(updatedGroup.purchased.plan.quantity).to.eql(4);
-  });
-});
@@ -0,0 +1,561 @@
+/* eslint-disable camelcase */
+import nconf from 'nconf';
+import moment from 'moment';
+import cc from 'coupon-code';
+
+import payments from '../../../../../website/server/libs/payments';
+import paypalPayments from '../../../../../website/server/libs/paypalPayments';
+import {
+  generateGroup,
+} from '../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../website/server/models/user';
+import { model as Coupon } from '../../../../../website/server/models/coupon';
+import common from '../../../../../website/common';
+
+const BASE_URL = nconf.get('BASE_URL');
+const i18n = common.i18n;
+
+describe('Paypal Payments', ()  => {
+  let subKey = 'basic_3mo';
+
+  describe('checkout', () => {
+    let paypalPaymentCreateStub;
+    let approvalHerf;
+
+    function getPaypalCreateOptions (description, amount) {
+      return {
+        intent: 'sale',
+        payer: { payment_method: 'Paypal' },
+        redirect_urls: {
+          return_url: `${BASE_URL}/paypal/checkout/success`,
+          cancel_url: `${BASE_URL}`,
+        },
+        transactions: [{
+          item_list: {
+            items: [{
+              name: description,
+              price: amount,
+              currency: 'USD',
+              quantity: 1,
+            }],
+          },
+          amount: {
+            currency: 'USD',
+            total: amount,
+          },
+          description,
+        }],
+      };
+    }
+
+    beforeEach(() => {
+      approvalHerf = 'approval_href';
+      paypalPaymentCreateStub = sinon.stub(paypalPayments, 'paypalPaymentCreate')
+        .returnsPromise().resolves({
+          links: [{ rel: 'approval_url', href: approvalHerf }],
+        });
+    });
+
+    afterEach(() => {
+      paypalPayments.paypalPaymentCreate.restore();
+    });
+
+    it('creates a link for gem purchases', async () => {
+      let link = await paypalPayments.checkout({user: new User()});
+
+      expect(paypalPaymentCreateStub).to.be.calledOnce;
+      expect(paypalPaymentCreateStub).to.be.calledWith(getPaypalCreateOptions('Habitica Gems', 5.00));
+      expect(link).to.eql(approvalHerf);
+    });
+
+    it('should error if gem amount is too low', async () => {
+      let receivingUser = new User();
+      receivingUser.save();
+      let gift = {
+        type: 'gems',
+        gems: {
+          amount: 0,
+          uuid: receivingUser._id,
+        },
+      };
+
+      await expect(paypalPayments.checkout({gift}))
+      .to.eventually.be.rejected.and.to.eql({
+        httpCode: 400,
+        message: 'Amount must be at least 1.',
+        name: 'BadRequest',
+      });
+    });
+
+    it('should error if the user cannot get gems', async () => {
+      let user = new User();
+      sinon.stub(user, 'canGetGems').returnsPromise().resolves(false);
+
+      await expect(paypalPayments.checkout({user})).to.eventually.be.rejected.and.to.eql({
+        httpCode: 401,
+        message: i18n.t('groupPolicyCannotGetGems'),
+        name: 'NotAuthorized',
+      });
+    });
+
+    it('creates a link for gifting gems', async () => {
+      let receivingUser = new User();
+      await receivingUser.save();
+      let gift = {
+        type: 'gems',
+        uuid: receivingUser._id,
+        gems: {
+          amount: 16,
+        },
+      };
+
+      let link = await paypalPayments.checkout({gift});
+
+      expect(paypalPaymentCreateStub).to.be.calledOnce;
+      expect(paypalPaymentCreateStub).to.be.calledWith(getPaypalCreateOptions('Habitica Gems (Gift)', '4.00'));
+      expect(link).to.eql(approvalHerf);
+    });
+
+    it('creates a link for gifting a subscription', async () => {
+      let receivingUser = new User();
+      receivingUser.save();
+      let gift = {
+        type: 'subscription',
+        subscription: {
+          key: subKey,
+          uuid: receivingUser._id,
+        },
+      };
+
+      let link = await paypalPayments.checkout({gift});
+
+      expect(paypalPaymentCreateStub).to.be.calledOnce;
+      expect(paypalPaymentCreateStub).to.be.calledWith(getPaypalCreateOptions('mo. Habitica Subscription (Gift)', '15.00'));
+      expect(link).to.eql(approvalHerf);
+    });
+  });
+
+  describe('checkout success', () => {
+    let user, gift, customerId, paymentId;
+    let paypalPaymentExecuteStub, paymentBuyGemsStub, paymentsCreateSubscritionStub;
+
+    beforeEach(() => {
+      user = new User();
+      customerId = 'customerId-test';
+      paymentId = 'paymentId-test';
+
+      paypalPaymentExecuteStub = sinon.stub(paypalPayments, 'paypalPaymentExecute').returnsPromise().resolves({});
+      paymentBuyGemsStub = sinon.stub(payments, 'buyGems').returnsPromise().resolves({});
+      paymentsCreateSubscritionStub = sinon.stub(payments, 'createSubscription').returnsPromise().resolves({});
+    });
+
+    afterEach(() => {
+      paypalPayments.paypalPaymentExecute.restore();
+      payments.buyGems.restore();
+      payments.createSubscription.restore();
+    });
+
+    it('purchases gems', async () => {
+      await paypalPayments.checkoutSuccess({user, gift, paymentId, customerId});
+
+      expect(paypalPaymentExecuteStub).to.be.calledOnce;
+      expect(paypalPaymentExecuteStub).to.be.calledWith(paymentId, { payer_id: customerId });
+      expect(paymentBuyGemsStub).to.be.calledOnce;
+      expect(paymentBuyGemsStub).to.be.calledWith({
+        user,
+        customerId,
+        paymentMethod: 'Paypal',
+      });
+    });
+
+    it('gifts gems', async () => {
+      let receivingUser = new User();
+      await receivingUser.save();
+      gift = {
+        type: 'gems',
+        gems: {
+          amount: 16,
+          uuid: receivingUser._id,
+        },
+      };
+
+      await paypalPayments.checkoutSuccess({user, gift, paymentId, customerId});
+
+      expect(paypalPaymentExecuteStub).to.be.calledOnce;
+      expect(paypalPaymentExecuteStub).to.be.calledWith(paymentId, { payer_id: customerId });
+      expect(paymentBuyGemsStub).to.be.calledOnce;
+      expect(paymentBuyGemsStub).to.be.calledWith({
+        user,
+        customerId,
+        paymentMethod: 'PayPal (Gift)',
+        gift,
+      });
+    });
+
+    it('gifts subscription', async () => {
+      let receivingUser = new User();
+      await receivingUser.save();
+      gift = {
+        type: 'subscription',
+        subscription: {
+          key: subKey,
+          uuid: receivingUser._id,
+        },
+      };
+
+      await paypalPayments.checkoutSuccess({user, gift, paymentId, customerId});
+
+      expect(paypalPaymentExecuteStub).to.be.calledOnce;
+      expect(paypalPaymentExecuteStub).to.be.calledWith(paymentId, { payer_id: customerId });
+      expect(paymentsCreateSubscritionStub).to.be.calledOnce;
+      expect(paymentsCreateSubscritionStub).to.be.calledWith({
+        user,
+        customerId,
+        paymentMethod: 'PayPal (Gift)',
+        gift,
+      });
+    });
+  });
+
+  describe('subscribe', () => {
+    let coupon, sub, approvalHerf;
+    let paypalBillingAgreementCreateStub;
+
+    beforeEach(() => {
+      approvalHerf = 'approvalHerf-test';
+      sub = common.content.subscriptionBlocks[subKey];
+
+      paypalBillingAgreementCreateStub = sinon.stub(paypalPayments, 'paypalBillingAgreementCreate')
+        .returnsPromise().resolves({
+          links: [{ rel: 'approval_url', href: approvalHerf }],
+        });
+    });
+
+    afterEach(() => {
+      paypalPayments.paypalBillingAgreementCreate.restore();
+    });
+
+    it('should throw an error when coupon code is missing', async () => {
+      sub.discount = 40;
+
+      await expect(paypalPayments.subscribe({sub, coupon}))
+        .to.eventually.be.rejected.and.to.eql({
+          httpCode: 400,
+          name: 'BadRequest',
+          message: i18n.t('couponCodeRequired'),
+        });
+    });
+
+    it('should throw an error when coupon code is invalid', async () => {
+      sub.discount = 40;
+      sub.key = 'google_6mo';
+      coupon = 'example-coupon';
+
+      let couponModel = new Coupon();
+      couponModel.event = 'google_6mo';
+      await couponModel.save();
+
+      sinon.stub(cc, 'validate').returns('invalid');
+
+      await expect(paypalPayments.subscribe({sub, coupon}))
+        .to.eventually.be.rejected.and.to.eql({
+          httpCode: 401,
+          name: 'NotAuthorized',
+          message: i18n.t('invalidCoupon'),
+        });
+      cc.validate.restore();
+    });
+
+    it('subscribes with amazon with a coupon', async () => {
+      sub.discount = 40;
+      sub.key = 'google_6mo';
+      coupon = 'example-coupon';
+
+      let couponModel = new Coupon();
+      couponModel.event = 'google_6mo';
+      let updatedCouponModel = await couponModel.save();
+
+      sinon.stub(cc, 'validate').returns(updatedCouponModel._id);
+
+      let link = await paypalPayments.subscribe({sub, coupon});
+
+      expect(link).to.eql(approvalHerf);
+      expect(paypalBillingAgreementCreateStub).to.be.calledOnce;
+      let billingPlanTitle = `Habitica Subscription ($${sub.price} every ${sub.months} months, recurring)`;
+      expect(paypalBillingAgreementCreateStub).to.be.calledWith({
+        name: billingPlanTitle,
+        description: billingPlanTitle,
+        start_date: moment().add({ minutes: 5 }).format(),
+        plan: {
+          id: sub.paypalKey,
+        },
+        payer: {
+          payment_method: 'Paypal',
+        },
+      });
+
+      cc.validate.restore();
+    });
+
+    it('creates a link for a subscription', async () => {
+      delete sub.discount;
+
+      let link = await paypalPayments.subscribe({sub, coupon});
+
+      expect(link).to.eql(approvalHerf);
+      expect(paypalBillingAgreementCreateStub).to.be.calledOnce;
+      let billingPlanTitle = `Habitica Subscription ($${sub.price} every ${sub.months} months, recurring)`;
+      expect(paypalBillingAgreementCreateStub).to.be.calledWith({
+        name: billingPlanTitle,
+        description: billingPlanTitle,
+        start_date: moment().add({ minutes: 5 }).format(),
+        plan: {
+          id: sub.paypalKey,
+        },
+        payer: {
+          payment_method: 'Paypal',
+        },
+      });
+    });
+  });
+
+  describe('subscribeSuccess', () => {
+    let user, group, block, groupId, token, headers, customerId;
+    let paypalBillingAgreementExecuteStub, paymentsCreateSubscritionStub;
+
+    beforeEach(async () => {
+      user = new User();
+
+      group = generateGroup({
+        name: 'test group',
+        type: 'guild',
+        privacy: 'public',
+        leader: user._id,
+      });
+
+      token = 'test-token';
+      headers = {};
+      block = common.content.subscriptionBlocks[subKey];
+      customerId = 'test-customerId';
+
+      paypalBillingAgreementExecuteStub = sinon.stub(paypalPayments, 'paypalBillingAgreementExecute')
+        .returnsPromise({}).resolves({
+          id: customerId,
+        });
+      paymentsCreateSubscritionStub = sinon.stub(payments, 'createSubscription').returnsPromise().resolves({});
+    });
+
+    afterEach(() => {
+      paypalPayments.paypalBillingAgreementExecute.restore();
+      payments.createSubscription.restore();
+    });
+
+    it('creates a user subscription', async () => {
+      await paypalPayments.subscribeSuccess({user, block, groupId, token, headers});
+
+      expect(paypalBillingAgreementExecuteStub).to.be.calledOnce;
+      expect(paypalBillingAgreementExecuteStub).to.be.calledWith(token, {});
+
+      expect(paymentsCreateSubscritionStub).to.be.calledOnce;
+      expect(paymentsCreateSubscritionStub).to.be.calledWith({
+        user,
+        groupId,
+        customerId,
+        paymentMethod: 'Paypal',
+        sub: block,
+        headers,
+      });
+    });
+
+    it('create a group subscription', async () => {
+      groupId = group._id;
+
+      await paypalPayments.subscribeSuccess({user, block, groupId, token, headers});
+
+      expect(paypalBillingAgreementExecuteStub).to.be.calledOnce;
+      expect(paypalBillingAgreementExecuteStub).to.be.calledWith(token, {});
+
+      expect(paymentsCreateSubscritionStub).to.be.calledOnce;
+      expect(paymentsCreateSubscritionStub).to.be.calledWith({
+        user,
+        groupId,
+        customerId,
+        paymentMethod: 'Paypal',
+        sub: block,
+        headers,
+      });
+    });
+  });
+
+  describe('subscribeCancel', () => {
+    let user, group, groupId, customerId, groupCustomerId, nextBillingDate;
+    let paymentCancelSubscriptionSpy, paypalBillingAgreementCancelStub, paypalBillingAgreementGetStub;
+
+    beforeEach(async () => {
+      customerId = 'customer-id';
+      groupCustomerId = 'groupCustomerId-test';
+
+      user = new User();
+      user.profile.name = 'sender';
+      user.purchased.plan.customerId = customerId;
+      user.purchased.plan.planId = subKey;
+      user.purchased.plan.lastBillingDate = new Date();
+
+      group = generateGroup({
+        name: 'test group',
+        type: 'guild',
+        privacy: 'public',
+        leader: user._id,
+      });
+      group.purchased.plan.customerId = groupCustomerId;
+      group.purchased.plan.planId = subKey;
+      group.purchased.plan.lastBillingDate = new Date();
+      await group.save();
+
+      nextBillingDate = new Date();
+
+      paypalBillingAgreementCancelStub = sinon.stub(paypalPayments, 'paypalBillingAgreementCancel').returnsPromise().resolves({});
+      paypalBillingAgreementGetStub = sinon.stub(paypalPayments, 'paypalBillingAgreementGet')
+        .returnsPromise().resolves({
+          agreement_details: {
+            next_billing_date: nextBillingDate,
+            cycles_completed: 1,
+          },
+        });
+      paymentCancelSubscriptionSpy = sinon.stub(payments, 'cancelSubscription').returnsPromise().resolves({});
+    });
+
+    afterEach(function () {
+      paypalPayments.paypalBillingAgreementGet.restore();
+      paypalPayments.paypalBillingAgreementCancel.restore();
+      payments.cancelSubscription.restore();
+    });
+
+    it('should throw an error if we are missing a subscription', async () => {
+      user.purchased.plan.customerId = undefined;
+
+      await expect(paypalPayments.subscribeCancel({user}))
+        .to.eventually.be.rejected.and.to.eql({
+          httpCode: 401,
+          name: 'NotAuthorized',
+          message: i18n.t('missingSubscription'),
+        });
+    });
+
+    it('should throw an error if group is not found', async () => {
+      await expect(paypalPayments.subscribeCancel({user, groupId: 'fake-id'}))
+        .to.eventually.be.rejected.and.to.eql({
+          httpCode: 404,
+          name: 'NotFound',
+          message: i18n.t('groupNotFound'),
+        });
+    });
+
+    it('should throw an error if user is not group leader', async () => {
+      let nonLeader = new User();
+      nonLeader.guilds.push(group._id);
+      await nonLeader.save();
+
+      await expect(paypalPayments.subscribeCancel({user: nonLeader, groupId: group._id}))
+        .to.eventually.be.rejected.and.to.eql({
+          httpCode: 401,
+          name: 'NotAuthorized',
+          message: i18n.t('onlyGroupLeaderCanManageSubscription'),
+        });
+    });
+
+    it('should cancel a user subscription', async () => {
+      await paypalPayments.subscribeCancel({user});
+
+      expect(paypalBillingAgreementGetStub).to.be.calledOnce;
+      expect(paypalBillingAgreementGetStub).to.be.calledWith(customerId);
+      expect(paypalBillingAgreementCancelStub).to.be.calledOnce;
+      expect(paypalBillingAgreementCancelStub).to.be.calledWith(customerId, { note: i18n.t('cancelingSubscription') });
+
+      expect(paymentCancelSubscriptionSpy).to.be.calledOnce;
+      expect(paymentCancelSubscriptionSpy).to.be.calledWith({
+        user,
+        groupId,
+        paymentMethod: 'Paypal',
+        nextBill: nextBillingDate,
+        cancellationReason: undefined,
+      });
+    });
+
+    it('should cancel a group subscription', async () => {
+      await paypalPayments.subscribeCancel({user, groupId: group._id});
+
+      expect(paypalBillingAgreementGetStub).to.be.calledOnce;
+      expect(paypalBillingAgreementGetStub).to.be.calledWith(groupCustomerId);
+      expect(paypalBillingAgreementCancelStub).to.be.calledOnce;
+      expect(paypalBillingAgreementCancelStub).to.be.calledWith(groupCustomerId, { note: i18n.t('cancelingSubscription') });
+
+      expect(paymentCancelSubscriptionSpy).to.be.calledOnce;
+      expect(paymentCancelSubscriptionSpy).to.be.calledWith({
+        user,
+        groupId: group._id,
+        paymentMethod: 'Paypal',
+        nextBill: nextBillingDate,
+        cancellationReason: undefined,
+      });
+    });
+  });
+
+  describe('ipn', () => {
+    let user, group, txn_type, userPaymentId, groupPaymentId;
+    let ipnVerifyAsyncStub, paymentCancelSubscriptionSpy;
+
+    beforeEach(async () => {
+      txn_type = 'recurring_payment_profile_cancel';
+      userPaymentId = 'userPaymentId-test';
+      groupPaymentId = 'groupPaymentId-test';
+
+      user = new User();
+      user.profile.name = 'sender';
+      user.purchased.plan.customerId = userPaymentId;
+      user.purchased.plan.planId = subKey;
+      user.purchased.plan.lastBillingDate = new Date();
+      await user.save();
+
+      group = generateGroup({
+        name: 'test group',
+        type: 'guild',
+        privacy: 'public',
+        leader: user._id,
+      });
+      group.purchased.plan.customerId = groupPaymentId;
+      group.purchased.plan.planId = subKey;
+      group.purchased.plan.lastBillingDate = new Date();
+      await group.save();
+
+      ipnVerifyAsyncStub = sinon.stub(paypalPayments, 'ipnVerifyAsync').returnsPromise().resolves({});
+      paymentCancelSubscriptionSpy = sinon.stub(payments, 'cancelSubscription').returnsPromise().resolves({});
+    });
+
+    afterEach(function () {
+      paypalPayments.ipnVerifyAsync.restore();
+      payments.cancelSubscription.restore();
+    });
+
+    it('should cancel a user subscription', async () => {
+      await paypalPayments.ipn({txn_type, recurring_payment_id: userPaymentId});
+
+      expect(ipnVerifyAsyncStub).to.be.calledOnce;
+      expect(ipnVerifyAsyncStub).to.be.calledWith({txn_type, recurring_payment_id: userPaymentId});
+
+      expect(paymentCancelSubscriptionSpy).to.be.calledOnce;
+      expect(paymentCancelSubscriptionSpy.args[0][0].user._id).to.eql(user._id);
+      expect(paymentCancelSubscriptionSpy.args[0][0].paymentMethod).to.eql('Paypal');
+    });
+
+    it('should cancel a group subscription', async () => {
+      await paypalPayments.ipn({txn_type, recurring_payment_id: groupPaymentId});
+
+      expect(ipnVerifyAsyncStub).to.be.calledOnce;
+      expect(ipnVerifyAsyncStub).to.be.calledWith({txn_type, recurring_payment_id: groupPaymentId});
+
+      expect(paymentCancelSubscriptionSpy).to.be.calledOnce;
+      expect(paymentCancelSubscriptionSpy).to.be.calledWith({ groupId: group._id, paymentMethod: 'Paypal' });
+    });
+  });
+});
@@ -13,9 +13,6 @@ import analyticsService from '../../../../../website/server/libs/analyticsServic
 import * as cronLib from '../../../../../website/server/libs/cron';
 import { v4 as generateUUID } from 'uuid';

-const CRON_TIMEOUT_WAIT = new Date(60 * 60 * 1000).getTime();
-const CRON_TIMEOUT_UNIT = new Date(60 * 1000).getTime();
-
 describe('cron middleware', () => {
  let res, req;
  let user;
@@ -238,13 +235,7 @@ describe('cron middleware', () => {
    sandbox.spy(cronLib, 'recoverCron');

    sandbox.stub(User, 'update')
-      .withArgs({
-        _id: user._id,
-        $or: [
-          {_cronSignature: 'NOT_RUNNING'},
-          {_cronSignature: {$lt: sinon.match.number}},
-        ],
-      })
+      .withArgs({ _id: user._id, _cronSignature: 'NOT_RUNNING' })
      .returns({
        exec () {
          return Promise.resolve(updatedUser);
@@ -260,48 +251,4 @@ describe('cron middleware', () => {
      });
    });
  });
-
-  it('cronSignature less than an hour ago should error', async () => {
-    user.lastCron = moment(new Date()).subtract({days: 2});
-    let now = new Date();
-    await User.update({
-      _id: user._id,
-    }, {
-      $set: {
-        _cronSignature: now.getTime() - CRON_TIMEOUT_WAIT + CRON_TIMEOUT_UNIT,
-      },
-    }).exec();
-    await user.save();
-    let expectedErrMessage = `Impossible to recover from cron for user ${user._id}.`;
-
-    await new Promise((resolve, reject) => {
-      cronMiddleware(req, res, (err) => {
-        if (!err) return reject(new Error('Cron should have failed.'));
-        expect(err.message).to.be.equal(expectedErrMessage);
-        resolve();
-      });
-    });
-  });
-
-  it('cronSignature longer than an hour ago should allow cron', async () => {
-    user.lastCron = moment(new Date()).subtract({days: 2});
-    let now = new Date();
-    await User.update({
-      _id: user._id,
-    }, {
-      $set: {
-        _cronSignature: now.getTime() - CRON_TIMEOUT_WAIT - CRON_TIMEOUT_UNIT,
-      },
-    }).exec();
-    await user.save();
-
-    await new Promise((resolve, reject) => {
-      cronMiddleware(req, res, (err) => {
-        if (err) return reject(err);
-        expect(moment(now).isSame(user.auth.timestamps.loggedin, 'day'));
-        expect(user._cronSignature).to.be.equal('NOT_RUNNING');
-        resolve();
-      });
-    });
-  });
 });
@@ -7,7 +7,6 @@ import {
 import i18n from '../../../../../website/common/script/i18n';
 import { ensureAdmin, ensureSudo } from '../../../../../website/server/middlewares/ensureAccessRight';
 import { NotAuthorized } from '../../../../../website/server/libs/errors';
-import apiMessages from '../../../../../website/server/libs/apiMessages';

 describe('ensure access middlewares', () => {
  let res, req, next;
@@ -43,7 +42,7 @@ describe('ensure access middlewares', () => {

      ensureSudo(req, res, next);

-      expect(next).to.be.calledWith(new NotAuthorized(apiMessages('noSudoAccess')));
+      expect(next).to.be.calledWith(new NotAuthorized(i18n.t('noSudoAccess')));
    });

    it('passes when user is a sudo user', () => {
@@ -4,7 +4,6 @@ import {
  generateNext,
 } from '../../../../helpers/api-unit.helper';
 import responseMiddleware from '../../../../../website/server/middlewares/response';
-import packageInfo from '../../../../../package.json';

 describe('response middleware', () => {
  let res, req, next;
@@ -35,7 +34,6 @@ describe('response middleware', () => {
      data: {field: 1},
      notifications: [],
      userV: res.locals.user._v,
-      appVersion: packageInfo.version,
    });
  });

@@ -53,7 +51,6 @@ describe('response middleware', () => {
      message: 'hello',
      notifications: [],
      userV: res.locals.user._v,
-      appVersion: packageInfo.version,
    });
  });

@@ -70,7 +67,6 @@ describe('response middleware', () => {
      data: {field: 1},
      notifications: [],
      userV: res.locals.user._v,
-      appVersion: packageInfo.version,
    });
  });

@@ -85,7 +81,6 @@ describe('response middleware', () => {
      data: {field: 1},
      notifications: [],
      userV: 0,
-      appVersion: packageInfo.version,
    });
  });

@@ -109,7 +104,6 @@ describe('response middleware', () => {
        },
      ],
      userV: res.locals.user._v,
-      appVersion: packageInfo.version,
    });
  });
 });
@@ -282,7 +282,7 @@ describe('Group Model', () => {
          expect(finishQuest).to.be.calledWith(quest);
        });

-        context('with healing Rage', () => {
+        context('with Rage', () => {
          beforeEach(async () => {
            party.quest.active = false;
            party.quest.key = 'trex_undead';
@@ -327,46 +327,6 @@ describe('Group Model', () => {
            expect(party.quest.progress.hp).to.eql(500);
          });
        });
-
-        context('with Mana drain Rage', () => {
-          beforeEach(async () => {
-            party.quest.active = false;
-            party.quest.key = 'lostMasterclasser4';
-
-            await party.startQuest(questLeader);
-            await party.save();
-          });
-
-          it('applies down progress to boss rage', async () => {
-            progress.down = -2;
-
-            await Group.processQuestProgress(participatingMember, progress);
-
-            party = await Group.findOne({_id: party._id});
-
-            expect(party.quest.progress.rage).to.eql(8);
-
-            let drainedUser = await User.findById(participatingMember._id);
-            expect(drainedUser.stats.mp).to.eql(10);
-          });
-
-          it('activates rage when progress.down triggers rage bar', async () => {
-            let quest = questScrolls[party.quest.key];
-
-            progress.down = -999;
-
-            await party.save();
-            await Group.processQuestProgress(participatingMember, progress);
-
-            party = await Group.findOne({_id: party._id});
-
-            expect(Group.prototype.sendChat).to.be.calledWith(quest.boss.rage.effect('en'));
-            expect(party.quest.progress.rage).to.eql(0);
-
-            let drainedUser = await User.findById(participatingMember._id);
-            expect(drainedUser.stats.mp).to.eql(0);
-          });
-        });
      });

      context('Collection Quests', () => {
@@ -391,20 +351,6 @@ describe('Group Model', () => {
          expect(party.quest.progress.collect.soapBars).to.eq(5);
        });

-        it('does not drop an item if not need when on a collection quest', async () => {
-          party.quest.key = 'dilatoryDistress1';
-          party.quest.active = false;
-          await party.startQuest(questLeader);
-          party.quest.progress.collect.fireCoral = 20;
-          await party.save();
-
-          await Group.processQuestProgress(participatingMember, progress);
-
-          party = await Group.findOne({_id: party._id});
-
-          expect(party.quest.progress.collect.fireCoral).to.eq(20);
-        });
-
        it('sends a chat message about progress', async () => {
          await Group.processQuestProgress(participatingMember, progress);

@@ -1396,42 +1342,6 @@ describe('Group Model', () => {
        expect(updatedParticipatingMember.achievements.quests[quest.key]).to.eql(1);
      });

-      it('gives out super awesome Masterclasser achievement to the deserving', async () => {
-        quest = questScrolls.lostMasterclasser4;
-        party.quest.key = quest.key;
-
-        questLeader.achievements.quests = {
-          mayhemMistiflying1: 1,
-          mayhemMistiflying2: 1,
-          mayhemMistiflying3: 1,
-          stoikalmCalamity1: 1,
-          stoikalmCalamity2: 1,
-          stoikalmCalamity3: 1,
-          taskwoodsTerror1: 1,
-          taskwoodsTerror2: 1,
-          taskwoodsTerror3: 1,
-          dilatoryDistress1: 1,
-          dilatoryDistress2: 1,
-          dilatoryDistress3: 1,
-          lostMasterclasser1: 1,
-          lostMasterclasser2: 1,
-          lostMasterclasser3: 1,
-        };
-        await questLeader.save();
-        await party.finishQuest(quest);
-
-        let [
-          updatedLeader,
-          updatedParticipatingMember,
-        ] = await Promise.all([
-          User.findById(questLeader._id),
-          User.findById(participatingMember._id),
-        ]);
-
-        expect(updatedLeader.achievements.lostMasterclasser).to.eql(true);
-        expect(updatedParticipatingMember.achievements.lostMasterclasser).to.not.eql(true);
-      });
-
      it('gives xp and gold', async () => {
        await party.finishQuest(quest);

--- a/Show More
+++ b/Show More