Merge branch 'develop' into api-v3

.eslintrc

@@ -81,9 +81,6 @@
         "block-spacing": [2, "always"],
         "key-spacing": [2, {"beforeColon": false, "afterColon": true}],
         "max-nested-callbacks": [2, 3],
-        "mocha/no-exclusive-tests": 2,
-        "mocha/no-global-tests": 2,
-        "mocha/handle-done-callback": 2,
         "new-cap": 2,
         "new-parens": 2,
         "newline-after-var": 2,
@@ -119,11 +116,5 @@
     ecmaFeatures : {
         modules: true
     },
-    "extends": "eslint:recommended",
+    "extends": "eslint:recommended"
-    "globals": {
-        "expect": true
-    },
-    "plugins": [
-        "mocha"
-    ]
 }

common/script/content/gear/index.js

@@ -61,11 +61,11 @@ each(GEAR_TYPES, (type) => {
         let _canOwn = item.canOwn || canOwnFuncTrue;
 
         item.canOwn = (user) => {
-          let userOwnsItem = Boolean(user.items.gear.owned[key]);
+          let userHasOwnedItem = ownsItem(key)(user);
           let eventIsCurrent = moment().isAfter(item.event.start) && moment().isBefore(item.event.end);
           let compatibleWithUserClass = item.specialClass ? user.stats.class === item.specialClass : true;
 
-          return _canOwn(user) && (userOwnsItem || eventIsCurrent) && compatibleWithUserClass;
+          return _canOwn(user) && (userHasOwnedItem || eventIsCurrent) && compatibleWithUserClass;
         };
       }
 

tasks/gulp-eslint.js

@@ -45,7 +45,18 @@ gulp.task('lint:tests', () => {
       '!./test/server_side/**/*',
       '!./test/spec/**/*',
     ])
-    .pipe(eslint())
+    .pipe(eslint({
+      rules: {
+        'no-unused-expressions': 0,
+        'mocha/no-exclusive-tests': 2,
+        'mocha/no-global-tests': 2,
+        'mocha/handle-done-callback': 2,
+      },
+      globals: {
+        'expect': true,
+      },
+      plugins: [ 'mocha' ],
+    }))
     .pipe(eslint.format())
     .pipe(eslint.failAfterError());
 });

test/helpers/api-integration.helper.js

@@ -1,3 +1,5 @@
+/* eslint-disable no-use-before-define */
+
 import {
   assign,
   each,
@@ -21,8 +23,8 @@ export function requester(user={}, additionalSets) {
     post: _requestMaker(user, 'post', additionalSets),
     put: _requestMaker(user, 'put', additionalSets),
     del: _requestMaker(user, 'del', additionalSets),
-  }
   };
+}
 
 // Use this to verify error messages returned by the server
 // That way, if the translated string changes, the test
@@ -38,18 +40,22 @@ export function translate(key, variables) {
   expect(translatedString).to.not.match(STRING_DOES_NOT_EXIST_MSG);
 
   return translatedString;
-};
+}
 
 // Useful for checking things that have been deleted,
 // but you no longer have access to,
 // like private parties or users
 export function checkExistence (collectionName, id) {
   return new Promise((resolve, reject) => {
-    mongo.connect('mongodb://localhost/habitrpg_test', (err, db) => {
+    mongo.connect('mongodb://localhost/habitrpg_test', (connectionError, db) => {
-      if (err) return reject(err);
+      if (connectionError) return reject(connectionError);
       let collection = db.collection(collectionName);
-      collection.find({_id: id}, {_id: 1}).limit(1).toArray((err, docs) => {
+
+      collection.find({_id: id}, {_id: 1}).limit(1).toArray((findError, docs) => {
+        if (findError) return reject(findError);
+
         let exists = docs.length > 0;
+
         db.close();
         resolve(exists);
       });
@@ -66,24 +72,24 @@ export function checkExistence(collectionName, id) {
 // { 'items.eggs.Wolf': 10 }
 export function generateUser (update = {}) {
   let username = generateUUID();
-  let password = 'password'
+  let password = 'password';
-  let email = username + '@example.com';
+  let email = `${username}@example.com`;
 
   let request = _requestMaker({}, 'post');
 
   return new Promise((resolve, reject) => {
     request('/register', {
-      username: username,
+      username,
-      email: email,
+      email,
-      password: password,
+      password,
       confirmPassword: password,
     }).then((user) => {
       _updateDocument('users', user, update, () => {
         resolve(user);
       });
+    }).catch(reject);
   });
-  });
+}
-};
 
 // Generates a new group. Requires a user object, which
 // will will become the groups leader. Takes an update
@@ -95,10 +101,10 @@ export function generateGroup(leader, update={}) {
     request('/groups').then((group) => {
       _updateDocument('groups', group, update, () => {
         resolve(group);
+      }).catch(reject);
     });
   });
-  });
+}
-};
 
 // This is generate group + the ability to create
 // real users to populate it. The settings object
@@ -115,7 +121,11 @@ export function generateGroup(leader, update={}) {
 // leader: the leader user object
 // group: the group object
 export function createAndPopulateGroup (settings = {}) {
-  let request, leader, members, invitees, group;
+  let request;
+  let leader;
+  let members;
+  let invitees;
+  let group;
 
   let numberOfMembers = settings.members || 0;
   let numberOfInvites = settings.invites || 0;
@@ -156,26 +166,27 @@ export function createAndPopulateGroup(settings={}) {
     }).then((users) => {
       invitees = users;
 
-      let invitePromises = [];
+      let invitationPromises = [];
 
       each(invitees, (invitee) => {
         let invitePromise = request(`/groups/${group._id}/invite`, {
-          uuids: [invitee._id]
+          uuids: [invitee._id],
-        });
-       invitePromises.push(invitePromise);
         });
 
-      return Promise.all(invitePromises);
+        invitationPromises.push(invitePromise);
-    }).then((inviteResults) => {
+      });
+
+      return Promise.all(invitationPromises);
+    }).then(() => {
       resolve({
-        leader: leader,
+        leader,
-        group: group,
+        group,
-        members: members,
+        members,
-        invitees: invitees,
+        invitees,
       });
     }).catch(reject);
   });
-};
+}
 
 // Specifically helpful for the GET /groups tests,
 // resets the db to an empty state and creates a tavern document
@@ -184,9 +195,10 @@ export function resetHabiticaDB() {
     mongo.connect('mongodb://localhost/habitrpg_test', (err, db) => {
       if (err) return reject(err);
 
-      db.dropDatabase((err) => {
+      db.dropDatabase((dbErr) => {
-        if (err) return reject(err);
+        if (dbErr) return reject(dbErr);
         let groups = db.collection('groups');
+
         groups.insertOne({
           _id: 'habitrpg',
           chat: [],
@@ -195,8 +207,8 @@ export function resetHabiticaDB() {
           type: 'guild',
           privacy: 'public',
           members: [],
-        }, (err) => {
+        }, (insertErr) => {
-          if (err) return reject(err);
+          if (insertErr) return reject(insertErr);
 
           db.close();
           resolve();
@@ -208,6 +220,7 @@ export function resetHabiticaDB() {
 
 function _requestMaker(user, method, additionalSets) {
   const API_V = process.env.API_VERSION || 'v2'
+
   return (route, send, query) => {
     return new Promise((resolve, reject) => {
       let request = superagent[method](`http://localhost:${API_TEST_SERVER_PORT}/api/${API_V}${route}`)
@@ -229,29 +242,31 @@ function _requestMaker(user, method, additionalSets) {
         .end((err, response) => {
           if (err) {
             if (!err.response) return reject(err);
-            let errorString = JSON.parse(err.response.text).err;
+
             return reject({
-              code: err.response.statusCode,
+              code: err.response.status,
-              text: errorString,
+              text: err.response.body.err,
             });
           }
 
           resolve(response.body);
         });
     });
-  }
+  };
 }
 
 function _updateDocument (collectionName, doc, update, cb) {
-  if (isEmpty(update)) { return cb(); }
+  if (isEmpty(update)) {
+    return cb();
+  }
 
-  mongo.connect('mongodb://localhost/habitrpg_test', (err, db) => {
+  mongo.connect('mongodb://localhost/habitrpg_test', (connectErr, db) => {
-    if (err) throw `Error connecting to database when updating ${collectionName} collection: ${err}`;
+    if (connectErr) throw new Error(`Error connecting to database when updating ${collectionName} collection: ${connectErr}`);
 
     let collection = db.collection(collectionName);
 
-    collection.update({ _id: doc._id }, { $set: update }, (err, result) => {
+    collection.update({ _id: doc._id }, { $set: update }, (updateErr) => {
-      if (err) throw `Error updating ${collectionName}: ${err}`;
+      if (updateErr) throw new Error(`Error updating ${collectionName}: ${updateErr}`);
       assign(doc, update);
       db.close();
       cb();

test/helpers/content.helper.js

@@ -15,7 +15,7 @@ export function expectValidTranslationString (attribute) {
   expect(translatedString).to.not.be.empty;
   expect(translatedString).to.not.eql(STRING_ERROR_MSG);
   expect(translatedString).to.not.match(STRING_DOES_NOT_EXIST_MSG);
-};
+}
 
 export function describeEachItem (testDescription, set, cb, describeFunction) {
   // describeFunction allows you to pass in 'only' or 'skip'
@@ -34,8 +34,8 @@ export function describeEachItem (testDescription, set, cb, describeFunction) {
 
 describeEachItem.only = (des, set, cb) => {
   describeEachItem(des, set, cb, 'only');
-}
+};
 
 describeEachItem.skip = (des, set, cb) => {
   describeEachItem(des, set, cb, 'skip');
-}
+};

test/helpers/globals.helper.js

@@ -1,14 +1,15 @@
+/* eslint-disable no-undef */
 require('babel-core/register');
 //------------------------------
 // Global modules
 //------------------------------
 
-global._ = require("lodash")
+global._ = require('lodash');
-global.chai = require("chai")
+global.chai = require('chai');
-global.sinon = require("sinon");
+chai.use(require('sinon-chai'));
-chai.use(require("sinon-chai"))
+chai.use(require('chai-as-promised'));
-chai.use(require("chai-as-promised"));
+global.expect = chai.expect;
-global.expect = chai.expect
+global.sinon = require('sinon');
 global.sandbox = sinon.sandbox.create();
 
 //------------------------------