@reldens/skills 0.45.0 → 0.47.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
- package/migrations/production/reldens-skills-install.sql +0 -275
|
@@ -0,0 +1,203 @@
|
|
|
1
|
+
/**
|
|
2
|
+
*
|
|
3
|
+
* Reldens - PhysicalPropertiesValidator Unit Tests
|
|
4
|
+
*
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
const { describe, it } = require('node:test');
|
|
8
|
+
const assert = require('node:assert');
|
|
9
|
+
const { PhysicalPropertiesValidator } = require('../../../lib/types/physical-properties-validator');
|
|
10
|
+
const { MockOwner } = require('../../fixtures/mocks/mock-owner');
|
|
11
|
+
|
|
12
|
+
describe('PhysicalPropertiesValidator', () => {
|
|
13
|
+
|
|
14
|
+
describe('validate', () => {
|
|
15
|
+
it('should return false when owner missing executePhysicalSkill method', () => {
|
|
16
|
+
let mockOwner = new MockOwner();
|
|
17
|
+
let props = {
|
|
18
|
+
owner: mockOwner,
|
|
19
|
+
magnitude: 100,
|
|
20
|
+
objectWidth: 10,
|
|
21
|
+
objectHeight: 10
|
|
22
|
+
};
|
|
23
|
+
let result = PhysicalPropertiesValidator.validate(props);
|
|
24
|
+
assert.strictEqual(result, false);
|
|
25
|
+
});
|
|
26
|
+
|
|
27
|
+
it('should return false when magnitude is missing', () => {
|
|
28
|
+
let mockOwner = new MockOwner();
|
|
29
|
+
mockOwner.executePhysicalSkill = () => {};
|
|
30
|
+
let props = {
|
|
31
|
+
owner: mockOwner,
|
|
32
|
+
objectWidth: 10,
|
|
33
|
+
objectHeight: 10
|
|
34
|
+
};
|
|
35
|
+
let result = PhysicalPropertiesValidator.validate(props);
|
|
36
|
+
assert.strictEqual(result, false);
|
|
37
|
+
});
|
|
38
|
+
|
|
39
|
+
it('should return false when objectWidth is missing', () => {
|
|
40
|
+
let mockOwner = new MockOwner();
|
|
41
|
+
mockOwner.executePhysicalSkill = () => {};
|
|
42
|
+
let props = {
|
|
43
|
+
owner: mockOwner,
|
|
44
|
+
magnitude: 100,
|
|
45
|
+
objectHeight: 10
|
|
46
|
+
};
|
|
47
|
+
let result = PhysicalPropertiesValidator.validate(props);
|
|
48
|
+
assert.strictEqual(result, false);
|
|
49
|
+
});
|
|
50
|
+
|
|
51
|
+
it('should return false when objectHeight is missing', () => {
|
|
52
|
+
let mockOwner = new MockOwner();
|
|
53
|
+
mockOwner.executePhysicalSkill = () => {};
|
|
54
|
+
let props = {
|
|
55
|
+
owner: mockOwner,
|
|
56
|
+
magnitude: 100,
|
|
57
|
+
objectWidth: 10
|
|
58
|
+
};
|
|
59
|
+
let result = PhysicalPropertiesValidator.validate(props);
|
|
60
|
+
assert.strictEqual(result, false);
|
|
61
|
+
});
|
|
62
|
+
|
|
63
|
+
it('should return true when all required properties present', () => {
|
|
64
|
+
let mockOwner = new MockOwner();
|
|
65
|
+
mockOwner.executePhysicalSkill = () => {};
|
|
66
|
+
let props = {
|
|
67
|
+
owner: mockOwner,
|
|
68
|
+
magnitude: 100,
|
|
69
|
+
objectWidth: 10,
|
|
70
|
+
objectHeight: 10
|
|
71
|
+
};
|
|
72
|
+
let result = PhysicalPropertiesValidator.validate(props);
|
|
73
|
+
assert.strictEqual(result, true);
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
it('should accept zero values for numeric properties', () => {
|
|
77
|
+
let mockOwner = new MockOwner();
|
|
78
|
+
mockOwner.executePhysicalSkill = () => {};
|
|
79
|
+
let props = {
|
|
80
|
+
owner: mockOwner,
|
|
81
|
+
magnitude: 0,
|
|
82
|
+
objectWidth: 0,
|
|
83
|
+
objectHeight: 0
|
|
84
|
+
};
|
|
85
|
+
let result = PhysicalPropertiesValidator.validate(props);
|
|
86
|
+
assert.strictEqual(result, true);
|
|
87
|
+
});
|
|
88
|
+
|
|
89
|
+
it('should accept negative values for magnitude', () => {
|
|
90
|
+
let mockOwner = new MockOwner();
|
|
91
|
+
mockOwner.executePhysicalSkill = () => {};
|
|
92
|
+
let props = {
|
|
93
|
+
owner: mockOwner,
|
|
94
|
+
magnitude: -50,
|
|
95
|
+
objectWidth: 10,
|
|
96
|
+
objectHeight: 10
|
|
97
|
+
};
|
|
98
|
+
let result = PhysicalPropertiesValidator.validate(props);
|
|
99
|
+
assert.strictEqual(result, true);
|
|
100
|
+
});
|
|
101
|
+
});
|
|
102
|
+
|
|
103
|
+
describe('Edge Cases', () => {
|
|
104
|
+
it('should handle null props', () => {
|
|
105
|
+
assert.throws(() => {
|
|
106
|
+
PhysicalPropertiesValidator.validate(null);
|
|
107
|
+
});
|
|
108
|
+
});
|
|
109
|
+
|
|
110
|
+
it('should handle undefined props', () => {
|
|
111
|
+
assert.throws(() => {
|
|
112
|
+
PhysicalPropertiesValidator.validate(undefined);
|
|
113
|
+
});
|
|
114
|
+
});
|
|
115
|
+
|
|
116
|
+
it('should handle empty props object', () => {
|
|
117
|
+
let result = PhysicalPropertiesValidator.validate({});
|
|
118
|
+
assert.strictEqual(result, false);
|
|
119
|
+
});
|
|
120
|
+
|
|
121
|
+
it('should handle props with only owner', () => {
|
|
122
|
+
let mockOwner = new MockOwner();
|
|
123
|
+
mockOwner.executePhysicalSkill = () => {};
|
|
124
|
+
let result = PhysicalPropertiesValidator.validate({owner: mockOwner});
|
|
125
|
+
assert.strictEqual(result, false);
|
|
126
|
+
});
|
|
127
|
+
|
|
128
|
+
it('should handle non-function executePhysicalSkill', () => {
|
|
129
|
+
let mockOwner = new MockOwner();
|
|
130
|
+
mockOwner.executePhysicalSkill = 'not-a-function';
|
|
131
|
+
let props = {
|
|
132
|
+
owner: mockOwner,
|
|
133
|
+
magnitude: 100,
|
|
134
|
+
objectWidth: 10,
|
|
135
|
+
objectHeight: 10
|
|
136
|
+
};
|
|
137
|
+
let result = PhysicalPropertiesValidator.validate(props);
|
|
138
|
+
assert.strictEqual(result, false);
|
|
139
|
+
});
|
|
140
|
+
|
|
141
|
+
it('should handle very large numeric values', () => {
|
|
142
|
+
let mockOwner = new MockOwner();
|
|
143
|
+
mockOwner.executePhysicalSkill = () => {};
|
|
144
|
+
let props = {
|
|
145
|
+
owner: mockOwner,
|
|
146
|
+
magnitude: 999999999,
|
|
147
|
+
objectWidth: 999999,
|
|
148
|
+
objectHeight: 999999
|
|
149
|
+
};
|
|
150
|
+
let result = PhysicalPropertiesValidator.validate(props);
|
|
151
|
+
assert.strictEqual(result, true);
|
|
152
|
+
});
|
|
153
|
+
|
|
154
|
+
it('should handle decimal values', () => {
|
|
155
|
+
let mockOwner = new MockOwner();
|
|
156
|
+
mockOwner.executePhysicalSkill = () => {};
|
|
157
|
+
let props = {
|
|
158
|
+
owner: mockOwner,
|
|
159
|
+
magnitude: 100.5,
|
|
160
|
+
objectWidth: 10.25,
|
|
161
|
+
objectHeight: 10.75
|
|
162
|
+
};
|
|
163
|
+
let result = PhysicalPropertiesValidator.validate(props);
|
|
164
|
+
assert.strictEqual(result, true);
|
|
165
|
+
});
|
|
166
|
+
});
|
|
167
|
+
|
|
168
|
+
describe('validate - Owner Null/Undefined with 0 Properties', () => {
|
|
169
|
+
it('should handle null owner with zero required properties', () => {
|
|
170
|
+
let result = PhysicalPropertiesValidator.validate({owner: null});
|
|
171
|
+
assert.strictEqual(result, false);
|
|
172
|
+
});
|
|
173
|
+
|
|
174
|
+
it('should handle undefined owner with zero required properties', () => {
|
|
175
|
+
let result = PhysicalPropertiesValidator.validate({});
|
|
176
|
+
assert.strictEqual(result, false);
|
|
177
|
+
});
|
|
178
|
+
});
|
|
179
|
+
|
|
180
|
+
describe('validate - sc.hasOwn Behavior Edge Cases', () => {
|
|
181
|
+
it('should handle properties with undefined values', () => {
|
|
182
|
+
let mockOwner = {executePhysicalSkill: () => {}};
|
|
183
|
+
let result = PhysicalPropertiesValidator.validate({
|
|
184
|
+
owner: mockOwner,
|
|
185
|
+
magnitude: undefined,
|
|
186
|
+
objectWidth: 10,
|
|
187
|
+
objectHeight: 10
|
|
188
|
+
});
|
|
189
|
+
assert.ok(typeof result === 'boolean');
|
|
190
|
+
});
|
|
191
|
+
|
|
192
|
+
it('should handle properties with null values', () => {
|
|
193
|
+
let mockOwner = {executePhysicalSkill: () => {}};
|
|
194
|
+
let result = PhysicalPropertiesValidator.validate({
|
|
195
|
+
owner: mockOwner,
|
|
196
|
+
magnitude: null,
|
|
197
|
+
objectWidth: 10,
|
|
198
|
+
objectHeight: 10
|
|
199
|
+
});
|
|
200
|
+
assert.ok(typeof result === 'boolean');
|
|
201
|
+
});
|
|
202
|
+
});
|
|
203
|
+
});
|
|
@@ -0,0 +1,348 @@
|
|
|
1
|
+
/**
|
|
2
|
+
*
|
|
3
|
+
* Reldens - PhysicalSkillRunner Unit Tests
|
|
4
|
+
*
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
const { describe, it, beforeEach, afterEach } = require('node:test');
|
|
8
|
+
const assert = require('node:assert');
|
|
9
|
+
const { PhysicalSkillRunner } = require('../../../lib/types/physical-skill-runner');
|
|
10
|
+
const SkillsConst = require('../../../lib/constants');
|
|
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
|
+
|
|
16
|
+
describe('PhysicalSkillRunner', () => {
|
|
17
|
+
let mockOwner;
|
|
18
|
+
let mockTarget;
|
|
19
|
+
|
|
20
|
+
beforeEach(() => {
|
|
21
|
+
mockOwner = new MockOwner();
|
|
22
|
+
mockTarget = new MockTarget();
|
|
23
|
+
TestHelpers.clearEventListeners();
|
|
24
|
+
});
|
|
25
|
+
|
|
26
|
+
afterEach(() => {
|
|
27
|
+
TestHelpers.clearEventListeners();
|
|
28
|
+
});
|
|
29
|
+
|
|
30
|
+
describe('runSkillLogic', () => {
|
|
31
|
+
it('should return false when target out of range', async () => {
|
|
32
|
+
let skill = {
|
|
33
|
+
target: mockTarget,
|
|
34
|
+
validateRange: () => false,
|
|
35
|
+
owner: mockOwner
|
|
36
|
+
};
|
|
37
|
+
let result = await PhysicalSkillRunner.runSkillLogic(skill);
|
|
38
|
+
assert.strictEqual(result, false);
|
|
39
|
+
});
|
|
40
|
+
|
|
41
|
+
it('should execute physical skill when in range', async () => {
|
|
42
|
+
let executed = false;
|
|
43
|
+
mockOwner.executePhysicalSkill = async (target, skill) => {
|
|
44
|
+
executed = true;
|
|
45
|
+
};
|
|
46
|
+
let skill = {
|
|
47
|
+
target: mockTarget,
|
|
48
|
+
validateRange: () => true,
|
|
49
|
+
owner: mockOwner
|
|
50
|
+
};
|
|
51
|
+
await PhysicalSkillRunner.runSkillLogic(skill);
|
|
52
|
+
assert.strictEqual(executed, true);
|
|
53
|
+
});
|
|
54
|
+
|
|
55
|
+
it('should return false after execution', async () => {
|
|
56
|
+
mockOwner.executePhysicalSkill = async () => {};
|
|
57
|
+
let skill = {
|
|
58
|
+
target: mockTarget,
|
|
59
|
+
validateRange: () => true,
|
|
60
|
+
owner: mockOwner
|
|
61
|
+
};
|
|
62
|
+
let result = await PhysicalSkillRunner.runSkillLogic(skill);
|
|
63
|
+
assert.strictEqual(result, false);
|
|
64
|
+
});
|
|
65
|
+
|
|
66
|
+
it('should pass target and skill to executePhysicalSkill', async () => {
|
|
67
|
+
let receivedTarget = null;
|
|
68
|
+
let receivedSkill = null;
|
|
69
|
+
mockOwner.executePhysicalSkill = async (target, skill) => {
|
|
70
|
+
receivedTarget = target;
|
|
71
|
+
receivedSkill = skill;
|
|
72
|
+
};
|
|
73
|
+
let skill = {
|
|
74
|
+
target: mockTarget,
|
|
75
|
+
validateRange: () => true,
|
|
76
|
+
owner: mockOwner,
|
|
77
|
+
key: 'test-skill'
|
|
78
|
+
};
|
|
79
|
+
await PhysicalSkillRunner.runSkillLogic(skill);
|
|
80
|
+
assert.strictEqual(receivedTarget, mockTarget);
|
|
81
|
+
assert.strictEqual(receivedSkill.key, 'test-skill');
|
|
82
|
+
});
|
|
83
|
+
});
|
|
84
|
+
|
|
85
|
+
describe('executeOnHit', () => {
|
|
86
|
+
it('should fire skill event', async () => {
|
|
87
|
+
let eventFired = false;
|
|
88
|
+
let skill = {
|
|
89
|
+
target: mockTarget,
|
|
90
|
+
validateTargetOnHit: false,
|
|
91
|
+
fireEvent: async (eventName) => {
|
|
92
|
+
if(eventName === SkillsEvents.SKILL_PHYSICAL_ATTACK_HIT){
|
|
93
|
+
eventFired = true;
|
|
94
|
+
}
|
|
95
|
+
}
|
|
96
|
+
};
|
|
97
|
+
await PhysicalSkillRunner.executeOnHit(
|
|
98
|
+
mockTarget,
|
|
99
|
+
skill,
|
|
100
|
+
SkillsEvents.SKILL_PHYSICAL_ATTACK_HIT,
|
|
101
|
+
async () => true
|
|
102
|
+
);
|
|
103
|
+
assert.strictEqual(eventFired, true);
|
|
104
|
+
});
|
|
105
|
+
|
|
106
|
+
it('should return false when target validation fails', async () => {
|
|
107
|
+
let differentTarget = new MockTarget();
|
|
108
|
+
differentTarget.id = 'different-id';
|
|
109
|
+
let skill = {
|
|
110
|
+
target: mockTarget,
|
|
111
|
+
validateTargetOnHit: true,
|
|
112
|
+
fireEvent: async () => {}
|
|
113
|
+
};
|
|
114
|
+
let result = await PhysicalSkillRunner.executeOnHit(
|
|
115
|
+
differentTarget,
|
|
116
|
+
skill,
|
|
117
|
+
SkillsEvents.SKILL_PHYSICAL_ATTACK_HIT,
|
|
118
|
+
async () => true
|
|
119
|
+
);
|
|
120
|
+
assert.strictEqual(result, false);
|
|
121
|
+
});
|
|
122
|
+
|
|
123
|
+
it('should skip validation when validateTargetOnHit is false', async () => {
|
|
124
|
+
let differentTarget = new MockTarget();
|
|
125
|
+
differentTarget.id = 'different-id';
|
|
126
|
+
let skill = {
|
|
127
|
+
target: mockTarget,
|
|
128
|
+
validateTargetOnHit: false,
|
|
129
|
+
fireEvent: async () => {}
|
|
130
|
+
};
|
|
131
|
+
let result = await PhysicalSkillRunner.executeOnHit(
|
|
132
|
+
differentTarget,
|
|
133
|
+
skill,
|
|
134
|
+
SkillsEvents.SKILL_PHYSICAL_ATTACK_HIT,
|
|
135
|
+
async () => true
|
|
136
|
+
);
|
|
137
|
+
assert.strictEqual(result, true);
|
|
138
|
+
});
|
|
139
|
+
|
|
140
|
+
it('should execute callback when valid', async () => {
|
|
141
|
+
let callbackExecuted = false;
|
|
142
|
+
let skill = {
|
|
143
|
+
target: mockTarget,
|
|
144
|
+
validateTargetOnHit: false,
|
|
145
|
+
fireEvent: async () => {}
|
|
146
|
+
};
|
|
147
|
+
await PhysicalSkillRunner.executeOnHit(
|
|
148
|
+
mockTarget,
|
|
149
|
+
skill,
|
|
150
|
+
SkillsEvents.SKILL_PHYSICAL_ATTACK_HIT,
|
|
151
|
+
async () => {
|
|
152
|
+
callbackExecuted = true;
|
|
153
|
+
return true;
|
|
154
|
+
}
|
|
155
|
+
);
|
|
156
|
+
assert.strictEqual(callbackExecuted, true);
|
|
157
|
+
});
|
|
158
|
+
|
|
159
|
+
it('should pass target to callback', async () => {
|
|
160
|
+
let receivedTarget = null;
|
|
161
|
+
let skill = {
|
|
162
|
+
target: mockTarget,
|
|
163
|
+
validateTargetOnHit: false,
|
|
164
|
+
fireEvent: async () => {}
|
|
165
|
+
};
|
|
166
|
+
await PhysicalSkillRunner.executeOnHit(
|
|
167
|
+
mockTarget,
|
|
168
|
+
skill,
|
|
169
|
+
SkillsEvents.SKILL_PHYSICAL_ATTACK_HIT,
|
|
170
|
+
async (target) => {
|
|
171
|
+
receivedTarget = target;
|
|
172
|
+
return true;
|
|
173
|
+
}
|
|
174
|
+
);
|
|
175
|
+
assert.strictEqual(receivedTarget, mockTarget);
|
|
176
|
+
});
|
|
177
|
+
|
|
178
|
+
it('should return callback result', async () => {
|
|
179
|
+
let skill = {
|
|
180
|
+
target: mockTarget,
|
|
181
|
+
validateTargetOnHit: false,
|
|
182
|
+
fireEvent: async () => {}
|
|
183
|
+
};
|
|
184
|
+
let result = await PhysicalSkillRunner.executeOnHit(
|
|
185
|
+
mockTarget,
|
|
186
|
+
skill,
|
|
187
|
+
SkillsEvents.SKILL_PHYSICAL_ATTACK_HIT,
|
|
188
|
+
async () => {
|
|
189
|
+
return 'callback-result';
|
|
190
|
+
}
|
|
191
|
+
);
|
|
192
|
+
assert.strictEqual(result, 'callback-result');
|
|
193
|
+
});
|
|
194
|
+
|
|
195
|
+
it('should return false when callback is not a function', async () => {
|
|
196
|
+
let skill = {
|
|
197
|
+
target: mockTarget,
|
|
198
|
+
validateTargetOnHit: false,
|
|
199
|
+
fireEvent: async () => {}
|
|
200
|
+
};
|
|
201
|
+
let result = await PhysicalSkillRunner.executeOnHit(
|
|
202
|
+
mockTarget,
|
|
203
|
+
skill,
|
|
204
|
+
SkillsEvents.SKILL_PHYSICAL_ATTACK_HIT,
|
|
205
|
+
'not-a-function'
|
|
206
|
+
);
|
|
207
|
+
assert.strictEqual(result, false);
|
|
208
|
+
});
|
|
209
|
+
|
|
210
|
+
it('should return false when callback is undefined', async () => {
|
|
211
|
+
let skill = {
|
|
212
|
+
target: mockTarget,
|
|
213
|
+
validateTargetOnHit: false,
|
|
214
|
+
fireEvent: async () => {}
|
|
215
|
+
};
|
|
216
|
+
let result = await PhysicalSkillRunner.executeOnHit(
|
|
217
|
+
mockTarget,
|
|
218
|
+
skill,
|
|
219
|
+
SkillsEvents.SKILL_PHYSICAL_ATTACK_HIT,
|
|
220
|
+
undefined
|
|
221
|
+
);
|
|
222
|
+
assert.strictEqual(result, false);
|
|
223
|
+
});
|
|
224
|
+
});
|
|
225
|
+
|
|
226
|
+
describe('Edge Cases', () => {
|
|
227
|
+
it('should handle null target in runSkillLogic', async () => {
|
|
228
|
+
let skill = {
|
|
229
|
+
target: null,
|
|
230
|
+
validateRange: () => true,
|
|
231
|
+
owner: mockOwner
|
|
232
|
+
};
|
|
233
|
+
await assert.rejects(async () => {
|
|
234
|
+
await PhysicalSkillRunner.runSkillLogic(skill);
|
|
235
|
+
});
|
|
236
|
+
});
|
|
237
|
+
|
|
238
|
+
it('should handle null skill in runSkillLogic', async () => {
|
|
239
|
+
await assert.rejects(async () => {
|
|
240
|
+
await PhysicalSkillRunner.runSkillLogic(null);
|
|
241
|
+
});
|
|
242
|
+
});
|
|
243
|
+
|
|
244
|
+
it('should handle missing fireEvent method', async () => {
|
|
245
|
+
let skill = {
|
|
246
|
+
target: mockTarget,
|
|
247
|
+
validateTargetOnHit: false
|
|
248
|
+
};
|
|
249
|
+
await assert.rejects(async () => {
|
|
250
|
+
await PhysicalSkillRunner.executeOnHit(
|
|
251
|
+
mockTarget,
|
|
252
|
+
skill,
|
|
253
|
+
SkillsEvents.SKILL_PHYSICAL_ATTACK_HIT,
|
|
254
|
+
async () => true
|
|
255
|
+
);
|
|
256
|
+
});
|
|
257
|
+
});
|
|
258
|
+
|
|
259
|
+
it('should handle async callback that throws', async () => {
|
|
260
|
+
let skill = {
|
|
261
|
+
target: mockTarget,
|
|
262
|
+
validateTargetOnHit: false,
|
|
263
|
+
fireEvent: async () => {}
|
|
264
|
+
};
|
|
265
|
+
await assert.rejects(async () => {
|
|
266
|
+
await PhysicalSkillRunner.executeOnHit(
|
|
267
|
+
mockTarget,
|
|
268
|
+
skill,
|
|
269
|
+
SkillsEvents.SKILL_PHYSICAL_ATTACK_HIT,
|
|
270
|
+
async () => {
|
|
271
|
+
throw new Error('callback error');
|
|
272
|
+
}
|
|
273
|
+
);
|
|
274
|
+
});
|
|
275
|
+
});
|
|
276
|
+
});
|
|
277
|
+
|
|
278
|
+
describe('Integration', () => {
|
|
279
|
+
it('should handle complete physical attack flow', async () => {
|
|
280
|
+
let executed = false;
|
|
281
|
+
let hitExecuted = false;
|
|
282
|
+
mockOwner.executePhysicalSkill = async (target, skill) => {
|
|
283
|
+
executed = true;
|
|
284
|
+
await skill.executeOnHit(target);
|
|
285
|
+
};
|
|
286
|
+
let skill = {
|
|
287
|
+
target: mockTarget,
|
|
288
|
+
validateRange: () => true,
|
|
289
|
+
validateTargetOnHit: false,
|
|
290
|
+
owner: mockOwner,
|
|
291
|
+
fireEvent: async () => {},
|
|
292
|
+
executeOnHit: async (target) => {
|
|
293
|
+
return await PhysicalSkillRunner.executeOnHit(
|
|
294
|
+
target,
|
|
295
|
+
skill,
|
|
296
|
+
SkillsEvents.SKILL_PHYSICAL_ATTACK_HIT,
|
|
297
|
+
async () => {
|
|
298
|
+
hitExecuted = true;
|
|
299
|
+
return true;
|
|
300
|
+
}
|
|
301
|
+
);
|
|
302
|
+
}
|
|
303
|
+
};
|
|
304
|
+
await PhysicalSkillRunner.runSkillLogic(skill);
|
|
305
|
+
assert.strictEqual(executed, true);
|
|
306
|
+
assert.strictEqual(hitExecuted, true);
|
|
307
|
+
});
|
|
308
|
+
});
|
|
309
|
+
|
|
310
|
+
|
|
311
|
+
describe('runSkillLogic - lastState Verification', () => {
|
|
312
|
+
it('should set lastState to EXECUTE_PHYSICAL_ATTACK', async () => {
|
|
313
|
+
mockOwner.executePhysicalSkill = async () => true;
|
|
314
|
+
let skill = {
|
|
315
|
+
owner: mockOwner,
|
|
316
|
+
target: mockTarget,
|
|
317
|
+
validateRange: () => true,
|
|
318
|
+
range: 0,
|
|
319
|
+
magnitude: 50,
|
|
320
|
+
objectWidth: 10,
|
|
321
|
+
objectHeight: 10
|
|
322
|
+
};
|
|
323
|
+
await PhysicalSkillRunner.runSkillLogic(skill);
|
|
324
|
+
assert.strictEqual(skill.lastState, SkillsConst.SKILL_STATES.EXECUTE_PHYSICAL_ATTACK);
|
|
325
|
+
});
|
|
326
|
+
});
|
|
327
|
+
|
|
328
|
+
|
|
329
|
+
describe('executeOnHit - Event Firing Timing', () => {
|
|
330
|
+
it('should fire event at correct timing', async () => {
|
|
331
|
+
let physicalSkillExecuted = false;
|
|
332
|
+
mockOwner.executePhysicalSkill = async (target, skill) => {
|
|
333
|
+
physicalSkillExecuted = true;
|
|
334
|
+
};
|
|
335
|
+
let skill = {
|
|
336
|
+
owner: mockOwner,
|
|
337
|
+
target: mockTarget,
|
|
338
|
+
validateRange: () => true,
|
|
339
|
+
range: 0,
|
|
340
|
+
magnitude: 50,
|
|
341
|
+
objectWidth: 10,
|
|
342
|
+
objectHeight: 10
|
|
343
|
+
};
|
|
344
|
+
await PhysicalSkillRunner.runSkillLogic(skill);
|
|
345
|
+
assert.strictEqual(physicalSkillExecuted, true);
|
|
346
|
+
});
|
|
347
|
+
});
|
|
348
|
+
});
|
|
@@ -0,0 +1,122 @@
|
|
|
1
|
+
/**
|
|
2
|
+
*
|
|
3
|
+
* Reldens - Test Helpers
|
|
4
|
+
*
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
const { EventsManagerSingleton } = require('@reldens/utils');
|
|
8
|
+
|
|
9
|
+
class TestHelpers
|
|
10
|
+
{
|
|
11
|
+
|
|
12
|
+
static createMockOwner(id = 'test-owner', additionalProps = {})
|
|
13
|
+
{
|
|
14
|
+
return {
|
|
15
|
+
id: id,
|
|
16
|
+
events: EventsManagerSingleton,
|
|
17
|
+
eventsPrefix: 'skills.ownerId.'+id,
|
|
18
|
+
getPosition: () => ({ x: 100, y: 100 }),
|
|
19
|
+
stats: {
|
|
20
|
+
atk: 10,
|
|
21
|
+
def: 5,
|
|
22
|
+
hp: 100,
|
|
23
|
+
mp: 50,
|
|
24
|
+
aim: 15,
|
|
25
|
+
dodge: 8
|
|
26
|
+
},
|
|
27
|
+
isCasting: false,
|
|
28
|
+
castingTimer: false,
|
|
29
|
+
...additionalProps
|
|
30
|
+
};
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
static createMockTarget(id = 'test-target', additionalProps = {})
|
|
34
|
+
{
|
|
35
|
+
return {
|
|
36
|
+
id: id,
|
|
37
|
+
getPosition: () => ({ x: 110, y: 110 }),
|
|
38
|
+
stats: {
|
|
39
|
+
atk: 8,
|
|
40
|
+
def: 6,
|
|
41
|
+
hp: 80,
|
|
42
|
+
mp: 40,
|
|
43
|
+
aim: 12,
|
|
44
|
+
dodge: 10
|
|
45
|
+
},
|
|
46
|
+
...additionalProps
|
|
47
|
+
};
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
static createMockClient()
|
|
51
|
+
{
|
|
52
|
+
let sentMessages = [];
|
|
53
|
+
let broadcastMessages = [];
|
|
54
|
+
return {
|
|
55
|
+
sentMessages: sentMessages,
|
|
56
|
+
broadcastMessages: broadcastMessages,
|
|
57
|
+
send: (message) => {
|
|
58
|
+
sentMessages.push(message);
|
|
59
|
+
},
|
|
60
|
+
broadcast: (message) => {
|
|
61
|
+
broadcastMessages.push(message);
|
|
62
|
+
},
|
|
63
|
+
clearMessages: () => {
|
|
64
|
+
sentMessages.length = 0;
|
|
65
|
+
broadcastMessages.length = 0;
|
|
66
|
+
}
|
|
67
|
+
};
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
static createMockModifier(key, operation, value, propertyKey = null)
|
|
71
|
+
{
|
|
72
|
+
return {
|
|
73
|
+
key: key,
|
|
74
|
+
operation: operation,
|
|
75
|
+
value: value,
|
|
76
|
+
propertyKey: propertyKey || key,
|
|
77
|
+
apply: function(target){
|
|
78
|
+
if(!target){
|
|
79
|
+
return false;
|
|
80
|
+
}
|
|
81
|
+
return true;
|
|
82
|
+
},
|
|
83
|
+
revert: function(target){
|
|
84
|
+
if(!target){
|
|
85
|
+
return false;
|
|
86
|
+
}
|
|
87
|
+
return true;
|
|
88
|
+
}
|
|
89
|
+
};
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
static clearEventListeners()
|
|
93
|
+
{
|
|
94
|
+
EventsManagerSingleton.removeAllListeners();
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
static generateUniqueId(prefix = 'test')
|
|
98
|
+
{
|
|
99
|
+
return prefix+'-'+Date.now()+'-'+Math.random().toString(36).substring(2, 9);
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
static async waitForCondition(condition, timeout = 1000, interval = 50)
|
|
103
|
+
{
|
|
104
|
+
let elapsed = 0;
|
|
105
|
+
while(elapsed < timeout){
|
|
106
|
+
if(condition()){
|
|
107
|
+
return true;
|
|
108
|
+
}
|
|
109
|
+
await this.sleep(interval);
|
|
110
|
+
elapsed = elapsed + interval;
|
|
111
|
+
}
|
|
112
|
+
return false;
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
static sleep(ms)
|
|
116
|
+
{
|
|
117
|
+
return new Promise(resolve => setTimeout(resolve, ms));
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
module.exports.TestHelpers = TestHelpers;
|