mirror of
https://github.com/HabitRPG/habitica.git
synced 2025-12-16 14:17:22 +01:00
377 lines
12 KiB
JavaScript
377 lines
12 KiB
JavaScript
import shared from '../../../website/common';
|
|
import {
|
|
generateUser,
|
|
} from '../../helpers/common.helper';
|
|
|
|
describe('achievements', () => {
|
|
describe('general well-formedness', () => {
|
|
let user = generateUser();
|
|
let achievements = shared.achievements.getAchievementsForProfile(user);
|
|
|
|
it('each category has \'label\' and \'achievements\' fields', () => {
|
|
_.each(achievements, (category) => {
|
|
expect(category).to.have.property('label')
|
|
.that.is.a('string');
|
|
expect(category).to.have.property('achievements')
|
|
.that.is.a('object');
|
|
});
|
|
});
|
|
|
|
it('each achievement has all required fields of correct types', () => {
|
|
_.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');
|
|
expect(achiev.text).to.be.a('string');
|
|
expect(achiev.icon).to.be.a('string');
|
|
expect(achiev.earned).to.be.a('boolean');
|
|
expect(achiev.index).to.be.a('number');
|
|
});
|
|
});
|
|
});
|
|
|
|
it('categories have unique labels', () => {
|
|
let achievementsArray = _.values(achievements).map(cat => cat.label);
|
|
let labels = _.uniq(achievementsArray);
|
|
|
|
expect(labels.length).to.be.greaterThan(0);
|
|
expect(labels.length).to.eql(_.size(achievements));
|
|
});
|
|
|
|
it('achievements have unique keys', () => {
|
|
let keysSoFar = {};
|
|
|
|
_.each(achievements, (category) => {
|
|
_.keys(category.achievements).forEach((key) => {
|
|
expect(keysSoFar[key]).to.be.undefined;
|
|
keysSoFar[key] = key;
|
|
});
|
|
});
|
|
});
|
|
|
|
it('achievements have unique indices', () => {
|
|
let indicesSoFar = {};
|
|
|
|
_.each(achievements, (category) => {
|
|
_.each(category.achievements, (achiev) => {
|
|
let i = achiev.index;
|
|
expect(indicesSoFar[i]).to.be.undefined;
|
|
indicesSoFar[i] = i;
|
|
});
|
|
});
|
|
});
|
|
|
|
it('all categories have at least 1 achievement', () => {
|
|
_.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;
|
|
|
|
it('streak and perfect day achievements exist with counts', () => {
|
|
let streak = basicAchievs.streak;
|
|
let perfect = basicAchievs.perfect;
|
|
|
|
expect(streak).to.exist;
|
|
expect(streak).to.have.property('optionalCount')
|
|
.that.is.a('number');
|
|
expect(perfect).to.exist;
|
|
expect(perfect).to.have.property('optionalCount')
|
|
.that.is.a('number');
|
|
});
|
|
|
|
it('party up/on achievements exist with no counts', () => {
|
|
let partyUp = basicAchievs.partyUp;
|
|
let partyOn = basicAchievs.partyOn;
|
|
|
|
expect(partyUp).to.exist;
|
|
expect(partyUp.optionalCount).to.be.undefined;
|
|
expect(partyOn).to.exist;
|
|
expect(partyOn.optionalCount).to.be.undefined;
|
|
});
|
|
|
|
it('pet/mount master and triad bingo achievements exist with counts', () => {
|
|
let beastMaster = basicAchievs.beastMaster;
|
|
let mountMaster = basicAchievs.mountMaster;
|
|
let triadBingo = basicAchievs.triadBingo;
|
|
|
|
expect(beastMaster).to.exist;
|
|
expect(beastMaster).to.have.property('optionalCount')
|
|
.that.is.a('number');
|
|
expect(mountMaster).to.exist;
|
|
expect(mountMaster).to.have.property('optionalCount')
|
|
.that.is.a('number');
|
|
expect(triadBingo).to.exist;
|
|
expect(triadBingo).to.have.property('optionalCount')
|
|
.that.is.a('number');
|
|
});
|
|
|
|
it('ultimate gear achievements exist with no counts', () => {
|
|
let gearTypes = ['healer', 'rogue', 'warrior', 'mage'];
|
|
gearTypes.forEach((gear) => {
|
|
let gearAchiev = basicAchievs[`${gear}UltimateGear`];
|
|
|
|
expect(gearAchiev).to.exist;
|
|
expect(gearAchiev.optionalCount).to.be.undefined;
|
|
});
|
|
});
|
|
|
|
it('card achievements exist with counts', () => {
|
|
let cardTypes = ['greeting', 'thankyou', 'birthday', 'congrats', 'getwell'];
|
|
cardTypes.forEach((card) => {
|
|
let cardAchiev = basicAchievs[`${card}Cards`];
|
|
|
|
expect(cardAchiev).to.exist;
|
|
expect(cardAchiev).to.have.property('optionalCount')
|
|
.that.is.a('number');
|
|
});
|
|
});
|
|
|
|
it('rebirth achievement exists with no count', () => {
|
|
let rebirth = basicAchievs.rebirth;
|
|
|
|
expect(rebirth).to.exist;
|
|
expect(rebirth.optionalCount).to.be.undefined;
|
|
});
|
|
});
|
|
|
|
describe('unearned seasonal achievements', () => {
|
|
let user = generateUser();
|
|
let seasonalAchievs = shared.achievements.getAchievementsForProfile(user).seasonal.achievements;
|
|
|
|
it('habiticaDays and habitBirthdays achievements exist with counts', () => {
|
|
let habiticaDays = seasonalAchievs.habiticaDays;
|
|
let habitBirthdays = seasonalAchievs.habitBirthdays;
|
|
|
|
expect(habiticaDays).to.exist;
|
|
expect(habiticaDays).to.have.property('optionalCount')
|
|
.that.is.a('number');
|
|
expect(habitBirthdays).to.exist;
|
|
expect(habitBirthdays).to.have.property('optionalCount')
|
|
.that.is.a('number');
|
|
});
|
|
|
|
it('spell achievements exist with counts', () => {
|
|
let spellTypes = ['snowball', 'spookySparkles', 'shinySeed', 'seafoam'];
|
|
spellTypes.forEach((spell) => {
|
|
let spellAchiev = seasonalAchievs[spell];
|
|
|
|
expect(spellAchiev).to.exist;
|
|
expect(spellAchiev).to.have.property('optionalCount')
|
|
.that.is.a('number');
|
|
});
|
|
});
|
|
|
|
it('quest achievements do not exist', () => {
|
|
let quests = ['dilatory', 'stressbeast', 'burnout', 'bewilder'];
|
|
quests.forEach((quest) => {
|
|
let questAchiev = seasonalAchievs[`${quest}Quest`];
|
|
|
|
expect(questAchiev).to.not.exist;
|
|
});
|
|
});
|
|
|
|
it('costumeContests achievement exists with count', () => {
|
|
let costumeContests = seasonalAchievs.costumeContests;
|
|
|
|
expect(costumeContests).to.exist;
|
|
expect(costumeContests).to.have.property('optionalCount')
|
|
.that.is.a('number');
|
|
});
|
|
|
|
it('card achievements exist with counts', () => {
|
|
let cardTypes = ['nye', 'valentine'];
|
|
cardTypes.forEach((card) => {
|
|
let cardAchiev = seasonalAchievs[`${card}Cards`];
|
|
|
|
expect(cardAchiev).to.exist;
|
|
expect(cardAchiev).to.have.property('optionalCount')
|
|
.that.is.a('number');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('unearned special achievements', () => {
|
|
let user = generateUser();
|
|
let specialAchievs = shared.achievements.getAchievementsForProfile(user).special.achievements;
|
|
|
|
it('habitSurveys achievement exists with count', () => {
|
|
let habitSurveys = specialAchievs.habitSurveys;
|
|
|
|
expect(habitSurveys).to.exist;
|
|
expect(habitSurveys).to.have.property('optionalCount')
|
|
.that.is.a('number');
|
|
});
|
|
|
|
it('contributor achievement exists with value and no count', () => {
|
|
let contributor = specialAchievs.contributor;
|
|
|
|
expect(contributor).to.exist;
|
|
expect(contributor).to.have.property('value')
|
|
.that.is.a('number');
|
|
expect(contributor.optionalCount).to.be.undefined;
|
|
});
|
|
|
|
it('npc achievement is hidden if unachieved', () => {
|
|
let npc = specialAchievs.npc;
|
|
expect(npc).to.not.exist;
|
|
});
|
|
|
|
it('kickstarter achievement is hidden if unachieved', () => {
|
|
let kickstarter = specialAchievs.kickstarter;
|
|
expect(kickstarter).to.not.exist;
|
|
});
|
|
|
|
it('veteran achievement is hidden if unachieved', () => {
|
|
let veteran = specialAchievs.veteran;
|
|
expect(veteran).to.not.exist;
|
|
});
|
|
|
|
it('originalUser achievement is hidden if unachieved', () => {
|
|
let originalUser = specialAchievs.originalUser;
|
|
expect(originalUser).to.not.exist;
|
|
});
|
|
});
|
|
|
|
describe('earned seasonal achievements', () => {
|
|
let user = generateUser();
|
|
let quests = ['dilatory', 'stressbeast', 'burnout', 'bewilder'];
|
|
quests.forEach((quest) => {
|
|
user.achievements.quests[quest] = 1;
|
|
});
|
|
let seasonalAchievs = shared.achievements.getAchievementsForProfile(user).seasonal.achievements;
|
|
|
|
it('quest achievements exist', () => {
|
|
quests.forEach((quest) => {
|
|
let questAchiev = seasonalAchievs[`${quest}Quest`];
|
|
|
|
expect(questAchiev).to.exist;
|
|
expect(questAchiev.optionalCount).to.be.undefined;
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('earned special achievements', () => {
|
|
let user = generateUser({
|
|
achievements: {
|
|
habitSurveys: 2,
|
|
veteran: true,
|
|
originalUser: true,
|
|
},
|
|
backer: {tier: 3},
|
|
contributor: {level: 1},
|
|
});
|
|
let specialAchievs = shared.achievements.getAchievementsForProfile(user).special.achievements;
|
|
|
|
it('habitSurveys achievement is earned with correct value', () => {
|
|
let habitSurveys = specialAchievs.habitSurveys;
|
|
|
|
expect(habitSurveys).to.exist;
|
|
expect(habitSurveys.earned).to.eql(true);
|
|
expect(habitSurveys.value).to.eql(2);
|
|
});
|
|
|
|
it('contributor achievement is earned with correct value', () => {
|
|
let contributor = specialAchievs.contributor;
|
|
|
|
expect(contributor).to.exist;
|
|
expect(contributor.earned).to.eql(true);
|
|
expect(contributor.value).to.eql(1);
|
|
});
|
|
|
|
it('npc achievement is earned with correct value', () => {
|
|
let npcUser = generateUser({
|
|
backer: {npc: 'test'},
|
|
});
|
|
let npc = shared.achievements.getAchievementsForProfile(npcUser).special.achievements.npc;
|
|
|
|
expect(npc).to.exist;
|
|
expect(npc.earned).to.eql(true);
|
|
expect(npc.value).to.eql('test');
|
|
});
|
|
|
|
it('kickstarter achievement is earned with correct value', () => {
|
|
let kickstarter = specialAchievs.kickstarter;
|
|
|
|
expect(kickstarter).to.exist;
|
|
expect(kickstarter.earned).to.eql(true);
|
|
expect(kickstarter.value).to.eql(3);
|
|
});
|
|
|
|
it('veteran achievement is earned', () => {
|
|
let veteran = specialAchievs.veteran;
|
|
|
|
expect(veteran).to.exist;
|
|
expect(veteran.earned).to.eql(true);
|
|
});
|
|
|
|
it('originalUser achievement is earned', () => {
|
|
let originalUser = specialAchievs.originalUser;
|
|
|
|
expect(originalUser).to.exist;
|
|
expect(originalUser.earned).to.eql(true);
|
|
});
|
|
});
|
|
|
|
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;
|
|
|
|
let beastMaster = basicAchievs.beastMaster;
|
|
let mountMaster = basicAchievs.mountMaster;
|
|
let triadBingo = basicAchievs.triadBingo;
|
|
|
|
expect(beastMaster.text).to.not.match(/released/);
|
|
expect(beastMaster.text).to.not.match(/0 time\(s\)/);
|
|
expect(mountMaster.text).to.not.match(/released/);
|
|
expect(mountMaster.text).to.not.match(/0 time\(s\)/);
|
|
expect(triadBingo.text).to.not.match(/released/);
|
|
expect(triadBingo.text).to.not.match(/0 time\(s\)/);
|
|
});
|
|
|
|
it('master and triad bingo achievements includes *Text2 strings if keys have been used', () => {
|
|
let user = generateUser({
|
|
achievements: {
|
|
beastMasterCount: 1,
|
|
mountMasterCount: 2,
|
|
triadBingoCount: 3,
|
|
},
|
|
});
|
|
let basicAchievs = shared.achievements.getAchievementsForProfile(user).basic.achievements;
|
|
|
|
let beastMaster = basicAchievs.beastMaster;
|
|
let mountMaster = basicAchievs.mountMaster;
|
|
let triadBingo = basicAchievs.triadBingo;
|
|
|
|
expect(beastMaster.text).to.match(/released/);
|
|
expect(beastMaster.text).to.match(/1 time\(s\)/);
|
|
expect(mountMaster.text).to.match(/released/);
|
|
expect(mountMaster.text).to.match(/2 time\(s\)/);
|
|
expect(triadBingo.text).to.match(/released/);
|
|
expect(triadBingo.text).to.match(/3 time\(s\)/);
|
|
});
|
|
});
|
|
|
|
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'];
|
|
|
|
gearTypes.forEach((gear) => {
|
|
let gearAchiev = basicAchievs[`${gear}UltimateGear`];
|
|
let classNameRegex = new RegExp(gear.charAt(0).toUpperCase() + gear.slice(1));
|
|
|
|
expect(gearAchiev.title).to.match(classNameRegex);
|
|
expect(gearAchiev.text).to.match(classNameRegex);
|
|
});
|
|
});
|
|
});
|
|
});
|