4.2.0

2017-10-04 18:35:05 -05:00
8297 changed files with 130730 additions and 46911 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.11.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"
+  }
+}
@@ -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']);
 }
@@ -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;
@@ -2,7 +2,7 @@ var _id = '';
 var update = {
  $addToSet: {
    'purchased.plan.mysteryItems':{
-      $each:['armor_mystery_201711','body_mystery_201711']
+      $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,7 +1,7 @@
 {
  "name": "habitica",
  "description": "A habit tracker app which treats your goals like a Role Playing Game.",
-  "version": "4.12.3",
+  "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,13 +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",
-    "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",
@@ -136,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",
@@ -145,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"
  },
@@ -178,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",
@@ -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},
-      });
-    });
-  });
 });
@@ -12,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';
@@ -97,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}))
@@ -180,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',
@@ -190,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;
@@ -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 () => {
@@ -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;
-    });
-  });
 });
@@ -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
  });
 });
@@ -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 () => {
@@ -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;
@@ -3,7 +3,7 @@
 import {
  generateUser,
  translate as t,
-} from '../../../../../helpers/api-integration/v3';
+} from '../../../../helpers/api-integration/v3';

 describe('POST /user/buy-gear/: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,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,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,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', () => {
@@ -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 () => {
@@ -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();
-      });
-    });
-  });
 });
@@ -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', () => {
@@ -1382,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);

@@ -0,0 +1,7 @@
+{
+    "globals": {
+      "browser": true,
+      "by": true,
+      "element": true
+    }
+}
@@ -0,0 +1,22 @@
+import fs from 'fs';
+import { resetHabiticaDB } from '../../helpers/mongo';
+
+before(async () => {
+  await resetHabiticaDB();
+});
+
+// based on https://github.com/angular/protractor/issues/114#issuecomment-29046939
+afterEach(async function () {
+  let lastTest = this.currentTest;
+
+  if (lastTest.state === 'failed') {
+    let filename = `exception_${lastTest.title}.png`;
+    let png = await browser.takeScreenshot();
+    let buffer = new Buffer(png, 'base64');
+    let stream = fs.createWriteStream(filename);
+
+    stream.write(buffer);
+    stream.end();
+  }
+});
+
@@ -0,0 +1,30 @@
+'use strict';
+
+let chai = require('chai');
+let chaiAsPromised = require('chai-as-promised');
+
+require('babel-register');
+require('babel-polyfill');
+
+exports.config = {
+  specs: ['./helper.js', './**/*.test.js'],
+  baseUrl: 'http://localhost:3003/',
+  capabilities: {
+    browserName: 'firefox',
+  },
+  directConnect: true,
+  seleniumAddress: 'http://localhost:4444/wd/hub',
+  framework: 'mocha',
+  mochaOpts: {
+    reporter: 'spec',
+    slow: 6000,
+    timeout: 10000,
+    compilers: 'js:babel-register',
+  },
+  onPrepare: () => {
+    browser.ignoreSynchronization = true;
+
+    chai.use(chaiAsPromised);
+    global.expect = chai.expect;
+  },
+};
@@ -0,0 +1,64 @@
+import { v4 as generateUniqueId } from 'uuid';
+
+describe('Static Front Page', () => {
+  beforeEach(() => {
+    browser.get('/');
+    browser.sleep(1000);
+  });
+
+  it('shows the front page', async () => {
+    let button = element(by.id('play-btn'));
+
+    await expect(button.getText()).to.eventually.eql('Join for free');
+  });
+
+  it('does not login when using wrong credentials', async () => {
+    let button = element(by.id('play-btn'));
+    let randomName = generateUniqueId();
+
+    button.click();
+    browser.sleep(1000);
+
+    element(by.model('loginUsername')).sendKeys(randomName);
+    element(by.model('loginPassword')).sendKeys('pass');
+
+    let login = element(by.css('#loginForm input[value="Login"]'));
+
+    login.click();
+    browser.sleep(1000);
+
+    let alertDialog = browser.switchTo().alert();
+
+    await expect(alertDialog.getText()).to.eventually.match(/username or password is incorrect./);
+
+    alertDialog.accept();
+  });
+
+  it('registers a new user', async function () {
+    this.timeout(30000); // TODO: Speed up registration action. Takes way too long and times out unless you extend the timeout
+
+    let button = element(by.id('play-btn'));
+    let randomName = generateUniqueId();
+
+    button.click();
+    browser.sleep(1000);
+
+    let registerTab = element(by.linkText('Register'));
+    registerTab.click();
+    element(by.model('registerVals.username')).sendKeys(randomName);
+    element(by.model('registerVals.email')).sendKeys(`${randomName}@example.com`);
+    element(by.model('registerVals.password')).sendKeys('pass');
+    element(by.model('registerVals.confirmPassword')).sendKeys('pass');
+
+    let register = element(by.css('#registrationForm input[type="submit"]'));
+
+    register.click();
+    browser.sleep(3000);
+
+    let url = await browser.getCurrentUrl();
+
+    expect(url).to.not.match(/static\/front/);
+  });
+
+  it('logs in an existing user');
+});
@@ -0,0 +1,31 @@
+'use strict';
+
+describe('AppJS', function() {
+  describe('Automatic page refresh', function(){
+    var clock;
+    beforeEach(function () {
+      clock = sandbox.useFakeTimers();
+      sandbox.stub(window, "refresher", function(){return true});
+    });
+
+    it('should not call refresher if idle time is less than 6 hours', function() {
+      window.awaitIdle();
+      clock.tick(21599999);
+      expect(window.refresher).to.not.be.called;
+    });
+
+    it('should not call refresher if awaitIdle is called within 6 hours', function() {
+      window.awaitIdle();
+      clock.tick(21500000);
+      window.awaitIdle();
+      clock.tick(21500000);
+      expect(window.refresher).to.not.be.called;
+    });
+
+    it('should call refresher if idle time is 6 hours or greater', function() {
+      window.awaitIdle();
+      clock.tick(21900000);
+      expect(window.refresher).to.be.called;
+    });
+  });
+});
@@ -0,0 +1,125 @@
+'use strict';
+
+describe('Auth Controller', function() {
+  var scope, ctrl, user, $httpBackend, $window, $modal, alert, Auth;
+
+  beforeEach(function(){
+    module(function($provide) {
+      Auth = {
+        runAuth: sandbox.spy(),
+      };
+      $provide.value('Analytics', analyticsMock);
+      $provide.value('Chat', { seenMessage: function() {} });
+      $provide.value('Auth', Auth);
+    });
+
+    inject(function(_$httpBackend_, $rootScope, $controller, _$modal_) {
+      $httpBackend = _$httpBackend_;
+      scope = $rootScope.$new();
+      scope.loginUsername = 'user';
+      scope.loginPassword = 'pass';
+      $window = { location: { href: ""}, alert: sandbox.spy() };
+      $modal = _$modal_;
+      user = { user: {}, authenticate: sandbox.spy() };
+      alert = { authErrorAlert: sandbox.spy() };
+
+      ctrl = $controller('AuthCtrl', {$scope: scope, $window: $window, User: user, Alert: alert});
+    })
+  });
+
+  describe('logging in', function() {
+    it('should log in users with correct uname / pass', function() {
+      $httpBackend.expectPOST('/api/v3/user/auth/local/login').respond({data: {id: 'abc', apiToken: 'abc'}});
+      scope.auth();
+      $httpBackend.flush();
+      expect(Auth.runAuth).to.be.calledOnce;
+      expect(alert.authErrorAlert).to.not.be.called;
+    });
+
+    it('should not log in users with incorrect uname / pass', function() {
+      $httpBackend.expectPOST('/api/v3/user/auth/local/login').respond(404, '');
+      scope.auth();
+      $httpBackend.flush();
+      expect(Auth.runAuth).to.not.be.called;
+      expect(alert.authErrorAlert).to.be.calledOnce;
+    });
+  });
+
+  describe('#clearLocalStorage', function () {
+    var timer;
+
+    beforeEach(function () {
+      timer = sandbox.useFakeTimers();
+      sandbox.stub($modal, 'open');
+    });
+
+    it('opens modal with message about clearing local storage and logging out', function () {
+      scope.clearLocalStorage();
+
+      expect($modal.open).to.be.calledOnce;
+      expect($modal.open).to.be.calledWith({
+        templateUrl: 'modals/message-modal.html',
+        scope: scope
+      });
+
+      expect(scope.messageModal.title).to.eql(window.env.t('localStorageClearing'));
+      expect(scope.messageModal.body).to.eql(window.env.t('localStorageClearingExplanation'));
+    });
+
+    it('does not call $scope.logout before 3 seconds', function () {
+      sandbox.stub(scope, 'logout');
+
+      scope.clearLocalStorage();
+
+      timer.tick(2999);
+
+      expect(scope.logout).to.not.be.called;
+    });
+
+    it('calls $scope.logout after 3 seconds', function () {
+      sandbox.stub(scope, 'logout');
+
+      scope.clearLocalStorage();
+
+      timer.tick(3000);
+
+      expect(scope.logout).to.be.calledOnce;
+    });
+
+    it('does not clear local storage before 3 seconds', function () {
+      sandbox.stub(localStorage, 'clear');
+
+      scope.clearLocalStorage();
+
+      timer.tick(2999);
+
+      expect(localStorage.clear).to.not.be.called;
+    });
+
+    it('clears local storage after 3 seconds', function () {
+      sandbox.stub(localStorage, 'clear');
+
+      scope.clearLocalStorage();
+
+      timer.tick(3000);
+
+      expect(localStorage.clear).to.be.calledOnce;
+    });
+
+    it('does not redirect to /logout route before 3 seconds', function () {
+      scope.clearLocalStorage();
+
+      timer.tick(2999);
+
+      expect($window.location.href).to.eql('');
+    });
+
+    it('redirects to /logout after 3 seconds', function () {
+      scope.clearLocalStorage();
+
+      timer.tick(3000);
+
+      expect($window.location.href).to.eql('/logout');
+    });
+  });
+});
@@ -0,0 +1,120 @@
+'use strict';
+
+describe("Autocomplete controller", function() {
+  var scope, ctrl, user, $rootScope, $controller;
+
+  beforeEach(function() {
+    module(function($provide) {
+      $provide.value('User', {});
+    });
+
+    inject(function($rootScope, _$controller_){
+      user = specHelper.newUser();
+      user._id = "unique-user-id";
+
+      scope = $rootScope.$new();
+      scope.group = {}
+      scope.group.chat = [];
+
+      $controller = _$controller_;
+
+      // Load RootCtrl to ensure shared behaviors are loaded
+      $controller('RootCtrl',  {$scope: scope, User: {user: user}});
+
+      ctrl = $controller('AutocompleteCtrl', {$scope: scope});
+    });
+  });
+
+  describe("clearUserList", function() {
+    it('calling the function clears the list of usernames and responses', function() {
+      scope.response.push("blah");
+      scope.usernames.push("blub");
+
+      scope.clearUserlist();
+      expect(scope.response).to.be.empty;
+      expect(scope.usernames).to.be.empty;
+    });
+
+    it('the function is called upon initialization of the controller', function() {
+      scope.response.push("blah");
+      scope.response.push("blub");
+      ctrl = $controller('AutocompleteCtrl', {$scope: scope});
+
+      expect(scope.response).to.be.empty;
+      expect(scope.usernames).to.be.empty;
+    });
+  })
+
+  describe("filterUser", function() {
+    it('filters with undefined query (not loaded yet) and returns false (so it will not be rendered)', function() {
+        expect(scope.filterUser({user: "boo"})).to.be.eq(false);
+    });
+
+    it('filters with null query (no typing yet) and returns false (so it will not be rendered)', function() {
+      scope.query = null
+      expect(scope.filterUser({user: "boo"})).to.be.eq(false);
+    });
+
+    it('filters with empty prefix and returns true', function() {
+      scope.query = {text: ""};
+      expect(scope.filterUser({user: "prefix"})).to.be.eq(true);
+    });
+
+    it('filters with prefix element and returns true', function() {
+      scope.query = {text: "pre"}
+      expect(scope.filterUser({user: "prefix"})).to.be.eq(true);
+    });
+
+    it('filters with prefix element of a different case and returns true', function() {
+      scope.query = {text: "pre"}
+      expect(scope.filterUser({user: "Prefix"})).to.be.eq(true);
+    });
+
+    it('filters with nonprefix element and returns false', function() {
+      scope.query = {text: "noprefix"}
+      expect(scope.filterUser({user: "prefix"})).to.be.eq(false);
+    });
+
+    it('filters out system messages (messages without username)', function() {
+      scope.query = {text: "myquery"}
+      expect(scope.filterUser({uuid: "system"})).to.be.eq(false);
+    });
+  });
+
+  describe("performCompletion", function() {
+    it('triggers autoComplete', function() {
+      scope.autoComplete = sandbox.spy();
+
+      var msg = {user: "boo"}; // scope.autoComplete only cares about user
+      scope.query = {text: "b"};
+      scope.performCompletion(msg);
+
+      expect(scope.query).to.be.eq(null);
+      expect(scope.autoComplete.callCount).to.be.eq(1);
+      expect(scope.autoComplete).to.have.been.calledWith(msg);
+    });
+  });
+
+  describe("addNewUser", function() {
+    it('a new message from a new user will modify the usernames', function() {
+      expect(scope.response).to.be.empty;
+      expect(scope.usernames).to.be.empty;
+
+      var msg = {user: "boo"};
+      scope.addNewUser(msg);
+      expect(scope.response[0]).to.be.eq(msg);
+      expect(scope.usernames[0]).to.be.eq("boo");
+    });
+  });
+
+  describe("chatChanged", function() {
+    it('if a new chat arrives, the new user name is extracted', function() {
+      var chatChanged = sandbox.spy(scope, 'chatChanged');
+      scope.$watch('group.chat',scope.chatChanged); // reinstantiate watch so spy works
+
+      scope.$digest(); // trigger watch
+      scope.group.chat.push({msg: "new chat", user: "boo"});
+      expect(chatChanged.callCount).to.be.eq(1);
+    });
+  });
+});
@@ -0,0 +1,774 @@
+'use strict';
+
+describe('Challenges Controller', function() {
+  var rootScope, scope, user, User, ctrl, groups, members, notification, state, challenges, tasks, tavernId;
+
+  beforeEach(function() {
+    module(function($provide) {
+      user = specHelper.newUser();
+      User = {
+        getBalanceInGems: sandbox.stub(),
+        sync: sandbox.stub(),
+        user: user
+      }
+      $provide.value('User', User);
+    });
+
+    inject(function($rootScope, $controller, _$state_, _Groups_, _Members_, _Notification_, _Challenges_, _Tasks_, _TAVERN_ID_){
+      scope = $rootScope.$new();
+      rootScope = $rootScope;
+
+      // Load RootCtrl to ensure shared behaviors are loaded
+      $controller('RootCtrl',  {$scope: scope, User: User});
+
+      ctrl = $controller('ChallengesCtrl', {$scope: scope, User: User});
+
+      challenges = _Challenges_;
+      tasks = _Tasks_;
+      groups = _Groups_;
+      members = _Members_;
+      notification = _Notification_;
+      state = _$state_;
+      tavernId = _TAVERN_ID_;
+    });
+  });
+
+  context('filtering', function() {
+    describe('filterChallenges', function() {
+      var ownMem, ownNotMem, notOwnMem, notOwnNotMem;
+
+      beforeEach(function() {
+        ownMem = specHelper.newChallenge({
+          description: 'You are the owner and member',
+          leader: user._id,
+          members: [user],
+          _isMember: true,
+          _id: 'ownMem-id',
+        });
+
+        ownNotMem = specHelper.newChallenge({
+          description: 'You are the owner, but not a member',
+          leader: user._id,
+          members: [],
+          _isMember: false,
+          _id: 'ownNotMem-id',
+        });
+
+        notOwnMem = specHelper.newChallenge({
+          description: 'Not owner but a member',
+          leader: {_id:"test"},
+          members: [user],
+          _isMember: true,
+          _id: 'notOwnMem-id',
+        });
+
+        notOwnNotMem = specHelper.newChallenge({
+          description: 'Not owner or member',
+          leader: {_id:"test"},
+          members: [],
+          _isMember: false,
+          _id: 'notOwnNotMem-id',
+        });
+
+        user.challenges = [ownMem._id, notOwnMem._id];
+
+        scope.search = {
+          group: _.transform(groups, function(m,g){m[g._id]=true;})
+        };
+      });
+
+      it('displays challenges that match membership: either and owner: either', function() {
+        scope.search._isMember = 'either';
+        scope.search._isOwner = 'either';
+        expect(scope.filterChallenges(ownMem)).to.eql(true);
+        expect(scope.filterChallenges(ownNotMem)).to.eql(true);
+        expect(scope.filterChallenges(notOwnMem)).to.eql(true);
+        expect(scope.filterChallenges(notOwnNotMem)).to.eql(true);
+      });
+
+      it('displays challenges that match membership: either and owner: true', function() {
+        scope.search._isMember = 'either';
+        scope.search._isOwner = true;
+        expect(scope.filterChallenges(ownMem)).to.eql(true);
+        expect(scope.filterChallenges(ownNotMem)).to.eql(true);
+        expect(scope.filterChallenges(notOwnMem)).to.eql(false);
+        expect(scope.filterChallenges(notOwnNotMem)).to.eql(false);
+      });
+
+      it('displays challenges that match membership: either and owner: false', function() {
+        scope.search._isMember = 'either';
+        scope.search._isOwner = false;
+        expect(scope.filterChallenges(ownMem)).to.eql(false);
+        expect(scope.filterChallenges(ownNotMem)).to.eql(false);
+        expect(scope.filterChallenges(notOwnMem)).to.eql(true);
+        expect(scope.filterChallenges(notOwnNotMem)).to.eql(true);
+      });
+
+      it('displays challenges that match membership: true and owner: either', function() {
+        scope.search._isMember = true;
+        scope.search._isOwner = 'either';
+        expect(scope.filterChallenges(ownMem)).to.eql(true);
+        expect(scope.filterChallenges(ownNotMem)).to.eql(false);
+        expect(scope.filterChallenges(notOwnMem)).to.eql(true);
+        expect(scope.filterChallenges(notOwnNotMem)).to.eql(false);
+      });
+
+      it('displays challenges that match membership: true and owner: true', function() {
+        scope.search._isMember = true;
+        scope.search._isOwner = true;
+        expect(scope.filterChallenges(ownMem)).to.eql(true);
+        expect(scope.filterChallenges(ownNotMem)).to.eql(false);
+        expect(scope.filterChallenges(notOwnMem)).to.eql(false);
+        expect(scope.filterChallenges(notOwnNotMem)).to.eql(false);
+      });
+
+      it('displays challenges that match membership: true and owner: false', function() {
+        scope.search._isMember = true;
+        scope.search._isOwner = false;
+        expect(scope.filterChallenges(ownMem)).to.eql(false);
+        expect(scope.filterChallenges(ownNotMem)).to.eql(false);
+        expect(scope.filterChallenges(notOwnMem)).to.eql(true);
+        expect(scope.filterChallenges(notOwnNotMem)).to.eql(false);
+      });
+
+      it('displays challenges that match membership: false and owner: either', function() {
+        scope.search._isMember = false;
+        scope.search._isOwner = 'either';
+        expect(scope.filterChallenges(ownMem)).to.eql(false);
+        expect(scope.filterChallenges(ownNotMem)).to.eql(true);
+        expect(scope.filterChallenges(notOwnMem)).to.eql(false);
+        expect(scope.filterChallenges(notOwnNotMem)).to.eql(true);
+      });
+
+      it('displays challenges that match membership: false and owner: true', function() {
+        scope.search._isMember = false;
+        scope.search._isOwner = true;
+        expect(scope.filterChallenges(ownMem)).to.eql(false);
+        expect(scope.filterChallenges(ownNotMem)).to.eql(true);
+        expect(scope.filterChallenges(notOwnMem)).to.eql(false);
+        expect(scope.filterChallenges(notOwnNotMem)).to.eql(false);
+      });
+
+      it('displays challenges that match membership: false and owner: false', function() {
+        scope.search._isMember = false;
+        scope.search._isOwner = false;
+        expect(scope.filterChallenges(ownMem)).to.eql(false);
+        expect(scope.filterChallenges(ownNotMem)).to.eql(false);
+        expect(scope.filterChallenges(notOwnMem)).to.eql(false);
+        expect(scope.filterChallenges(notOwnNotMem)).to.eql(true);
+      });
+
+      it('filters challenges to a single group when group id filter is set', inject(function($controller) {
+        scope.search = { };
+        scope.groupsFilter = {
+          0: specHelper.newGroup({_id: 'group-one'}),
+          1: specHelper.newGroup({_id: 'group-two'}),
+          2: specHelper.newGroup({_id: 'group-three'})
+        };
+
+        scope.groupIdFilter = 'group-one';
+        scope.filterInitialChallenges();
+        expect(scope.search.group).to.eql({'group-one': true});
+      }));
+    });
+
+    describe('selectAll', function() {
+      it('sets all groups in seach.group to true', function() {
+        scope.search = { };
+        scope.groupsFilter = {
+          0: specHelper.newGroup({_id: 'group-one'}),
+          1: specHelper.newGroup({_id: 'group-two'}),
+          2: specHelper.newGroup({_id: 'group-three'})
+        };
+        scope.selectAll();
+
+        expect(scope.search.group).to.eql({
+          'group-one': true,
+          'group-two': true,
+          'group-three': true
+        });
+      });
+    });
+
+    describe('selectNone', function() {
+      it('sets all groups in seach.group to false', function() {
+        scope.search = { };
+        scope.groupsFilter = {
+          0: specHelper.newGroup({_id: 'group-one'}),
+          1: specHelper.newGroup({_id: 'group-two'}),
+          2: specHelper.newGroup({_id: 'group-three'})
+        };
+        scope.selectNone();
+
+        expect(scope.search.group).to.eql({
+          'group-one': false,
+          'group-two': false,
+          'group-three': false
+        });
+      });
+    });
+  });
+
+  context('task manipulation', function() {
+
+    describe('shouldShow', function() {
+      it('overrides task controller function by always returning true', function() {
+        expect(scope.shouldShow()).to.eq(true);
+      });
+    });
+
+    describe('addTask', function() {
+      var challenge;
+
+      beforeEach(function () {
+        challenge = specHelper.newChallenge({
+          description: 'You are the owner and member',
+          leader: user._id,
+          members: [user],
+          _isMember: true
+        });
+      });
+
+      it('adds default task to array', function() {
+        var taskArray = [];
+        var listDef = {
+          newTask: 'new todo text',
+          type: 'todo'
+        }
+
+        scope.addTask(listDef, challenge);
+
+        expect(challenge['todos'].length).to.eql(1);
+        expect(challenge['todos'][0].text).to.eql('new todo text');
+        expect(challenge['todos'][0].type).to.eql('todo');
+      });
+
+      it('adds the task to the front of the array', function() {
+        var previousTask = specHelper.newTodo({ text: 'previous task' });
+        var taskArray = [];
+        challenge['todos'] = [previousTask];
+        var listDef = {
+          newTask: 'new todo',
+          type: 'todo'
+        }
+
+        scope.addTask(listDef, challenge);
+
+        expect(challenge['todos'].length).to.eql(2);
+        expect(challenge['todos'][0].text).to.eql('new todo');
+        expect(challenge['todos'][1].text).to.eql('previous task');
+      });
+
+      it('removes text from new task input box', function() {
+        var taskArray = [];
+        var listDef = {
+          newTask: 'new todo text',
+          type: 'todo'
+        }
+
+        scope.addTask(listDef, challenge);
+
+        expect(listDef.newTask).to.not.exist;
+      });
+    });
+
+    describe('editTask', function() {
+      it('is Tasks.editTask', function() {
+        inject(function(Tasks) {
+          // @TODO: Currently we override the task function in the challenge ctrl, but we should abstract it again
+          // expect(scope.editTask).to.eql(Tasks.editTask);
+        });
+      });
+    });
+
+    describe('removeTask', function() {
+      var task, challenge;
+
+      beforeEach(function() {
+        sandbox.stub(window, 'confirm');
+        task = specHelper.newTodo();
+        challenge = specHelper.newChallenge({
+          description: 'You are the owner and member',
+          leader: user._id,
+          members: [user],
+          _isMember: true
+        });
+        challenge['todos'] = [task];
+      });
+
+      it('asks user to confirm deletion', function() {
+        scope.removeTask(task, challenge);
+        expect(window.confirm).to.be.calledOnce;
+      });
+
+      it('does not remove task from list if not confirmed', function() {
+        window.confirm.returns(false);
+        scope.removeTask(task, challenge);
+
+        expect(challenge['todos']).to.include(task);
+      });
+
+      it('removes task from list', function() {
+        window.confirm.returns(true);
+        scope.removeTask(task, challenge);
+
+        expect(challenge['todos']).to.not.include(task);
+      });
+    });
+
+    describe('saveTask', function() {
+      it('sets task._editing to false', function() {
+        var task = specHelper.newTask({ _editing: true });
+
+        scope.saveTask(task);
+
+        expect(task._editing).to.be.eql(false);
+      });
+    });
+  });
+
+  context('challenge owner interactions', function() {
+    describe("save challenge", function() {
+      var alert, createChallengeSpy, challengeResponse, taskChallengeCreateSpy;
+
+      beforeEach(function(){
+        alert = sandbox.stub(window, "alert");
+        createChallengeSpy = sinon.stub(challenges, 'createChallenge');
+        challengeResponse = {data: {data: {_id: 'new-challenge'}}};
+        createChallengeSpy.returns(Promise.resolve(challengeResponse));
+
+        taskChallengeCreateSpy = sinon.stub(tasks, 'createChallengeTasks');
+        var taskResponse = {data: {data: []}};
+        taskChallengeCreateSpy.returns(Promise.resolve(taskResponse));
+      });
+
+      it("opens an alert box if challenge.group is not specified", function() {
+        var challenge = specHelper.newChallenge({
+          name: 'Challenge without a group',
+          shortName: 'chal without group',
+          group: null
+        });
+
+        scope.save(challenge);
+
+        expect(alert).to.be.calledOnce;
+        expect(alert).to.be.calledWith(window.env.t('selectGroup'));
+      });
+
+      it("opens an alert box if isNew and user does not have enough gems", function() {
+        var challenge = specHelper.newChallenge({
+          name: 'Challenge without enough gems',
+          shortName: 'chal without gem',
+          prize: 5
+        });
+
+        scope.maxPrize = 4;
+        scope.save(challenge);
+
+        expect(alert).to.be.calledOnce;
+        expect(alert).to.be.calledWith(window.env.t('challengeNotEnoughGems'));
+      });
+
+      it("saves the challenge if user does not have enough gems, but the challenge is not new", function() {
+        var updateChallengeSpy = sinon.spy(challenges, 'updateChallenge');
+
+        var challenge = specHelper.newChallenge({
+          _id: 'challenge-has-id-so-its-not-new',
+          name: 'Challenge without enough gems',
+          shortName: 'chal without gem',
+          prize: 5,
+        });
+
+        scope.maxPrize = 0;
+        scope.save(challenge);
+
+        expect(updateChallengeSpy).to.be.calledOnce;
+        expect(alert).to.not.be.called;
+      });
+
+      it("saves the challenge if user has enough gems and challenge is new", function() {
+        var challenge = specHelper.newChallenge({
+          name: 'Challenge without enough gems',
+          shortName: 'chal without gem',
+          prize: 5,
+        });
+
+        scope.maxPrize = 5;
+        scope.save(challenge);
+
+        expect(createChallengeSpy).to.be.calledOnce;
+        expect(alert).to.not.be.called;
+      });
+
+      it('saves challenge and then proceeds to detail page', function(done) {
+        sandbox.stub(state, 'transitionTo');
+
+        var challenge = specHelper.newChallenge({
+          name: 'Challenge',
+          shortName: 'chal',
+        });
+
+        setTimeout(function() {
+          expect(createChallengeSpy).to.be.calledOnce;
+          expect(state.transitionTo).to.be.calledWith(
+            'options.social.challenges.detail',
+            { cid: 'new-challenge' },
+            {
+              reload: true, inherit: false, notify: true
+            }
+          );
+          done();
+        }, 1000);
+
+        scope.save(challenge);
+      });
+
+      it('saves new challenge and syncs User', function(done) {
+        var challenge = specHelper.newChallenge();
+        challenge.shortName = 'chal';
+
+        setTimeout(function() {
+          expect(User.sync).to.be.calledOnce;
+          done();
+        }, 1000);
+
+        scope.save(challenge);
+      });
+
+      it('saves new challenge and syncs User', function(done) {
+        sinon.stub(notification, 'text');
+
+        var challenge = specHelper.newChallenge();
+        challenge.shortName = 'chal';
+
+        setTimeout(function() {
+          expect(notification.text).to.be.calledOnce;
+          expect(notification.text).to.be.calledWith(window.env.t('challengeCreated'));
+          done();
+        }, 1000);
+
+        scope.save(challenge);
+      });
+    });
+
+    describe('create', function() {
+      it('creates new challenge with group that user has selected in filter', function() {
+        var party = specHelper.newGroup({
+          type: 'party',
+          _id: 'user-party'
+        });
+        scope.groupsFilter = [party];
+        scope.search = {
+          group: {
+            'user-party': true
+          }
+        };
+
+        scope.create();
+
+        expect(scope.newChallenge.group).to.eql('user-party');
+      });
+
+      it('uses first group in $scope.groups if more than one exists', function() {
+        var party = specHelper.newGroup({
+          type: 'party',
+          _id: 'user-party'
+        });
+        var guild = specHelper.newGroup({
+          type: 'guild',
+          _id: 'guild'
+        });
+        scope.groups = [party, guild];
+        scope.groupsFilter = [party, guild];
+        scope.search = {
+          group: {
+            'user-party': true,
+            'guild': true
+          }
+        };
+
+        scope.create();
+
+        expect(scope.newChallenge.group).to.eql('user-party');
+      });
+
+      it('defaults to tavern if no group can be set as default', function() {
+        scope.create();
+
+        expect(scope.newChallenge.group).to.eql(tavernId);
+      });
+
+      it('calculates maxPrize', function() {
+        User.getBalanceInGems.returns(20);
+        scope.create();
+
+        expect(scope.maxPrize).to.eql(20);
+      });
+
+      it('sets newChallenge to a blank challenge', function() {
+        scope.create();
+
+        var chal = scope.newChallenge;
+
+        expect(chal.name).to.eql('');
+        expect(chal.description).to.eql('');
+        expect(chal.habits).to.eql([]);
+        expect(chal.dailys).to.eql([]);
+        expect(chal.todos).to.eql([]);
+        expect(chal.rewards).to.eql([]);
+        expect(chal.leader).to.eql('unique-user-id');
+        expect(chal.group).to.eql(tavernId);
+        expect(chal.timestamp).to.be.greaterThan(0);
+        expect(chal.official).to.eql(false);
+      });
+    });
+
+    describe('insufficientGemsForTavernChallenge', function() {
+      context('tavern challenge', function() {
+        it('returns true if user has no gems', function() {
+          User.user.balance = 0;
+          scope.newChallenge = specHelper.newChallenge({
+            group: tavernId
+          });
+
+          var cannotCreateTavernChallenge = scope.insufficientGemsForTavernChallenge();
+          expect(cannotCreateTavernChallenge).to.eql(true);
+        });
+
+        it('returns false if user has gems', function() {
+          User.user.balance = .25;
+          scope.newChallenge = specHelper.newChallenge({
+            group: tavernId
+          });
+
+          var cannotCreateTavernChallenge = scope.insufficientGemsForTavernChallenge();
+          expect(cannotCreateTavernChallenge).to.eql(false);
+        });
+      });
+
+      context('non-tavern challenge', function() {
+        it('returns false', function() {
+          User.user.balance = 0;
+          scope.newChallenge = specHelper.newChallenge({
+            group: 'not-tavern'
+          });
+
+          var cannotCreateTavernChallenge = scope.insufficientGemsForTavernChallenge();
+          expect(cannotCreateTavernChallenge).to.eql(false);
+        });
+      });
+    });
+
+    describe('edit', function() {
+      it('transitions to edit page', function() {
+        sandbox.stub(state, 'transitionTo');
+        var challenge = specHelper.newChallenge({
+          _id: 'challenge-id'
+        });
+
+        scope.edit(challenge);
+
+        expect(state.transitionTo).to.be.calledOnce;
+        expect(state.transitionTo).to.be.calledWith(
+          'options.social.challenges.edit',
+          { cid: challenge._id },
+          { reload: true, inherit: false, notify: true }
+        );
+      });
+    });
+
+    describe('discard', function() {
+      it('sets new challenge to null', function() {
+        scope.newChallenge = specHelper.newChallenge();
+
+        scope.discard();
+
+        expect(scope.newChallenge).to.not.exist;
+      });
+    });
+
+    describe('clone', function() {
+
+      var challengeToClone = {
+        name: 'copyChallenge',
+        description: 'copyChallenge',
+        habits: [specHelper.newHabit()],
+        dailys: [specHelper.newDaily()],
+        todos: [specHelper.newTodo()],
+        rewards: [specHelper.newReward()],
+        leader: 'unique-user-id',
+        group: { _id: "copyGroup" },
+        timestamp: new Date("October 13, 2014 11:13:00"),
+        members: ['id', 'another-id'],
+        official: true,
+        _isMember: true,
+        prize: 1
+      };
+
+      it('Clones the basic challenge info', function() {
+
+        scope.clone(challengeToClone);
+
+        expect(scope.newChallenge.name).to.eql(challengeToClone.name);
+        expect(scope.newChallenge.shortName).to.eql(challengeToClone.shortName);
+        expect(scope.newChallenge.description).to.eql(challengeToClone.description);
+        expect(scope.newChallenge.leader).to.eql(user._id);
+        expect(scope.newChallenge.group).to.eql(challengeToClone.group._id);
+        expect(scope.newChallenge.official).to.eql(challengeToClone.official);
+        expect(scope.newChallenge.prize).to.eql(challengeToClone.prize);
+      });
+
+      it('does not clone members', function() {
+        scope.clone(challengeToClone);
+
+        expect(scope.newChallenge.members).to.not.exist;
+      });
+
+      it('does not clone timestamp', function() {
+        scope.clone(challengeToClone);
+
+        expect(scope.newChallenge.timestamp).to.not.exist;
+      });
+
+      it('clones habits', function() {
+        scope.clone(challengeToClone);
+
+        expect(scope.newChallenge.habits.length).to.eql(challengeToClone.habits.length);
+        expect(scope.newChallenge.habits[0].text).to.eql(challengeToClone.habits[0].text);
+        expect(scope.newChallenge.habits[0].notes).to.eql(challengeToClone.habits[0].notes);
+      });
+
+      it('clones dailys', function() {
+        scope.clone(challengeToClone);
+
+        expect(scope.newChallenge.dailys.length).to.eql(challengeToClone.dailys.length);
+        expect(scope.newChallenge.dailys[0].text).to.eql(challengeToClone.dailys[0].text);
+        expect(scope.newChallenge.dailys[0].notes).to.eql(challengeToClone.dailys[0].notes);
+      });
+
+      it('clones todos', function() {
+        scope.clone(challengeToClone);
+
+        expect(scope.newChallenge.todos.length).to.eql(challengeToClone.todos.length);
+        expect(scope.newChallenge.todos[0].text).to.eql(challengeToClone.todos[0].text);
+        expect(scope.newChallenge.todos[0].notes).to.eql(challengeToClone.todos[0].notes);
+      });
+
+      it('clones rewards', function() {
+        scope.clone(challengeToClone);
+
+        expect(scope.newChallenge.rewards.length).to.eql(challengeToClone.rewards.length);
+        expect(scope.newChallenge.rewards[0].text).to.eql(challengeToClone.rewards[0].text);
+        expect(scope.newChallenge.rewards[0].notes).to.eql(challengeToClone.rewards[0].notes);
+      });
+    });
+  });
+
+  context('User interactions', function() {
+    describe('join', function() {
+      it('calls challenge join', function(){
+        var joinChallengeSpy = sinon.spy(challenges, 'joinChallenge');
+
+        var challenge = specHelper.newChallenge({
+          _id: 'challenge-to-join',
+        });
+
+        scope.join(challenge);
+
+        expect(joinChallengeSpy).to.be.calledOnce;
+      });
+    });
+
+    describe('clickLeave', function() {
+      var clickEvent = {
+        target: 'button'
+      };
+
+      it('sets selectedChal to passed in challenge', function() {
+        var challenge = specHelper.newChallenge({
+          _id: 'popover-challenge-to-leave'
+        });
+
+        expect(scope.selectedChal).to.not.exist;
+
+        scope.clickLeave(challenge, clickEvent);
+        expect(scope.selectedChal).to.eql(challenge);
+      });
+
+      it('creates popover element', function() {
+        var challenge = specHelper.newChallenge({
+          _id: 'popover-challenge-to-leave'
+        });
+
+        expect(scope.popoverEl).to.not.exist;
+        scope.clickLeave(challenge, clickEvent);
+        expect(scope.popoverEl).to.exist;
+      });
+    });
+
+    describe('leave', function() {
+      var challenge = specHelper.newChallenge({
+        _id: 'challenge-to-leave',
+      });
+
+      var clickEvent = {
+        target: 'button'
+      };
+
+      it('removes selectedChal when cancel is chosen', function() {
+        scope.clickLeave(challenge, clickEvent);
+
+        expect(scope.selectedChal).to.eql(challenge);
+
+        scope.leave('cancel');
+        expect(scope.selectedChal).to.not.exist;
+      });
+
+      it('calls challenge leave when anything but cancel is chosen', function() {
+        var leaveChallengeSpy = sinon.spy(challenges, 'leaveChallenge');
+        scope.clickLeave(challenge, clickEvent);
+
+        scope.leave('not-cancel', challenge);
+        expect(leaveChallengeSpy).to.be.calledOnce;
+      });
+    });
+  });
+
+  context('modal actions', function() {
+    beforeEach(function() {
+      sandbox.stub(members, 'selectMember');
+      sandbox.stub(rootScope, 'openModal');
+      members.selectMember.returns(Promise.resolve());
+    });
+
+    describe('sendMessageToChallengeParticipant', function() {
+      it('opens private-message modal', function(done) {
+        scope.sendMessageToChallengeParticipant(user._id);
+
+        setTimeout(function() {
+          expect(rootScope.openModal).to.be.calledOnce;
+          expect(rootScope.openModal).to.be.calledWith(
+            'private-message',
+            { controller: 'MemberModalCtrl' }
+          );
+          done();
+        }, 1000);
+      });
+    });
+
+    describe('sendGiftToChallengeParticipant', function() {
+      it('opens send-gift modal', function(done) {
+        scope.sendGiftToChallengeParticipant(user._id);
+
+        setTimeout(function() {
+          expect(rootScope.openModal).to.be.calledOnce;
+          expect(rootScope.openModal).to.be.calledWith(
+            'send-gift',
+            { controller: 'MemberModalCtrl' }
+          );
+          done();
+        }, 1000);
+      });
+    });
+  });
+});
@@ -0,0 +1,121 @@
+'use strict';
+
+describe("Chat Controller", function() {
+  var scope, ctrl, user, $rootScope, $controller, $httpBackend, html;
+
+  beforeEach(function() {
+    module(function($provide) {
+      $provide.value('User', {});
+    });
+
+    inject(function(_$rootScope_, _$controller_, _$compile_, _$httpBackend_){
+      user = specHelper.newUser();
+      user._id = "unique-user-id";
+      $rootScope = _$rootScope_;
+
+      scope = _$rootScope_.$new();
+
+      $controller = _$controller_;
+      $httpBackend = _$httpBackend_;
+
+      // Load RootCtrl to ensure shared behaviors are loaded
+      $controller('RootCtrl',  {$scope: scope, User: {user: user}});
+
+      html = _$compile_('<div><form ng-submit="postChat(group, message.content)"><textarea submit-on-meta-enter ng-model="message.content" ng-model-options="{debounce: 250}"></textarea></form></div>')(scope);
+      document.body.appendChild(html[0]);
+      ctrl = $controller('ChatCtrl', {$scope: scope, $element: html});
+    });
+  });
+  
+  afterEach(function() {
+    html.remove();
+  });
+
+  describe('copyToDo', function() {
+    it('when copying a user message it opens modal with information from message', function() {
+      scope.group = {
+        name: "Princess Bride"
+      };
+
+      var modalSpy = sandbox.spy($rootScope, "openModal");
+      var message = {
+        uuid: 'the-dread-pirate-roberts',
+        user: 'Wesley',
+        text: 'As you wish'
+      };
+
+      scope.copyToDo(message);
+
+      modalSpy.should.have.been.calledOnce;
+
+      modalSpy.should.have.been.calledWith('copyChatToDo', sinon.match(function(callArgToMatch){
+        return callArgToMatch.controller == 'CopyMessageModalCtrl'
+            && callArgToMatch.scope.text == message.text
+      }));
+    });
+
+    it('when copying a system message it opens modal with information from message', function() {
+      scope.group = {
+        name: "Princess Bride"
+      };
+
+      var modalSpy = sandbox.spy($rootScope, "openModal");
+      var message = {
+        uuid: 'system',
+        text: 'Wesley attacked the ROUS in the Fire Swamp'
+      };
+
+      scope.copyToDo(message);
+
+      modalSpy.should.have.been.calledOnce;
+
+      modalSpy.should.have.been.calledWith('copyChatToDo', sinon.match(function(callArgToMatch){
+        return callArgToMatch.controller == 'CopyMessageModalCtrl'
+            && callArgToMatch.scope.text == message.text
+      }));
+    });
+  });
+  
+  it('updates model on enter key press', function() {
+    // Set initial state of the page with some dummy data.
+    scope.group = { name: 'group' };
+    
+    // The main controller is going to try to fetch the template right off. 
+    // No big deal, just return an empty string.
+    $httpBackend.when('GET', 'partials/main.html').respond('');
+
+    // Let the page settle, and the controllers set their initial state.
+    $rootScope.$digest();
+
+    // Watch for calls to postChat & make sure it doesn't do anything.
+    let postChatSpy = sandbox.stub(scope, 'postChat');
+    
+    // Pretend we typed 'aaa' into the textarea.
+    var textarea = html.find('textarea');    
+    textarea[0].value = 'aaa';
+    let inputEvent = new Event('input');
+    textarea[0].dispatchEvent(inputEvent);
+
+    // Give a change for the ng-model watchers to notice that the value in the
+    // textarea has changed.
+    $rootScope.$digest();
+    
+    // Since no time has elapsed and we debounce the model change, we should 
+    // see no model update just yet.
+    expect(scope.message.content).to.equal('');
+    
+    // Now, press the enter key in the textarea. We use jquery here to paper 
+    // over browser differences with initializing the keyboard event.
+    var keyboardEvent = jQuery.Event('keydown', {keyCode: 13, key: 'Enter', metaKey: true});
+    jQuery(textarea).trigger(keyboardEvent);
+
+    // Now, allow the model to update given the changes to the page still
+    // without letting any time elapse...
+    $rootScope.$digest();
+    
+    // ... and nevertheless seeing the desired call to postChat with the right
+    // data. Yay!
+    postChatSpy.should.have.been.calledWith(scope.group, 'aaa');
+  });
+});
+
@@ -0,0 +1,59 @@
+'use strict';
+
+describe("CopyMessageModal controller", function() {
+  var scope, ctrl, user, Notification, $rootScope, $controller;
+
+  beforeEach(function() {
+    module(function($provide) {
+      var mockWindow = {href: '', alert: sandbox.spy(), location: {search: '', pathname: '', href: ''}};
+
+      $provide.value('$window', mockWindow);
+    });
+
+    inject(function($rootScope, _$controller_, _Notification_, User){
+      user = specHelper.newUser();
+      user._id = "unique-user-id";
+      user.ops = {
+        addTask: sandbox.spy()
+      };
+
+      scope = $rootScope.$new();
+      scope.$close = sandbox.spy();
+
+      $controller = _$controller_;
+
+      User.setUser(user);
+
+      // Load RootCtrl to ensure shared behaviors are loaded
+      $controller('RootCtrl',  {$scope: scope, User: User});
+
+      ctrl = $controller('CopyMessageModalCtrl', {$scope: scope, User: User});
+
+      Notification = _Notification_;
+      Notification.text = sandbox.spy();
+    });
+  });
+
+  describe("saveTodo", function() {
+    it('saves todo', function() {
+
+      scope.text = "A Tavern msg";
+      scope.notes = "Some notes";
+      var payload = {
+        body: {
+          text: scope.text,
+          type: 'todo',
+          notes: scope.notes
+        }
+      };
+
+      scope.saveTodo();
+
+      user.ops.addTask.should.have.been.calledOnce;
+      user.ops.addTask.should.have.been.calledWith(payload);
+      Notification.text.should.have.been.calledOnce;
+      Notification.text.should.have.been.calledWith(window.env.t('messageAddedAsToDo'));
+      scope.$close.should.have.been.calledOnce;
+    });
+  });
+});
@@ -0,0 +1,51 @@
+'use strict';
+
+describe('Filters Controller', function() {
+  var scope, user, userService;
+
+  beforeEach(function () {
+    module(function($provide) {
+      var mockWindow = {href: '', alert: sandbox.spy(), location: {search: '', pathname: '', href: ''}};
+
+      $provide.value('$window', mockWindow);
+    });
+
+    inject(function($rootScope, $controller, Shared, User) {
+      user = specHelper.newUser();
+      Shared.wrap(user);
+      scope = $rootScope.$new();
+      // user.filters = {};
+      User.setUser(user);
+      User.user.filters = {};
+      userService = User;
+      $controller('FiltersCtrl', {$scope: scope, User: User});
+    })
+  });
+
+  describe('tags', function(){
+    it('creates a tag', function(){
+      scope._newTag = {name:'tagName'}
+      scope.createTag();
+      expect(user.tags).to.have.length(1);
+      expect(user.tags[0].name).to.eql('tagName');
+      expect(user.tags[0]).to.have.property('id');
+    });
+
+    it('toggles tag filtering', inject(function(Shared){
+      var tag = {id: Shared.uuid(), name: 'myTag'};
+      scope.toggleFilter(tag);
+      expect(userService.user.filters[tag.id]).to.eql(true);
+      scope.toggleFilter(tag);
+      expect(userService.user.filters[tag.id]).to.not.eql(true);
+    }));
+  });
+
+  describe('updateTaskFilter', function(){
+    it('updatest user\'s filter query with the value of filterQuery', function () {
+      scope.filterQuery = 'task';
+      scope.updateTaskFilter();
+
+      expect(userService.user.filterQuery).to.eql(scope.filterQuery);
+    });
+  });
+});
@@ -0,0 +1,86 @@
+'use strict';
+
+describe('Footer Controller', function() {
+  var scope, user, User;
+
+  beforeEach(inject(function($rootScope, $controller) {
+    user = specHelper.newUser();
+    User = {
+      log: sandbox.stub(),
+      set: sandbox.stub(),
+      addTenGems: sandbox.stub(),
+      addHourglass: sandbox.stub(),
+      user: user
+    };
+    scope = $rootScope.$new();
+    $controller('FooterCtrl', {$scope: scope, User: User, Social: {}});
+  }));
+
+  context('Debug mode', function() {
+    before(function() {
+      window.env.NODE_ENV = 'test';
+    });
+
+    after(function() {
+      delete window.env.NODE_ENV;
+    });
+
+    describe('#setHealthLow', function(){
+      it('sets user health to 1');
+    });
+
+    describe('#addMissedDay', function(){
+      beforeEach(function() {
+        sandbox.stub(confirm).returns(true);
+      });
+
+      it('Cancels if confirm box is not confirmed');
+
+      it('allows multiple days');
+
+      it('sets users last cron');
+
+      it('notifies uers');
+    });
+
+    describe('#addTenGems', function() {
+      it('posts to /user/addTenGems', inject(function($httpBackend) {
+        scope.addTenGems();
+
+        expect(User.addTenGems).to.have.been.called;
+      }));
+    });
+
+    describe('#addHourglass', function() {
+      it('posts to /user/addHourglass', inject(function($httpBackend) {
+        scope.addHourglass();
+
+        expect(User.addHourglass).to.have.been.called;
+      }));
+    });
+
+    describe('#addGold', function() {
+      it('adds 500 gold to user');
+    });
+
+    describe('#addMana', function() {
+      it('adds 500 mana to user');
+    });
+
+    describe('#addLevelsAndGold', function() {
+      it('adds 10000 experience to user');
+
+      it('adds 10000 gp to user');
+
+      it('adds 10000 mp to user');
+    });
+
+    describe('#addOneLevel', function() {
+      it('adds one level to user');
+    });
+
+    describe('#addBossQuestProgressUp', function() {
+      it('adds 1000 progress to quest.progress.up');
+    });
+  });
+});
@@ -0,0 +1,279 @@
+'use strict';
+
+describe('Groups Controller', function() {
+  var scope, ctrl, groups, user, guild, $rootScope;
+
+  beforeEach(function() {
+    module(function($provide) {
+      $provide.value('User', {});
+    });
+
+    inject(function($rootScope, $controller, Groups){
+      user = specHelper.newUser();
+      user._id = "unique-user-id";
+
+      scope = $rootScope.$new();
+
+      // Load RootCtrl to ensure shared behaviors are loaded
+      $controller('RootCtrl',  {$scope: scope, User: {user: user}});
+
+      ctrl = $controller('GroupsCtrl', {$scope: scope, User: {user: user}});
+
+      groups = Groups;
+    });
+  });
+
+  describe("isMemberOfPendingQuest", function() {
+    var party;
+    var partyStub;
+
+    beforeEach(function () {
+      party = specHelper.newGroup({
+        _id: "unique-party-id",
+        type: 'party',
+        members: ['leader-id'] // Ensure we wouldn't pass automatically.
+      });
+
+      partyStub = sandbox.stub(groups, "party", function() {
+        return party;
+      });
+    });
+
+    it("returns false if group is does not have a quest", function() {
+      expect(scope.isMemberOfPendingQuest(user._id, party)).to.not.be.ok;
+    });
+
+    it("returns false if group quest has not members", function() {
+      party.quest = {
+        'key': 'random-key',
+      };
+      expect(scope.isMemberOfPendingQuest(user._id, party)).to.not.be.ok;
+    });
+
+    it("returns false if group quest is active", function() {
+      party.quest = {
+        'key': 'random-key',
+        'members': {},
+        'active': true,
+      };
+      party.quest.members[user._id] = true;
+      expect(scope.isMemberOfPendingQuest(user._id, party)).to.not.be.ok;
+    });
+
+    it("returns true if user is a member of a pending quest", function() {
+      party.quest = {
+        'key': 'random-key',
+        'members': {},
+      };
+      party.quest.members[user._id] = true;
+      expect(scope.isMemberOfPendingQuest(user._id, party)).to.be.ok;
+    });
+  });
+
+  describe("isMemberOfGroup", function() {
+    it("returns true if group is the user's party retrieved from groups service", function() {
+      var party = specHelper.newGroup({
+        _id: "unique-party-id",
+        type: 'party',
+        members: ['leader-id'] // Ensure we wouldn't pass automatically.
+      });
+
+      var partyStub = sandbox.stub(groups, "party", function() {
+        return party;
+      });
+
+      expect(scope.isMemberOfGroup(user._id, party)).to.be.ok;
+    });
+
+    it('returns true if guild is included in myGuilds call', function(){
+
+      var guild = specHelper.newGroup({
+        _id: "unique-guild-id",
+        type: 'guild',
+        members: [user._id]
+      });
+
+      user.guilds = [guild._id];
+
+      expect(scope.isMemberOfGroup(user._id, guild)).to.be.ok;
+    });
+
+    it('does not return true if guild is not included in myGuilds call', function(){
+
+      var guild = specHelper.newGroup({
+        _id: "unique-guild-id",
+        type: 'guild',
+        members: ['not-user-id']
+      });
+
+      user.guilds = [];
+
+      expect(scope.isMemberOfGroup(user._id, guild)).to.not.be.ok;
+    });
+  });
+
+  describe('isAbleToEditGroup', () => {
+    var guild;
+
+    beforeEach(() => {
+      user.contributor = {};
+      guild = specHelper.newGroup({
+        _id: 'unique-guild-id',
+        type: 'guild',
+        members: ['not-user-id'],
+        $save: sandbox.spy(),
+      });
+    });
+
+    it('returns true if user is an admin', () => {
+      guild.leader = 'not-user-id';
+      user.contributor.admin = true;
+      expect(scope.isAbleToEditGroup(guild)).to.be.ok;
+    });
+
+    it('returns true if user is group leader', () => {
+      guild.leader = {_id: user._id}
+      expect(scope.isAbleToEditGroup(guild)).to.be.ok;
+    });
+
+    it('returns false is user is not a leader or admin', () => {
+      expect(scope.isAbleToEditGroup(guild)).to.not.be.ok;
+    });
+
+    it('returns false is user is an admin but group is a party', () => {
+      guild.type = 'party';
+      user.contributor.admin = true;
+      expect(scope.isAbleToEditGroup(guild)).to.not.be.ok;
+    });
+  });
+
+  describe('editGroup', () => {
+    var guild;
+
+    beforeEach(() => {
+      guild = specHelper.newGroup({
+        _id: 'unique-guild-id',
+        leader: 'old leader',
+        type: 'guild',
+        members: ['not-user-id'],
+        $save: sandbox.spy(),
+      });
+    });
+
+    it('marks group as being in edit mode', () => {
+      scope.editGroup(guild);
+
+      expect(guild._editing).to.eql(true);
+    });
+
+    it('copies group to groupCopy', () => {
+      scope.editGroup(guild);
+
+      for (var key in scope.groupCopy) {
+        expect(scope.groupCopy[key]).to.eql(guild[key]);
+      }
+    });
+
+    it('does not change original group when groupCopy is changed', () => {
+      scope.editGroup(guild);
+
+      scope.groupCopy.leader = 'new leader';
+      expect(scope.groupCopy.leader).to.not.eql(guild.leader);
+    });
+  });
+
+  describe('saveEdit', () => {
+    let guild;
+
+    beforeEach(() => {
+      guild = specHelper.newGroup({
+        _id: 'unique-guild-id',
+        name: 'old name',
+        leader: 'old leader',
+        type: 'guild',
+        members: ['not-user-id'],
+        $save: () => {},
+      });
+
+      scope.editGroup(guild);
+    });
+
+    it('calls group update', () => {
+      let guildUpdate = sandbox.spy(groups.Group, 'update');
+
+      scope.saveEdit(guild);
+
+      expect(guildUpdate).to.be.calledOnce;
+    });
+
+    it('calls cancelEdit', () => {
+      sandbox.stub(scope, 'cancelEdit');
+
+      scope.saveEdit(guild);
+
+      expect(scope.cancelEdit).to.be.calledOnce;
+    });
+
+    it('applies changes to groupCopy to original group', () => {
+      scope.groupCopy.name = 'new name';
+
+      scope.saveEdit(guild);
+
+      expect(guild.name).to.eql('new name');
+    });
+
+    it('assigns leader id to group if leader has changed', () => {
+      scope.groupCopy._newLeader = { _id: 'some leader id' };
+
+      scope.saveEdit(guild);
+
+      expect(guild.leader).to.eql('some leader id');
+    });
+
+    it('does not assign new leader id if leader object is not passed in', () => {
+      scope.groupCopy._newLeader = 'not an object';
+
+      scope.saveEdit(guild);
+
+      expect(guild.leader).to.eql('old leader');
+    });
+  });
+
+  describe('cancelEdit', () => {
+    beforeEach(() => {
+      guild = specHelper.newGroup({
+        _id: 'unique-guild-id',
+        name: 'old name',
+        leader: 'old leader',
+        type: 'guild',
+        members: ['not-user-id'],
+        $save: () => {},
+      });
+
+      scope.editGroup(guild);
+    });
+
+    it('sets _editing to false on group', () => {
+      expect(guild._editing).to.eql(true);
+
+      scope.cancelEdit(guild);
+
+      expect(guild._editing).to.eql(false);
+    });
+
+    it('reset groupCopy to an empty object', () => {
+      expect(scope.groupCopy).to.not.eql({});
+
+      scope.cancelEdit(guild);
+
+      expect(scope.groupCopy).to.eql({});
+    });
+  });
+
+  /* TODO: Modal testing */
+  describe.skip("deleteAllMessages", function() { });
+  describe.skip("clickMember", function() { });
+  describe.skip("removeMember", function() { });
+  describe.skip("confirmRemoveMember", function() { });
+  describe.skip("quickReply", function() { });
+});
@@ -0,0 +1,63 @@
+describe('Group Tasks Meta Actions Controller', () => {
+  let rootScope, scope, user, userSerivce;
+
+  beforeEach(() => {
+    module(function($provide) {
+      $provide.value('User', {});
+    });
+
+    inject(($rootScope, $controller) => {
+      rootScope = $rootScope;
+
+      user = specHelper.newUser();
+      user._id = "unique-user-id";
+      userSerivce = {user: user};
+
+      scope = $rootScope.$new();
+
+      scope.task = {
+        group: {
+          assignedUsers: [],
+          approval: {
+            required: false,
+          }
+        },
+      };
+      scope.task._edit = angular.copy(scope.task);
+
+      $controller('GroupTaskActionsCtrl', {$scope: scope, User: userSerivce});
+    });
+  });
+
+  describe('toggleTaskRequiresApproval', function () {
+    it('toggles task approval required field from false to true', function () {
+      scope.toggleTaskRequiresApproval();
+      expect(scope.task._edit.group.approval.required).to.be.true;
+    });
+
+    it('toggles task approval required field from true to false', function () {
+      scope.task._edit.group.approval.required = true;
+      scope.toggleTaskRequiresApproval();
+      expect(scope.task._edit.group.approval.required).to.be.false;
+    });
+  });
+
+
+  describe('assign events', function () {
+    it('adds a group member to assigned users on "addedGroupMember" event ', () => {
+      var testId = 'test-id';
+      rootScope.$broadcast('addedGroupMember', testId);
+      expect(scope.task.group.assignedUsers).to.contain(testId);
+      expect(scope.task._edit.group.assignedUsers).to.contain(testId);
+    });
+
+    it('removes a group member to assigned users on "addedGroupMember" event ', () => {
+      var testId = 'test-id';
+      scope.task.group.assignedUsers.push(testId);
+      scope.task._edit.group.assignedUsers.push(testId);
+      rootScope.$broadcast('removedGroupMember', testId);
+      expect(scope.task.group.assignedUsers).to.not.contain(testId);
+      expect(scope.task._edit.group.assignedUsers).to.not.contain(testId);
+    });
+  });
+});
@@ -0,0 +1,42 @@
+describe('Group Task Actions Controller', () => {
+  let scope, user, userSerivce;
+
+  beforeEach(() => {
+    module(function($provide) {
+      $provide.value('User', {});
+    });
+
+    inject(($rootScope, $controller) => {
+      user = specHelper.newUser();
+      user._id = "unique-user-id";
+      userSerivce = {user: user};
+      userSerivce.sync = sandbox.stub();
+
+      scope = $rootScope.$new();
+
+      $controller('GroupTaskMetaActionsCtrl', {$scope: scope, User: userSerivce});
+
+      scope.task = {
+        group: {
+          assignedUsers: [],
+        },
+      };
+    });
+  });
+
+  describe('claim', () => {
+    beforeEach(() => {
+      sandbox.stub(window, 'confirm').returns(true);
+    });
+
+    it('adds user to assigned users of scope task ', () => {
+      scope.claim();
+      expect(scope.task.group.assignedUsers).to.contain(user._id);
+    });
+
+    it('syncs user tasks ', () => {
+      scope.claim();
+      expect(userSerivce.sync).to.be.calledOnce;
+    });
+  });
+});
@@ -0,0 +1,32 @@
+'use strict';
+
+describe('Hall of Heroes Controller', function() {
+  var scope, ctrl, user, $rootScope;
+
+  beforeEach(function() {
+    module(function($provide) {
+      $provide.value('User', {});
+    });
+
+    inject(function($rootScope, $controller){
+      user = specHelper.newUser();
+
+      scope = $rootScope.$new();
+
+      // Load RootCtrl to ensure shared behaviors are loaded
+      $controller('RootCtrl',  {$scope: scope, User: {user: user}});
+
+      ctrl = $controller('HallHeroesCtrl', {$scope: scope, User: {user: user}});
+    });
+  });
+
+  it('populates contributor input with selected hero id', function(){
+    var loadHero = sandbox.spy(scope, "loadHero");
+    var scrollTo = sandbox.spy(window, "scrollTo");
+
+    scope.populateContributorInput(user._id);
+    expect(scope._heroID).to.eql(user._id);
+    expect(loadHero.callCount).to.eql(1);
+    expect(scrollTo.callCount).to.eql(1);
+  });
+});
@@ -0,0 +1,50 @@
+'use strict';
+
+describe('Header Controller', function() {
+  var scope, ctrl, user, $location, $rootScope;
+
+  beforeEach(function() {
+    module(function($provide) {
+      user = specHelper.newUser();
+      user._id = "unique-user-id"
+      $provide.value('User', {user: user});
+    });
+
+    inject(function(_$rootScope_, _$controller_, _$location_){
+      scope = _$rootScope_.$new();
+      $rootScope = _$rootScope_;
+
+      $location = _$location_;
+
+      // Load RootCtrl to ensure shared behaviors are loaded
+      _$controller_('RootCtrl',  {$scope: scope, User: {user: user}});
+
+      ctrl = _$controller_('HeaderCtrl', {$scope: scope, User: {user: user}});
+    });
+  });
+
+  context('inviteOrStartParty', function(){
+    beforeEach(function(){
+      sandbox.stub($location, 'path');
+      sandbox.stub($rootScope, 'openModal');
+    });
+
+    it('redirects to party page if user does not have a party', function(){
+      var group = {};
+      scope.inviteOrStartParty(group);
+
+      expect($location.path).to.be.calledWith("/options/groups/party");
+      expect($rootScope.openModal).to.not.be.called;
+    });
+
+    it('Opens invite-friends modal if user has a party', function(){
+      var group = {
+        type: 'party'
+      };
+      scope.inviteOrStartParty(group);
+
+      expect($rootScope.openModal).to.be.calledOnce;
+      expect($location.path).to.not.be.called;
+    });
+  });
+});
@@ -0,0 +1,73 @@
+'use strict';
+
+describe('inbox Controller', function() {
+  var scope, ctrl, user, $rootScope, $controller;
+
+  beforeEach(function() {
+    module(function($provide) {
+      $provide.value('User', {});
+    });
+
+    inject(function(_$rootScope_, _$controller_){
+      user = specHelper.newUser();
+      user._id = 'unique-user-id';
+      $rootScope = _$rootScope_;
+
+      scope = _$rootScope_.$new();
+
+      $controller = _$controller_;
+
+      // Load RootCtrl to ensure shared behaviors are loaded
+      $controller('RootCtrl',  {$scope: scope, User: {user: user}});
+
+      ctrl = $controller('InboxCtrl', {$scope: scope});
+    });
+  });
+
+  describe('copyToDo', function() {
+    it('when copying a user message it opens modal with information from message', function() {
+      scope.group = {
+        name: 'Princess Bride'
+      };
+
+      sandbox.spy($rootScope, 'openModal');
+      var message = {
+        uuid: 'the-dread-pirate-roberts',
+        user: 'Wesley',
+        text: 'As you wish'
+      };
+
+      scope.copyToDo(message);
+
+      expect($rootScope.openModal).to.be.calledOnce;
+      expect($rootScope.openModal).to.be.calledWith('copyChatToDo', sinon.match(function(callArgToMatch){
+        var taskText = env.t('taskTextFromInbox', {
+          from: message.user
+        });
+        return callArgToMatch.controller == 'CopyMessageModalCtrl'
+        && callArgToMatch.scope.text == taskText
+      }));
+    });
+
+    it('when copying a system message it opens modal with information from message', function() {
+
+      var modalSpy = sandbox.spy($rootScope, 'openModal');
+      var message = {
+        uuid: 'system',
+        text: 'Wesley attacked the ROUS in the Fire Swamp'
+      };
+
+      scope.copyToDo(message);
+
+      modalSpy.should.have.been.calledOnce;
+
+      modalSpy.should.have.been.calledWith('copyChatToDo', sinon.match(function(callArgToMatch){
+        var taskText = env.t('taskTextFromInbox', {
+          from: 'system'
+        });
+        return callArgToMatch.controller == 'CopyMessageModalCtrl'
+        && callArgToMatch.scope.text == taskText
+      }));
+    });
+  });
+});
@@ -0,0 +1,538 @@
+'use strict';
+
+describe('Inventory Controller', function() {
+  var scope, ctrl, user, rootScope, shared, achievement;
+
+  beforeEach(function() {
+    module(function($provide) {
+      var mockWindow = {
+        confirm: function(msg) {
+          return true;
+        },
+        location: {search: '', pathname: '', href: ''},
+      };
+
+      $provide.value('$window', mockWindow);
+    });
+
+    inject(function($rootScope, $controller, Shared, User, $location, $window, Achievement) {
+      user = specHelper.newUser({
+        balance: 4,
+        items: {
+          gear: { owned: {} },
+          eggs: { Cactus: 1 },
+          hatchingPotions: { Base: 1 },
+          food: { Meat: 1 },
+          pets: {},
+          mounts: {}
+        },
+        preferences: {
+          suppressModals: {}
+        },
+        purchased: {
+          plan: {
+            mysteryItems: [],
+          },
+        },
+      });
+
+      Shared.wrap(user);
+      shared = Shared;
+      achievement = Achievement;
+
+      scope = $rootScope.$new();
+      rootScope = $rootScope;
+
+      User.user = user;
+      User.setUser(user);
+
+      // Load RootCtrl to ensure shared behaviors are loaded
+      $controller('RootCtrl',  {$scope: scope, User: User});
+
+      ctrl = $controller('InventoryCtrl', {$scope: scope, User: User});
+    });
+  });
+
+  it('starts without any item selected', function(){
+    expect(scope.selectedEgg).to.eql(null);
+    expect(scope.selectedPotion).to.eql(null);
+    expect(scope.selectedFood).to.eql(undefined);
+  });
+
+  it('chooses an egg', function(){
+    scope.chooseEgg('Cactus');
+    expect(scope.selectedEgg.key).to.eql('Cactus');
+  });
+
+  it('chooses a potion', function(){
+    scope.choosePotion('Base');
+    expect(scope.selectedPotion.key).to.eql('Base');
+  });
+
+  describe('Hatching Pets', function(){
+    beforeEach(function() {
+      sandbox.stub(rootScope, 'openModal');
+    });
+
+    it('hatches a pet', function(){
+      scope.chooseEgg('Cactus');
+      scope.choosePotion('Base');
+      expect(user.items.eggs).to.eql({Cactus: 0});
+      expect(user.items.hatchingPotions).to.eql({Base: 0});
+      expect(user.items.pets).to.eql({'Cactus-Base': 5});
+      expect(scope.selectedEgg).to.eql(null);
+      expect(scope.selectedPotion).to.eql(null);
+    });
+
+    it('shows a modal for pet hatching', function(){
+      scope.chooseEgg('Cactus');
+      scope.choosePotion('Base');
+
+      expect(rootScope.openModal).to.have.been.calledOnce;
+      expect(rootScope.openModal).to.have.been.calledWith('hatchPet');
+    });
+
+    it('shows modal even if user has raised that pet to a mount', function(){
+      user.items.pets['Cactus-Base'] = -1;
+      scope.chooseEgg('Cactus');
+      scope.choosePotion('Base');
+
+      expect(rootScope.openModal).to.have.been.calledOnce;
+      expect(rootScope.openModal).to.have.been.calledWith('hatchPet');
+    });
+
+    //@TODO: Fix Common hatch
+    xit('does not show modal if user tries to hatch a pet they own', function(){
+      user.items.pets['Cactus-Base'] = 5;
+      scope.chooseEgg('Cactus');
+      scope.choosePotion('Base');
+      expect(rootScope.openModal).to.not.have.been.called;
+    });
+
+    //@TODO: Fix Common hatch
+    xit('does not show modal if user tries to hatch a premium quest pet', function(){
+      user.items.eggs = {Snake: 1};
+      user.items.hatchingPotions = {Peppermint: 1};
+      scope.chooseEgg('Snake');
+      scope.choosePotion('Peppermint');
+      expect(rootScope.openModal).to.not.have.been.called;
+    });
+
+    it('does not show pet hatching modal if user has opted out', function(){
+      user.preferences.suppressModals.hatchPet = true;
+      scope.chooseEgg('Cactus');
+      scope.choosePotion('Base');
+
+      expect(rootScope.openModal).to.not.be.called;
+    });
+
+    it('shows beastMaster achievement modal if user has all 90 pets', function(){
+      sandbox.stub(achievement, 'displayAchievement');
+      sandbox.stub(shared.count, "beastMasterProgress").returns(90);
+      scope.chooseEgg('Cactus');
+      scope.choosePotion('Base');
+
+      expect(achievement.displayAchievement).to.be.called;
+      expect(achievement.displayAchievement).to.be.calledWith('beastMaster');
+    });
+
+    it('shows triadBingo achievement modal if user has all pets twice and all mounts', function(){
+      sandbox.stub(achievement, 'displayAchievement');
+      sandbox.stub(shared.count, "mountMasterProgress").returns(90);
+      sandbox.stub(shared.count, "dropPetsCurrentlyOwned").returns(90);
+      scope.chooseEgg('Cactus');
+      scope.choosePotion('Base');
+
+      expect(achievement.displayAchievement).to.be.called;
+      expect(achievement.displayAchievement).to.be.calledWith('triadBingo');
+    });
+  });
+
+  describe('Feeding and Raising Pets', function() {
+    beforeEach(function() {
+      sandbox.stub(rootScope, 'openModal');
+      user.items.pets = {'PandaCub-Base':5};
+      user.items.mounts = {'PandaCub-Base':false};
+    });
+
+    it('feeds a pet', function() {
+      scope.chooseFood('Meat');
+      scope.choosePet('PandaCub','Base');
+
+      expect(user.items.pets['PandaCub-Base']).to.eql(10);
+    });
+
+    it('gives weaker benefit when feeding inappropriate food', function() {
+      user.items.food.Honey = 1;
+
+      scope.chooseFood('Honey');
+      scope.choosePet('PandaCub','Base');
+
+      expect(user.items.pets['PandaCub-Base']).to.eql(7);
+    });
+
+    it('raises pet to a mount when feeding gauge maxes out', function() {
+      user.items.pets['PandaCub-Base'] = 45;
+
+      scope.chooseFood('Meat');
+      scope.choosePet('PandaCub','Base');
+
+      expect(user.items.pets['PandaCub-Base']).to.eql(-1);
+      expect(user.items.mounts['PandaCub-Base']).to.exist;
+    });
+
+    it('raises pet to a mount instantly when using a Saddle', function() {
+      user.items.food.Saddle = 1;
+
+      scope.chooseFood('Saddle');
+      scope.choosePet('PandaCub','Base');
+
+      expect(user.items.pets['PandaCub-Base']).to.eql(-1);
+      expect(user.items.mounts['PandaCub-Base']).to.exist;
+    });
+
+    it('displays mount raising modal for drop pets', function() {
+      user.items.food.Saddle = 1;
+
+      scope.chooseFood('Saddle');
+      scope.choosePet('PandaCub','Base');
+
+      expect(rootScope.openModal).to.have.been.calledOnce;
+      expect(rootScope.openModal).to.have.been.calledWith('raisePet');
+    });
+
+    it('displays mount raising modal for quest pets', function() {
+      user.items.food.Saddle = 1;
+      user.items.pets['Snake-Base'] = 1;
+
+      scope.chooseFood('Saddle');
+      scope.choosePet('Snake','Base');
+
+      expect(rootScope.openModal).to.have.been.calledOnce;
+      expect(rootScope.openModal).to.have.been.calledWith('raisePet');
+    });
+
+    it('displays mount raising modal for premium pets', function() {
+      user.items.food.Saddle = 1;
+      user.items.pets['TigerCub-Spooky'] = 1;
+
+      scope.chooseFood('Saddle');
+      scope.choosePet('TigerCub','Spooky');
+
+      expect(rootScope.openModal).to.have.been.calledOnce;
+      expect(rootScope.openModal).to.have.been.calledWith('raisePet');
+    });
+
+    it('shows mountMaster achievement modal if user has all 90 mounts', function(){
+      sandbox.stub(achievement, 'displayAchievement');
+      sandbox.stub(shared.count, "mountMasterProgress").returns(90);
+      scope.chooseFood('Meat');
+      scope.choosePet('PandaCub','Base');
+
+      expect(achievement.displayAchievement).to.be.calledOnce;
+      expect(achievement.displayAchievement).to.be.calledWith('mountMaster');
+    });
+  });
+
+  it('sells an egg', function(){
+    scope.chooseEgg('Cactus');
+    scope.sellInventory();
+    expect(user.items.eggs).to.eql({Cactus: 0});
+    expect(user.stats.gp).to.eql(3);
+  });
+
+  it('sells a potion', function(){
+    scope.choosePotion('Base');
+    scope.sellInventory();
+    expect(user.items.hatchingPotions).to.eql({Base: 0});
+    expect(user.stats.gp).to.eql(2);
+  });
+
+  it('sells food', function(){
+    scope.chooseFood('Meat');
+    scope.sellInventory();
+    expect(user.items.food).to.eql({Meat: 0});
+    expect(user.stats.gp).to.eql(1);
+  });
+
+  it('chooses a pet', function(){
+    user.items.pets['Cactus-Base'] = 5;
+    scope.choosePet('Cactus', 'Base');
+    expect(user.items.currentPet).to.eql('Cactus-Base');
+  });
+
+  it('purchases an egg', inject(function(Content){
+    scope.purchase('eggs', Content.eggs['Wolf']);
+    expect(user.balance).to.eql(3.25);
+    expect(user.items.eggs).to.eql({Cactus: 1, Wolf: 1})
+  }));
+
+  describe('Deselecting Items', function() {
+    it('deselects a food', function(){
+      scope.chooseFood('Meat');
+      scope.deselectItem();
+      expect(scope.selectedFood).to.eql(null);
+    });
+
+    it('deselects a potion', function(){
+      scope.choosePotion('Base');
+      scope.deselectItem();
+      expect(scope.selectedPotion).to.eql(null);
+    });
+
+    it('deselects a egg', function(){
+      scope.chooseEgg('Cactus');
+      scope.deselectItem();
+      expect(scope.selectedEgg).to.eql(null);
+    });
+  });
+
+  describe('openCardsModal', function(type, numberOfVariations) {
+    var cardsModalScope;
+
+    beforeEach(function() {
+      cardsModalScope = {};
+      sandbox.stub(rootScope, 'openModal');
+      sandbox.stub(rootScope, '$new').returns(cardsModalScope);
+    });
+
+    it('opens cards modal', function() {
+      scope.openCardsModal('valentine', 4);
+
+      expect(rootScope.openModal).to.be.calledOnce;
+      expect(rootScope.openModal).to.be.calledWith(
+        'cards'
+      );
+    });
+
+    it('instantiates a new scope for the modal', function() {
+      scope.openCardsModal('valentine', 4);
+
+      expect(rootScope.$new).to.be.calledOnce;
+      expect(cardsModalScope.cardType).to.eql('valentine');
+      expect(cardsModalScope.cardMessage).to.exist;
+    });
+
+    it('provides a card message', function() {
+      scope.openCardsModal('valentine', 1);
+
+      expect(cardsModalScope.cardMessage).to.eql(env.t('valentine0'));
+    });
+
+    it('randomly generates message from x number of messages', function() {
+      var possibleValues = [env.t('valentine0'), env.t('valentine1')];
+
+      scope.openCardsModal('valentine', 2);
+
+      expect(possibleValues).to.contain(cardsModalScope.cardMessage);
+    });
+  });
+
+  describe('#buyQuest', function() {
+    var quests, questObject;
+
+    beforeEach(inject(function(Quests) {
+      quests = Quests;
+      questObject = { key: 'whale' };
+
+      sandbox.stub(quests, 'buyQuest').returns({ then: function(res) { res(questObject); } });
+    }));
+
+    it('calls Quests.buyQuest', function() {
+      scope.buyQuest('foo');
+
+      expect(quests.buyQuest).to.be.calledOnce;
+      expect(quests.buyQuest).to.be.calledWith('foo');
+    });
+
+    it('sets selectedQuest to resolved quest object', function() {
+      scope.buyQuest('whale');
+
+      expect(rootScope.selectedQuest).to.eql(questObject);
+    });
+
+    it('opens buyQuest modal', function() {
+      sandbox.spy(rootScope, 'openModal');
+
+      scope.buyQuest('whale');
+
+      expect(rootScope.openModal).to.be.calledOnce;
+      expect(rootScope.openModal).to.be.calledWith('buyQuest', {controller: 'InventoryCtrl'});
+    });
+  });
+
+  describe('#showQuest', function() {
+    var quests, questObject;
+
+    beforeEach(inject(function(Quests) {
+      quests = Quests;
+      questObject = { key: 'whale' };
+
+      sandbox.stub(quests, 'showQuest').returns({ then: function(res) { res(questObject); } });
+    }));
+
+    it('calls Quests.showQuest', function() {
+      scope.showQuest('foo');
+
+      expect(quests.showQuest).to.be.calledOnce;
+      expect(quests.showQuest).to.be.calledWith('foo');
+    });
+
+    it('sets selectedQuest to resolved quest object', function() {
+      scope.showQuest('whale');
+
+      expect(rootScope.selectedQuest).to.eql(questObject);
+    });
+
+    it('opens showQuest modal', function() {
+      sandbox.spy(rootScope, 'openModal');
+
+      scope.showQuest('whale');
+
+      expect(rootScope.openModal).to.be.calledOnce;
+      expect(rootScope.openModal).to.be.calledWith('showQuest', {controller: 'InventoryCtrl'});
+    });
+  });
+
+  describe('#hasAllTimeTravelerItems', function() {
+    it('returns false if items remain for purchase with Mystic Hourglasses', function() {
+      expect(scope.hasAllTimeTravelerItems()).to.eql(false);
+    });
+
+    it('returns true if there are no items left to purchase', inject(function(Content) {
+      _.forEach(Content.gear.flat, function(v,item) {
+        if (item.indexOf('mystery') > -1) {
+          user.items.gear.owned[item] = true;
+        }
+      });
+      _.forEach(Content.timeTravelStable.pets, function(v,pet) {
+        user.items.pets[pet] = 5;
+      });
+      _.forEach(Content.timeTravelStable.mounts, function(v,mount) {
+        user.items.mounts[mount] = true;
+      });
+
+      expect(scope.hasAllTimeTravelerItems()).to.eql(true);
+    }));
+  });
+
+  describe('#hasAllTimeTravelerItemsOfType', function() {
+    it('returns false for Mystery Sets if there are sets left in the time traveler store', function() {
+      expect(scope.hasAllTimeTravelerItemsOfType('mystery')).to.eql(false);
+    });
+
+    it('returns true for Mystery Sets if there are no sets left to purchase', inject(function(Content) {
+      _.forEach(Content.gear.flat, function(v,item) {
+        if (item.indexOf('mystery') > -1) {
+          user.items.gear.owned[item] = true;
+        }
+      });
+
+      expect(scope.hasAllTimeTravelerItemsOfType('mystery')).to.eql(true);
+    }));
+
+    it('returns false for pets if user does not own all pets in the Time Travel Stable', function() {
+      expect(scope.hasAllTimeTravelerItemsOfType('pets')).to.eql(false);
+    });
+
+    it('returns true for pets if user owns all pets in the Time Travel Stable', inject(function(Content) {
+      _.forEach(Content.timeTravelStable.pets, function(v,pet) {
+        user.items.pets[pet] = 5;
+      });
+
+      expect(scope.hasAllTimeTravelerItemsOfType('pets')).to.eql(true);
+    }));
+
+    it('returns false for mounts if user does not own all mounts in the Time Travel Stable', function() {
+      expect(scope.hasAllTimeTravelerItemsOfType('mounts')).to.eql(false);
+    });
+
+    it('returns true for mounts if user owns all mounts in the Time Travel Stable', inject(function(Content) {
+      _.forEach(Content.timeTravelStable.mounts, function(v,mount) {
+        user.items.mounts[mount] = true;
+      });
+
+      expect(scope.hasAllTimeTravelerItemsOfType('mounts')).to.eql(true);
+    }));
+  });
+
+  describe('Gear search filter', function() {
+    var wrap = function(text) {
+      return {'text': function() {return text;}};
+    }
+
+    var toText = function(list) {
+      return _.map(list, function(ele) { return ele.text(); });
+    }
+
+    var gearByClass, gearByType;
+
+    beforeEach(function() {
+      scope.$digest();
+      gearByClass = {'raw': [wrap('kale'), wrap('sashimi')],
+                     'cooked': [wrap('chicken'), wrap('potato')]};
+
+      gearByType = {'veg': [wrap('kale'), wrap('potato')],
+                    'not': [wrap('chicken'), wrap('sashimi')]};
+      scope.gearByClass = gearByClass;
+      scope.gearByType = gearByType;
+      scope.equipmentQuery.query = 'a';
+    });
+
+    it('filters nothing if equipmentQuery is nothing', function() {
+      scope.equipmentQuery.query = '';
+      scope.$digest();
+      expect(toText(scope.filteredGearByClass['raw'])).to.eql(['kale', 'sashimi']);
+      expect(toText(scope.filteredGearByClass['cooked'])).to.eql(['chicken', 'potato']);
+      expect(toText(scope.filteredGearByType['veg'])).to.eql(['kale', 'potato']);
+      expect(toText(scope.filteredGearByType['not'])).to.eql(['chicken', 'sashimi']);
+    });
+
+    it('filters out gear if class gear changes', function() {
+      scope.$digest();
+      expect(toText(scope.filteredGearByClass['raw'])).to.eql(['kale', 'sashimi']);
+      expect(toText(scope.filteredGearByClass['cooked'])).to.eql(['potato']);
+
+      scope.gearByClass['raw'].push(wrap('zucchini'));
+      scope.gearByClass['cooked'].push(wrap('pizza'));
+      scope.$digest();
+      expect(toText(scope.filteredGearByClass['raw'])).to.eql(['kale', 'sashimi']);
+      expect(toText(scope.filteredGearByClass['cooked'])).to.eql(['potato', 'pizza']);
+    });
+
+    it('filters out gear if typed gear changes', function() {
+      scope.$digest();
+      expect(toText(scope.filteredGearByType['veg'])).to.eql(['kale', 'potato']);
+      expect(toText(scope.filteredGearByType['not'])).to.eql(['sashimi']);
+
+      scope.gearByType['veg'].push(wrap('zucchini'));
+      scope.gearByType['not'].push(wrap('pizza'));
+
+      scope.$digest();
+      expect(toText(scope.filteredGearByType['veg'])).to.eql(['kale', 'potato']);
+      expect(toText(scope.filteredGearByType['not'])).to.eql(['sashimi', 'pizza']);
+    });
+
+    it('filters out gear if filter query changes', function() {
+      scope.equipmentQuery.query = 'c';
+      scope.$digest();
+
+      expect(toText(scope.filteredGearByClass['raw'])).to.eql([]);
+      expect(toText(scope.filteredGearByClass['cooked'])).to.eql(['chicken']);
+      expect(toText(scope.filteredGearByType['veg'])).to.eql([]);
+      expect(toText(scope.filteredGearByType['not'])).to.eql(['chicken']);
+    });
+
+    it('returns the right filtered gear', function() {
+      var equipment = [wrap('spicy tuna'), wrap('dragon'), wrap('rainbow'), wrap('caterpillar')];
+      expect(toText(scope.equipmentSearch(equipment, 'ra'))).to.eql(['dragon', 'rainbow']);
+    });
+
+    it('returns the right filtered gear if the source gear has unicode', function() {
+      // blue hat, red hat, red shield
+      var equipment = [wrap('藍色軟帽'), wrap('紅色軟帽'), wrap('紅色盾牌')];
+      // searching for 'red' gives red hat, red shield
+      expect(toText(scope.equipmentSearch(equipment, '紅色'))).to.eql(['紅色軟帽', '紅色盾牌']);
+    });
+  });
+});
@@ -0,0 +1,257 @@
+'use strict';
+
+describe('Invite to Group Controller', function() {
+  var scope, ctrl, groups, user, guild, rootScope, $controller;
+
+  beforeEach(function() {
+    user = specHelper.newUser({
+      profile: { name: 'Mario' }
+    });
+
+    module(function($provide) {
+      $provide.value('User', {});
+      $provide.value('injectedGroup', { user: user });
+    });
+
+    inject(function(_$rootScope_, _$controller_, Groups) {
+      rootScope = _$rootScope_;
+
+      scope = _$rootScope_.$new();
+
+      $controller = _$controller_;
+
+      // Load RootCtrl to ensure shared behaviors are loaded
+      $controller('RootCtrl',  {$scope: scope, User: {user: user}});
+
+      ctrl = $controller('InviteToGroupCtrl', {$scope: scope, User: {user: user}});
+
+      groups = Groups;
+    });
+  });
+
+  describe('addEmail', function() {
+    it('adds blank email to email list', function() {
+      scope.emails = [{name: 'Mario', email: 'mario@mushroomkingdom.com'}];
+      scope.addEmail();
+
+      expect(scope.emails).to.eql([{name: 'Mario', email: 'mario@mushroomkingdom.com'}, {name: '', email: ''}]);
+    });
+  });
+
+  describe('addUuid', function() {
+    it('adds blank uuid to invitees list', function() {
+      scope.invitees = [{uuid: 'user1'}];
+      scope.addUuid();
+
+      expect(scope.invitees).to.eql([{uuid: 'user1'}, {uuid: ''}]);
+    });
+  });
+
+  describe('inviteNewUsers', function() {
+    var groupInvite, groupCreate;
+
+    beforeEach(function() {
+      scope.group = specHelper.newGroup({
+        type: 'party',
+      });
+
+      groupCreate = sandbox.stub(groups.Group, 'create');
+      groupInvite = sandbox.stub(groups.Group, 'invite');
+    });
+
+    context('if the party does not already exist', function() {
+      var groupResponse;
+
+      beforeEach(function() {
+        delete scope.group._id;
+        groupResponse = {data: {data: scope.group}}
+      });
+
+      it('saves the group if a new group is being created', function() {
+        groupCreate.returns(Promise.resolve(groupResponse));
+        scope.inviteNewUsers('uuid');
+        expect(groupCreate).to.be.calledOnce;
+      });
+
+      it('uses provided name', function() {
+        scope.group.name = 'test party';
+
+        groupCreate.returns(Promise.resolve(groupResponse));
+
+        scope.inviteNewUsers('uuid');
+
+        expect(groupCreate).to.be.calledWith(scope.group);
+        expect(scope.group.name).to.eql('test party');
+      });
+
+      it('names the group if no name is provided', function() {
+        scope.group.name = '';
+
+        groupCreate.returns(Promise.resolve(groupResponse));
+
+        scope.inviteNewUsers('uuid');
+
+        expect(groupCreate).to.be.calledWith(scope.group);
+        expect(scope.group.name).to.eql(env.t('possessiveParty', {name: user.profile.name}));
+      });
+    });
+
+    context('email', function() {
+      beforeEach(function () {
+        sandbox.stub(rootScope, 'hardRedirect');
+      });
+
+      it('invites user with emails', function(done) {
+        scope.emails = [
+          {name: 'Luigi', email: 'mario_bro@themushroomkingdom.com'},
+          {name: 'Mario', email: 'mario@tmk.com'}
+        ];
+
+        var inviteDetails = {
+          inviter: user.profile.name,
+          emails: [
+            {name: 'Luigi', email: 'mario_bro@themushroomkingdom.com'},
+            {name: 'Mario', email: 'mario@tmk.com'}
+          ]
+        };
+
+        groupInvite.returns(
+          Promise.resolve()
+            .then(function () {
+              expect(groupInvite).to.be.calledOnce;
+              expect(groupInvite).to.be.calledWith(scope.group._id, inviteDetails);
+              done();
+            })
+        );
+
+        scope.inviteNewUsers('email');
+      });
+
+      it('resets email list after sending', function(done) {
+        scope.emails[0].name = 'Luigi';
+        scope.emails[0].email = 'mario_bro@themushroomkingdom.com';
+
+        groupInvite.returns(
+          Promise.resolve()
+            .then(function () {
+              //We use a timeout to test items that happen after the promise is resolved
+              setTimeout(function(){
+                expect(scope.emails).to.eql([{name:'', email: ''},{name:'', email: ''}]);
+                done();
+              }, 1000);
+            })
+        );
+
+        scope.inviteNewUsers('email');
+      });
+
+      it('filters out blank email inputs', function() {
+        scope.emails = [
+          {name: 'Luigi', email: 'mario_bro@themushroomkingdom.com'},
+          {name: 'Toad', email: ''},
+          {name: 'Mario', email: 'mario@tmk.com'}
+        ];
+
+        var inviteDetails = {
+          inviter: user.profile.name,
+          emails: [
+            {name: 'Luigi', email: 'mario_bro@themushroomkingdom.com'},
+            {name: 'Mario', email: 'mario@tmk.com'}
+          ]
+        };
+
+        groupInvite.returns(
+          Promise.resolve()
+            .then(function () {
+              expect(groupInvite).to.be.calledOnce;
+              expect(groupInvite).to.be.calledWith(scope.group._id, inviteDetails);
+              done();
+            })
+        );
+
+        scope.inviteNewUsers('email');
+      });
+    });
+
+    context('uuid', function() {
+      beforeEach(function () {
+        sandbox.stub(rootScope, 'hardRedirect');
+      });
+
+      it('invites user with uuid', function(done) {
+        scope.invitees = [{uuid: '1234'}];
+
+        groupInvite.returns(
+          Promise.resolve()
+            .then(function () {
+              expect(groupInvite).to.be.calledOnce;
+              expect(groupInvite).to.be.calledWith(scope.group._id, { uuids: ['1234'] });
+              done();
+            })
+        );
+
+        scope.inviteNewUsers('uuid');
+      });
+
+      it('invites users with uuids', function(done) {
+        scope.invitees = [{uuid: 'user1'}, {uuid: 'user2'}, {uuid: 'user3'}];
+
+        groupInvite.returns(
+          Promise.resolve()
+            .then(function () {
+              expect(groupInvite).to.be.calledOnce;
+              expect(groupInvite).to.be.calledWith(scope.group._id, { uuids: ['user1', 'user2', 'user3'] });
+              done();
+            })
+        );
+
+        scope.inviteNewUsers('uuid');
+      });
+
+      it('resets invitee list after sending', function(done) {
+        scope.invitees = [{uuid: 'user1'}, {uuid: 'user2'}, {uuid: 'user3'}];
+
+        groupInvite.returns(
+          Promise.resolve()
+            .then(function () {
+              //We use a timeout to test items that happen after the promise is resolved
+              setTimeout(function(){
+                expect(scope.invitees).to.eql([{uuid: ''}]);
+                done();
+              }, 1000);
+              done();
+            })
+        );
+
+        scope.inviteNewUsers('uuid');
+      });
+
+      it('removes blank fields from being sent', function() {
+        scope.invitees = [{uuid: 'user1'}, {uuid: ''}, {uuid: 'user3'}];
+
+        groupInvite.returns(
+          Promise.resolve()
+            .then(function () {
+              expect(groupInvite).to.be.calledOnce;
+              expect(groupInvite).to.be.calledWith(scope.group._id, { uuids: ['user1', 'user3'] });
+              done();
+            })
+        );
+
+        scope.inviteNewUsers('uuid');
+      });
+    });
+
+    context('invalid invite method', function() {
+      it('logs error', function() {
+        sandbox.stub(console, 'log');
+
+        scope.inviteNewUsers();
+        expect(groups.Group.invite).to.not.be.called;
+        expect(console.log).to.be.calledOnce;
+        expect(console.log).to.be.calledWith('Invalid invite method.');
+      });
+    });
+
+  });
+});
@@ -0,0 +1,26 @@
+'use strict';
+
+describe('Menu Controller', function() {
+
+  describe('MenuCtrl', function(){
+    var scope, ctrl, user, $httpBackend, $window;
+
+    beforeEach(function(){
+      module(function($provide) {
+        $provide.value('Chat', { seenMessage: function() {} });
+      });
+
+      inject(function(_$httpBackend_, $rootScope, $controller) {
+        scope = $rootScope.$new();
+
+        ctrl = $controller('MenuCtrl', {$scope: scope, $window: $window, User: user});
+      })
+    });
+
+    describe('clearMessage', function() {
+      it('is Chat.seenMessage', inject(function(Chat) {
+        expect(scope.clearMessages).to.eql(Chat.markChatSeen);
+      }));
+    });
+  });
+});
@@ -0,0 +1,191 @@
+'use strict';
+
+describe('Notification Controller', function() {
+  var user, scope, rootScope, fakeBackend, achievement, ctrl;
+
+  beforeEach(function() {
+    user = specHelper.newUser();
+    user._id = "unique-user-id";
+    user.needsCron = false;
+
+    var userSync = sinon.stub().returns({
+      then: function then (f) { f(); }
+    });
+
+    let User = {
+      user,
+      readNotification: function noop () {},
+      readNotifications: function noop () {},
+      sync: userSync
+    };
+
+    module(function($provide) {
+      $provide.value('User', User);
+      $provide.value('Guide', {});
+    });
+
+    inject(function(_$rootScope_, $httpBackend, _$controller_, Achievement, Shared) {
+      scope = _$rootScope_.$new();
+      rootScope = _$rootScope_;
+
+      fakeBackend = $httpBackend;
+      fakeBackend.when('GET', 'partials/main.html').respond({});
+
+      achievement = Achievement;
+
+      Shared.wrap(user);
+
+      // Load RootCtrl to ensure shared behaviors are loaded
+      _$controller_('RootCtrl',  {$scope: scope, User});
+
+      ctrl = _$controller_('NotificationCtrl', {$scope: scope, User});
+    });
+
+    sandbox.stub(rootScope, 'openModal');
+    sandbox.stub(achievement, 'displayAchievement');
+  });
+
+  describe('Quest Invitation modal watch', function() {
+    it('opens quest invitation modal', function() {
+      user.party.quest.RSVPNeeded = true;
+      delete user.party.quest.completed;
+      scope.$digest();
+
+      expect(rootScope.openModal).to.be.calledOnce;
+      expect(rootScope.openModal).to.be.calledWith('questInvitation', {controller:'PartyCtrl'});
+    });
+
+    it('does not open quest invitation modal if RSVPNeeded is not true', function() {
+      user.party.quest.RSVPNeeded = false;
+      delete user.party.quest.completed;
+      scope.$digest();
+
+      expect(rootScope.openModal).to.not.be.called;
+    });
+
+    it('does not open quest invitation modal if quest.completed contains a quest key', function() {
+      user.party.quest.RSVPNeeded = true;
+      user.party.quest.completed = "hedgebeast";
+      scope.$digest();
+
+      expect(rootScope.openModal).to.not.be.calledWith('questInvitation', {controller:'PartyCtrl'});
+    });
+  });
+
+  describe('Quest Completion modal watch', function() {
+    it('opens quest completion modal', function() {
+      user.party.quest.completed = "hedgebeast";
+      scope.$digest();
+
+      expect(rootScope.openModal).to.be.calledOnce;
+      expect(rootScope.openModal).to.be.calledWith('questCompleted', {controller:'InventoryCtrl'});
+    });
+
+    // Ensures that the completion modal opens before the invitation modal
+    it('opens quest completion modal if RSVPNeeded is true', function() {
+      user.party.quest.RSVPNeeded = true;
+      user.party.quest.completed = "hedgebeast";
+      scope.$digest();
+
+      expect(rootScope.openModal).to.be.calledOnce;
+      expect(rootScope.openModal).to.be.calledWith('questCompleted', {controller:'InventoryCtrl'});
+    });
+
+    it('does not open quest completion modal if quest.completed is null', function() {
+      user.party.quest.completed = null;
+      scope.$digest();
+
+      expect(rootScope.openModal).to.not.be.called;
+    });
+  });
+
+  describe('User challenge won notification watch', function() {
+    it('opens challenge won modal when a challenge-won notification is received', function() {
+      rootScope.$digest();
+      rootScope.userNotifications.push({type: 'WON_CHALLENGE'});
+      rootScope.$digest();
+
+      expect(achievement.displayAchievement).to.be.called;
+      expect(achievement.displayAchievement).to.be.calledWith('wonChallenge');
+    });
+
+    it('does not open challenge won modal if no new challenge-won notification is received', function() {
+      rootScope.$digest();
+      rootScope.$digest();
+
+      expect(achievement.displayAchievement).to.not.be.calledWith('wonChallenge');
+    });
+  });
+
+  describe('User streak achievement notification watch', function() {
+    it('opens streak achievement modal when a streak-achievement notification is received', function() {
+      rootScope.$digest();
+      rootScope.userNotifications.push({type: 'STREAK_ACHIEVEMENT'});
+      rootScope.$digest();
+
+      expect(achievement.displayAchievement).to.be.called;
+      expect(achievement.displayAchievement).to.be.calledWith('streak', {size: 'md'});
+    });
+
+    it('does not open streak achievement modal if no new streak-achievement notification is received', function() {
+      rootScope.$digest();
+      rootScope.$digest();
+
+      expect(achievement.displayAchievement).to.not.be.calledWith('streak', {size: 'md'});
+    });
+  });
+
+  describe('User ultimate gear set achievement notification watch', function() {
+    it('opens ultimate gear set achievement modal when an ultimate-gear-achievement notification is received', function() {
+      rootScope.$digest();
+      rootScope.userNotifications.push({type: 'ULTIMATE_GEAR_ACHIEVEMENT'});
+      rootScope.$digest();
+
+      expect(achievement.displayAchievement).to.be.called;
+      expect(achievement.displayAchievement).to.be.calledWith('ultimateGear', {size: 'md'});
+    });
+
+    it('does not open ultimate gear set achievement modal if no new ultimate-gear-achievement notification is received', function() {
+      rootScope.$digest();
+      rootScope.$digest();
+
+      expect(achievement.displayAchievement).to.not.be.calledWith('ultimateGear', {size: 'md'});
+    });
+  });
+
+  describe('User rebirth achievement notification watch', function() {
+    it('opens rebirth achievement modal when a rebirth-achievement notification is received', function() {
+      rootScope.$digest();
+      rootScope.userNotifications.push({type: 'REBIRTH_ACHIEVEMENT'});
+      rootScope.$digest();
+
+      expect(achievement.displayAchievement).to.be.called;
+      expect(achievement.displayAchievement).to.be.calledWith('rebirth');
+    });
+
+    it('does not open rebirth achievement modal if no new rebirth-achievement notification is received', function() {
+      rootScope.$digest();
+      rootScope.$digest();
+
+      expect(achievement.displayAchievement).to.not.be.calledWith('rebirth');
+    });
+  });
+
+  describe('User contributor achievement notification watch', function() {
+    it('opens contributor achievement modal when a new-contributor-level notification is received', function() {
+      rootScope.$digest();
+      rootScope.userNotifications.push({type: 'NEW_CONTRIBUTOR_LEVEL'});
+      rootScope.$digest();
+
+      expect(achievement.displayAchievement).to.be.called;
+      expect(achievement.displayAchievement).to.be.calledWith('contributor', {size: 'md'});
+    });
+
+    it('does not open contributor achievement modal if no new new-contributor-level notification is received', function() {
+      rootScope.$digest();
+      rootScope.$digest();
+
+      expect(achievement.displayAchievement).to.not.be.calledWith('contributor', {size: 'md'});
+    });
+  });
+});
@@ -0,0 +1,489 @@
+'use strict';
+
+describe("Party Controller", function() {
+  var scope, ctrl, user, User, questsService, groups, achievement, rootScope, $controller, deferred, party;
+
+  beforeEach(function() {
+    user = specHelper.newUser(),
+    user._id = "unique-user-id";
+    User = {
+      user: user,
+      sync: sandbox.spy(),
+      set: sandbox.spy()
+    };
+
+    party = specHelper.newGroup({
+      _id: "unique-party-id",
+      type: 'party',
+      members: ['leader-id'] // Ensure we wouldn't pass automatically.
+    });
+
+    module(function($provide) {
+      $provide.value('User', User);
+    });
+
+    inject(function(_$rootScope_, _$controller_, Groups, Quests, _$q_, Achievement){
+
+      rootScope = _$rootScope_;
+
+      scope = _$rootScope_.$new();
+
+      $controller = _$controller_;
+
+      groups = Groups;
+      questsService = Quests;
+      achievement = Achievement;
+
+      // Load RootCtrl to ensure shared behaviors are loaded
+      $controller('RootCtrl',  {$scope: scope, User: User});
+
+      ctrl = $controller('PartyCtrl', {$scope: scope, User: User});
+    });
+  });
+
+  describe('initialization', function() {
+    var groupResponse;
+
+    function initializeControllerWithStubbedState() {
+      inject(function(_$state_) {
+        var state = _$state_;
+        sandbox.stub(state, 'is').returns(true);
+
+        var syncParty = sinon.stub(groups.Group, 'syncParty')
+        syncParty.returns(Promise.resolve(groupResponse));
+
+        var froceSyncParty = sinon.stub(groups, 'party')
+        froceSyncParty.returns(Promise.resolve(groupResponse));
+
+        $controller('PartyCtrl', { $scope: scope, $state: state, User: User });
+        expect(state.is).to.be.calledOnce;
+      });
+    };
+
+    beforeEach(function() {
+      sandbox.stub(achievement, 'displayAchievement');
+    });
+
+    context('party has 1 member', function() {
+      it('awards no new achievements', function() {
+        groupResponse = {_id: "test", type: "party", memberCount: 1};
+
+        initializeControllerWithStubbedState();
+
+        expect(User.set).to.not.be.called;
+        expect(achievement.displayAchievement).to.not.be.called;
+      });
+    });
+
+    context('party has 2 members', function() {
+      context('user does not have "Party Up" achievement', function() {
+        it('awards "Party Up" achievement', function(done) {
+          groupResponse = {_id: "test", type: "party", memberCount: 2};
+
+          initializeControllerWithStubbedState();
+
+          setTimeout(function() {
+            expect(User.set).to.be.calledOnce;
+            expect(User.set).to.be.calledWith(
+              { 'achievements.partyUp': true }
+            );
+            expect(achievement.displayAchievement).to.be.calledOnce;
+            expect(achievement.displayAchievement).to.be.calledWith('partyUp');
+            done();
+          }, 1000);
+        });
+      });
+    });
+
+    context('party has 4 members', function() {
+
+      beforeEach(function() {
+        groupResponse = {_id: "test", type: "party", memberCount: 4};
+      });
+
+      context('user has "Party Up" but not "Party On" achievement', function() {
+        it('awards "Party On" achievement', function(done) {
+          user.achievements.partyUp = true;
+
+          initializeControllerWithStubbedState();
+
+          setTimeout(function(){
+            expect(User.set).to.be.calledOnce;
+            expect(User.set).to.be.calledWith(
+              { 'achievements.partyOn': true }
+            );
+            expect(achievement.displayAchievement).to.be.calledOnce;
+            expect(achievement.displayAchievement).to.be.calledWith('partyOn');
+            done();
+          }, 1000);
+        });
+      });
+
+      context('user has neither "Party Up" nor "Party On" achievements', function() {
+        it('awards "Party Up" and "Party On" achievements', function(done) {
+          initializeControllerWithStubbedState();
+
+          setTimeout(function(){
+            expect(User.set).to.have.been.called;
+            expect(User.set).to.be.calledWith(
+              { 'achievements.partyUp': true}
+            );
+            expect(User.set).to.be.calledWith(
+              { 'achievements.partyOn': true}
+            );
+            expect(achievement.displayAchievement).to.have.been.called;
+            expect(achievement.displayAchievement).to.be.calledWith('partyUp');
+            expect(achievement.displayAchievement).to.be.calledWith('partyOn');
+            done();
+          }, 1000);
+        });
+      });
+
+      context('user has both "Party Up" and "Party On" achievements', function() {
+        it('awards no new achievements', function() {
+          user.achievements.partyUp = true;
+          user.achievements.partyOn = true;
+
+          initializeControllerWithStubbedState();
+
+          expect(User.set).to.not.be.called;
+          expect(achievement.displayAchievement).to.not.be.called;
+        });
+      });
+    });
+  });
+
+  describe("create", function() {
+    var partyStub;
+
+    beforeEach(function () {
+      partyStub = sinon.stub(groups.Group, "create");
+      partyStub.returns(Promise.resolve(party));
+      sinon.stub(rootScope, 'hardRedirect');
+    });
+
+    it("creates a new party", function() {
+      var group = {
+        type: 'party',
+      };
+      scope.create(group);
+      expect(partyStub).to.be.calledOnce;
+      //@TODO: Check user party  console.log(User.user.party.id)
+    });
+  });
+
+  describe('questAccept', function() {
+    var sendAction;
+    var memberResponse;
+
+    beforeEach(function() {
+      scope.group = {
+        quest: { members: { 'user-id': true } }
+      };
+
+      memberResponse = {members: {another: true}};
+      sinon.stub(questsService, 'sendAction')
+      questsService.sendAction.returns(Promise.resolve(memberResponse));
+    });
+
+    it('calls Quests.sendAction', function() {
+      scope.questAccept();
+
+      expect(questsService.sendAction).to.be.calledOnce;
+      expect(questsService.sendAction).to.be.calledWith('quests/accept');
+    });
+
+
+    it('updates quest object with new participants list', function(done) {
+      scope.group.quest = {
+        members: { user: true, another: true }
+      };
+
+      setTimeout(function(){
+        expect(scope.group.quest).to.eql(memberResponse);
+        done();
+      }, 1000);
+
+      scope.questAccept();
+    });
+  });
+
+  describe('questReject', function() {
+    var memberResponse;
+
+    beforeEach(function() {
+      scope.group = {
+        quest: { members: { 'user-id': true } }
+      };
+
+      memberResponse = {members: {another: true}};
+      var sendAction = sinon.stub(questsService, 'sendAction')
+      sendAction.returns(Promise.resolve(memberResponse));
+    });
+
+    it('calls Quests.sendAction', function() {
+      scope.questReject();
+
+      expect(questsService.sendAction).to.be.calledOnce;
+      expect(questsService.sendAction).to.be.calledWith('quests/reject');
+    });
+
+
+    it('updates quest object with new participants list', function(done) {
+      scope.group.quest = {
+        members: { user: true, another: true }
+      };
+
+      setTimeout(function(){
+        expect(scope.group.quest).to.eql(memberResponse);
+        done();
+      }, 1000);
+
+      scope.questReject();
+    });
+  });
+
+  describe('questCancel', function() {
+    var party, cancelSpy, windowSpy, memberResponse;
+
+    beforeEach(function() {
+      scope.group = {
+        quest: { members: { 'user-id': true } }
+      };
+
+      memberResponse = {members: {another: true}};
+      sinon.stub(questsService, 'sendAction')
+      questsService.sendAction.returns(Promise.resolve(memberResponse));
+    });
+
+    it('calls Quests.sendAction when alert box is confirmed', function() {
+      sandbox.stub(window, "confirm").returns(true);
+
+      scope.questCancel();
+
+      expect(window.confirm).to.be.calledOnce;
+      expect(window.confirm).to.be.calledWith(window.env.t('sureCancel'));
+      expect(questsService.sendAction).to.be.calledOnce;
+      expect(questsService.sendAction).to.be.calledWith('quests/cancel');
+    });
+
+    it('does not call Quests.sendAction when alert box is not confirmed', function() {
+      sandbox.stub(window, "confirm").returns(false);
+
+      scope.questCancel();
+
+      expect(window.confirm).to.be.calledOnce;
+      expect(questsService.sendAction).to.not.be.called;
+    });
+  });
+
+  describe('questAbort', function() {
+    var memberResponse;
+
+    beforeEach(function() {
+      scope.group = {
+        quest: { members: { 'user-id': true } }
+      };
+
+      memberResponse = {members: {another: true}};
+      sinon.stub(questsService, 'sendAction')
+      questsService.sendAction.returns(Promise.resolve(memberResponse));
+    });
+
+    it('calls Quests.sendAction when two alert boxes are confirmed', function() {
+      sandbox.stub(window, "confirm", function(){return true});
+
+      scope.questAbort();
+      expect(window.confirm).to.be.calledTwice;
+      expect(window.confirm).to.be.calledWith(window.env.t('sureAbort'));
+      expect(window.confirm).to.be.calledWith(window.env.t('doubleSureAbort'));
+
+      expect(questsService.sendAction).to.be.calledOnce;
+      expect(questsService.sendAction).to.be.calledWith('quests/abort');
+    });
+
+    it('does not call Quests.sendAction when first alert box is not confirmed', function() {
+      sandbox.stub(window, "confirm", function(){return false});
+
+      scope.questAbort();
+
+      expect(window.confirm).to.be.calledOnce;
+      expect(window.confirm).to.be.calledWith(window.env.t('sureAbort'));
+      expect(window.confirm).to.not.be.calledWith(window.env.t('doubleSureAbort'));
+
+      expect(questsService.sendAction).to.not.be.called;
+    });
+
+    it('does not call Quests.sendAction when first alert box is confirmed but second one is not', function() {
+      // Hack to confirm first window, but not second
+      // Should not be necessary when we upgrade sinon
+      var shouldReturn = false;
+      sandbox.stub(window, 'confirm', function(){
+        shouldReturn = !shouldReturn;
+        return shouldReturn;
+      });
+
+      scope.questAbort();
+
+      expect(window.confirm).to.be.calledTwice;
+      expect(window.confirm).to.be.calledWith(window.env.t('sureAbort'));
+      expect(window.confirm).to.be.calledWith(window.env.t('doubleSureAbort'));
+      expect(questsService.sendAction).to.not.be.called;
+    });
+  });
+
+  describe('#questLeave', function() {
+    var memberResponse;
+
+    beforeEach(function() {
+      scope.group = {
+        quest: { members: { 'user-id': true } }
+      };
+
+      memberResponse = {members: {another: true}};
+      sinon.stub(questsService, 'sendAction')
+      questsService.sendAction.returns(Promise.resolve(memberResponse));
+    });
+
+    it('calls Quests.sendAction when alert box is confirmed', function() {
+      sandbox.stub(window, "confirm").returns(true);
+
+      scope.questLeave();
+
+      expect(window.confirm).to.be.calledOnce;
+      expect(window.confirm).to.be.calledWith(window.env.t('sureLeave'));
+      expect(questsService.sendAction).to.be.calledOnce;
+      expect(questsService.sendAction).to.be.calledWith('quests/leave');
+    });
+
+    it('does not call Quests.sendAction when alert box is not confirmed', function() {
+      sandbox.stub(window, "confirm").returns(false);
+
+      scope.questLeave();
+
+      expect(window.confirm).to.be.calledOnce;
+      questsService.sendAction.should.not.have.been.calledOnce;
+    });
+
+    it('updates quest object with new participants list', function(done) {
+      scope.group.quest = {
+        members: { user: true, another: true }
+      };
+      sandbox.stub(window, "confirm").returns(true);
+
+      setTimeout(function(){
+        expect(scope.group.quest).to.eql(memberResponse);
+        done();
+      }, 1000);
+
+      scope.questLeave();
+    });
+  });
+
+  describe('clickStartQuest', function() {
+    beforeEach(function() {
+      sandbox.stub(rootScope, 'openModal');
+      sandbox.stub(rootScope.$state, 'go');
+    });
+
+    it('opens quest modal if user has a quest', function() {
+      user.items.quests = {
+        whale: 1
+      };
+
+      scope.clickStartQuest();
+
+      expect(rootScope.$state.go).to.not.be.called;
+      expect(rootScope.openModal).to.be.calledOnce;
+      expect(rootScope.openModal).to.be.calledWith(
+        'ownedQuests',
+        { controller: 'InventoryCtrl' }
+      );
+    });
+
+    it('does not open modal if user has no quests', function() {
+      user.items.quests = { };
+
+      scope.clickStartQuest();
+
+      expect(rootScope.openModal).to.not.be.called;
+      expect(rootScope.$state.go).to.be.calledOnce;
+      expect(rootScope.$state.go).to.be.calledWith('options.inventory.quests');
+    });
+
+    it('does not open modal if user had quests previously, but does not now', function() {
+      user.items.quests = {
+        whale: 0,
+        atom1: 0
+      };
+
+      scope.clickStartQuest();
+
+      expect(rootScope.openModal).to.not.be.called;
+      expect(rootScope.$state.go).to.be.calledOnce;
+      expect(rootScope.$state.go).to.be.calledWith('options.inventory.quests');
+    });
+  });
+
+  describe('#leaveOldPartyAndJoinNewParty', function() {
+    beforeEach(function() {
+      sandbox.stub(scope, 'join');
+      groups.data.party = { _id: 'old-party' };
+      var groupLeave = sandbox.stub(groups.Group, 'leave');
+      groupLeave.returns(Promise.resolve({}));
+      sandbox.stub(groups, 'party').returns({
+        _id: 'old-party'
+      });
+      sandbox.stub(window, 'confirm').returns(true);
+    });
+
+    it('does nothing if user declines confirmation', function() {
+      window.confirm.returns(false);
+      scope.leaveOldPartyAndJoinNewParty('some-id', 'some-name');
+
+      expect(groups.Group.leave).to.not.be.called;
+    })
+
+    it('leaves user\'s current party', function() {
+      scope.leaveOldPartyAndJoinNewParty('some-id', 'some-name');
+
+      expect(groups.Group.leave).to.be.calledOnce;
+      expect(groups.Group.leave).to.be.calledWith('old-party', false);
+    });
+
+    it('joins the new party', function(done) {
+      scope.leaveOldPartyAndJoinNewParty('some-id', 'some-name');
+
+      setTimeout(function() {
+        expect(scope.join).to.be.calledOnce;
+        expect(scope.join).to.be.calledWith({id: 'some-id', name: 'some-name'});
+        done();
+      }, 1000);
+    });
+  });
+
+  describe('#canEditQuest', function() {
+    var party;
+
+    beforeEach(function() {
+      party = specHelper.newGroup({
+        type: 'party',
+        leader: {},
+        quest: {}
+      });
+      scope.group = party;
+    });
+
+    it('returns false if user is not the quest leader', function() {
+      party.quest.leader = 'another-user';
+
+      expect(scope.canEditQuest(party)).to.eql(false);
+    });
+
+    it('returns true if user is quest leader', function() {
+      party.quest.leader = 'unique-user-id';
+
+      expect(scope.canEditQuest(party)).to.eql(true);
+    });
+  });
+});
@@ -0,0 +1,187 @@
+'use strict';
+
+describe('Root Controller', function() {
+  var scope, rootscope, user, User, notification, ctrl, $httpBackend;
+
+  beforeEach(function () {
+    module(function($provide) {
+      $provide.value('User', {});
+      $provide.service('$templateCache', function () {
+        return {
+          get: function () {},
+          put: function () {}
+        }
+      });
+    });
+
+    inject(function($rootScope, $controller, _$httpBackend_, Notification) {
+      scope = $rootScope.$new();
+      scope.loginUsername = 'user';
+      scope.loginPassword = 'pass';
+
+      rootscope = $rootScope;
+
+      $httpBackend = _$httpBackend_;
+
+      notification = Notification;
+      sandbox.stub(notification, 'text');
+      sandbox.stub(notification, 'markdown');
+
+      user = specHelper.newUser();
+      User = {user: user};
+      User.save = sandbox.spy();
+      User.sync = sandbox.spy();
+
+      $httpBackend.whenGET(/partials/).respond();
+
+      ctrl = $controller('RootCtrl', {$scope: scope, User: User});
+    });
+  });
+
+  describe('contribText', function(){
+    it('shows contributor level text', function(){
+      expect(scope.contribText()).to.eql(undefined);
+      expect(scope.contribText(null, {npc: 'NPC'})).to.eql('NPC');
+      expect(scope.contribText({level: 0, text: 'Blacksmith'})).to.eql(undefined);
+      expect(scope.contribText({level: 1, text: 'Blacksmith'})).to.eql('Friend Blacksmith');
+      expect(scope.contribText({level: 2, text: 'Blacksmith'})).to.eql('Friend Blacksmith');
+      expect(scope.contribText({level: 3, text: 'Blacksmith'})).to.eql('Elite Blacksmith');
+      expect(scope.contribText({level: 4, text: 'Blacksmith'})).to.eql('Elite Blacksmith');
+      expect(scope.contribText({level: 5, text: 'Blacksmith'})).to.eql('Champion Blacksmith');
+      expect(scope.contribText({level: 6, text: 'Blacksmith'})).to.eql('Champion Blacksmith');
+      expect(scope.contribText({level: 7, text: 'Blacksmith'})).to.eql('Legendary Blacksmith');
+      expect(scope.contribText({level: 8, text: 'Blacksmith'})).to.eql('Guardian Blacksmith');
+      expect(scope.contribText({level: 9, text: 'Blacksmith'})).to.eql('Heroic Blacksmith');
+      expect(scope.contribText({level: 9, text: 'Blacksmith'}, {npc: 'NPC'})).to.eql('NPC');
+    });
+  });
+
+  describe('castEnd', function(){
+    var task_target, type;
+
+    beforeEach(function(){
+      task_target = {
+        id: 'task-id',
+        text: 'task'
+      };
+      type = 'task';
+      scope.spell = {
+        target: 'task',
+        key: 'fireball',
+        mana: 10,
+        text: function() { return env.t('spellWizardFireballText') },
+        cast: function(){}
+      };
+      rootscope.applyingAction = true;
+    });
+
+    context('fails', function(){
+      it('exits early if there is no applying action', function(){
+        rootscope.applyingAction = null;
+        expect(scope.castEnd(task_target, type)).to.be.eql('No applying action');
+      });
+
+      it('sends notification if target is invalid', function(){
+        scope.spell.target = 'not_the_same_target';
+
+        scope.castEnd(task_target, type);
+
+        notification.text.should.have.been.calledWith(window.env.t('invalidTarget'));
+      });
+    });
+
+    context('succeeds', function(){
+      it('sets scope.spell and rootScope.applyingAction to falsy values', function(){
+
+        scope.castEnd(task_target, type);
+
+        expect(rootscope.applyingAction).to.eql(false);
+        expect(scope.spell).to.eql(null);
+      });
+
+      it('calls $scope.spell.cast', function(){
+        // Kind of a hack, would prefer to use sinon.spy,
+        // but scope.spell gets turned to null in scope.castEnd
+        var spellWasCast = false;
+        scope.spell.cast = function(){ spellWasCast = true };
+
+        scope.castEnd(task_target, type);
+
+        expect(spellWasCast).to.eql(true);
+      });
+
+      it('calls cast endpoint', function() {
+        $httpBackend.expectPOST(/cast/).respond(201);
+        scope.castEnd(task_target, type);
+
+        $httpBackend.flush();
+      });
+
+      it('sends notification that spell was cast on task', function() {
+        $httpBackend.expectPOST(/cast/).respond(201);
+        scope.castEnd(task_target, type);
+        $httpBackend.flush();
+
+        expect(notification.markdown).to.be.calledOnce;
+        expect(notification.markdown).to.be.calledWith('You cast Burst of Flames on task.');
+        expect(User.sync).to.be.calledOnce;
+      });
+
+      it('sends notification that spell was cast on user', function() {
+        var user_target = {
+          profile: { name: 'Lefnire' }
+        };
+        scope.spell = {
+          target: 'user',
+          key: 'snowball',
+          mana: 0,
+          text: function() { return env.t('spellSpecialSnowballAuraText') },
+          cast: function(){}
+        };
+        $httpBackend.expectPOST(/cast/).respond(201);
+        scope.castEnd(user_target, 'user');
+        $httpBackend.flush();
+
+        expect(notification.markdown).to.be.calledOnce;
+        expect(notification.markdown).to.be.calledWith('You cast Snowball on Lefnire.');
+        expect(User.sync).to.be.calledOnce;
+      });
+
+      it('sends notification that spell was cast on party', function() {
+        var party_target = {};
+        scope.spell = {
+          target: 'party',
+          key: 'healAll',
+          mana: 25,
+          text: function() { return env.t('spellHealerHealAllText') },
+          cast: function(){}
+        };
+        $httpBackend.expectPOST(/cast/).respond(201);
+        scope.castEnd(party_target, 'party');
+        $httpBackend.flush();
+
+        expect(notification.markdown).to.be.calledOnce;
+        expect(notification.markdown).to.be.calledWith('You cast Blessing for the party.');
+        expect(User.sync).to.be.calledOnce;
+      });
+
+      it('sends notification that spell was cast on self', function() {
+        var self_target = {};
+        scope.spell = {
+          target: 'self',
+          key: 'stealth',
+          mana: 45,
+          text: function() { return env.t('spellRogueStealthText') },
+          cast: function(){}
+        };
+        $httpBackend.expectPOST(/cast/).respond(201);
+        scope.castEnd(self_target, 'self');
+        $httpBackend.flush();
+
+        expect(notification.markdown).to.be.calledOnce;
+        expect(notification.markdown).to.be.calledWith('You cast Stealth.');
+        expect(User.sync).to.be.calledOnce;
+      });
+    });
+  });
+});
@@ -0,0 +1,367 @@
+'use strict';
+
+describe('Settings Controller', function () {
+  var rootScope, scope, $httpBackend, user, User, ctrl, Notification;
+
+  const actionClickEvent = {
+    target: document.createElement('button'),
+  };
+
+  beforeEach(function () {
+    module(function($provide) {
+      user = specHelper.newUser();
+      User = {
+        set: sandbox.stub(),
+        reroll: sandbox.stub(),
+        rebirth: sandbox.stub(),
+        releasePets: sandbox.stub(),
+        releaseMounts: sandbox.stub(),
+        releaseBoth: sandbox.stub(),
+        setCustomDayStart: sandbox.stub(),
+        user: user
+      };
+
+      User.user.ops = {
+        reroll: sandbox.stub(),
+        rebirth: sandbox.stub(),
+        releasePets: sandbox.stub(),
+        releaseMounts: sandbox.stub(),
+        releaseBoth: sandbox.stub(),
+      };
+
+      Notification = {
+        error: sandbox.stub(),
+        text: sandbox.stub()
+      };
+
+      $provide.value('Notification', Notification);
+      $provide.value('User', User);
+      $provide.value('Guide', sandbox.stub());
+    });
+
+    inject(function(_$rootScope_, _$controller_, _$httpBackend_) {
+      scope = _$rootScope_.$new();
+      rootScope = _$rootScope_;
+      $httpBackend = _$httpBackend_;
+
+      $httpBackend.whenGET(/partials/).respond();
+
+      // Load RootCtrl to ensure shared behaviors are loaded
+      _$controller_('RootCtrl',  {$scope: scope, User: User, Notification: Notification});
+
+      ctrl = _$controller_('SettingsCtrl', {$scope: scope, User: User, Notification: Notification});
+    });
+  });
+
+  describe('#openDayStartModal', function () {
+    beforeEach(function () {
+      sandbox.stub(rootScope, 'openModal');
+      sandbox.stub(window, 'alert');
+    });
+
+    it('opens the day start modal', function () {
+      scope.openDayStartModal(5);
+
+      expect(rootScope.openModal).to.be.calledOnce;
+      expect(rootScope.openModal).to.be.calledWith('change-day-start', {scope: scope});
+    });
+
+    it('sets nextCron variable', function () {
+      expect(scope.nextCron).to.not.exist;
+
+      scope.openDayStartModal(5);
+
+      expect(scope.nextCron).to.exist;
+    });
+
+    it('calculates the next time cron will run', function () {
+      var fakeCurrentTime = new Date(2013, 3, 1, 3, 12).getTime();
+      var expectedTime = new Date(2013, 3, 1, 5, 0, 0).getTime();
+      sandbox.useFakeTimers(fakeCurrentTime);
+
+      scope.openDayStartModal(5);
+
+      expect(scope.nextCron).to.eq(expectedTime);
+    });
+
+    it('calculates the next time cron will run and adds a day if cron would have already passed', function () {
+      var fakeCurrentTime = new Date(2013, 3, 1, 8, 12).getTime();
+      var expectedTime = new Date(2013, 3, 2, 5, 0, 0).getTime();
+      sandbox.useFakeTimers(fakeCurrentTime);
+
+      scope.openDayStartModal(5);
+
+      expect(scope.nextCron).to.eq(expectedTime);
+    });
+  });
+
+  describe('#saveDayStart', function () {
+    it('updates user\'s custom day start', function () {
+      scope.dayStart = 5;
+      scope.saveDayStart();
+
+      expect(User.setCustomDayStart).to.be.calledWith(5);
+    });
+  });
+
+  context('Player Reroll', function () {
+    describe('#reroll', function () {
+      beforeEach(function () {
+        scope.clickReroll(actionClickEvent);
+      });
+
+      it('destroys the previous popover if it exists', function () {
+        sandbox.spy($.fn, 'popover');
+
+        scope.reroll(false);
+
+        expect(scope.popoverEl).to.exist;
+        expect($.fn.popover).to.be.calledWith('destroy');
+      });
+
+      it('doesn\'t call reroll when not confirmed', function () {
+        scope.reroll(false);
+
+        expect(user.ops.reroll).to.not.be.calledOnce;
+      });
+
+      it('calls reroll on the user when confirmed', function () {
+        sandbox.stub(rootScope.$state, 'go');
+
+        scope.reroll(true);
+
+        expect(User.reroll).to.be.calledWith({});
+      });
+
+      it('navigates to the tasks page when confirmed', function () {
+        sandbox.stub(rootScope.$state, 'go');
+
+        scope.reroll(true);
+
+        expect(rootScope.$state.go).to.be.calledWith('tasks');
+      });
+    });
+
+    describe('#clickReroll', function () {
+      it('displays a confirmation popover for the user', function () {
+        sandbox.spy($.fn, 'popover');
+
+        scope.clickReroll(actionClickEvent);
+
+        expect($.fn.popover).to.be.calledWith('destroy');
+        expect($.fn.popover).to.be.calledWith('show');
+      });
+    });
+  });
+
+  context('Player Rebirth', function () {
+    describe('#rebirth', function () {
+      beforeEach(function () {
+        scope.clickRebirth(actionClickEvent);
+      });
+
+      it('destroys the previous popover if it exists', function () {
+        sandbox.spy($.fn, 'popover');
+
+        scope.rebirth(false);
+
+        expect(scope.popoverEl).to.exist;
+        expect($.fn.popover).to.be.calledWith('destroy');
+      });
+
+      it('doesn\'t call rebirth when not confirmed', function () {
+        scope.rebirth(false);
+
+        expect(user.ops.rebirth).to.not.be.calledOnce;
+      });
+
+      it('calls rebirth on the user when confirmed', function () {
+        sandbox.stub(rootScope.$state, 'go');
+
+        scope.rebirth(true);
+
+        expect(User.rebirth).to.be.calledWith({});
+      });
+
+      it('navigates to tasks page when confirmed', function () {
+        sandbox.stub(rootScope.$state, 'go');
+
+        scope.rebirth(true);
+
+        expect(rootScope.$state.go).to.be.calledWith('tasks');
+      });
+    });
+
+    describe('#clickRebirth', function () {
+      it('displays a confirmation popover for the user', function () {
+        sandbox.spy($.fn, 'popover');
+
+        scope.clickRebirth(actionClickEvent);
+
+        expect($.fn.popover).to.be.calledWith('destroy');
+        expect($.fn.popover).to.be.calledWith('show');
+      });
+    });
+  })
+
+  context('Releasing pets and mounts', function () {
+    describe('#release', function () {
+      beforeEach(function () {
+        scope.clickRelease('dummy', actionClickEvent);
+
+        sandbox.stub(rootScope.$state, 'go');
+      });
+
+      it('destroys the previous popover if it exists', function () {
+        sandbox.spy($.fn, 'popover');
+
+        scope.releaseAnimals('', false);
+
+        expect($.fn.popover).to.be.calledWith('destroy');
+      });
+
+      it('doesn\'t call any release method if type is not provided', function () {
+        scope.releaseAnimals();
+
+        expect(User.releasePets).to.not.be.called;
+        expect(User.releaseMounts).to.not.be.called;
+        expect(User.releaseBoth).to.not.be.called;
+      });
+
+      it('doesn\'t redirect to tasks page if type is not provided', function () {
+        scope.releaseAnimals();
+
+        expect(rootScope.$state.go).to.not.be.called;
+      })
+
+      it('calls releasePets when "pets" is provided', function () {
+        scope.releaseAnimals('pets');
+
+        expect(User.releasePets).to.be.calledOnce;
+      });
+
+      it('navigates to the tasks page when "pets" is provided', function () {
+        scope.releaseAnimals('pets');
+
+        expect(rootScope.$state.go).to.be.calledOnce;
+      });
+
+      it('calls releaseMounts when "mounts" is provided', function () {
+        scope.releaseAnimals('mounts');
+
+        expect(User.releaseMounts).to.be.calledOnce;
+      });
+
+      it('navigates to the tasks page when "mounts" is provided', function () {
+        scope.releaseAnimals('mounts');
+
+        expect(rootScope.$state.go).to.be.calledOnce;
+      });
+
+      it('calls releaseBoth when "both" is provided', function () {
+        scope.releaseAnimals('both');
+
+        expect(User.releaseBoth).to.be.calledOnce;
+      });
+
+      it('navigates to the tasks page when "both" is provided', function () {
+        scope.releaseAnimals('both');
+
+        expect(rootScope.$state.go).to.be.calledOnce;
+      });
+
+      it('does not call release functions when non-applicable argument is passed in', function () {
+        scope.releaseAnimals('dummy');
+
+        expect(User.releasePets).to.not.be.called;
+        expect(User.releaseMounts).to.not.be.called;
+        expect(User.releaseBoth).to.not.be.called;
+      });
+    });
+
+    describe('#clickRelease', function () {
+      it('displays a confirmation popover for the user', function () {
+        sandbox.spy($.fn, 'popover');
+        scope.clickRelease('dummy', actionClickEvent);
+
+        expect($.fn.popover).to.be.calledWith('destroy');
+        expect($.fn.popover).to.be.called;
+        expect($.fn.popover).to.be.calledWith('show');
+      });
+    });
+  });
+
+  context('Validating coupons', function () {
+    describe('#applyCoupon', function () {
+      it('displays an error when an invalid coupon is applied', function () {
+        $httpBackend
+          .whenPOST('/api/v3/coupons/validate/INVALID_COUPON?userV=undefined')
+          .respond(200, {
+            success: true,
+            data: {
+              valid: false
+            },
+            notifications: [],
+            userV: 'undefined'
+          });
+
+        scope.applyCoupon('INVALID_COUPON');
+
+        $httpBackend.flush();
+
+        expect(Notification.error).to.be.called;
+        expect(Notification.error).to.be.calledWith(env.t('invalidCoupon'), true);
+      });
+
+      it('displays an confirmation when a valid coupon is applied', function () {
+        $httpBackend
+          .whenPOST('/api/v3/coupons/validate/VALID_COUPON?userV=undefined')
+          .respond(200, {
+            success: true,
+            data: {
+              valid: true
+            },
+            notifications: [],
+            userV: 'undefined'
+          });
+
+        scope.applyCoupon('VALID_COUPON');
+
+        $httpBackend.flush();
+
+        expect(Notification.error).to.not.be.called;
+        expect(Notification.text).to.be.calledWith('Coupon applied!');
+      });
+    });
+  });
+
+  context('Fixing character values', function () {
+    describe('#restore', function () {
+      var blankRestoreValues = {
+        stats: {
+          hp: 0,
+          exp: 0,
+          gp: 0,
+          lvl: 0,
+          mp: 0,
+        },
+        achievements: {
+          streak: 0,
+        },
+      };
+
+      it('doesn\'t update character values when level is less than 1', function () {
+        scope.restoreValues = blankRestoreValues;
+        scope.restore();
+        expect(User.set).to.not.be.called;
+      });
+
+      it('updates character values when level is at least 1', function () {
+        scope.restoreValues = blankRestoreValues;
+        scope.restoreValues.stats.lvl = 1;
+        scope.restore();
+        expect(User.set).to.be.called;
+      });
+    });
+  });
+});
@@ -0,0 +1,41 @@
+describe('Sortable Inventory Controller', () => {
+  let scope;
+
+  beforeEach(inject(($rootScope, $controller) => {
+    scope = $rootScope.$new();
+    $controller('SortableInventoryController', {$scope: scope});
+  }));
+
+  it('defaults scope.order to set', () => {
+    expect(scope.order).to.eql('set')
+  });
+
+  describe('#setOrder', () => {
+    it('sets sort criteria for all standard attributes', () =>{
+      let oldOrder = scope.order;
+
+      let attrs = [
+        'constitution',
+        'intelligence',
+        'perception',
+        'strength',
+        'set'
+      ];
+
+      attrs.forEach((attribute) => {
+        scope.setOrder(attribute);
+        expect(scope.order).to.exist;
+        expect(scope.order).to.not.eql(oldOrder);
+        oldOrder = scope.order;
+      });
+    });
+
+    it('does nothing when missing sort criteria', () =>{
+      scope.order = null;
+
+      scope.setOrder('foooo');
+
+      expect(scope.order).to.not.exist;
+    });
+  });
+});
@@ -0,0 +1,76 @@
+'use strict';
+
+describe('Tasks Controller', function() {
+  var $rootScope, shared, scope, user, User, ctrl;
+
+  beforeEach(function() {
+    user = specHelper.newUser();
+    User = {
+      user: user
+    };
+
+    User.deleteTask = sandbox.stub();
+    User.user.ops = {
+      deleteTask:  sandbox.stub(),
+    };
+    module(function($provide) {
+      $provide.value('User', User);
+      $provide.value('Guide', {});
+    });
+
+    inject(function($rootScope, $controller, Shared){
+
+      scope = $rootScope.$new();
+      shared = Shared;
+      $controller('RootCtrl',  {$scope: scope, User: User});
+
+      ctrl = $controller('TasksCtrl', {$scope: scope, User: User});
+
+    });
+  });
+
+  describe('editTask', function() {
+    it('is Tasks.editTask', function() {
+      inject(function(Tasks) {
+        // @TODO: Currently we override the task function in the challenge ctrl, but we should abstract it again
+        // expect(scope.editTask).to.eql(Tasks.editTask);
+      });
+    });
+  });
+
+  describe('removeTask', function() {
+    var task;
+
+    beforeEach(function() {
+      sandbox.stub(window, 'confirm');
+      task = specHelper.newTodo();
+    });
+
+    it('asks user to confirm deletion', function() {
+      scope.removeTask(task);
+      expect(window.confirm).to.be.calledOnce;
+    });
+
+    it('does not remove task if not confirmed', function() {
+      window.confirm.returns(false);
+      scope.removeTask(task);
+      expect(User.deleteTask).to.not.be.called;
+    });
+
+    it('removes task', function() {
+      window.confirm.returns(true);
+      scope.removeTask(task);
+      expect(User.deleteTask).to.be.calledOnce;
+    });
+  });
+
+  describe('watch to updateStore', function() {
+    it('updates itemStore when user gear changes', function() {
+      sinon.stub(shared, 'updateStore').returns({item: true});
+      user.items.gear.owned.foo = true;
+
+      scope.$digest();
+      expect(scope.itemStore).to.eql({item: true});
+    });
+  });
+});
@@ -0,0 +1,69 @@
+'use strict';
+
+describe('User Controller', function() {
+  var $rootScope, $window, User, shared, scope, ctrl, content;
+
+  beforeEach(function() {
+    module(function ($provide) {
+      var user = specHelper.newUser();
+      User = {user: user}
+      $provide.value('Guide', sandbox.stub());
+      $provide.value('User', User);
+      $provide.value('Achievement', sandbox.stub());
+      $provide.value('Social', sandbox.stub());
+      $provide.value('Shared', {
+        achievements: {
+          getAchievementsForProfile: sandbox.stub()
+        },
+        shops: {
+          getBackgroundShopSets: sandbox.stub()
+        }
+      });
+      $provide.value('Content', {
+        loginIncentives: sandbox.stub()
+      })
+    });
+
+    inject(function($rootScope, $controller, User, Content) {
+      scope = $rootScope.$new();
+      content = Content;
+      $controller('RootCtrl', { $scope: scope, User: User});
+      ctrl = $controller('UserCtrl', { $scope: scope, User: User, $window: $window});
+    });
+  });
+
+  describe('getProgressDisplay', function() {
+
+    beforeEach(() => {
+      sandbox.stub(window.env, 't');
+      window.env.t.onFirstCall().returns('Progress until next');
+    });
+
+    it('should return initial progress', function() {
+      scope.profile.loginIncentives = 0;
+      content.loginIncentives = [{
+        nextRewardAt: 1,
+        reward: true
+      }];
+      var actual = scope.getProgressDisplay();
+      expect(actual.trim()).to.eql('Progress until next 0/1');
+    });
+
+    it('should return progress between next reward and current reward', function() {
+      scope.profile.loginIncentives = 1;
+      content.loginIncentives = [{
+        nextRewardAt: 1,
+        reward: true
+      }, {
+        prevRewardAt: 0,
+        nextRewardAt: 2,
+        reward: true
+      }, {
+        prevRewardAt: 1,
+        nextRewardAt: 3
+      }];
+      var actual = scope.getProgressDisplay();
+      expect(actual.trim()).to.eql('Progress until next 0/1');
+    });
+  });
+});
@@ -0,0 +1,30 @@
+'use strict';
+
+describe('focusElement Directive', function() {
+  var elementToFocus, scope;
+
+  beforeEach(module('habitrpg'));
+
+  beforeEach(inject(function($rootScope, $compile) {
+    scope = $rootScope.$new();
+
+    scope.focusThisLink = false;
+    var element = '<input data-focus-element="focusThisLink" />';
+
+    elementToFocus = $compile(element)(scope);
+    scope.$digest();
+  }));
+
+  it('places focus on the element it is applied to when the expression it binds to evaluates to true', inject(function($timeout) {
+    var focusSpy = sandbox.spy();
+
+    elementToFocus.appendTo(document.body);
+    elementToFocus.on('focus', focusSpy);
+    scope.focusThisLink = true;
+    scope.$digest();
+
+    $timeout.flush();
+    expect(document.activeElement.dataset.focusElement).to.eql("focusThisLink");
+    expect(focusSpy).to.have.been.called;
+    }));
+});
@@ -0,0 +1,89 @@
+'use strict';
+
+describe('fromNow Directive', function() {
+  var element, scope;
+  var fromNow = 'recently';
+  var diff    = 0;
+
+  beforeEach(module('habitrpg'));
+
+  beforeEach(inject(function($rootScope, $compile) {
+    scope = $rootScope.$new();
+    scope.message = {};
+
+    sandbox.stub(window, 'moment').returns({
+      fromNow: function() { return fromNow },
+      diff:    function() { return diff    }
+    });
+
+    element = "<p from-now></p>";
+
+    element = $compile(element)(scope);
+    scope.$digest();
+  }));
+
+  afterEach(function() {
+    window.moment.restore();
+  });
+
+  it('sets the element text to the elapsed time', function() {
+    expect(element.text()).to.eql('recently');
+  });
+
+  describe('when the elapsed time is less than an hour', function() {
+    beforeEach(inject(function($compile) {
+      fromNow = 'recently';
+      diff    = 0;
+
+      element = $compile('<p from-now></p>')(scope);
+      scope.$digest();
+    }));
+
+    it('updates the elapsed time every minute', inject(function($interval) {
+      fromNow = 'later';
+
+      expect(element.text()).to.eql('recently');
+      $interval.flush(60001);
+
+      expect(element.text()).to.eql('later');
+    }));
+
+    it('moves to hourly updates after an hour', inject(function($timeout, $interval) {
+      diff = 61;
+
+      $timeout.flush();
+      $interval.flush(60001);
+
+      fromNow = 'later';
+
+      $interval.flush(60001);
+      expect(element.text()).to.eql('recently');
+
+      $interval.flush(3600000);
+      expect(element.text()).to.eql('later');
+    }));
+  });
+
+  describe('when the elapsed time is more than an hour', function() {
+    beforeEach(inject(function($compile) {
+      fromNow = 'recently';
+      diff    = 65;
+
+      element = $compile('<p from-now></p>')(scope);
+      scope.$digest();
+    }));
+
+    it('updates the elapsed time every hour', inject(function($interval) {
+      fromNow = 'later';
+
+      expect(element.text()).to.eql('recently');
+
+      $interval.flush(60001);
+      expect(element.text()).to.eql('recently');
+
+      $interval.flush(3600000);
+      expect(element.text()).to.eql('later');
+    }));
+  });
+
+});
@@ -0,0 +1,35 @@
+describe('task Directive', () => {
+  var compile, scope, directiveElem, $modal;
+
+  beforeEach(function(){
+    module(function($provide) {
+      $modal = {
+        open: sandbox.spy(),
+      };
+      $provide.value('$modal', $modal);
+    });
+
+    inject(function($compile, $rootScope, $templateCache) {
+      compile = $compile;
+      scope = $rootScope.$new();
+
+      $templateCache.put('templates/task.html', '<div>Task</div>');
+    });
+
+
+    directiveElem = getCompiledElement();
+  });
+
+  function getCompiledElement(){
+    var element = angular.element('<task></task>');
+    var compiledElement = compile(element)(scope);
+    scope.$digest();
+    return compiledElement;
+  }
+
+  xit('opens task note modal', () => {
+    scope.showNoteDetails();
+
+    expect($modal.open).to.be.calledOnce;
+  });
+})
@@ -0,0 +1,33 @@
+describe('roundLargeNumbers', function() {
+
+  beforeEach(module('habitrpg'));
+
+  it('returns same number if less than 1000', inject(function(roundLargeNumbersFilter) {
+    for(var num = 0; num < 1000; num++) {
+      expect(roundLargeNumbersFilter(num)).to.eql(num);
+    };
+  }));
+
+  it('truncates number and appends "k" if number is 1000-999999', inject(function(roundLargeNumbersFilter) {
+    expect(roundLargeNumbersFilter(999.01)).to.eql("1.0k");
+    expect(roundLargeNumbersFilter(1000)).to.eql("1.0k");
+    expect(roundLargeNumbersFilter(3284.12)).to.eql("3.3k");
+    expect(roundLargeNumbersFilter(52983.99)).to.eql("53.0k");
+    expect(roundLargeNumbersFilter(452983.99)).to.eql("453.0k");
+    expect(roundLargeNumbersFilter(999999)).to.eql("1000.0k");
+  }));
+
+  it('truncates number and appends "m" if number is 1000000-999999999', inject(function(roundLargeNumbersFilter) {
+    expect(roundLargeNumbersFilter(999999.01)).to.eql("1.0m");
+    expect(roundLargeNumbersFilter(1000000)).to.eql("1.0m");
+    expect(roundLargeNumbersFilter(3284124.12)).to.eql("3.3m");
+    expect(roundLargeNumbersFilter(52983105.99)).to.eql("53.0m");
+    expect(roundLargeNumbersFilter(452983410.99)).to.eql("453.0m");
+    expect(roundLargeNumbersFilter(999999999)).to.eql("1000.0m");
+  }));
+
+  it('truncates number and appends b" if number is greater than 999999999', inject(function(roundLargeNumbersFilter) {
+    expect(roundLargeNumbersFilter(999999999.01)).to.eql("1.0b");
+    expect(roundLargeNumbersFilter(1423985738.54)).to.eql("1.4b");
+  }));
+});
@@ -0,0 +1,35 @@
+describe('filter', function() {
+
+  beforeEach(module('habitrpg'));
+
+  describe('gold', function() {
+    it('rounds down decimal values', inject(function(goldFilter) {
+      expect(goldFilter(10)).to.eql(10);
+      expect(goldFilter(10.0)).to.eql(10);
+      expect(goldFilter(10.1)).to.eql(10);
+      expect(goldFilter(10.2)).to.eql(10);
+      expect(goldFilter(10.3)).to.eql(10);
+      expect(goldFilter(10.4)).to.eql(10);
+      expect(goldFilter(10.5)).to.eql(10);
+      expect(goldFilter(10.6)).to.eql(10);
+      expect(goldFilter(10.7)).to.eql(10);
+      expect(goldFilter(10.8)).to.eql(10);
+      expect(goldFilter(10.9)).to.eql(10);
+      expect(goldFilter(11)).to.eql(11);
+    }));
+  });
+
+  describe('silver', function() {
+    it('converts decimal value of gold to silver', inject(function(silverFilter) {
+      expect(silverFilter(10)).to.be.closeTo(0, 1);
+      expect(silverFilter(10.01)).to.be.closeTo(1, 1);
+      expect(silverFilter(10.05)).to.be.closeTo(5, 1);
+      expect(silverFilter(10.17)).to.be.closeTo(17, 1);
+      expect(silverFilter(10.23)).to.be.closeTo(23, 1);
+      expect(silverFilter(10.25)).to.be.closeTo(25, 1);
+      expect(silverFilter(10.53)).to.be.closeTo(53, 1);
+      expect(silverFilter(10.75)).to.be.closeTo(75, 1);
+      expect(silverFilter(10.99)).to.be.closeTo(99, 1);
+    }));
+  });
+});
@@ -0,0 +1,94 @@
+'use strict';
+
+describe('Task Ordering Filters', function() {
+  var filter, orderBySpy;
+
+  beforeEach(function() {
+    orderBySpy = sandbox.spy();
+
+    module(function($provide) {
+      $provide.value('orderByFilter', orderBySpy);
+    });
+    inject(function($rootScope, $filter) {
+      filter  = $filter;
+    });
+  });
+
+  describe('conditionalOrderBy', function() {
+    describe('when the predicate is true', function() {
+      it('delegates the arguments to the orderBy filter', function() {
+        filter('conditionalOrderBy')('array', true, 'sortPredicate', 'reverseOrder');
+        expect(orderBySpy).to.have.been.calledWith('array','sortPredicate','reverseOrder');
+      });
+    });
+
+    describe('when the predicate is false', function() {
+      it('returns the initial array', function() {
+        expect(filter('conditionalOrderBy')([1,2,3], false)).to.eql([1,2,3]);
+      });
+    });
+  });
+
+  describe('filterByTaskInfo', function () {
+    it('returns undefined when no input given', function () {
+      expect(filter('filterByTaskInfo')()).to.eql(undefined);
+    });
+
+    it('returns all tasks if term is not a string', function () {
+      var tasks  = [1, 2, 3];
+      expect(filter('filterByTaskInfo')(tasks, undefined)).to.eql(tasks);
+      expect(filter('filterByTaskInfo')(tasks, [])).to.eql(tasks);
+      expect(filter('filterByTaskInfo')(tasks, new Date())).to.eql(tasks);
+    });
+
+    it('returns tasks if term is an empty string', function () {
+      var tasks  = [1, 2, 3];
+      expect(filter('filterByTaskInfo')(tasks, '')).to.eql(tasks);
+    });
+
+    it('filters items by text', function () {
+      var tasks = [
+        { text: 'foo' },
+        { text: 'some text that contains foo' },
+        { text: 'some text that should not be matched' }
+      ];
+
+      expect(filter('filterByTaskInfo')(tasks, 'foo')).to.eql([tasks[0], tasks[1]]);
+    });
+
+    it('filters items by notes', function () {
+      var tasks = [
+        { text: 'some text', notes: 'foo' },
+        { text: 'some text', notes: 'a note that contains foo' },
+        { text: 'some text', notes: 'some text' },
+        { text: 'some text' }
+      ];
+
+      expect(filter('filterByTaskInfo')(tasks, 'foo')).to.eql([tasks[0], tasks[1]]);
+    });
+
+    it('filters items by checklists', function () {
+      var tasks = [
+        { text: 'foo' },
+        { text: 'foo', notes: 'bar', checklist: [ {text: "checkListToFind"} ] },
+        { text: 'foo', notes: 'bar', checklist: [ {text: "checkListToNotFind"} ] }
+      ];
+
+      expect(filter('filterByTaskInfo')(tasks, 'checkListToFind')).to.eql([tasks[1]]);
+    });
+
+    it('only includes task once, even with multiple matches in checklist', function() {
+      var tasks = [
+        {
+          text: 'foo', notes: 'bar', checklist: [
+            {text: "checkListToFind"},
+            {text: "checkListToFind"},
+            {text: "checkListToFind"}
+          ]
+        }
+      ];
+
+      expect(filter('filterByTaskInfo')(tasks, 'checkListToFind')).to.eql([tasks[0]]);
+    });
+  });
+});
@@ -0,0 +1,20 @@
+describe('timezoneOffsetToUtc', function() {
+
+  beforeEach(module('habitrpg'));
+
+  it('formats the timezone offset with a - sign if the offset is positive', inject(function(timezoneOffsetToUtcFilter) {
+    expect(timezoneOffsetToUtcFilter(90)).to.eql('UTC-1:30');
+  }));
+
+  it('formats the timezone offset with a + sign if the offset is negative', inject(function(timezoneOffsetToUtcFilter) {
+    expect(timezoneOffsetToUtcFilter(-525)).to.eql('UTC+8:45');
+  }));
+
+  it('prepends the minutes with a 0 if the minute the offset is less than 10', inject(function(timezoneOffsetToUtcFilter) {
+    expect(timezoneOffsetToUtcFilter(60)).to.eql('UTC-1:00');
+  }));
+
+  it('returns the string UTC+0:00 if the offset is 0', inject(function(timezoneOffsetToUtcFilter) {
+    expect(timezoneOffsetToUtcFilter(0)).to.eql('UTC+0:00');
+  }));
+});
@@ -0,0 +1,98 @@
+// Karma configuration
+// http://karma-runner.github.io/0.10/config/configuration-file.html
+
+module.exports = function karmaConfig (config) {
+  config.set({
+    // base path, that will be used to resolve files and exclude
+    basePath: '',
+
+    // testing framework to use (jasmine/mocha/qunit/...)
+    frameworks: ['mocha', 'chai', 'chai-as-promised', 'sinon-chai'],
+
+    // list of files / patterns to load in the browser
+    files: [
+      '../../../website/client-old/bower_components/jquery/dist/jquery.js',
+      '../../../website/client-old/bower_components/pnotify/jquery.pnotify.js',
+      '../../../website/client-old/bower_components/angular/angular.js',
+      '../../../website/client-old/bower_components/angular-loading-bar/build/loading-bar.min.js',
+      '../../../website/client-old/bower_components/angular-resource/angular-resource.min.js',
+      '../../../website/client-old/bower_components/hello/dist/hello.all.min.js',
+      '../../../website/client-old/bower_components/angular-sanitize/angular-sanitize.js',
+      '../../../website/client-old/bower_components/bootstrap/dist/js/bootstrap.js',
+      '../../../website/client-old/bower_components/angular-bootstrap/ui-bootstrap.js',
+      '../../../website/client-old/bower_components/angular-bootstrap/ui-bootstrap-tpls.js',
+      '../../../website/client-old/bower_components/angular-ui-router/release/angular-ui-router.js',
+      '../../../website/client-old/bower_components/angular-filter/dist/angular-filter.js',
+      '../../../website/client-old/bower_components/angular-ui/build/angular-ui.js',
+      '../../../website/client-old/bower_components/angular-ui-utils/ui-utils.min.js',
+      '../../../website/client-old/bower_components/Angular-At-Directive/src/at.js',
+      '../../../website/client-old/bower_components/Angular-At-Directive/src/caret.js',
+      '../../../website/client-old/bower_components/angular-mocks/angular-mocks.js',
+      '../../../website/client-old/bower_components/ngInfiniteScroll/build/ng-infinite-scroll.js',
+      '../../../website/client-old/bower_components/select2/select2.js',
+      '../../../website/client-old/bower_components/angular-ui-select2/src/select2.js',
+      '../../../website/client-old/bower_components/habitica-markdown/dist/habitica-markdown.min.js',
+      '../../../website/client-old/js/habitrpg-shared.js',
+
+      '../../../test/client-old/spec/mocks/**/*.js',
+
+      '../../../website/client-old/js/env.js',
+      '../../../website/client-old/js/app.js',
+      '../../../website/client-old/js/config.js',
+
+      '../../../website/client-old/js/services/**/*.js',
+      '../../../website/client-old/js/filters/**/*.js',
+      '../../../website/client-old/js/directives/**/*.js',
+      '../../../website/client-old/js/controllers/**/*.js',
+      '../../../website/client-old/js/components/**/*.js',
+
+      '../../../test/client-old/spec/specHelper.js',
+      '../../../test/client-old/spec/**/*.js',
+    ],
+
+    // list of files / patterns to exclude
+    exclude: [],
+
+    // web server port
+    port: 8080,
+
+    // level of logging
+    // possible values: LOG_DISABLE || LOG_ERROR || LOG_WARN || LOG_INFO || LOG_DEBUG
+    logLevel: config.LOG_INFO,
+
+
+    // enable / disable watching file and executing tests whenever any file changes
+    autoWatch: true,
+
+
+    // Start these browsers, currently available:
+    // - Chrome
+    // - ChromeCanary
+    // - Firefox
+    // - Opera
+    // - Safari (only Mac)
+    // - PhantomJS
+    // - IE (only Windows)
+    browsers: ['PhantomJS'],
+
+    preprocessors: {
+      '../../../website/client-old/js/**/*.js': ['coverage'],
+      '../../../test/**/*.js': ['babel'],
+    },
+
+    coverageReporter: {
+      reporters: [
+        { type: 'lcov', subdir: '.' },
+        { type: 'text-summary' },
+      ],
+      dir: '../../../coverage/karma',
+    },
+
+    // Enable mocha-style reporting, for better test visibility
+    reporters: ['mocha', 'coverage'],
+
+    // Continuous Integration mode
+    // if true, it capture browsers, run tests and exit
+    singleRun: false,
+  });
+};
@@ -0,0 +1,5 @@
+var sandbox = sinon.sandbox.create();
+
+afterEach(function() {
+  sandbox.restore();
+});
@@ -0,0 +1,8 @@
+'use strict'
+
+var analyticsMock = {
+  login: sandbox.spy(),
+  register: sandbox.spy(),
+  updateUser: sandbox.spy(),
+  track: sandbox.spy()
+};
@@ -0,0 +1,55 @@
+'use strict';
+
+describe('achievementServices', function() {
+  var achievementService, rootScope;
+
+  beforeEach(function() {
+    rootScope = { 'openModal': sandbox.stub() };
+    module(function($provide) {
+      $provide.value('$rootScope', rootScope);
+    });
+
+    inject(function(Achievement) {
+      achievementService = Achievement;
+    });
+  });
+
+  describe('#displayAchievement', function() {
+    it('passes given achievement name to openModal', function() {
+      achievementService.displayAchievement('beastMaster');
+
+      expect(rootScope.openModal).to.be.calledOnce;
+      expect(rootScope.openModal).to.be.calledWith('achievements/beastMaster');
+    });
+
+    it('calls openModal with UserCtrl and small modal size if no other size is given', function() {
+      achievementService.displayAchievement('test');
+
+      expect(rootScope.openModal).to.be.calledOnce;
+      expect(rootScope.openModal).to.be.calledWith(
+        'achievements/test',
+        { controller: 'UserCtrl', size: 'sm' }
+      );
+    });
+
+    it('calls openModal with UserCtrl and specified modal size if one is given', function() {
+      achievementService.displayAchievement('test', {size: 'md'});
+
+      expect(rootScope.openModal).to.be.calledOnce;
+      expect(rootScope.openModal).to.be.calledWith(
+        'achievements/test',
+        { controller: 'UserCtrl', size: 'md' }
+      );
+    });
+
+    it('calls openModal with UserCtrl and default \'sm\' size if invalid size is given', function() {
+      achievementService.displayAchievement('test', {size: 'INVALID_SIZE'});
+
+      expect(rootScope.openModal).to.be.calledOnce;
+      expect(rootScope.openModal).to.be.calledWith(
+        'achievements/test',
+        { controller: 'UserCtrl', size: 'sm' }
+      );
+    });
+  });
+});
@@ -0,0 +1,282 @@
+'use strict';
+
+describe('Analytics Service', function () {
+  var analytics, user, clock;
+
+  beforeEach(function() {
+    clock = sandbox.useFakeTimers();
+    sandbox.stub(window, 'refresher', function(){return true});
+    user = specHelper.newUser({
+      contributor: {},
+      purchased: { plan: {} },
+    });
+    user.flags.tour = { intro: null };
+
+    module(function($provide) {
+      $provide.value('User', {user: user});
+    });
+
+    inject(function(Analytics) {
+      analytics = Analytics;
+    });
+  });
+
+  context('functions', function() {
+
+    describe('register', function() {
+
+      beforeEach(function() {
+        sandbox.stub(amplitude, 'setUserId');
+        sandbox.stub(window, 'ga');
+      });
+
+      it('sets up user with Amplitude', function() {
+        analytics.register();
+        clock.tick();
+        expect(amplitude.setUserId).to.have.been.calledOnce;
+        expect(amplitude.setUserId).to.have.been.calledWith(user._id);
+      });
+
+      it('sets up user with Google Analytics', function() {
+        analytics.register();
+        clock.tick();
+        expect(ga).to.have.been.calledOnce;
+        expect(ga).to.have.been.calledWith('set', {userId: user._id});
+      });
+    });
+
+    describe('login', function() {
+
+      beforeEach(function() {
+        sandbox.stub(amplitude, 'setUserId');
+        sandbox.stub(window, 'ga');
+      });
+
+      it('sets up tracking for amplitude', function() {
+        analytics.login();
+        clock.tick();
+
+        expect(amplitude.setUserId).to.have.been.calledOnce;
+        expect(amplitude.setUserId).to.have.been.calledWith(user._id);
+      });
+
+      it('sets up tracking for google analytics', function() {
+        analytics.login();
+        clock.tick();
+
+        expect(ga).to.have.been.calledOnce;
+        expect(ga).to.have.been.calledWith('set', {userId: user._id});
+      });
+    });
+
+    describe('track', function() {
+
+      beforeEach(function() {
+        sandbox.stub(amplitude, 'logEvent');
+        sandbox.stub(window, 'ga');
+      });
+
+      context('successful tracking', function() {
+
+        it('tracks a simple user action with Amplitude', function() {
+          var properties = {'hitType':'event','eventCategory':'behavior','eventAction':'cron'};
+          analytics.track(properties);
+          clock.tick();
+
+          expect(amplitude.logEvent).to.have.been.calledOnce;
+          expect(amplitude.logEvent).to.have.been.calledWith('cron', properties);
+        });
+
+        it('tracks a simple user action with Google Analytics', function() {
+          var properties = {'hitType':'event','eventCategory':'behavior','eventAction':'cron'};
+          analytics.track(properties);
+          clock.tick();
+
+          expect(ga).to.have.been.calledOnce;
+          expect(ga).to.have.been.calledWith('send', properties);
+        });
+
+        it('tracks a user action with additional properties in Amplitude', function() {
+          var properties = {'hitType':'event','eventCategory':'behavior','eventAction':'cron','booleanProperty':true,'numericProperty':17,'stringProperty':'bagel'};
+          analytics.track(properties);
+          clock.tick();
+
+          expect(amplitude.logEvent).to.have.been.calledOnce;
+          expect(amplitude.logEvent).to.have.been.calledWith('cron', properties);
+        });
+
+        it('tracks a user action with additional properties in google analytics', function() {
+          var properties = {'hitType':'event','eventCategory':'behavior','eventAction':'cron','booleanProperty':true,'numericProperty':17,'stringProperty':'bagel'};
+          analytics.track(properties);
+          clock.tick();
+
+          expect(ga).to.have.been.calledOnce;
+          expect(ga).to.have.been.calledWith('send', properties);
+        });
+      });
+
+      context('unsuccessful tracking', function() {
+
+        beforeEach(function() {
+          sandbox.stub(console, 'log');
+        });
+
+        context('events without required properties', function() {
+          beforeEach(function(){
+            analytics.track('action');
+            analytics.track({'hitType':'pageview','eventCategory':'green'});
+            analytics.track({'hitType':'pageview','eventAction':'eat'});
+            analytics.track({'eventCategory':'green','eventAction':'eat'});
+            analytics.track({'hitType':'pageview'});
+            analytics.track({'eventCategory':'green'});
+            analytics.track({'eventAction':'eat'});
+            clock.tick();
+          });
+
+          it('logs errors to console', function() {
+            expect(console.log.callCount).to.eql(7);
+          });
+
+          it('does not call out to Amplitude', function() {
+            expect(amplitude.logEvent).to.not.be.called;
+          });
+
+          it('does not call out to Google Analytics', function() {
+            expect(ga).to.not.be.called;
+          });
+        });
+
+        context('incorrect hit type', function() {
+          beforeEach(function() {
+            analytics.track({'hitType':'moogly','eventCategory':'green','eventAction':'eat'});
+            clock.tick();
+          });
+
+          it('logs error to console', function () {
+            expect(console.log).to.have.been.calledOnce;
+          });
+
+          it('does not call out to Amplitude', function() {
+            expect(amplitude.logEvent).to.not.be.called;
+          });
+
+          it('does not call out to Google Analytics', function() {
+            expect(ga).to.not.be.called;
+          });
+        });
+      });
+    });
+
+    describe('updateUser', function() {
+
+      beforeEach(function() {
+        sandbox.stub(amplitude, 'setUserProperties');
+        sandbox.stub(window, 'ga');
+      });
+
+      context('properties argument provided', function(){
+        var properties = {'userBoolean': false, 'userNumber': -8, 'userString': 'Enlightened'};
+        var expectedProperties = _.cloneDeep(properties);
+        expectedProperties.UUID = 'unique-user-id';
+        expectedProperties.Class = 'wizard';
+        expectedProperties.Experience = 35;
+        expectedProperties.Gold = 43;
+        expectedProperties.Health = 48;
+        expectedProperties.Level = 24;
+        expectedProperties.Mana = 41;
+        expectedProperties.tutorialComplete = false;
+        expectedProperties["Number Of Tasks"] = {
+          habits: 1,
+          dailys: 1,
+          todos: 1,
+          rewards: 1
+        };
+        expectedProperties.balance = 12;
+        expectedProperties.balanceGemAmount = 48;
+
+        beforeEach(function() {
+          user._id = 'unique-user-id';
+          user.stats.class = 'wizard';
+          user.stats.exp = 35.7;
+          user.stats.gp = 43.2;
+          user.stats.hp = 47.8;
+          user.stats.lvl = 24;
+          user.stats.mp = 41;
+          user.flags.tour.intro = 3;
+          user.habits = [{_id: 'habit'}];
+          user.dailys = [{_id: 'daily'}];
+          user.todos = [{_id: 'todo'}];
+          user.rewards = [{_id: 'reward'}];
+          user.balance = 12;
+
+          analytics.updateUser(properties);
+          clock.tick();
+        });
+
+        it('calls Amplitude with provided properties and select user info', function() {
+          expect(amplitude.setUserProperties).to.have.been.calledOnce;
+          expect(amplitude.setUserProperties).to.have.been.calledWith(expectedProperties);
+        });
+
+        it('calls Google Analytics with provided properties and select user info', function() {
+          expect(ga).to.have.been.calledOnce;
+          expect(ga).to.have.been.calledWith('set', expectedProperties);
+        });
+      });
+
+      context('no properties argument provided', function() {
+        var expectedProperties = {
+          UUID: 'unique-user-id',
+          Class: 'wizard',
+          Experience: 35,
+          Gold: 43,
+          Health: 48,
+          Level: 24,
+          Mana: 41,
+          contributorLevel: 1,
+          subscription: 'unique-plan-id',
+          tutorialComplete: true,
+          "Number Of Tasks": {
+            todos: 1,
+            dailys: 1,
+            habits: 1,
+            rewards: 1
+          },
+          balance: 12,
+          balanceGemAmount: 48
+        };
+
+        beforeEach(function() {
+          user._id = 'unique-user-id';
+          user.stats.class = 'wizard';
+          user.stats.exp = 35.7;
+          user.stats.gp = 43.2;
+          user.stats.hp = 47.8;
+          user.stats.lvl = 24;
+          user.stats.mp = 41;
+          user.contributor.level = 1;
+          user.purchased.plan.planId = 'unique-plan-id';
+          user.flags.tour.intro = -2;
+          user.habits = [{_id: 'habit'}];
+          user.dailys = [{_id: 'daily'}];
+          user.todos = [{_id: 'todo'}];
+          user.rewards = [{_id: 'reward'}];
+          user.balance = 12;
+
+          analytics.updateUser();
+          clock.tick();
+        });
+
+        it('calls Amplitude with select user info', function() {
+          expect(amplitude.setUserProperties).to.have.been.calledOnce;
+          expect(amplitude.setUserProperties).to.have.been.calledWith(expectedProperties);
+        });
+
+        it('calls Google Analytics with select user info', function() {
+          expect(ga).to.have.been.calledOnce;
+          expect(ga).to.have.been.calledWith('set', expectedProperties);
+        });
+      });
+    });
+  });
+});
@@ -0,0 +1,88 @@
+'use strict';
+
+describe('challengeServices', function() {
+  var $httpBackend, $http, challenges, user;
+  var apiV3Prefix = '/api/v3';
+
+  beforeEach(function() {
+    module(function($provide) {
+      $provide.value('User', {user:user});
+    });
+
+    inject(function(_$httpBackend_, Challenges, User) {
+      $httpBackend = _$httpBackend_;
+      challenges = Challenges;
+      user = User;
+      user.sync = function(){};
+    });
+  });
+
+  it('calls create challenge endpoint', function() {
+    $httpBackend.expectPOST(apiV3Prefix + '/challenges').respond({});
+    challenges.createChallenge();
+    $httpBackend.flush();
+  });
+
+  it('calls join challenge endpoint', function() {
+    var challengeId = 1;
+    $httpBackend.expectPOST(apiV3Prefix + '/challenges/' + challengeId + '/join').respond({});
+    challenges.joinChallenge(challengeId);
+    $httpBackend.flush();
+  });
+
+  it('calls leave challenge endpoint', function() {
+    var challengeId = 1;
+    $httpBackend.expectPOST(apiV3Prefix + '/challenges/' + challengeId + '/leave').respond({});
+    challenges.leaveChallenge(challengeId);
+    $httpBackend.flush();
+  });
+
+  it('calls get user challenges endpoint', function() {
+    $httpBackend.expectGET(apiV3Prefix + '/challenges/user').respond({});
+    challenges.getUserChallenges();
+    $httpBackend.flush();
+  });
+
+  it('calls get group challenges endpoint', function() {
+    var groupId = 1;
+    $httpBackend.expectGET(apiV3Prefix + '/challenges/groups/' + groupId).respond({});
+    challenges.getGroupChallenges(groupId);
+    $httpBackend.flush();
+  });
+
+  it('calls get challenge endpoint', function() {
+    var challengeId = 1;
+    $httpBackend.expectGET(apiV3Prefix + '/challenges/' + challengeId).respond({});
+    challenges.getChallenge(challengeId);
+    $httpBackend.flush();
+  });
+
+  it('calls export challenge to csv endpoint', function() {
+    var challengeId = 1;
+    $httpBackend.expectGET(apiV3Prefix + '/challenges/' + challengeId + '/export/csv').respond({});
+    challenges.exportChallengeCsv(challengeId);
+    $httpBackend.flush();
+  });
+
+  it('calls update challenge endpoint', function() {
+    var challengeId = 1;
+    $httpBackend.expectPUT(apiV3Prefix + '/challenges/' + challengeId).respond({});
+    challenges.updateChallenge(challengeId);
+    $httpBackend.flush();
+  });
+
+  it('calls delete challenge endpoint', function() {
+    var challengeId = 1;
+    $httpBackend.expectDELETE(apiV3Prefix + '/challenges/' + challengeId).respond({});
+    challenges.deleteChallenge(challengeId);
+    $httpBackend.flush();
+  });
+
+  it('calls select challenge winner endpoint', function() {
+    var challengeId = 1;
+    var winnerId = 2;
+    $httpBackend.expectPOST(apiV3Prefix + '/challenges/' + challengeId + '/selectWinner/' + winnerId).respond({});
+    challenges.selectChallengeWinner(challengeId, winnerId);
+    $httpBackend.flush();
+  });
+});
@@ -0,0 +1,73 @@
+'use strict';
+
+describe('chatServices', function() {
+  var $httpBackend, $http, chat, user;
+  var apiV3Prefix = '/api/v3';
+
+  beforeEach(function() {
+    module(function($provide) {
+      $provide.value('User', {user:user});
+    });
+
+    inject(function(_$httpBackend_, Chat, User) {
+      $httpBackend = _$httpBackend_;
+      chat = Chat;
+      user = User;
+      user.sync = function(){};
+    });
+  });
+
+  it('calls get chat endpoint', function() {
+    var groupId = 1;
+    $httpBackend.expectGET(apiV3Prefix + '/groups/' + groupId + '/chat').respond({});
+    chat.getChat(groupId);
+    $httpBackend.flush();
+  });
+
+  it('calls get chat endpoint', function() {
+    var groupId = 1;
+    var message = "test message";
+    $httpBackend.expectPOST(apiV3Prefix + '/groups/' + groupId + '/chat').respond({});
+    chat.postChat(groupId, message);
+    $httpBackend.flush();
+  });
+
+  it('calls delete chat endpoint', function() {
+    var groupId = 1;
+    var chatId = 2;
+    $httpBackend.expectDELETE(apiV3Prefix + '/groups/' + groupId + '/chat/' + chatId).respond({});
+    chat.deleteChat(groupId, chatId);
+    $httpBackend.flush();
+  });
+
+  it('calls like chat endpoint', function() {
+    var groupId = 1;
+    var chatId = 2;
+    $httpBackend.expectPOST(apiV3Prefix + '/groups/' + groupId + '/chat/' + chatId + '/like').respond({});
+    chat.like(groupId, chatId);
+    $httpBackend.flush();
+  });
+
+  it('calls flag chat endpoint', function() {
+    var groupId = 1;
+    var chatId = 2;
+    $httpBackend.expectPOST(apiV3Prefix + '/groups/' + groupId + '/chat/' + chatId + '/flag').respond({});
+    chat.flagChatMessage(groupId, chatId);
+    $httpBackend.flush();
+  });
+
+  it('calls clearflags chat endpoint', function() {
+    var groupId = 1;
+    var chatId = 2;
+    $httpBackend.expectPOST(apiV3Prefix + '/groups/' + groupId + '/chat/' + chatId + '/clearflags').respond({});
+    chat.clearFlagCount(groupId, chatId);
+    $httpBackend.flush();
+  });
+
+  it('calls chat seen endpoint', function() {
+    var groupId = 1;
+    $httpBackend.expectPOST(apiV3Prefix + '/groups/' + groupId + '/chat/seen').respond({});
+    chat.markChatSeen(groupId);
+    $httpBackend.flush();
+  });
+});
@@ -0,0 +1,200 @@
+'use strict';
+
+describe('groupServices', function() {
+  var $httpBackend, $http, groups, user, $rootScope;
+  var groupApiUrlPrefix = '/api/v3/groups';
+
+  beforeEach(function() {
+    module(function($provide) {
+      user = specHelper.newUser();
+      user._id = "unique-user-id"
+      user.party._id = 'unique-party-id';
+      user.sync = function(){};
+      $provide.value('User', {user: user});
+    });
+
+    inject(function(_$httpBackend_, _$rootScope_, Groups, User) {
+      $httpBackend = _$httpBackend_;
+      $rootScope = _$rootScope_;
+      $rootScope.openModal = function() {}
+      groups = Groups;
+    });
+  });
+
+  it('calls get groups', function() {
+    $httpBackend.expectGET(groupApiUrlPrefix).respond({});
+    groups.Group.getGroups();
+    $httpBackend.flush();
+  });
+
+  it('calls get group', function() {
+    var gid = 1;
+    $httpBackend.expectGET(groupApiUrlPrefix + '/' + gid).respond({});
+    groups.Group.get(gid);
+    $httpBackend.flush();
+  });
+
+  it('calls party endpoint', function() {
+    var groupId = '1234';
+    var groupResponse = {data: {_id: groupId}};
+    $httpBackend.expectGET(groupApiUrlPrefix + '/party').respond(groupResponse);
+    $httpBackend.expectGET('/api/v3/groups/' + groupId + '/members?includeAllPublicFields=true').respond({});
+    $httpBackend.expectGET('/api/v3/groups/' + groupId + '/invites').respond({});
+    $httpBackend.expectGET('/api/v3/challenges/groups/' + groupId).respond({});
+    groups.Group.syncParty();
+    $httpBackend.flush();
+  });
+
+  it('calls create endpoint', function() {
+    $httpBackend.expectPOST(groupApiUrlPrefix).respond({});
+    groups.Group.create({});
+    $httpBackend.flush();
+  });
+
+  it('calls update group', function() {
+    var gid = 1;
+    var groupDetails = { _id: gid };
+    $httpBackend.expectPUT(groupApiUrlPrefix + '/' + gid).respond({});
+    groups.Group.update(groupDetails);
+    $httpBackend.flush();
+  });
+
+  it('calls join group', function() {
+    var gid = 1;
+    $httpBackend.expectPOST(groupApiUrlPrefix + '/' + gid + '/join').respond({});
+    groups.Group.join(gid);
+    $httpBackend.flush();
+  });
+
+  it('calls reject invite group', function() {
+    var gid = 1;
+    $httpBackend.expectPOST(groupApiUrlPrefix + '/' + gid + '/reject-invite').respond({});
+    groups.Group.rejectInvite(gid);
+    $httpBackend.flush();
+  });
+
+  it('calls invite group', function() {
+    var gid = 1;
+    $httpBackend.expectPOST(groupApiUrlPrefix + '/' + gid + '/invite').respond({});
+    groups.Group.invite(gid, [], []);
+    $httpBackend.flush();
+  });
+
+  it('calls party endpoint when party is not cached', function() {
+    var groupId = '1234';
+    var groupResponse = {data: {_id: groupId}};
+    $httpBackend.expectGET(groupApiUrlPrefix + '/party').respond(groupResponse);
+    $httpBackend.expectGET('/api/v3/groups/' + groupId + '/members?includeAllPublicFields=true').respond({});
+    $httpBackend.expectGET('/api/v3/groups/' + groupId + '/invites').respond({});
+    $httpBackend.expectGET('/api/v3/challenges/groups/' + groupId).respond({});
+    groups.party();
+    $httpBackend.flush();
+  });
+
+  it('returns party if cached', function (done) {
+    var uid = 'abc';
+    var party = {
+      _id: uid,
+    };
+    groups.data.party = party;
+    groups.party()
+      .then(function (result) {
+        expect(result).to.eql(party);
+        done();
+      });
+    $httpBackend.flush();
+  });
+
+  it('calls tavern endpoint when tavern is not cached', function() {
+    $httpBackend.expectGET(groupApiUrlPrefix + '/habitrpg').respond({});
+    groups.tavern();
+    $httpBackend.flush();
+  });
+
+  it('returns tavern if cached', function (done) {
+    var uid = 'abc';
+    var tavern = {
+      _id: uid,
+    };
+    groups.data.tavern = tavern;
+    groups.tavern()
+      .then(function (result) {
+        expect(result).to.eql(tavern);
+        done();
+      });
+    $httpBackend.flush();
+  });
+
+  it('calls public guilds endpoint', function() {
+    $httpBackend.expectGET(groupApiUrlPrefix + '?type=publicGuilds').respond([]);
+    groups.publicGuilds();
+    $httpBackend.flush();
+  });
+
+  it('returns public guilds if cached', function (done) {
+    var uid = 'abc';
+    var publicGuilds = [
+      {_id: uid},
+    ];
+    groups.data.publicGuilds = publicGuilds;
+
+    groups.publicGuilds()
+      .then(function (result) {
+        expect(result).to.eql(publicGuilds);
+        done();
+      });
+
+    $httpBackend.flush();
+  });
+
+  it('calls my guilds endpoint', function() {
+    $httpBackend.expectGET(groupApiUrlPrefix + '?type=guilds').respond([]);
+    groups.myGuilds();
+    $httpBackend.flush();
+  });
+
+  it('returns my guilds if cached', function (done) {
+    var uid = 'abc';
+    var myGuilds = [
+      {_id: uid},
+    ];
+    groups.data.myGuilds = myGuilds;
+
+    groups.myGuilds()
+      .then(function (myGuilds) {
+        expect(myGuilds).to.eql(myGuilds);
+        done();
+      });
+
+    $httpBackend.flush()
+  });
+
+  it('sets a "sendInviteText" property on a party to "Send Invitations"', function() {
+    var sendInviteText = window.env.t('sendInvitations');
+    var party = {
+      type: 'party',
+      data: {
+        _id: '1234',
+      },
+    };
+    groups.inviteOrStartParty(party);
+    expect(party.sendInviteText).to.eql(sendInviteText);
+  });
+
+  it('sets a "sendInviteText" proptery on a guild to "Send Invitations +$3.00/month/user"', function() {
+    var sendInviteText = window.env.t('sendInvitations');
+    var guild = {
+      type: 'guild',
+      data: {
+        _id: '12345',
+      },
+      purchased: {
+        plan: {
+          customerId: '123',
+        },
+      },
+    };
+    groups.inviteOrStartParty(guild);
+    expect(guild.sendInviteText).to.eql(sendInviteText + window.env.t('groupAdditionalUserCost'));
+  });
+});
--- a/Show More
+++ b/Show More