@reldens/skills 0.46.0 → 0.48.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.claude/architecture.md +472 -0
- package/.claude/class-hierarchy.md +982 -0
- package/.claude/event-system-architecture.md +475 -0
- package/.claude/level-progression.md +1259 -0
- package/.claude/skill-execution-flow.md +979 -0
- package/.claude/testing-guide.md +356 -0
- package/.claude/testing-patterns.md +1096 -0
- package/CLAUDE.md +164 -29
- package/lib/class-path.js +13 -10
- package/lib/client/receiver.js +1 -3
- package/lib/levels-set.js +24 -17
- package/lib/server/sender.js +1 -1
- package/lib/skill.js +19 -16
- package/lib/types/attack.js +28 -11
- package/lib/types/effect.js +10 -4
- package/lib/types/physical-attack.js +2 -2
- package/lib/types/physical-effect.js +2 -2
- package/lib/types/physical-properties-validator.js +1 -1
- package/lib/types/physical-skill-runner.js +5 -5
- package/package.json +9 -3
- package/tests/fixtures/levels/base-levels.js +89 -0
- package/tests/fixtures/mocks/mock-client.js +44 -0
- package/tests/fixtures/mocks/mock-owner.js +60 -0
- package/tests/fixtures/mocks/mock-target.js +50 -0
- package/tests/fixtures/skills/base-skills.js +80 -0
- package/tests/run-tests.js +88 -0
- package/tests/unit/client/test-receiver.js +249 -0
- package/tests/unit/server/test-sender.js +527 -0
- package/tests/unit/test-class-path.js +1239 -0
- package/tests/unit/test-level.js +176 -0
- package/tests/unit/test-levels-set.js +1227 -0
- package/tests/unit/test-server.js +266 -0
- package/tests/unit/test-skill.js +1302 -0
- package/tests/unit/types/test-attack.js +1195 -0
- package/tests/unit/types/test-effect.js +587 -0
- package/tests/unit/types/test-physical-attack.js +564 -0
- package/tests/unit/types/test-physical-effect.js +769 -0
- package/tests/unit/types/test-physical-properties-validator.js +203 -0
- package/tests/unit/types/test-physical-skill-runner.js +348 -0
- package/tests/utils/test-helpers.js +122 -0
|
@@ -0,0 +1,1239 @@
|
|
|
1
|
+
/**
|
|
2
|
+
*
|
|
3
|
+
* Reldens - ClassPath Unit Tests
|
|
4
|
+
*
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
const { describe, it, beforeEach, afterEach } = require('node:test');
|
|
8
|
+
const assert = require('node:assert');
|
|
9
|
+
const ClassPath = require('../../lib/class-path');
|
|
10
|
+
const Skill = require('../../lib/skill');
|
|
11
|
+
const SkillsEvents = require('../../lib/skills-events');
|
|
12
|
+
const { TestHelpers } = require('../utils/test-helpers');
|
|
13
|
+
const { MockOwner } = require('../fixtures/mocks/mock-owner');
|
|
14
|
+
const { MockTarget } = require('../fixtures/mocks/mock-target');
|
|
15
|
+
const { BaseLevelsFixtures } = require('../fixtures/levels/base-levels');
|
|
16
|
+
const { BaseSkillsFixtures } = require('../fixtures/skills/base-skills');
|
|
17
|
+
|
|
18
|
+
describe('ClassPath', () => {
|
|
19
|
+
let mockOwner;
|
|
20
|
+
let mockTarget;
|
|
21
|
+
|
|
22
|
+
beforeEach(() => {
|
|
23
|
+
mockOwner = new MockOwner();
|
|
24
|
+
mockTarget = new MockTarget();
|
|
25
|
+
TestHelpers.clearEventListeners();
|
|
26
|
+
});
|
|
27
|
+
|
|
28
|
+
afterEach(() => {
|
|
29
|
+
TestHelpers.clearEventListeners();
|
|
30
|
+
});
|
|
31
|
+
|
|
32
|
+
describe('Constructor and Init', () => {
|
|
33
|
+
it('should initialize with basic properties', async () => {
|
|
34
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
35
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
36
|
+
await classPath.init({
|
|
37
|
+
key: 'warrior',
|
|
38
|
+
label: 'Warrior',
|
|
39
|
+
levels: levels,
|
|
40
|
+
currentLevel: 1,
|
|
41
|
+
currentExp: 0
|
|
42
|
+
});
|
|
43
|
+
assert.strictEqual(classPath.key, 'warrior');
|
|
44
|
+
assert.strictEqual(classPath.label, 'Warrior');
|
|
45
|
+
assert.strictEqual(classPath.currentLevel, 1);
|
|
46
|
+
});
|
|
47
|
+
|
|
48
|
+
it('should return false when key is missing', async () => {
|
|
49
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
50
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
51
|
+
let result = await classPath.init({
|
|
52
|
+
levels: levels,
|
|
53
|
+
currentLevel: 1,
|
|
54
|
+
currentExp: 0
|
|
55
|
+
});
|
|
56
|
+
assert.strictEqual(result, false);
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
it('should use key as label when label is not provided', async () => {
|
|
60
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
61
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
62
|
+
await classPath.init({
|
|
63
|
+
key: 'mage',
|
|
64
|
+
levels: levels,
|
|
65
|
+
currentLevel: 1,
|
|
66
|
+
currentExp: 0
|
|
67
|
+
});
|
|
68
|
+
assert.strictEqual(classPath.label, 'mage');
|
|
69
|
+
});
|
|
70
|
+
|
|
71
|
+
it('should initialize with labelsByLevel', async () => {
|
|
72
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
73
|
+
let labelsByLevel = {
|
|
74
|
+
1: 'Novice Warrior',
|
|
75
|
+
3: 'Experienced Warrior',
|
|
76
|
+
5: 'Master Warrior'
|
|
77
|
+
};
|
|
78
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
79
|
+
await classPath.init({
|
|
80
|
+
key: 'warrior',
|
|
81
|
+
label: 'Warrior',
|
|
82
|
+
levels: levels,
|
|
83
|
+
currentLevel: 1,
|
|
84
|
+
currentExp: 0,
|
|
85
|
+
labelsByLevel: labelsByLevel
|
|
86
|
+
});
|
|
87
|
+
assert.strictEqual(classPath.currentLabel, 'Novice Warrior');
|
|
88
|
+
});
|
|
89
|
+
|
|
90
|
+
it('should initialize with skillsByLevel', async () => {
|
|
91
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
92
|
+
let skill1 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill1', owner: mockOwner});
|
|
93
|
+
let skill2 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill2', owner: mockOwner});
|
|
94
|
+
let skillsByLevel = {
|
|
95
|
+
1: [skill1],
|
|
96
|
+
2: [skill2]
|
|
97
|
+
};
|
|
98
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
99
|
+
await classPath.init({
|
|
100
|
+
key: 'warrior',
|
|
101
|
+
levels: levels,
|
|
102
|
+
currentLevel: 1,
|
|
103
|
+
currentExp: 0,
|
|
104
|
+
skillsByLevel: skillsByLevel
|
|
105
|
+
});
|
|
106
|
+
assert.ok(classPath.currentSkills['skill1']);
|
|
107
|
+
assert.strictEqual(classPath.currentSkills['skill2'], undefined);
|
|
108
|
+
});
|
|
109
|
+
|
|
110
|
+
it('should fire INIT_CLASS_PATH_END event', async () => {
|
|
111
|
+
let eventFired = false;
|
|
112
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
113
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
114
|
+
classPath.listenEvent(SkillsEvents.INIT_CLASS_PATH_END, () => {
|
|
115
|
+
eventFired = true;
|
|
116
|
+
}, 'init-test');
|
|
117
|
+
await classPath.init({
|
|
118
|
+
key: 'warrior',
|
|
119
|
+
levels: levels,
|
|
120
|
+
currentLevel: 1,
|
|
121
|
+
currentExp: 0
|
|
122
|
+
});
|
|
123
|
+
assert.strictEqual(eventFired, true);
|
|
124
|
+
});
|
|
125
|
+
});
|
|
126
|
+
|
|
127
|
+
describe('levelUp', () => {
|
|
128
|
+
it('should add skills on level up', async () => {
|
|
129
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
130
|
+
let skill1 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill1', owner: mockOwner});
|
|
131
|
+
let skill2 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill2', owner: mockOwner});
|
|
132
|
+
let skillsByLevel = {
|
|
133
|
+
1: [skill1],
|
|
134
|
+
2: [skill2]
|
|
135
|
+
};
|
|
136
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
137
|
+
await classPath.init({
|
|
138
|
+
key: 'warrior',
|
|
139
|
+
levels: levels,
|
|
140
|
+
currentLevel: 1,
|
|
141
|
+
currentExp: 0,
|
|
142
|
+
skillsByLevel: skillsByLevel
|
|
143
|
+
});
|
|
144
|
+
assert.strictEqual(classPath.currentSkills['skill2'], undefined);
|
|
145
|
+
await classPath.levelUp();
|
|
146
|
+
assert.ok(classPath.currentSkills['skill2']);
|
|
147
|
+
});
|
|
148
|
+
|
|
149
|
+
it('should update label on level up', async () => {
|
|
150
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
151
|
+
let labelsByLevel = {
|
|
152
|
+
1: 'Novice',
|
|
153
|
+
2: 'Experienced'
|
|
154
|
+
};
|
|
155
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
156
|
+
await classPath.init({
|
|
157
|
+
key: 'warrior',
|
|
158
|
+
label: 'Warrior',
|
|
159
|
+
levels: levels,
|
|
160
|
+
currentLevel: 1,
|
|
161
|
+
currentExp: 0,
|
|
162
|
+
labelsByLevel: labelsByLevel
|
|
163
|
+
});
|
|
164
|
+
assert.strictEqual(classPath.currentLabel, 'Novice');
|
|
165
|
+
await classPath.levelUp();
|
|
166
|
+
assert.strictEqual(classPath.currentLabel, 'Experienced');
|
|
167
|
+
});
|
|
168
|
+
|
|
169
|
+
it('should call parent levelUp', async () => {
|
|
170
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
171
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
172
|
+
await classPath.init({
|
|
173
|
+
key: 'warrior',
|
|
174
|
+
levels: levels,
|
|
175
|
+
currentLevel: 1,
|
|
176
|
+
currentExp: 0
|
|
177
|
+
});
|
|
178
|
+
await classPath.levelUp();
|
|
179
|
+
assert.strictEqual(classPath.currentLevel, 2);
|
|
180
|
+
});
|
|
181
|
+
});
|
|
182
|
+
|
|
183
|
+
describe('levelDown', () => {
|
|
184
|
+
it('should remove skills on level down', async () => {
|
|
185
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
186
|
+
let skill1 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill1', owner: mockOwner});
|
|
187
|
+
let skill2 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill2', owner: mockOwner});
|
|
188
|
+
let skillsByLevel = {
|
|
189
|
+
1: [skill1],
|
|
190
|
+
2: [skill2]
|
|
191
|
+
};
|
|
192
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
193
|
+
await classPath.init({
|
|
194
|
+
key: 'warrior',
|
|
195
|
+
levels: levels,
|
|
196
|
+
currentLevel: 2,
|
|
197
|
+
currentExp: 100,
|
|
198
|
+
skillsByLevel: skillsByLevel
|
|
199
|
+
});
|
|
200
|
+
assert.ok(classPath.currentSkills['skill2']);
|
|
201
|
+
await classPath.levelDown();
|
|
202
|
+
assert.strictEqual(classPath.currentSkills['skill2'], undefined);
|
|
203
|
+
});
|
|
204
|
+
|
|
205
|
+
it('should update label on level down', async () => {
|
|
206
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
207
|
+
let labelsByLevel = {
|
|
208
|
+
1: 'Novice',
|
|
209
|
+
2: 'Experienced'
|
|
210
|
+
};
|
|
211
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
212
|
+
await classPath.init({
|
|
213
|
+
key: 'warrior',
|
|
214
|
+
label: 'Warrior',
|
|
215
|
+
levels: levels,
|
|
216
|
+
currentLevel: 2,
|
|
217
|
+
currentExp: 100,
|
|
218
|
+
labelsByLevel: labelsByLevel
|
|
219
|
+
});
|
|
220
|
+
assert.strictEqual(classPath.currentLabel, 'Experienced');
|
|
221
|
+
await classPath.levelDown();
|
|
222
|
+
assert.strictEqual(classPath.currentLabel, 'Novice');
|
|
223
|
+
});
|
|
224
|
+
});
|
|
225
|
+
|
|
226
|
+
describe('addSkills', () => {
|
|
227
|
+
it('should add skills to currentSkills', async () => {
|
|
228
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
229
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
230
|
+
await classPath.init({
|
|
231
|
+
key: 'warrior',
|
|
232
|
+
levels: levels,
|
|
233
|
+
currentLevel: 1,
|
|
234
|
+
currentExp: 0
|
|
235
|
+
});
|
|
236
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, key: 'newSkill', owner: mockOwner});
|
|
237
|
+
await classPath.addSkills([skill]);
|
|
238
|
+
assert.ok(classPath.currentSkills['newSkill']);
|
|
239
|
+
});
|
|
240
|
+
|
|
241
|
+
it('should fire ADD_SKILLS_BEFORE event', async () => {
|
|
242
|
+
let eventFired = false;
|
|
243
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
244
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
245
|
+
await classPath.init({
|
|
246
|
+
key: 'warrior',
|
|
247
|
+
levels: levels,
|
|
248
|
+
currentLevel: 1,
|
|
249
|
+
currentExp: 0
|
|
250
|
+
});
|
|
251
|
+
classPath.listenEvent(SkillsEvents.ADD_SKILLS_BEFORE, () => {
|
|
252
|
+
eventFired = true;
|
|
253
|
+
}, 'add-before-test');
|
|
254
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, key: 'newSkill', owner: mockOwner});
|
|
255
|
+
await classPath.addSkills([skill]);
|
|
256
|
+
assert.strictEqual(eventFired, true);
|
|
257
|
+
});
|
|
258
|
+
|
|
259
|
+
it('should fire ADD_SKILLS_AFTER event', async () => {
|
|
260
|
+
let eventFired = false;
|
|
261
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
262
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
263
|
+
await classPath.init({
|
|
264
|
+
key: 'warrior',
|
|
265
|
+
levels: levels,
|
|
266
|
+
currentLevel: 1,
|
|
267
|
+
currentExp: 0
|
|
268
|
+
});
|
|
269
|
+
classPath.listenEvent(SkillsEvents.ADD_SKILLS_AFTER, () => {
|
|
270
|
+
eventFired = true;
|
|
271
|
+
}, 'add-after-test');
|
|
272
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, key: 'newSkill', owner: mockOwner});
|
|
273
|
+
await classPath.addSkills([skill]);
|
|
274
|
+
assert.strictEqual(eventFired, true);
|
|
275
|
+
});
|
|
276
|
+
});
|
|
277
|
+
|
|
278
|
+
describe('removeSkills', () => {
|
|
279
|
+
it('should remove skills from currentSkills', async () => {
|
|
280
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
281
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, key: 'toRemove', owner: mockOwner});
|
|
282
|
+
let skillsByLevel = {
|
|
283
|
+
1: [skill]
|
|
284
|
+
};
|
|
285
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
286
|
+
await classPath.init({
|
|
287
|
+
key: 'warrior',
|
|
288
|
+
levels: levels,
|
|
289
|
+
currentLevel: 1,
|
|
290
|
+
currentExp: 0,
|
|
291
|
+
skillsByLevel: skillsByLevel
|
|
292
|
+
});
|
|
293
|
+
assert.ok(classPath.currentSkills['toRemove']);
|
|
294
|
+
await classPath.removeSkills(['toRemove']);
|
|
295
|
+
assert.strictEqual(classPath.currentSkills['toRemove'], undefined);
|
|
296
|
+
});
|
|
297
|
+
|
|
298
|
+
it('should fire REMOVE_SKILLS_BEFORE event', async () => {
|
|
299
|
+
let eventFired = false;
|
|
300
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
301
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, key: 'toRemove', owner: mockOwner});
|
|
302
|
+
let skillsByLevel = {
|
|
303
|
+
1: [skill]
|
|
304
|
+
};
|
|
305
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
306
|
+
await classPath.init({
|
|
307
|
+
key: 'warrior',
|
|
308
|
+
levels: levels,
|
|
309
|
+
currentLevel: 1,
|
|
310
|
+
currentExp: 0,
|
|
311
|
+
skillsByLevel: skillsByLevel
|
|
312
|
+
});
|
|
313
|
+
classPath.listenEvent(SkillsEvents.REMOVE_SKILLS_BEFORE, () => {
|
|
314
|
+
eventFired = true;
|
|
315
|
+
}, 'remove-before-test');
|
|
316
|
+
await classPath.removeSkills(['toRemove']);
|
|
317
|
+
assert.strictEqual(eventFired, true);
|
|
318
|
+
});
|
|
319
|
+
|
|
320
|
+
it('should fire REMOVE_SKILLS_AFTER event', async () => {
|
|
321
|
+
let eventFired = false;
|
|
322
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
323
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, key: 'toRemove', owner: mockOwner});
|
|
324
|
+
let skillsByLevel = {
|
|
325
|
+
1: [skill]
|
|
326
|
+
};
|
|
327
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
328
|
+
await classPath.init({
|
|
329
|
+
key: 'warrior',
|
|
330
|
+
levels: levels,
|
|
331
|
+
currentLevel: 1,
|
|
332
|
+
currentExp: 0,
|
|
333
|
+
skillsByLevel: skillsByLevel
|
|
334
|
+
});
|
|
335
|
+
classPath.listenEvent(SkillsEvents.REMOVE_SKILLS_AFTER, () => {
|
|
336
|
+
eventFired = true;
|
|
337
|
+
}, 'remove-after-test');
|
|
338
|
+
await classPath.removeSkills(['toRemove']);
|
|
339
|
+
assert.strictEqual(eventFired, true);
|
|
340
|
+
});
|
|
341
|
+
});
|
|
342
|
+
|
|
343
|
+
describe('setOwnerSkills', () => {
|
|
344
|
+
it('should set skills for current level', async () => {
|
|
345
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
346
|
+
let skill1 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill1', owner: mockOwner});
|
|
347
|
+
let skill2 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill2', owner: mockOwner});
|
|
348
|
+
let skill3 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill3', owner: mockOwner});
|
|
349
|
+
let skillsByLevel = {
|
|
350
|
+
1: [skill1],
|
|
351
|
+
2: [skill2],
|
|
352
|
+
3: [skill3]
|
|
353
|
+
};
|
|
354
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
355
|
+
await classPath.init({
|
|
356
|
+
key: 'warrior',
|
|
357
|
+
levels: levels,
|
|
358
|
+
currentLevel: 2,
|
|
359
|
+
currentExp: 100,
|
|
360
|
+
skillsByLevel: skillsByLevel
|
|
361
|
+
});
|
|
362
|
+
assert.ok(classPath.currentSkills['skill1']);
|
|
363
|
+
assert.ok(classPath.currentSkills['skill2']);
|
|
364
|
+
assert.strictEqual(classPath.currentSkills['skill3'], undefined);
|
|
365
|
+
});
|
|
366
|
+
|
|
367
|
+
it('should fire SET_SKILLS event', async () => {
|
|
368
|
+
let eventFired = false;
|
|
369
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
370
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
371
|
+
classPath.listenEvent(SkillsEvents.SET_SKILLS, () => {
|
|
372
|
+
eventFired = true;
|
|
373
|
+
}, 'set-skills-test');
|
|
374
|
+
await classPath.init({
|
|
375
|
+
key: 'warrior',
|
|
376
|
+
levels: levels,
|
|
377
|
+
currentLevel: 1,
|
|
378
|
+
currentExp: 0
|
|
379
|
+
});
|
|
380
|
+
assert.strictEqual(eventFired, true);
|
|
381
|
+
});
|
|
382
|
+
|
|
383
|
+
it('should use provided currentSkills', async () => {
|
|
384
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
385
|
+
let skill1 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'providedSkill', owner: mockOwner});
|
|
386
|
+
let providedSkills = {providedSkill: skill1};
|
|
387
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
388
|
+
await classPath.init({
|
|
389
|
+
key: 'warrior',
|
|
390
|
+
levels: levels,
|
|
391
|
+
currentLevel: 1,
|
|
392
|
+
currentExp: 0,
|
|
393
|
+
currentSkills: providedSkills
|
|
394
|
+
});
|
|
395
|
+
assert.ok(classPath.currentSkills['providedSkill']);
|
|
396
|
+
});
|
|
397
|
+
});
|
|
398
|
+
|
|
399
|
+
describe('getCurrentLabel', () => {
|
|
400
|
+
it('should return label from labelsByLevel', async () => {
|
|
401
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
402
|
+
let labelsByLevel = {
|
|
403
|
+
1: 'Novice',
|
|
404
|
+
2: 'Expert'
|
|
405
|
+
};
|
|
406
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
407
|
+
await classPath.init({
|
|
408
|
+
key: 'warrior',
|
|
409
|
+
label: 'Warrior',
|
|
410
|
+
levels: levels,
|
|
411
|
+
currentLevel: 1,
|
|
412
|
+
currentExp: 0,
|
|
413
|
+
labelsByLevel: labelsByLevel
|
|
414
|
+
});
|
|
415
|
+
let label = classPath.getCurrentLabel();
|
|
416
|
+
assert.strictEqual(label, 'Novice');
|
|
417
|
+
});
|
|
418
|
+
|
|
419
|
+
it('should loop levels when exact match not found', async () => {
|
|
420
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
421
|
+
let labelsByLevel = {
|
|
422
|
+
1: 'Novice',
|
|
423
|
+
5: 'Master'
|
|
424
|
+
};
|
|
425
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
426
|
+
await classPath.init({
|
|
427
|
+
key: 'warrior',
|
|
428
|
+
label: 'Warrior',
|
|
429
|
+
levels: levels,
|
|
430
|
+
currentLevel: 3,
|
|
431
|
+
currentExp: 250,
|
|
432
|
+
labelsByLevel: labelsByLevel
|
|
433
|
+
});
|
|
434
|
+
let label = classPath.getCurrentLabel();
|
|
435
|
+
assert.strictEqual(label, 'Novice');
|
|
436
|
+
});
|
|
437
|
+
|
|
438
|
+
it('should return base label when labelsByLevel is false', async () => {
|
|
439
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
440
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
441
|
+
await classPath.init({
|
|
442
|
+
key: 'warrior',
|
|
443
|
+
label: 'Warrior',
|
|
444
|
+
levels: levels,
|
|
445
|
+
currentLevel: 1,
|
|
446
|
+
currentExp: 0
|
|
447
|
+
});
|
|
448
|
+
let label = classPath.getCurrentLabel();
|
|
449
|
+
assert.strictEqual(label, 'Warrior');
|
|
450
|
+
});
|
|
451
|
+
});
|
|
452
|
+
|
|
453
|
+
describe('getSkillsByLevelKeys', () => {
|
|
454
|
+
it('should extract skill keys from skillsByLevel', async () => {
|
|
455
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
456
|
+
let skill1 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill1', owner: mockOwner});
|
|
457
|
+
let skill2 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill2', owner: mockOwner});
|
|
458
|
+
let skillsByLevel = {
|
|
459
|
+
1: [skill1],
|
|
460
|
+
2: [skill2]
|
|
461
|
+
};
|
|
462
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
463
|
+
await classPath.init({
|
|
464
|
+
key: 'warrior',
|
|
465
|
+
levels: levels,
|
|
466
|
+
currentLevel: 1,
|
|
467
|
+
currentExp: 0,
|
|
468
|
+
skillsByLevel: skillsByLevel
|
|
469
|
+
});
|
|
470
|
+
assert.ok(classPath.skillsByLevelKeys);
|
|
471
|
+
assert.ok(Array.isArray(classPath.skillsByLevelKeys[1]));
|
|
472
|
+
assert.ok(classPath.skillsByLevelKeys[1].includes('skill1'));
|
|
473
|
+
});
|
|
474
|
+
|
|
475
|
+
it('should return false when skillsByLevel is not set', async () => {
|
|
476
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
477
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
478
|
+
await classPath.init({
|
|
479
|
+
key: 'warrior',
|
|
480
|
+
levels: levels,
|
|
481
|
+
currentLevel: 1,
|
|
482
|
+
currentExp: 0
|
|
483
|
+
});
|
|
484
|
+
assert.strictEqual(classPath.skillsByLevelKeys, false);
|
|
485
|
+
});
|
|
486
|
+
});
|
|
487
|
+
|
|
488
|
+
describe('Error Conditions - Invalid Inputs', () => {
|
|
489
|
+
it('should return false with null key', async () => {
|
|
490
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
491
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
492
|
+
let result = await classPath.init({
|
|
493
|
+
key: null,
|
|
494
|
+
levels: levels,
|
|
495
|
+
currentLevel: 1,
|
|
496
|
+
currentExp: 0
|
|
497
|
+
});
|
|
498
|
+
assert.strictEqual(result, false);
|
|
499
|
+
});
|
|
500
|
+
|
|
501
|
+
it('should return false with undefined key', async () => {
|
|
502
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
503
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
504
|
+
let result = await classPath.init({
|
|
505
|
+
levels: levels,
|
|
506
|
+
currentLevel: 1,
|
|
507
|
+
currentExp: 0
|
|
508
|
+
});
|
|
509
|
+
assert.strictEqual(result, false);
|
|
510
|
+
});
|
|
511
|
+
|
|
512
|
+
it('should handle empty skillsByLevel', async () => {
|
|
513
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
514
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
515
|
+
await classPath.init({
|
|
516
|
+
key: 'warrior',
|
|
517
|
+
levels: levels,
|
|
518
|
+
currentLevel: 1,
|
|
519
|
+
currentExp: 0,
|
|
520
|
+
skillsByLevel: {}
|
|
521
|
+
});
|
|
522
|
+
assert.ok(classPath.currentSkills);
|
|
523
|
+
assert.strictEqual(Object.keys(classPath.currentSkills).length, 0);
|
|
524
|
+
});
|
|
525
|
+
|
|
526
|
+
it('should handle null skillsByLevel', async () => {
|
|
527
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
528
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
529
|
+
await classPath.init({
|
|
530
|
+
key: 'warrior',
|
|
531
|
+
levels: levels,
|
|
532
|
+
currentLevel: 1,
|
|
533
|
+
currentExp: 0,
|
|
534
|
+
skillsByLevel: null
|
|
535
|
+
});
|
|
536
|
+
assert.ok(classPath.currentSkills);
|
|
537
|
+
});
|
|
538
|
+
|
|
539
|
+
it('should handle empty labelsByLevel', async () => {
|
|
540
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
541
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
542
|
+
await classPath.init({
|
|
543
|
+
key: 'warrior',
|
|
544
|
+
label: 'Warrior',
|
|
545
|
+
levels: levels,
|
|
546
|
+
currentLevel: 1,
|
|
547
|
+
currentExp: 0,
|
|
548
|
+
labelsByLevel: {}
|
|
549
|
+
});
|
|
550
|
+
assert.strictEqual(classPath.currentLabel, 'Warrior');
|
|
551
|
+
});
|
|
552
|
+
});
|
|
553
|
+
|
|
554
|
+
describe('Event System - Parameter Variations', () => {
|
|
555
|
+
it('should fire event with masterKey', async () => {
|
|
556
|
+
let eventFired = false;
|
|
557
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
558
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
559
|
+
let masterKey = classPath.getOwnerEventKey();
|
|
560
|
+
classPath.listenEvent(SkillsEvents.INIT_CLASS_PATH_END, () => {
|
|
561
|
+
eventFired = true;
|
|
562
|
+
}, 'sub-key', masterKey);
|
|
563
|
+
await classPath.init({
|
|
564
|
+
key: 'warrior',
|
|
565
|
+
levels: levels,
|
|
566
|
+
currentLevel: 1,
|
|
567
|
+
currentExp: 0
|
|
568
|
+
});
|
|
569
|
+
assert.strictEqual(eventFired, true);
|
|
570
|
+
});
|
|
571
|
+
|
|
572
|
+
it('should fire event without any keys', async () => {
|
|
573
|
+
let eventFired = false;
|
|
574
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
575
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
576
|
+
classPath.listenEvent(SkillsEvents.INIT_CLASS_PATH_END, () => {
|
|
577
|
+
eventFired = true;
|
|
578
|
+
});
|
|
579
|
+
await classPath.init({
|
|
580
|
+
key: 'warrior',
|
|
581
|
+
levels: levels,
|
|
582
|
+
currentLevel: 1,
|
|
583
|
+
currentExp: 0
|
|
584
|
+
});
|
|
585
|
+
assert.strictEqual(eventFired, true);
|
|
586
|
+
});
|
|
587
|
+
|
|
588
|
+
it('should handle multiple listeners', async () => {
|
|
589
|
+
let count = 0;
|
|
590
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
591
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
592
|
+
classPath.listenEvent(SkillsEvents.INIT_CLASS_PATH_END, () => { count++; }, 'key1');
|
|
593
|
+
classPath.listenEvent(SkillsEvents.INIT_CLASS_PATH_END, () => { count++; }, 'key2');
|
|
594
|
+
classPath.listenEvent(SkillsEvents.INIT_CLASS_PATH_END, () => { count++; }, 'key3');
|
|
595
|
+
await classPath.init({
|
|
596
|
+
key: 'warrior',
|
|
597
|
+
levels: levels,
|
|
598
|
+
currentLevel: 1,
|
|
599
|
+
currentExp: 0
|
|
600
|
+
});
|
|
601
|
+
assert.strictEqual(count, 3);
|
|
602
|
+
});
|
|
603
|
+
});
|
|
604
|
+
|
|
605
|
+
describe('Edge Cases', () => {
|
|
606
|
+
it('should handle numeric key', async () => {
|
|
607
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
608
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
609
|
+
await classPath.init({
|
|
610
|
+
key: 123,
|
|
611
|
+
levels: levels,
|
|
612
|
+
currentLevel: 1,
|
|
613
|
+
currentExp: 0
|
|
614
|
+
});
|
|
615
|
+
assert.strictEqual(classPath.key, 123);
|
|
616
|
+
});
|
|
617
|
+
|
|
618
|
+
it('should handle affectedProperty', async () => {
|
|
619
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
620
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
621
|
+
await classPath.init({
|
|
622
|
+
key: 'warrior',
|
|
623
|
+
levels: levels,
|
|
624
|
+
currentLevel: 1,
|
|
625
|
+
currentExp: 0,
|
|
626
|
+
affectedProperty: 'stats/hp'
|
|
627
|
+
});
|
|
628
|
+
assert.strictEqual(classPath.affectedProperty, 'stats/hp');
|
|
629
|
+
});
|
|
630
|
+
|
|
631
|
+
it('should handle false affectedProperty', async () => {
|
|
632
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
633
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
634
|
+
await classPath.init({
|
|
635
|
+
key: 'warrior',
|
|
636
|
+
levels: levels,
|
|
637
|
+
currentLevel: 1,
|
|
638
|
+
currentExp: 0
|
|
639
|
+
});
|
|
640
|
+
assert.strictEqual(classPath.affectedProperty, false);
|
|
641
|
+
});
|
|
642
|
+
});
|
|
643
|
+
|
|
644
|
+
describe('loopLevelsForLabel - Direct Unit Tests', () => {
|
|
645
|
+
it('should return label from labelsByLevel when found', async () => {
|
|
646
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
647
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
648
|
+
await classPath.init({
|
|
649
|
+
key: 'warrior',
|
|
650
|
+
levels: levels,
|
|
651
|
+
currentLevel: 3,
|
|
652
|
+
label: 'Warrior',
|
|
653
|
+
labelsByLevel: {3: 'Veteran Warrior', 5: 'Master Warrior'}
|
|
654
|
+
});
|
|
655
|
+
let label = classPath.loopLevelsForLabel(classPath.currentLevel);
|
|
656
|
+
assert.strictEqual(label, 'Veteran Warrior');
|
|
657
|
+
});
|
|
658
|
+
|
|
659
|
+
it('should return base label when not found in labelsByLevel', async () => {
|
|
660
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
661
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
662
|
+
await classPath.init({
|
|
663
|
+
key: 'warrior',
|
|
664
|
+
levels: levels,
|
|
665
|
+
currentLevel: 2,
|
|
666
|
+
label: 'Warrior',
|
|
667
|
+
labelsByLevel: {3: 'Veteran Warrior'}
|
|
668
|
+
});
|
|
669
|
+
let label = classPath.loopLevelsForLabel(classPath.currentLevel);
|
|
670
|
+
assert.strictEqual(label, 'Warrior');
|
|
671
|
+
});
|
|
672
|
+
|
|
673
|
+
it('should handle null labelsByLevel', async () => {
|
|
674
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
675
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
676
|
+
await classPath.init({
|
|
677
|
+
key: 'warrior',
|
|
678
|
+
levels: levels,
|
|
679
|
+
currentLevel: 2,
|
|
680
|
+
label: 'Warrior'
|
|
681
|
+
});
|
|
682
|
+
classPath.labelsByLevel = null;
|
|
683
|
+
assert.throws(
|
|
684
|
+
() => classPath.loopLevelsForLabel(classPath.currentLevel),
|
|
685
|
+
TypeError
|
|
686
|
+
);
|
|
687
|
+
});
|
|
688
|
+
|
|
689
|
+
it('should handle empty labelsByLevel', async () => {
|
|
690
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
691
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
692
|
+
await classPath.init({
|
|
693
|
+
key: 'warrior',
|
|
694
|
+
levels: levels,
|
|
695
|
+
currentLevel: 2,
|
|
696
|
+
label: 'Warrior',
|
|
697
|
+
labelsByLevel: {}
|
|
698
|
+
});
|
|
699
|
+
let label = classPath.loopLevelsForLabel(classPath.currentLevel);
|
|
700
|
+
assert.strictEqual(label, 'Warrior');
|
|
701
|
+
});
|
|
702
|
+
|
|
703
|
+
it('should handle level 0', async () => {
|
|
704
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
705
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
706
|
+
await classPath.init({
|
|
707
|
+
key: 'warrior',
|
|
708
|
+
levels: levels,
|
|
709
|
+
currentLevel: 0,
|
|
710
|
+
label: 'Novice'
|
|
711
|
+
});
|
|
712
|
+
let label = classPath.loopLevelsForLabel(0);
|
|
713
|
+
assert.strictEqual(label, 'Novice');
|
|
714
|
+
});
|
|
715
|
+
|
|
716
|
+
it('should handle negative level', async () => {
|
|
717
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
718
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
719
|
+
await classPath.init({
|
|
720
|
+
key: 'warrior',
|
|
721
|
+
levels: levels,
|
|
722
|
+
currentLevel: 1,
|
|
723
|
+
label: 'Warrior'
|
|
724
|
+
});
|
|
725
|
+
let label = classPath.loopLevelsForLabel(-5);
|
|
726
|
+
assert.ok(typeof label === 'string');
|
|
727
|
+
});
|
|
728
|
+
});
|
|
729
|
+
|
|
730
|
+
describe('init - Numeric Key Behavior', () => {
|
|
731
|
+
it('should handle numeric key values', async () => {
|
|
732
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
733
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
734
|
+
await classPath.init({
|
|
735
|
+
key: 123,
|
|
736
|
+
levels: levels,
|
|
737
|
+
currentLevel: 1
|
|
738
|
+
});
|
|
739
|
+
assert.strictEqual(classPath.key, 123);
|
|
740
|
+
});
|
|
741
|
+
});
|
|
742
|
+
|
|
743
|
+
describe('init - Parent Init Validation', () => {
|
|
744
|
+
it('should call parent LevelsSet init', async () => {
|
|
745
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
746
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
747
|
+
await classPath.init({
|
|
748
|
+
key: 'warrior',
|
|
749
|
+
levels: levels,
|
|
750
|
+
currentLevel: 1,
|
|
751
|
+
currentExp: 0
|
|
752
|
+
});
|
|
753
|
+
assert.strictEqual(classPath.currentLevel, 1);
|
|
754
|
+
assert.strictEqual(classPath.currentExp, 0);
|
|
755
|
+
assert.ok(classPath.levels);
|
|
756
|
+
});
|
|
757
|
+
});
|
|
758
|
+
|
|
759
|
+
describe('levelUp - Skills and Labels', () => {
|
|
760
|
+
it('should handle levelUp with no skills at next level', async () => {
|
|
761
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
762
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
763
|
+
await classPath.init({
|
|
764
|
+
key: 'warrior',
|
|
765
|
+
levels: levels,
|
|
766
|
+
currentLevel: 1,
|
|
767
|
+
skillsByLevel: {1: [new Skill({...BaseSkillsFixtures.basicSkill, owner: mockOwner})]}
|
|
768
|
+
});
|
|
769
|
+
await classPath.levelUp();
|
|
770
|
+
assert.strictEqual(classPath.currentLevel, 2);
|
|
771
|
+
});
|
|
772
|
+
|
|
773
|
+
it('should handle levelUp with no label at next level', async () => {
|
|
774
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
775
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
776
|
+
await classPath.init({
|
|
777
|
+
key: 'warrior',
|
|
778
|
+
levels: levels,
|
|
779
|
+
currentLevel: 1,
|
|
780
|
+
label: 'Warrior',
|
|
781
|
+
labelsByLevel: {1: 'Novice Warrior'}
|
|
782
|
+
});
|
|
783
|
+
await classPath.levelUp();
|
|
784
|
+
assert.strictEqual(classPath.currentLevel, 2);
|
|
785
|
+
assert.ok(classPath.currentLabel);
|
|
786
|
+
});
|
|
787
|
+
|
|
788
|
+
it('should update skills and label in correct order', async () => {
|
|
789
|
+
let updateOrder = [];
|
|
790
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
791
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
792
|
+
await classPath.init({
|
|
793
|
+
key: 'warrior',
|
|
794
|
+
levels: levels,
|
|
795
|
+
currentLevel: 1,
|
|
796
|
+
label: 'Warrior',
|
|
797
|
+
labelsByLevel: {2: 'Advanced Warrior'},
|
|
798
|
+
skillsByLevel: {2: [new Skill({...BaseSkillsFixtures.basicSkill, owner: mockOwner})]}
|
|
799
|
+
});
|
|
800
|
+
let originalAddSkills = classPath.addSkills.bind(classPath);
|
|
801
|
+
classPath.addSkills = async (...args) => {
|
|
802
|
+
updateOrder.push('skills');
|
|
803
|
+
return await originalAddSkills(...args);
|
|
804
|
+
};
|
|
805
|
+
await classPath.levelUp();
|
|
806
|
+
assert.ok(updateOrder.includes('skills'));
|
|
807
|
+
assert.strictEqual(classPath.currentLevel, 2);
|
|
808
|
+
});
|
|
809
|
+
|
|
810
|
+
it('should fire ADD_SKILLS event when skills exist at new level', async () => {
|
|
811
|
+
let eventFired = false;
|
|
812
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
813
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, owner: mockOwner});
|
|
814
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
815
|
+
await classPath.init({
|
|
816
|
+
key: 'warrior',
|
|
817
|
+
levels: levels,
|
|
818
|
+
currentLevel: 1,
|
|
819
|
+
skillsByLevel: {2: [skill]}
|
|
820
|
+
});
|
|
821
|
+
classPath.listenEvent(SkillsEvents.ADD_SKILLS_AFTER, () => {
|
|
822
|
+
eventFired = true;
|
|
823
|
+
}, 'add-skills-listener');
|
|
824
|
+
await classPath.levelUp();
|
|
825
|
+
assert.strictEqual(eventFired, true);
|
|
826
|
+
});
|
|
827
|
+
});
|
|
828
|
+
|
|
829
|
+
describe('levelDown - Skills and Labels', () => {
|
|
830
|
+
it('should handle levelDown from level 1', async () => {
|
|
831
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
832
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
833
|
+
await classPath.init({
|
|
834
|
+
key: 'warrior',
|
|
835
|
+
levels: levels,
|
|
836
|
+
currentLevel: 1
|
|
837
|
+
});
|
|
838
|
+
let result = await classPath.levelDown();
|
|
839
|
+
assert.strictEqual(result, undefined);
|
|
840
|
+
});
|
|
841
|
+
|
|
842
|
+
it('should update skills and label in correct order on levelDown', async () => {
|
|
843
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
844
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
845
|
+
await classPath.init({
|
|
846
|
+
key: 'warrior',
|
|
847
|
+
levels: levels,
|
|
848
|
+
currentLevel: 2,
|
|
849
|
+
label: 'Warrior',
|
|
850
|
+
labelsByLevel: {1: 'Novice Warrior', 2: 'Advanced Warrior'}
|
|
851
|
+
});
|
|
852
|
+
let initialLevel = classPath.currentLevel;
|
|
853
|
+
await classPath.levelDown();
|
|
854
|
+
assert.strictEqual(classPath.currentLevel, initialLevel - 1);
|
|
855
|
+
assert.ok(classPath.currentLabel);
|
|
856
|
+
});
|
|
857
|
+
|
|
858
|
+
it('should maintain round-trip consistency on levelDown then levelUp', async () => {
|
|
859
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
860
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, key: 'level-2-skill', owner: mockOwner});
|
|
861
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
862
|
+
await classPath.init({
|
|
863
|
+
key: 'warrior',
|
|
864
|
+
levels: levels,
|
|
865
|
+
currentLevel: 2,
|
|
866
|
+
label: 'Warrior',
|
|
867
|
+
labelsByLevel: {2: 'Advanced Warrior'},
|
|
868
|
+
skillsByLevel: {2: [skill]}
|
|
869
|
+
});
|
|
870
|
+
await classPath.levelDown();
|
|
871
|
+
assert.strictEqual(classPath.currentLevel, 1);
|
|
872
|
+
await classPath.levelUp();
|
|
873
|
+
assert.strictEqual(classPath.currentLevel, 2);
|
|
874
|
+
assert.strictEqual(classPath.currentLabel, 'Advanced Warrior');
|
|
875
|
+
});
|
|
876
|
+
});
|
|
877
|
+
|
|
878
|
+
describe('addSkills - Edge Cases', () => {
|
|
879
|
+
it('should handle adding empty skills array', async () => {
|
|
880
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
881
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
882
|
+
await classPath.init({
|
|
883
|
+
key: 'warrior',
|
|
884
|
+
levels: levels,
|
|
885
|
+
currentLevel: 1
|
|
886
|
+
});
|
|
887
|
+
await classPath.addSkills([]);
|
|
888
|
+
assert.ok(classPath.currentSkills);
|
|
889
|
+
});
|
|
890
|
+
|
|
891
|
+
it('should handle adding null skills', async () => {
|
|
892
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
893
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
894
|
+
await classPath.init({
|
|
895
|
+
key: 'warrior',
|
|
896
|
+
levels: levels,
|
|
897
|
+
currentLevel: 1
|
|
898
|
+
});
|
|
899
|
+
await assert.rejects(
|
|
900
|
+
async () => await classPath.addSkills(null),
|
|
901
|
+
TypeError
|
|
902
|
+
);
|
|
903
|
+
});
|
|
904
|
+
|
|
905
|
+
it('should handle adding undefined skills', async () => {
|
|
906
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
907
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
908
|
+
await classPath.init({
|
|
909
|
+
key: 'warrior',
|
|
910
|
+
levels: levels,
|
|
911
|
+
currentLevel: 1
|
|
912
|
+
});
|
|
913
|
+
await assert.rejects(
|
|
914
|
+
async () => await classPath.addSkills(undefined),
|
|
915
|
+
TypeError
|
|
916
|
+
);
|
|
917
|
+
});
|
|
918
|
+
|
|
919
|
+
it('should handle skills with duplicate keys', async () => {
|
|
920
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
921
|
+
let skill1 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'duplicate', owner: mockOwner});
|
|
922
|
+
let skill2 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'duplicate', owner: mockOwner});
|
|
923
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
924
|
+
await classPath.init({
|
|
925
|
+
key: 'warrior',
|
|
926
|
+
levels: levels,
|
|
927
|
+
currentLevel: 1
|
|
928
|
+
});
|
|
929
|
+
await classPath.addSkills([skill1, skill2]);
|
|
930
|
+
assert.strictEqual(Object.keys(classPath.currentSkills).filter(k => k === 'duplicate').length, 1);
|
|
931
|
+
});
|
|
932
|
+
|
|
933
|
+
it('should handle skills with invalid key property', async () => {
|
|
934
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
935
|
+
let invalidSkill = new Skill({...BaseSkillsFixtures.basicSkill, owner: mockOwner});
|
|
936
|
+
invalidSkill.key = null;
|
|
937
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
938
|
+
await classPath.init({
|
|
939
|
+
key: 'warrior',
|
|
940
|
+
levels: levels,
|
|
941
|
+
currentLevel: 1
|
|
942
|
+
});
|
|
943
|
+
await classPath.addSkills([invalidSkill]);
|
|
944
|
+
assert.ok(classPath.currentSkills);
|
|
945
|
+
});
|
|
946
|
+
|
|
947
|
+
it('should fire ADD_SKILLS events with correct parameters', async () => {
|
|
948
|
+
let beforeEventFired = false;
|
|
949
|
+
let afterEventFired = false;
|
|
950
|
+
let receivedSkills = null;
|
|
951
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
952
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, owner: mockOwner});
|
|
953
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
954
|
+
await classPath.init({
|
|
955
|
+
key: 'warrior',
|
|
956
|
+
levels: levels,
|
|
957
|
+
currentLevel: 1
|
|
958
|
+
});
|
|
959
|
+
classPath.listenEvent(SkillsEvents.ADD_SKILLS_BEFORE, (cp, skills) => {
|
|
960
|
+
beforeEventFired = true;
|
|
961
|
+
receivedSkills = skills;
|
|
962
|
+
}, 'before-listener');
|
|
963
|
+
classPath.listenEvent(SkillsEvents.ADD_SKILLS_AFTER, () => {
|
|
964
|
+
afterEventFired = true;
|
|
965
|
+
}, 'after-listener');
|
|
966
|
+
await classPath.addSkills([skill]);
|
|
967
|
+
assert.strictEqual(beforeEventFired, true);
|
|
968
|
+
assert.strictEqual(afterEventFired, true);
|
|
969
|
+
assert.ok(receivedSkills);
|
|
970
|
+
});
|
|
971
|
+
});
|
|
972
|
+
|
|
973
|
+
describe('removeSkills - Edge Cases', () => {
|
|
974
|
+
it('should handle removing empty skills array', async () => {
|
|
975
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
976
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
977
|
+
await classPath.init({
|
|
978
|
+
key: 'warrior',
|
|
979
|
+
levels: levels,
|
|
980
|
+
currentLevel: 1
|
|
981
|
+
});
|
|
982
|
+
await classPath.removeSkills([]);
|
|
983
|
+
assert.ok(classPath.currentSkills);
|
|
984
|
+
});
|
|
985
|
+
|
|
986
|
+
it('should handle removing non-existent skill', async () => {
|
|
987
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
988
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, owner: mockOwner});
|
|
989
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
990
|
+
await classPath.init({
|
|
991
|
+
key: 'warrior',
|
|
992
|
+
levels: levels,
|
|
993
|
+
currentLevel: 1
|
|
994
|
+
});
|
|
995
|
+
await classPath.addSkills([skill]);
|
|
996
|
+
let nonExistentSkill = new Skill({...BaseSkillsFixtures.basicSkill, key: 'non-existent', owner: mockOwner});
|
|
997
|
+
await classPath.removeSkills([nonExistentSkill]);
|
|
998
|
+
assert.ok(classPath.currentSkills[skill.key]);
|
|
999
|
+
});
|
|
1000
|
+
|
|
1001
|
+
it('should handle removing with mixed instances and keys', async () => {
|
|
1002
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1003
|
+
let skill1 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill-1', owner: mockOwner});
|
|
1004
|
+
let skill2 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill-2', owner: mockOwner});
|
|
1005
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
1006
|
+
await classPath.init({
|
|
1007
|
+
key: 'warrior',
|
|
1008
|
+
levels: levels,
|
|
1009
|
+
currentLevel: 1
|
|
1010
|
+
});
|
|
1011
|
+
await classPath.addSkills([skill1, skill2]);
|
|
1012
|
+
await classPath.removeSkills([skill1, 'skill-2']);
|
|
1013
|
+
assert.strictEqual(Object.keys(classPath.currentSkills).length, 0);
|
|
1014
|
+
});
|
|
1015
|
+
|
|
1016
|
+
it('should fire REMOVE_SKILLS events with correct parameters', async () => {
|
|
1017
|
+
let beforeEventFired = false;
|
|
1018
|
+
let afterEventFired = false;
|
|
1019
|
+
let receivedSkills = null;
|
|
1020
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1021
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, owner: mockOwner});
|
|
1022
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
1023
|
+
await classPath.init({
|
|
1024
|
+
key: 'warrior',
|
|
1025
|
+
levels: levels,
|
|
1026
|
+
currentLevel: 1
|
|
1027
|
+
});
|
|
1028
|
+
classPath.listenEvent(SkillsEvents.REMOVE_SKILLS_BEFORE, (cp, skills) => {
|
|
1029
|
+
beforeEventFired = true;
|
|
1030
|
+
receivedSkills = skills;
|
|
1031
|
+
}, 'remove-before-listener');
|
|
1032
|
+
classPath.listenEvent(SkillsEvents.REMOVE_SKILLS_AFTER, () => {
|
|
1033
|
+
afterEventFired = true;
|
|
1034
|
+
}, 'remove-after-listener');
|
|
1035
|
+
await classPath.addSkills([skill]);
|
|
1036
|
+
await classPath.removeSkills([skill]);
|
|
1037
|
+
assert.strictEqual(beforeEventFired, true);
|
|
1038
|
+
assert.strictEqual(afterEventFired, true);
|
|
1039
|
+
assert.ok(receivedSkills);
|
|
1040
|
+
});
|
|
1041
|
+
});
|
|
1042
|
+
|
|
1043
|
+
describe('setOwnerSkills - Edge Cases', () => {
|
|
1044
|
+
it('should handle currentLevel = 0', async () => {
|
|
1045
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1046
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, owner: mockOwner});
|
|
1047
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
1048
|
+
await classPath.init({
|
|
1049
|
+
key: 'warrior',
|
|
1050
|
+
levels: levels,
|
|
1051
|
+
currentLevel: 0,
|
|
1052
|
+
skillsByLevel: {1: [skill]}
|
|
1053
|
+
});
|
|
1054
|
+
assert.ok(classPath.currentSkills);
|
|
1055
|
+
});
|
|
1056
|
+
|
|
1057
|
+
it('should handle currentLevel = negative', async () => {
|
|
1058
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1059
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
1060
|
+
await classPath.init({
|
|
1061
|
+
key: 'warrior',
|
|
1062
|
+
levels: levels,
|
|
1063
|
+
currentLevel: -5
|
|
1064
|
+
});
|
|
1065
|
+
assert.ok(classPath.currentSkills);
|
|
1066
|
+
});
|
|
1067
|
+
|
|
1068
|
+
it('should accumulate skills from multiple levels', async () => {
|
|
1069
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1070
|
+
let skill1 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill-1', owner: mockOwner});
|
|
1071
|
+
let skill2 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill-2', owner: mockOwner});
|
|
1072
|
+
let skill3 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill-3', owner: mockOwner});
|
|
1073
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
1074
|
+
await classPath.init({
|
|
1075
|
+
key: 'warrior',
|
|
1076
|
+
levels: levels,
|
|
1077
|
+
currentLevel: 3,
|
|
1078
|
+
skillsByLevel: {
|
|
1079
|
+
1: [skill1],
|
|
1080
|
+
2: [skill2],
|
|
1081
|
+
3: [skill3]
|
|
1082
|
+
}
|
|
1083
|
+
});
|
|
1084
|
+
assert.strictEqual(Object.keys(classPath.currentSkills).length, 3);
|
|
1085
|
+
assert.ok(classPath.currentSkills['skill-1']);
|
|
1086
|
+
assert.ok(classPath.currentSkills['skill-2']);
|
|
1087
|
+
assert.ok(classPath.currentSkills['skill-3']);
|
|
1088
|
+
});
|
|
1089
|
+
|
|
1090
|
+
it('should NOT include skills from future levels', async () => {
|
|
1091
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1092
|
+
let skill1 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'skill-1', owner: mockOwner});
|
|
1093
|
+
let futureSkill = new Skill({...BaseSkillsFixtures.basicSkill, key: 'future-skill', owner: mockOwner});
|
|
1094
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
1095
|
+
await classPath.init({
|
|
1096
|
+
key: 'warrior',
|
|
1097
|
+
levels: levels,
|
|
1098
|
+
currentLevel: 1,
|
|
1099
|
+
skillsByLevel: {
|
|
1100
|
+
1: [skill1],
|
|
1101
|
+
5: [futureSkill]
|
|
1102
|
+
}
|
|
1103
|
+
});
|
|
1104
|
+
assert.ok(classPath.currentSkills['skill-1']);
|
|
1105
|
+
assert.strictEqual(classPath.currentSkills['future-skill'], undefined);
|
|
1106
|
+
});
|
|
1107
|
+
});
|
|
1108
|
+
|
|
1109
|
+
describe('getCurrentLabel - Edge Cases', () => {
|
|
1110
|
+
it('should handle labelsByLevel is null', async () => {
|
|
1111
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1112
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
1113
|
+
await classPath.init({
|
|
1114
|
+
key: 'warrior',
|
|
1115
|
+
levels: levels,
|
|
1116
|
+
currentLevel: 1,
|
|
1117
|
+
label: 'Warrior'
|
|
1118
|
+
});
|
|
1119
|
+
classPath.labelsByLevel = null;
|
|
1120
|
+
assert.throws(
|
|
1121
|
+
() => classPath.getCurrentLabel(),
|
|
1122
|
+
TypeError
|
|
1123
|
+
);
|
|
1124
|
+
});
|
|
1125
|
+
|
|
1126
|
+
it('should handle labelsByLevel is empty', async () => {
|
|
1127
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1128
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
1129
|
+
await classPath.init({
|
|
1130
|
+
key: 'warrior',
|
|
1131
|
+
levels: levels,
|
|
1132
|
+
currentLevel: 1,
|
|
1133
|
+
label: 'Warrior',
|
|
1134
|
+
labelsByLevel: {}
|
|
1135
|
+
});
|
|
1136
|
+
let label = classPath.getCurrentLabel();
|
|
1137
|
+
assert.strictEqual(label, 'Warrior');
|
|
1138
|
+
});
|
|
1139
|
+
|
|
1140
|
+
it('should handle currentLevel = 0', async () => {
|
|
1141
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1142
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
1143
|
+
await classPath.init({
|
|
1144
|
+
key: 'warrior',
|
|
1145
|
+
levels: levels,
|
|
1146
|
+
currentLevel: 0,
|
|
1147
|
+
label: 'Novice'
|
|
1148
|
+
});
|
|
1149
|
+
let label = classPath.getCurrentLabel();
|
|
1150
|
+
assert.ok(typeof label === 'string');
|
|
1151
|
+
});
|
|
1152
|
+
|
|
1153
|
+
it('should handle currentLevel = negative', async () => {
|
|
1154
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1155
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
1156
|
+
await classPath.init({
|
|
1157
|
+
key: 'warrior',
|
|
1158
|
+
levels: levels,
|
|
1159
|
+
currentLevel: -1,
|
|
1160
|
+
label: 'Warrior'
|
|
1161
|
+
});
|
|
1162
|
+
let label = classPath.getCurrentLabel();
|
|
1163
|
+
assert.ok(typeof label === 'string');
|
|
1164
|
+
});
|
|
1165
|
+
|
|
1166
|
+
it('should handle label value is null', async () => {
|
|
1167
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1168
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
1169
|
+
await classPath.init({
|
|
1170
|
+
key: 'warrior',
|
|
1171
|
+
levels: levels,
|
|
1172
|
+
currentLevel: 1,
|
|
1173
|
+
label: null
|
|
1174
|
+
});
|
|
1175
|
+
let label = classPath.getCurrentLabel();
|
|
1176
|
+
assert.ok(label === null || typeof label === 'string');
|
|
1177
|
+
});
|
|
1178
|
+
|
|
1179
|
+
it('should handle label value is undefined', async () => {
|
|
1180
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1181
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
1182
|
+
await classPath.init({
|
|
1183
|
+
key: 'warrior',
|
|
1184
|
+
levels: levels,
|
|
1185
|
+
currentLevel: 1
|
|
1186
|
+
});
|
|
1187
|
+
let label = classPath.getCurrentLabel();
|
|
1188
|
+
assert.ok(label === undefined || typeof label === 'string');
|
|
1189
|
+
});
|
|
1190
|
+
});
|
|
1191
|
+
|
|
1192
|
+
describe('getSkillsByLevelKeys - Edge Cases', () => {
|
|
1193
|
+
it('should handle null key property', async () => {
|
|
1194
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1195
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
1196
|
+
await classPath.init({
|
|
1197
|
+
key: 'warrior',
|
|
1198
|
+
levels: levels,
|
|
1199
|
+
currentLevel: 1,
|
|
1200
|
+
skillsByLevel: {1: [{key: null}]}
|
|
1201
|
+
});
|
|
1202
|
+
let skills = classPath.getSkillsByLevelKeys();
|
|
1203
|
+
assert.ok(typeof skills === 'object' || skills === false);
|
|
1204
|
+
});
|
|
1205
|
+
|
|
1206
|
+
it('should handle non-array values in skillsByLevel', async () => {
|
|
1207
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1208
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
1209
|
+
await classPath.init({
|
|
1210
|
+
key: 'warrior',
|
|
1211
|
+
levels: levels,
|
|
1212
|
+
currentLevel: 1
|
|
1213
|
+
});
|
|
1214
|
+
classPath.skillsByLevel = {1: 'not-an-array'};
|
|
1215
|
+
let skills = classPath.getSkillsByLevelKeys();
|
|
1216
|
+
assert.ok(typeof skills === 'object' || skills === false);
|
|
1217
|
+
});
|
|
1218
|
+
|
|
1219
|
+
it('should handle duplicate keys across levels', async () => {
|
|
1220
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1221
|
+
let skill1 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'duplicate', owner: mockOwner});
|
|
1222
|
+
let skill2 = new Skill({...BaseSkillsFixtures.basicSkill, key: 'duplicate', owner: mockOwner});
|
|
1223
|
+
let classPath = new ClassPath({owner: mockOwner});
|
|
1224
|
+
await classPath.init({
|
|
1225
|
+
key: 'warrior',
|
|
1226
|
+
levels: levels,
|
|
1227
|
+
currentLevel: 1,
|
|
1228
|
+
skillsByLevel: {
|
|
1229
|
+
1: [skill1],
|
|
1230
|
+
2: [skill2]
|
|
1231
|
+
}
|
|
1232
|
+
});
|
|
1233
|
+
let skillsByLevelKeys = classPath.getSkillsByLevelKeys();
|
|
1234
|
+
assert.ok(typeof skillsByLevelKeys === 'object');
|
|
1235
|
+
assert.ok(Array.isArray(skillsByLevelKeys['1']));
|
|
1236
|
+
assert.ok(Array.isArray(skillsByLevelKeys['2']));
|
|
1237
|
+
});
|
|
1238
|
+
});
|
|
1239
|
+
});
|