krikkert/habitica
1
0
Fork 0
mirror of https://github.com/HabitRPG/habitica.git synced 2025-12-18 15:17:25 +01:00
Code Issues Packages Projects Releases Wiki Activity

fix test lint

Browse Source
This commit is contained in:
Matteo Pagliazzi
2019-10-08 20:45:38 +02:00
parent e37f4467f8
commit 85fb5f33aa
367 changed files with 6635 additions and 6080 deletions
Download Patch File Download Diff File Expand all files Collapse all files

176
test/common/libs/achievements.test.js
View File

@@ -5,11 +5,11 @@ import {
describe('achievements', () => {
describe('general well-formedness', () => {
let user = generateUser();
let achievements = shared.achievements.getAchievementsForProfile(user);
const user = generateUser();
const achievements = shared.achievements.getAchievementsForProfile(user);
it('each category has \'label\' and \'achievements\' fields', () => {
_.each(achievements, (category) => {
_.each(achievements, category => {
expect(category).to.have.property('label')
.that.is.a('string');
expect(category).to.have.property('achievements')
@@ -18,8 +18,8 @@ describe('achievements', () => {
});
it('each achievement has all required fields of correct types', () => {
_.each(achievements, (category) => {
_.each(category.achievements, (achiev) => {
_.each(achievements, category => {
_.each(category.achievements, achiev => {
// May have additional fields (such as 'value' and 'optionalCount').
expect(achiev).to.contain.all.keys(['title', 'text', 'icon', 'earned', 'index']);
expect(achiev.title).to.be.a('string');
@@ -32,18 +32,18 @@ describe('achievements', () => {
});
it('categories have unique labels', () => {
let achievementsArray = _.values(achievements).map(cat => cat.label);
let labels = _.uniq(achievementsArray);
const achievementsArray = _.values(achievements).map(cat => cat.label);
const labels = _.uniq(achievementsArray);
expect(labels.length).to.be.greaterThan(0);
expect(labels.length).to.eql(_.size(achievements));
});
it('achievements have unique keys', () => {
let keysSoFar = {};
const keysSoFar = {};
_.each(achievements, (category) => {
_.keys(category.achievements).forEach((key) => {
_.each(achievements, category => {
_.keys(category.achievements).forEach(key => {
expect(keysSoFar[key]).to.be.undefined;
keysSoFar[key] = key;
});
@@ -51,11 +51,11 @@ describe('achievements', () => {
});
it('achievements have unique indices', () => {
let indicesSoFar = {};
const indicesSoFar = {};
_.each(achievements, (category) => {
_.each(category.achievements, (achiev) => {
let i = achiev.index;
_.each(achievements, category => {
_.each(category.achievements, achiev => {
const i = achiev.index;
expect(indicesSoFar[i]).to.be.undefined;
indicesSoFar[i] = i;
});
@@ -63,19 +63,19 @@ describe('achievements', () => {
});
it('all categories have at least 1 achievement', () => {
_.each(achievements, (category) => {
_.each(achievements, category => {
expect(_.size(category.achievements)).to.be.greaterThan(0);
});
});
});
describe('unearned basic achievements', () => {
let user = generateUser();
let basicAchievs = shared.achievements.getAchievementsForProfile(user).basic.achievements;
const user = generateUser();
const basicAchievs = shared.achievements.getAchievementsForProfile(user).basic.achievements;
it('streak and perfect day achievements exist with counts', () => {
let streak = basicAchievs.streak;
let perfect = basicAchievs.perfect;
const { streak } = basicAchievs;
const { perfect } = basicAchievs;
expect(streak).to.exist;
expect(streak).to.have.property('optionalCount')
@@ -86,8 +86,8 @@ describe('achievements', () => {
});
it('party up/on achievements exist with no counts', () => {
let partyUp = basicAchievs.partyUp;
let partyOn = basicAchievs.partyOn;
const { partyUp } = basicAchievs;
const { partyOn } = basicAchievs;
expect(partyUp).to.exist;
expect(partyUp.optionalCount).to.be.undefined;
@@ -96,9 +96,9 @@ describe('achievements', () => {
});
it('pet/mount master and triad bingo achievements exist with counts', () => {
let beastMaster = basicAchievs.beastMaster;
let mountMaster = basicAchievs.mountMaster;
let triadBingo = basicAchievs.triadBingo;
const { beastMaster } = basicAchievs;
const { mountMaster } = basicAchievs;
const { triadBingo } = basicAchievs;
expect(beastMaster).to.exist;
expect(beastMaster).to.have.property('optionalCount')
@@ -112,9 +112,9 @@ describe('achievements', () => {
});
it('ultimate gear achievements exist with no counts', () => {
let gearTypes = ['healer', 'rogue', 'warrior', 'mage'];
gearTypes.forEach((gear) => {
let gearAchiev = basicAchievs[`${gear}UltimateGear`];
const gearTypes = ['healer', 'rogue', 'warrior', 'mage'];
gearTypes.forEach(gear => {
const gearAchiev = basicAchievs[`${gear}UltimateGear`];
expect(gearAchiev).to.exist;
expect(gearAchiev.optionalCount).to.be.undefined;
@@ -122,9 +122,9 @@ describe('achievements', () => {
});
it('card achievements exist with counts', () => {
let cardTypes = ['greeting', 'thankyou', 'birthday', 'congrats', 'getwell', 'goodluck'];
cardTypes.forEach((card) => {
let cardAchiev = basicAchievs[`${card}Cards`];
const cardTypes = ['greeting', 'thankyou', 'birthday', 'congrats', 'getwell', 'goodluck'];
cardTypes.forEach(card => {
const cardAchiev = basicAchievs[`${card}Cards`];
expect(cardAchiev).to.exist;
expect(cardAchiev).to.have.property('optionalCount')
@@ -133,7 +133,7 @@ describe('achievements', () => {
});
it('rebirth achievement exists with no count', () => {
let rebirth = basicAchievs.rebirth;
const { rebirth } = basicAchievs;
expect(rebirth).to.exist;
expect(rebirth.optionalCount).to.be.undefined;
@@ -141,12 +141,13 @@ describe('achievements', () => {
});
describe('unearned seasonal achievements', () => {
let user = generateUser();
let seasonalAchievs = shared.achievements.getAchievementsForProfile(user).seasonal.achievements;
const user = generateUser();
const userAchievements = shared.achievements.getAchievementsForProfile(user);
const seasonalAchievs = userAchievements.seasonal.achievements;
it('habiticaDays and habitBirthdays achievements exist with counts', () => {
let habiticaDays = seasonalAchievs.habiticaDays;
let habitBirthdays = seasonalAchievs.habitBirthdays;
const { habiticaDays } = seasonalAchievs;
const { habitBirthdays } = seasonalAchievs;
expect(habiticaDays).to.exist;
expect(habiticaDays).to.have.property('optionalCount')
@@ -157,9 +158,9 @@ describe('achievements', () => {
});
it('spell achievements exist with counts', () => {
let spellTypes = ['snowball', 'spookySparkles', 'shinySeed', 'seafoam'];
spellTypes.forEach((spell) => {
let spellAchiev = seasonalAchievs[spell];
const spellTypes = ['snowball', 'spookySparkles', 'shinySeed', 'seafoam'];
spellTypes.forEach(spell => {
const spellAchiev = seasonalAchievs[spell];
expect(spellAchiev).to.exist;
expect(spellAchiev).to.have.property('optionalCount')
@@ -168,16 +169,16 @@ describe('achievements', () => {
});
it('quest achievements do not exist', () => {
let quests = ['dilatory', 'stressbeast', 'burnout', 'bewilder'];
quests.forEach((quest) => {
let questAchiev = seasonalAchievs[`${quest}Quest`];
const quests = ['dilatory', 'stressbeast', 'burnout', 'bewilder'];
quests.forEach(quest => {
const questAchiev = seasonalAchievs[`${quest}Quest`];
expect(questAchiev).to.not.exist;
});
});
it('costumeContests achievement exists with count', () => {
let costumeContests = seasonalAchievs.costumeContests;
const { costumeContests } = seasonalAchievs;
expect(costumeContests).to.exist;
expect(costumeContests).to.have.property('optionalCount')
@@ -185,9 +186,9 @@ describe('achievements', () => {
});
it('card achievements exist with counts', () => {
let cardTypes = ['nye', 'valentine'];
cardTypes.forEach((card) => {
let cardAchiev = seasonalAchievs[`${card}Cards`];
const cardTypes = ['nye', 'valentine'];
cardTypes.forEach(card => {
const cardAchiev = seasonalAchievs[`${card}Cards`];
expect(cardAchiev).to.exist;
expect(cardAchiev).to.have.property('optionalCount')
@@ -197,11 +198,11 @@ describe('achievements', () => {
});
describe('unearned special achievements', () => {
let user = generateUser();
let specialAchievs = shared.achievements.getAchievementsForProfile(user).special.achievements;
const user = generateUser();
const specialAchievs = shared.achievements.getAchievementsForProfile(user).special.achievements;
it('habitSurveys achievement exists with count', () => {
let habitSurveys = specialAchievs.habitSurveys;
const { habitSurveys } = specialAchievs;
expect(habitSurveys).to.exist;
expect(habitSurveys).to.have.property('optionalCount')
@@ -209,7 +210,7 @@ describe('achievements', () => {
});
it('contributor achievement exists with value and no count', () => {
let contributor = specialAchievs.contributor;
const { contributor } = specialAchievs;
expect(contributor).to.exist;
expect(contributor).to.have.property('value')
@@ -218,37 +219,38 @@ describe('achievements', () => {
});
it('npc achievement is hidden if unachieved', () => {
let npc = specialAchievs.npc;
const { npc } = specialAchievs;
expect(npc).to.not.exist;
});
it('kickstarter achievement is hidden if unachieved', () => {
let kickstarter = specialAchievs.kickstarter;
const { kickstarter } = specialAchievs;
expect(kickstarter).to.not.exist;
});
it('veteran achievement is hidden if unachieved', () => {
let veteran = specialAchievs.veteran;
const { veteran } = specialAchievs;
expect(veteran).to.not.exist;
});
it('originalUser achievement is hidden if unachieved', () => {
let originalUser = specialAchievs.originalUser;
const { originalUser } = specialAchievs;
expect(originalUser).to.not.exist;
});
});
describe('earned seasonal achievements', () => {
let user = generateUser();
let quests = ['dilatory', 'stressbeast', 'burnout', 'bewilder'];
quests.forEach((quest) => {
const user = generateUser();
const quests = ['dilatory', 'stressbeast', 'burnout', 'bewilder'];
quests.forEach(quest => {
user.achievements.quests[quest] = 1;
});
let seasonalAchievs = shared.achievements.getAchievementsForProfile(user).seasonal.achievements;
const userAchievements = shared.achievements.getAchievementsForProfile(user);
const seasonalAchievs = userAchievements.seasonal.achievements;
it('quest achievements exist', () => {
quests.forEach((quest) => {
let questAchiev = seasonalAchievs[`${quest}Quest`];
quests.forEach(quest => {
const questAchiev = seasonalAchievs[`${quest}Quest`];
expect(questAchiev).to.exist;
expect(questAchiev.optionalCount).to.be.undefined;
@@ -257,19 +259,19 @@ describe('achievements', () => {
});
describe('earned special achievements', () => {
let user = generateUser({
const user = generateUser({
achievements: {
habitSurveys: 2,
veteran: true,
originalUser: true,
},
backer: {tier: 3},
contributor: {level: 1},
backer: { tier: 3 },
contributor: { level: 1 },
});
let specialAchievs = shared.achievements.getAchievementsForProfile(user).special.achievements;
const specialAchievs = shared.achievements.getAchievementsForProfile(user).special.achievements;
it('habitSurveys achievement is earned with correct value', () => {
let habitSurveys = specialAchievs.habitSurveys;
const { habitSurveys } = specialAchievs;
expect(habitSurveys).to.exist;
expect(habitSurveys.earned).to.eql(true);
@@ -277,7 +279,7 @@ describe('achievements', () => {
});
it('contributor achievement is earned with correct value', () => {
let contributor = specialAchievs.contributor;
const { contributor } = specialAchievs;
expect(contributor).to.exist;
expect(contributor.earned).to.eql(true);
@@ -285,10 +287,10 @@ describe('achievements', () => {
});
it('npc achievement is earned with correct value', () => {
let npcUser = generateUser({
backer: {npc: 'test'},
const npcUser = generateUser({
backer: { npc: 'test' },
});
let npc = shared.achievements.getAchievementsForProfile(npcUser).special.achievements.npc;
const { npc } = shared.achievements.getAchievementsForProfile(npcUser).special.achievements;
expect(npc).to.exist;
expect(npc.earned).to.eql(true);
@@ -296,7 +298,7 @@ describe('achievements', () => {
});
it('kickstarter achievement is earned with correct value', () => {
let kickstarter = specialAchievs.kickstarter;
const { kickstarter } = specialAchievs;
expect(kickstarter).to.exist;
expect(kickstarter.earned).to.eql(true);
@@ -304,14 +306,14 @@ describe('achievements', () => {
});
it('veteran achievement is earned', () => {
let veteran = specialAchievs.veteran;
const { veteran } = specialAchievs;
expect(veteran).to.exist;
expect(veteran.earned).to.eql(true);
});
it('originalUser achievement is earned', () => {
let originalUser = specialAchievs.originalUser;
const { originalUser } = specialAchievs;
expect(originalUser).to.exist;
expect(originalUser.earned).to.eql(true);
@@ -320,12 +322,12 @@ describe('achievements', () => {
describe('mountMaster, beastMaster, and triadBingo achievements', () => {
it('master and triad bingo achievements do not include *Text2 strings if no keys have been used', () => {
let user = generateUser();
let basicAchievs = shared.achievements.getAchievementsForProfile(user).basic.achievements;
const user = generateUser();
const basicAchievs = shared.achievements.getAchievementsForProfile(user).basic.achievements;
let beastMaster = basicAchievs.beastMaster;
let mountMaster = basicAchievs.mountMaster;
let triadBingo = basicAchievs.triadBingo;
const { beastMaster } = basicAchievs;
const { mountMaster } = basicAchievs;
const { triadBingo } = basicAchievs;
expect(beastMaster.text).to.not.match(/released/);
expect(beastMaster.text).to.not.match(/0 time\(s\)/);
@@ -336,18 +338,18 @@ describe('achievements', () => {
});
it('master and triad bingo achievements includes *Text2 strings if keys have been used', () => {
let user = generateUser({
const user = generateUser({
achievements: {
beastMasterCount: 1,
mountMasterCount: 2,
triadBingoCount: 3,
},
});
let basicAchievs = shared.achievements.getAchievementsForProfile(user).basic.achievements;
const basicAchievs = shared.achievements.getAchievementsForProfile(user).basic.achievements;
let beastMaster = basicAchievs.beastMaster;
let mountMaster = basicAchievs.mountMaster;
let triadBingo = basicAchievs.triadBingo;
const { beastMaster } = basicAchievs;
const { mountMaster } = basicAchievs;
const { triadBingo } = basicAchievs;
expect(beastMaster.text).to.match(/released/);
expect(beastMaster.text).to.match(/1 time\(s\)/);
@@ -360,13 +362,13 @@ describe('achievements', () => {
describe('ultimateGear achievements', () => {
it('title and text contain localized class info', () => {
let user = generateUser();
let basicAchievs = shared.achievements.getAchievementsForProfile(user).basic.achievements;
let gearTypes = ['healer', 'rogue', 'warrior', 'mage'];
const user = generateUser();
const basicAchievs = shared.achievements.getAchievementsForProfile(user).basic.achievements;
const gearTypes = ['healer', 'rogue', 'warrior', 'mage'];
gearTypes.forEach((gear) => {
let gearAchiev = basicAchievs[`${gear}UltimateGear`];
let classNameRegex = new RegExp(gear.charAt(0).toUpperCase() + gear.slice(1));
gearTypes.forEach(gear => {
const gearAchiev = basicAchievs[`${gear}UltimateGear`];
const classNameRegex = new RegExp(gear.charAt(0).toUpperCase() + gear.slice(1));
expect(gearAchiev.title).to.match(classNameRegex);
expect(gearAchiev.text).to.match(classNameRegex);

6
test/common/libs/appliedTags.test.js
View File

@@ -2,9 +2,9 @@ import appliedTags from '../../../website/common/script/libs/appliedTags';
describe('appliedTags', () => {
it('returns the tasks', () => {
let userTags = [{ id: 'tag1', name: 'tag 1' }, { id: 'tag2', name: 'tag 2' }, { id: 'tag3', name: 'tag 3' }];
let taskTags = ['tag2', 'tag3'];
let result = appliedTags(userTags, taskTags);
const userTags = [{ id: 'tag1', name: 'tag 1' }, { id: 'tag2', name: 'tag 2' }, { id: 'tag3', name: 'tag 3' }];
const taskTags = ['tag2', 'tag3'];
const result = appliedTags(userTags, taskTags);
expect(result).to.eql('tag 2, tag 3');
});
});

16
test/common/libs/hasClass.test.js
View File

@@ -3,49 +3,49 @@ import { generateUser } from '../../helpers/common.helper';
describe('hasClass', () => {
it('returns false for user with level below 10', () => {
let userLvl9 = generateUser({
const userLvl9 = generateUser({
'stats.lvl': 9,
'flags.classSelected': true,
'preferences.disableClasses': false,
});
let result = hasClass(userLvl9);
const result = hasClass(userLvl9);
expect(result).to.eql(false);
});
it('returns false for user with class not selected', () => {
let userClassNotSelected = generateUser({
const userClassNotSelected = generateUser({
'stats.lvl': 10,
'flags.classSelected': false,
'preferences.disableClasses': false,
});
let result = hasClass(userClassNotSelected);
const result = hasClass(userClassNotSelected);
expect(result).to.eql(false);
});
it('returns false for user with classes disabled', () => {
let userClassesDisabled = generateUser({
const userClassesDisabled = generateUser({
'stats.lvl': 10,
'flags.classSelected': true,
'preferences.disableClasses': true,
});
let result = hasClass(userClassesDisabled);
const result = hasClass(userClassesDisabled);
expect(result).to.eql(false);
});
it('returns true for user with class', () => {
let userClassSelected = generateUser({
const userClassSelected = generateUser({
'stats.lvl': 10,
'flags.classSelected': true,
'preferences.disableClasses': false,
});
let result = hasClass(userClassSelected);
const result = hasClass(userClassSelected);
expect(result).to.eql(true);
});

21
test/common/libs/inAppRewards.js
View File

@@ -1,7 +1,7 @@
import {
generateUser,
} from '../../helpers/common.helper';
import getOfficialPinnedItems from '../../../website/common/script/libs/getOfficialPinnedItems.js';
import getOfficialPinnedItems from '../../../website/common/script/libs/getOfficialPinnedItems';
import inAppRewards from '../../../website/common/script/libs/inAppRewards';
describe('inAppRewards', () => {
@@ -16,7 +16,8 @@ describe('inAppRewards', () => {
officialPinnedItems = getOfficialPinnedItems(user);
officialPinnedItemPaths = [];
// officialPinnedItems are returned in { type: ..., path:... } format but we just need the paths for testPinnedItemsOrder
// officialPinnedItems are returned in { type: ..., path:... } format
// but we just need the paths for testPinnedItemsOrder
if (officialPinnedItems.length > 0) {
officialPinnedItemPaths = officialPinnedItems.map(item => item.path);
}
@@ -56,7 +57,7 @@ describe('inAppRewards', () => {
user.pinnedItems = testPinnedItems;
user.pinnedItemsOrder = testPinnedItemsOrder;
let result = inAppRewards(user);
const result = inAppRewards(user);
expect(result[2].path).to.eql('armoire');
expect(result[9].path).to.eql('potion');
@@ -68,7 +69,7 @@ describe('inAppRewards', () => {
user.pinnedItems.push(undefined);
user.pinnedItemsOrder = testPinnedItemsOrder;
let result = inAppRewards(user);
const result = inAppRewards(user);
expect(result[2].path).to.eql('armoire');
expect(result[9].path).to.eql('potion');
@@ -79,18 +80,18 @@ describe('inAppRewards', () => {
return; // if no seasonal items, this test is not applicable
}
let testUnpinnedItem = officialPinnedItems[0];
let testUnpinnedPath = testUnpinnedItem.path;
let testUnpinnedItems = [
{ type: testUnpinnedItem.type, path: testUnpinnedPath},
const testUnpinnedItem = officialPinnedItems[0];
const testUnpinnedPath = testUnpinnedItem.path;
const testUnpinnedItems = [
{ type: testUnpinnedItem.type, path: testUnpinnedPath },
];
user.pinnedItems = testPinnedItems;
user.pinnedItemsOrder = testPinnedItemsOrder;
user.unpinnedItems = testUnpinnedItems;
let result = inAppRewards(user);
let itemPaths = result.map(item => item.path);
const result = inAppRewards(user);
const itemPaths = result.map(item => item.path);
expect(itemPaths).to.not.include(testUnpinnedPath);
});
});

4
test/common/libs/noTags.test.js
View File

@@ -2,12 +2,12 @@ import noTags from '../../../website/common/script/libs/noTags';
describe('noTags', () => {
it('returns true for no tags', () => {
let result = noTags([]);
const result = noTags([]);
expect(result).to.eql(true);
});
it('returns false for some tags', () => {
let result = noTags(['a', 'b', 'c']);
const result = noTags(['a', 'b', 'c']);
expect(result).to.eql(false);
});
});

4
test/common/libs/pickDeep.js
View File

@@ -6,7 +6,7 @@ describe('pickDeep', () => {
});
it('returns an object of properties taken from the input object', () => {
let obj = {
const obj = {
a: true,
b: [1, 2, 3],
c: {
@@ -19,7 +19,7 @@ describe('pickDeep', () => {
d: false,
};
let res = pickDeep(obj, ['a', 'b[0]', 'c.nested.two.times']);
const res = pickDeep(obj, ['a', 'b[0]', 'c.nested.two.times']);
expect(res.a).to.be.true;
expect(res.b).to.eql([1]);
expect(res.c).to.eql({

6
test/common/libs/randomVal.js
View File

@@ -1,5 +1,5 @@
import { times } from 'lodash';
import randomVal from '../../../website/common/script/libs/randomVal';
import {times} from 'lodash';
describe('randomVal', () => {
let obj;
@@ -18,7 +18,7 @@ describe('randomVal', () => {
});
it('returns a random value from an object', () => {
let result = randomVal(obj);
const result = randomVal(obj);
expect(result).to.be.oneOf([1, 2, 3, 4]);
});
@@ -31,7 +31,7 @@ describe('randomVal', () => {
});
it('returns a random key when the key option is passed in', () => {
let result = randomVal(obj, { key: true });
const result = randomVal(obj, { key: true });
expect(result).to.be.oneOf(['a', 'b', 'c', 'd']);
});
});

22
test/common/libs/refPush.js
View File

@@ -1,10 +1,10 @@
import shared from '../../../website/common';
import { v4 as generateUUID } from 'uuid';
import shared from '../../../website/common';
describe('refPush', () => {
it('it hashes one object into another by its id', () => {
let referenceObject = {};
let objectToHash = {
const referenceObject = {};
const objectToHash = {
a: 1,
id: generateUUID(),
};
@@ -17,16 +17,14 @@ describe('refPush', () => {
});
it('it hashes one object into another by a uuid when object does not have an id', () => {
let referenceObject = {};
let objectToHash = {
const referenceObject = {};
const objectToHash = {
a: 1,
};
shared.refPush(referenceObject, objectToHash);
let hashedObject = _.find(referenceObject, (hashedItem) => {
return objectToHash.a === hashedItem.a;
});
const hashedObject = _.find(referenceObject, hashedItem => objectToHash.a === hashedItem.a);
expect(hashedObject.a).to.equal(objectToHash.a);
expect(hashedObject.id).to.equal(objectToHash.id);
@@ -34,17 +32,15 @@ describe('refPush', () => {
});
it('it hashes one object into another by a id and gives it the highest sort value', () => {
let referenceObject = {};
const referenceObject = {};
referenceObject[generateUUID()] = { b: 2, sort: 1 };
let objectToHash = {
const objectToHash = {
a: 1,
};
shared.refPush(referenceObject, objectToHash);
let hashedObject = _.find(referenceObject, (hashedItem) => {
return objectToHash.a === hashedItem.a;
});
const hashedObject = _.find(referenceObject, hashedItem => objectToHash.a === hashedItem.a);
expect(hashedObject.a).to.equal(objectToHash.a);
expect(hashedObject.id).to.equal(objectToHash.id);

80
test/common/libs/shops.js
View File

@@ -4,31 +4,31 @@ import {
} from '../../helpers/common.helper';
describe('shops', () => {
let user = generateUser();
const user = generateUser();
describe('market', () => {
let shopCategories = shared.shops.getMarketCategories(user);
const shopCategories = shared.shops.getMarketCategories(user);
it('contains at least the 3 default categories', () => {
expect(shopCategories.length).to.be.greaterThan(2);
});
it('does not contain an empty category', () => {
_.each(shopCategories, (category) => {
_.each(shopCategories, category => {
expect(category.items.length).to.be.greaterThan(0);
});
});
it('does not duplicate identifiers', () => {
let identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
const identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
expect(identifiers.length).to.eql(shopCategories.length);
});
it('items contain required fields', () => {
_.each(shopCategories, (category) => {
_.each(category.items, (item) => {
_.each(['key', 'text', 'notes', 'value', 'currency', 'locked', 'purchaseType', 'class'], (key) => {
_.each(shopCategories, category => {
_.each(category.items, item => {
_.each(['key', 'text', 'notes', 'value', 'currency', 'locked', 'purchaseType', 'class'], key => {
expect(_.has(item, key)).to.eql(true);
});
});
@@ -36,7 +36,7 @@ describe('shops', () => {
});
it('shows relevant non class gear in special category', () => {
let contributor = generateUser({
const contributor = generateUser({
contributor: {
level: 7,
critical: true,
@@ -50,18 +50,18 @@ describe('shops', () => {
},
});
let gearCategories = shared.shops.getMarketGearCategories(contributor);
let specialCategory = gearCategories.find(o => o.identifier === 'none');
expect(specialCategory.items.find((item) => item.key === 'weapon_special_1'));
expect(specialCategory.items.find((item) => item.key === 'armor_special_1'));
expect(specialCategory.items.find((item) => item.key === 'head_special_1'));
expect(specialCategory.items.find((item) => item.key === 'shield_special_1'));
expect(specialCategory.items.find((item) => item.key === 'weapon_special_critical'));
expect(specialCategory.items.find((item) => item.key === 'weapon_armoire_basicCrossbow'));// eslint-disable-line camelcase
const gearCategories = shared.shops.getMarketGearCategories(contributor);
const specialCategory = gearCategories.find(o => o.identifier === 'none');
expect(specialCategory.items.find(item => item.key === 'weapon_special_1'));
expect(specialCategory.items.find(item => item.key === 'armor_special_1'));
expect(specialCategory.items.find(item => item.key === 'head_special_1'));
expect(specialCategory.items.find(item => item.key === 'shield_special_1'));
expect(specialCategory.items.find(item => item.key === 'weapon_special_critical'));
expect(specialCategory.items.find(item => item.key === 'weapon_armoire_basicCrossbow'));// eslint-disable-line camelcase
});
it('does not show gear when it is all owned', () => {
let userWithItems = generateUser({
const userWithItems = generateUser({
stats: {
class: 'wizard',
},
@@ -91,12 +91,12 @@ describe('shops', () => {
});
let shopWizardItems = shared.shops.getMarketGearCategories(userWithItems).find(x => x.identifier === 'wizard').items.filter(x => x.klass === 'wizard' && (x.owned === false || x.owned === undefined));
const shopWizardItems = shared.shops.getMarketGearCategories(userWithItems).find(x => x.identifier === 'wizard').items.filter(x => x.klass === 'wizard' && (x.owned === false || x.owned === undefined));
expect(shopWizardItems.length).to.eql(0);
});
it('shows available gear not yet purchased and previously owned', () => {
let userWithItems = generateUser({
const userWithItems = generateUser({
stats: {
class: 'wizard',
},
@@ -123,7 +123,7 @@ describe('shops', () => {
});
let shopWizardItems = shared.shops.getMarketGearCategories(userWithItems).find(x => x.identifier === 'wizard').items.filter(x => x.klass === 'wizard' && (x.owned === false || x.owned === undefined));
const shopWizardItems = shared.shops.getMarketGearCategories(userWithItems).find(x => x.identifier === 'wizard').items.filter(x => x.klass === 'wizard' && (x.owned === false || x.owned === undefined));
expect(shopWizardItems.find(item => item.key === 'weapon_wizard_5').locked).to.eql(false);
expect(shopWizardItems.find(item => item.key === 'weapon_wizard_6').locked).to.eql(true);
expect(shopWizardItems.find(item => item.key === 'armor_wizard_3').locked).to.eql(false);
@@ -134,31 +134,31 @@ describe('shops', () => {
});
describe('questShop', () => {
let shopCategories = shared.shops.getQuestShopCategories(user);
const shopCategories = shared.shops.getQuestShopCategories(user);
it('does not contain an empty category', () => {
_.each(shopCategories, (category) => {
_.each(shopCategories, category => {
expect(category.items.length).to.be.greaterThan(0);
});
});
it('does not duplicate identifiers', () => {
let identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
const identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
expect(identifiers.length).to.eql(shopCategories.length);
});
it('items contain required fields', () => {
_.each(shopCategories, (category) => {
_.each(shopCategories, category => {
if (category.identifier === 'bundle') {
_.each(category.items, (item) => {
_.each(['key', 'text', 'notes', 'value', 'currency', 'purchaseType', 'class'], (key) => {
_.each(category.items, item => {
_.each(['key', 'text', 'notes', 'value', 'currency', 'purchaseType', 'class'], key => {
expect(_.has(item, key)).to.eql(true);
});
});
} else {
_.each(category.items, (item) => {
_.each(['key', 'text', 'notes', 'value', 'currency', 'locked', 'purchaseType', 'boss', 'class', 'collect', 'drop', 'unlockCondition', 'lvl'], (key) => {
_.each(category.items, item => {
_.each(['key', 'text', 'notes', 'value', 'currency', 'locked', 'purchaseType', 'boss', 'class', 'collect', 'drop', 'unlockCondition', 'lvl'], key => {
expect(_.has(item, key)).to.eql(true);
});
});
@@ -168,24 +168,24 @@ describe('shops', () => {
});
describe('timeTravelers', () => {
let shopCategories = shared.shops.getTimeTravelersCategories(user);
const shopCategories = shared.shops.getTimeTravelersCategories(user);
it('does not contain an empty category', () => {
_.each(shopCategories, (category) => {
_.each(shopCategories, category => {
expect(category.items.length).to.be.greaterThan(0);
});
});
it('does not duplicate identifiers', () => {
let identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
const identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
expect(identifiers.length).to.eql(shopCategories.length);
});
it('items contain required fields', () => {
_.each(shopCategories, (category) => {
_.each(category.items, (item) => {
_.each(['key', 'text', 'value', 'currency', 'locked', 'purchaseType', 'class', 'notes', 'class'], (key) => {
_.each(shopCategories, category => {
_.each(category.items, item => {
_.each(['key', 'text', 'value', 'currency', 'locked', 'purchaseType', 'class', 'notes', 'class'], key => {
expect(_.has(item, key)).to.eql(true);
});
});
@@ -194,24 +194,24 @@ describe('shops', () => {
});
describe('seasonalShop', () => {
let shopCategories = shared.shops.getSeasonalShopCategories(user);
const shopCategories = shared.shops.getSeasonalShopCategories(user);
it('does not contain an empty category', () => {
_.each(shopCategories, (category) => {
_.each(shopCategories, category => {
expect(category.items.length).to.be.greaterThan(0);
});
});
it('does not duplicate identifiers', () => {
let identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
const identifiers = Array.from(new Set(shopCategories.map(cat => cat.identifier)));
expect(identifiers.length).to.eql(shopCategories.length);
});
it('items contain required fields', () => {
_.each(shopCategories, (category) => {
_.each(category.items, (item) => {
_.each(['key', 'text', 'notes', 'value', 'currency', 'locked', 'purchaseType', 'type'], (key) => {
_.each(shopCategories, category => {
_.each(category.items, item => {
_.each(['key', 'text', 'notes', 'value', 'currency', 'locked', 'purchaseType', 'type'], key => {
expect(_.has(item, key)).to.eql(true);
});
});

14
test/common/libs/taskDefaults.test.js
View File

@@ -5,7 +5,7 @@ import { generateUser } from '../../helpers/common.helper';
describe('taskDefaults', () => {
it('applies defaults to undefined type or habit', () => {
let task = taskDefaults({}, generateUser());
const task = taskDefaults({}, generateUser());
expect(task.type).to.eql('habit');
expect(task._id).to.exist;
expect(task.text).to.eql(task._id);
@@ -21,7 +21,7 @@ describe('taskDefaults', () => {
});
it('applies defaults to a daily', () => {
let task = taskDefaults({ type: 'daily' }, generateUser());
const task = taskDefaults({ type: 'daily' }, generateUser());
expect(task.type).to.eql('daily');
expect(task._id).to.exist;
expect(task.text).to.eql(task._id);
@@ -45,7 +45,7 @@ describe('taskDefaults', () => {
});
it('applies defaults a reward', () => {
let task = taskDefaults({ type: 'reward' }, generateUser());
const task = taskDefaults({ type: 'reward' }, generateUser());
expect(task.type).to.eql('reward');
expect(task._id).to.exist;
expect(task.text).to.eql(task._id);
@@ -55,7 +55,7 @@ describe('taskDefaults', () => {
});
it('applies defaults a todo', () => {
let task = taskDefaults({ type: 'todo' }, generateUser());
const task = taskDefaults({ type: 'todo' }, generateUser());
expect(task.type).to.eql('todo');
expect(task._id).to.exist;
expect(task.text).to.eql(task._id);
@@ -67,15 +67,15 @@ describe('taskDefaults', () => {
it('starts a task yesterday if user cron is later today', () => {
// Configure to have a day start that's *always* tomorrow.
let user = generateUser({'preferences.dayStart': 25});
let task = taskDefaults({ type: 'daily' }, user);
const user = generateUser({ 'preferences.dayStart': 25 });
const task = taskDefaults({ type: 'daily' }, user);
expect(task.startDate).to.eql(
moment()
.zone(user.preferences.timezoneOffset, 'hour')
.startOf('day')
.subtract(1, 'day')
.toDate()
.toDate(),
);
});
});

36
test/common/libs/updateStore.js
View File

@@ -6,52 +6,36 @@ import i18n from '../../../website/common/script/i18n';
describe('updateStore', () => {
context('returns a list of gear items available for purchase', () => {
let user = generateUser();
const user = generateUser();
user.items.gear.owned.armor_armoire_lunarArmor = false; // eslint-disable-line camelcase
user.contributor.level = 2;
user.purchased.plan.mysteryItems = ['armor_mystery_201402'];
user.items.gear.owned.armor_mystery_201402 = false; // eslint-disable-line camelcase
let list = shared.updateStore(user);
const list = shared.updateStore(user);
it('contains the first item not purchased for each gear type', () => {
expect(_.find(list, item => {
return item.text() === i18n.t('armorWarrior1Text');
})).to.exist;
expect(_.find(list, item => item.text() === i18n.t('armorWarrior1Text'))).to.exist;
expect(_.find(list, item => {
return item.text() === i18n.t('armorWarrior2Text');
})).to.not.exist;
expect(_.find(list, item => item.text() === i18n.t('armorWarrior2Text'))).to.not.exist;
});
it('contains mystery items the user can own', () => {
expect(_.find(list, item => {
return item.text() === i18n.t('armorMystery201402Text');
})).to.exist;
expect(_.find(list, item => item.text() === i18n.t('armorMystery201402Text'))).to.exist;
expect(_.find(list, item => {
return item.text() === i18n.t('armorMystery201403Text');
})).to.not.exist;
expect(_.find(list, item => item.text() === i18n.t('armorMystery201403Text'))).to.not.exist;
});
it('contains special items the user can own', () => {
expect(_.find(list, item => {
return item.text() === i18n.t('armorSpecial1Text');
})).to.exist;
expect(_.find(list, item => item.text() === i18n.t('armorSpecial1Text'))).to.exist;
expect(_.find(list, item => {
return item.text() === i18n.t('headSpecial1Text');
})).to.not.exist;
expect(_.find(list, item => item.text() === i18n.t('headSpecial1Text'))).to.not.exist;
});
it('contains armoire items the user can own', () => {
expect(_.find(list, item => {
return item.text() === i18n.t('armorArmoireLunarArmorText');
})).to.exist;
expect(_.find(list, item => item.text() === i18n.t('armorArmoireLunarArmorText'))).to.exist;
expect(_.find(list, item => {
return item.text() === i18n.t('armorArmoireGladiatorArmorText');
})).to.not.exist;
expect(_.find(list, item => item.text() === i18n.t('armorArmoireGladiatorArmorText'))).to.not.exist;
});
});
});