Adjust helper files for linting preferences.

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) => {
-      if (err) return reject(err);
+    mongo.connect('mongodb://localhost/habitrpg_test', (connectionError, db) => {
+      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 email = username + '@example.com';
+  let password = 'password';
+  let email = `${username}@example.com`;
 
   let request = _requestMaker({}, 'post');
 
   return new Promise((resolve, reject) => {
     request('/register', {
-      username: username,
-      email: email,
-      password: password,
+      username,
+      email,
+      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]
-        });
-       invitePromises.push(invitePromise);
+          uuids: [invitee._id],
         });
 
-      return Promise.all(invitePromises);
-    }).then((inviteResults) => {
+        invitationPromises.push(invitePromise);
+      });
+
+      return Promise.all(invitationPromises);
+    }).then(() => {
       resolve({
-        leader: leader,
-        group: group,
-        members: members,
-        invitees: invitees,
+        leader,
+        group,
+        members,
+        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) => {
-        if (err) return reject(err);
+      db.dropDatabase((dbErr) => {
+        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) => {
-          if (err) return reject(err);
+        }, (insertErr) => {
+          if (insertErr) return reject(insertErr);
 
           db.close();
           resolve();
@@ -228,29 +240,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,
-              text: errorString,
+              code: err.response.status,
+              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) => {
-    if (err) throw `Error connecting to database when updating ${collectionName} collection: ${err}`;
+  mongo.connect('mongodb://localhost/habitrpg_test', (connectErr, db) => {
+    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) => {
-      if (err) throw `Error updating ${collectionName}: ${err}`;
+    collection.update({ _id: doc._id }, { $set: update }, (updateErr) => {
+      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,9 +1,10 @@
+/* eslint-disable no-undef */
 //------------------------------
 // Global modules
 //------------------------------
 
-global._ = require("lodash")
-global.chai = require("chai")
-chai.use(require("sinon-chai"))
-chai.use(require("chai-as-promised"));
-global.expect = chai.expect
+global._ = require('lodash');
+global.chai = require('chai');
+chai.use(require('sinon-chai'));
+chai.use(require('chai-as-promised'));
+global.expect = chai.expect;