@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,249 @@
|
|
|
1
|
+
/**
|
|
2
|
+
*
|
|
3
|
+
* Reldens - Receiver Unit Tests
|
|
4
|
+
*
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
const { describe, it, beforeEach, afterEach } = require('node:test');
|
|
8
|
+
const assert = require('node:assert');
|
|
9
|
+
const Receiver = require('../../../lib/client/receiver');
|
|
10
|
+
const SkillConst = require('../../../lib/constants');
|
|
11
|
+
const { TestHelpers } = require('../../utils/test-helpers');
|
|
12
|
+
const { MockOwner } = require('../../fixtures/mocks/mock-owner');
|
|
13
|
+
|
|
14
|
+
describe('Receiver', () => {
|
|
15
|
+
let mockOwner;
|
|
16
|
+
|
|
17
|
+
beforeEach(() => {
|
|
18
|
+
mockOwner = new MockOwner();
|
|
19
|
+
TestHelpers.clearEventListeners();
|
|
20
|
+
});
|
|
21
|
+
|
|
22
|
+
afterEach(() => {
|
|
23
|
+
TestHelpers.clearEventListeners();
|
|
24
|
+
});
|
|
25
|
+
|
|
26
|
+
describe('Constructor', () => {
|
|
27
|
+
it('should initialize with owner', () => {
|
|
28
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
29
|
+
assert.ok(receiver);
|
|
30
|
+
assert.strictEqual(typeof receiver.actions, 'object');
|
|
31
|
+
});
|
|
32
|
+
|
|
33
|
+
it('should log error when owner is undefined', () => {
|
|
34
|
+
let receiver = new Receiver({});
|
|
35
|
+
assert.ok(receiver);
|
|
36
|
+
assert.ok(typeof receiver.actions === 'object');
|
|
37
|
+
});
|
|
38
|
+
|
|
39
|
+
it('should log error when owner has no getPosition method', () => {
|
|
40
|
+
let invalidOwner = {id: 'test'};
|
|
41
|
+
let receiver = new Receiver({owner: invalidOwner});
|
|
42
|
+
assert.ok(receiver);
|
|
43
|
+
assert.ok(typeof receiver.actions === 'object');
|
|
44
|
+
});
|
|
45
|
+
|
|
46
|
+
it('should use custom actions when provided', () => {
|
|
47
|
+
let customActions = {customAction: 'customMethod'};
|
|
48
|
+
let receiver = new Receiver({owner: mockOwner, actions: customActions});
|
|
49
|
+
assert.ok(receiver.actions.customAction);
|
|
50
|
+
assert.strictEqual(receiver.actions.customAction, 'customMethod');
|
|
51
|
+
});
|
|
52
|
+
|
|
53
|
+
it('should skip default methods when avoidDefaults is true', () => {
|
|
54
|
+
let receiver = new Receiver({owner: mockOwner, avoidDefaults: true});
|
|
55
|
+
assert.strictEqual(Object.keys(receiver.actions).length, 0);
|
|
56
|
+
});
|
|
57
|
+
|
|
58
|
+
it('should set default methods when avoidDefaults is false', () => {
|
|
59
|
+
let receiver = new Receiver({owner: mockOwner, avoidDefaults: false});
|
|
60
|
+
assert.ok(Object.keys(receiver.actions).length > 0);
|
|
61
|
+
});
|
|
62
|
+
});
|
|
63
|
+
|
|
64
|
+
describe('setDefaultMethods', () => {
|
|
65
|
+
it('should map all action constants to method names', () => {
|
|
66
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
67
|
+
assert.strictEqual(receiver.actions[SkillConst.ACTION_INIT_LEVEL_SET_START], 'onInitLevelSetStart');
|
|
68
|
+
assert.strictEqual(receiver.actions[SkillConst.ACTION_INIT_LEVEL_SET_END], 'onInitLevelSetEnd');
|
|
69
|
+
assert.strictEqual(receiver.actions[SkillConst.ACTION_INIT_CLASS_PATH_END], 'onInitClassPathEnd');
|
|
70
|
+
assert.strictEqual(receiver.actions[SkillConst.ACTION_LEVEL_UP], 'onLevelUp');
|
|
71
|
+
assert.strictEqual(receiver.actions[SkillConst.ACTION_LEVEL_DOWN], 'onLevelDown');
|
|
72
|
+
assert.strictEqual(receiver.actions[SkillConst.ACTION_SKILL_BEFORE_CAST], 'onSkillBeforeCast');
|
|
73
|
+
assert.strictEqual(receiver.actions[SkillConst.ACTION_SKILL_ATTACK_APPLY_DAMAGE], 'onSkillAttackApplyDamage');
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
it('should map all 29 default actions', () => {
|
|
77
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
78
|
+
assert.strictEqual(Object.keys(receiver.actions).length, 29);
|
|
79
|
+
});
|
|
80
|
+
});
|
|
81
|
+
|
|
82
|
+
describe('processMessage', () => {
|
|
83
|
+
it('should return false for invalid message prefix', () => {
|
|
84
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
85
|
+
let message = {act: 'invalid.action'};
|
|
86
|
+
let result = receiver.processMessage(message);
|
|
87
|
+
assert.strictEqual(result, false);
|
|
88
|
+
});
|
|
89
|
+
|
|
90
|
+
it('should return false when action not found in actions', () => {
|
|
91
|
+
let receiver = new Receiver({owner: mockOwner, avoidDefaults: true});
|
|
92
|
+
let message = {act: SkillConst.ACTIONS_PREF+'unknownAction'};
|
|
93
|
+
let result = receiver.processMessage(message);
|
|
94
|
+
assert.strictEqual(result, false);
|
|
95
|
+
});
|
|
96
|
+
|
|
97
|
+
it('should return false when mapped method does not exist', () => {
|
|
98
|
+
let receiver = new Receiver({owner: mockOwner, avoidDefaults: true});
|
|
99
|
+
receiver.actions[SkillConst.ACTIONS_PREF+'test'] = 'nonExistentMethod';
|
|
100
|
+
let message = {act: SkillConst.ACTIONS_PREF+'test'};
|
|
101
|
+
let result = receiver.processMessage(message);
|
|
102
|
+
assert.strictEqual(result, false);
|
|
103
|
+
});
|
|
104
|
+
|
|
105
|
+
it('should call mapped method when valid', () => {
|
|
106
|
+
let called = false;
|
|
107
|
+
let receiver = new Receiver({owner: mockOwner, avoidDefaults: true});
|
|
108
|
+
receiver.actions[SkillConst.ACTION_LEVEL_UP] = 'onLevelUp';
|
|
109
|
+
receiver.onLevelUp = (message) => {
|
|
110
|
+
called = true;
|
|
111
|
+
};
|
|
112
|
+
let message = {act: SkillConst.ACTION_LEVEL_UP, data: {lvl: 2}};
|
|
113
|
+
receiver.processMessage(message);
|
|
114
|
+
assert.strictEqual(called, true);
|
|
115
|
+
});
|
|
116
|
+
|
|
117
|
+
it('should pass message to mapped method', () => {
|
|
118
|
+
let receivedMessage = null;
|
|
119
|
+
let receiver = new Receiver({owner: mockOwner, avoidDefaults: true});
|
|
120
|
+
receiver.actions[SkillConst.ACTION_LEVEL_UP] = 'onLevelUp';
|
|
121
|
+
receiver.onLevelUp = (message) => {
|
|
122
|
+
receivedMessage = message;
|
|
123
|
+
};
|
|
124
|
+
let message = {act: SkillConst.ACTION_LEVEL_UP, data: {lvl: 2}};
|
|
125
|
+
receiver.processMessage(message);
|
|
126
|
+
assert.deepStrictEqual(receivedMessage, message);
|
|
127
|
+
});
|
|
128
|
+
});
|
|
129
|
+
|
|
130
|
+
describe('isValidMessage', () => {
|
|
131
|
+
it('should return true for valid message with correct prefix', () => {
|
|
132
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
133
|
+
let message = {act: SkillConst.ACTIONS_PREF+'test'};
|
|
134
|
+
assert.strictEqual(receiver.isValidMessage(message), true);
|
|
135
|
+
});
|
|
136
|
+
|
|
137
|
+
it('should return false for message with wrong prefix', () => {
|
|
138
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
139
|
+
let message = {act: 'wrong.prefix.test'};
|
|
140
|
+
assert.strictEqual(receiver.isValidMessage(message), false);
|
|
141
|
+
});
|
|
142
|
+
|
|
143
|
+
it('should return false for message with prefix not at beginning', () => {
|
|
144
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
145
|
+
let message = {act: 'prefix'+SkillConst.ACTIONS_PREF+'test'};
|
|
146
|
+
assert.strictEqual(receiver.isValidMessage(message), false);
|
|
147
|
+
});
|
|
148
|
+
|
|
149
|
+
it('should validate all default action constants', () => {
|
|
150
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
151
|
+
let validActions = [
|
|
152
|
+
SkillConst.ACTION_INIT_LEVEL_SET_START,
|
|
153
|
+
SkillConst.ACTION_INIT_CLASS_PATH_END,
|
|
154
|
+
SkillConst.ACTION_LEVEL_UP,
|
|
155
|
+
SkillConst.ACTION_SKILL_BEFORE_CAST
|
|
156
|
+
];
|
|
157
|
+
for(let action of validActions){
|
|
158
|
+
let message = {act: action};
|
|
159
|
+
assert.strictEqual(receiver.isValidMessage(message), true);
|
|
160
|
+
}
|
|
161
|
+
});
|
|
162
|
+
});
|
|
163
|
+
|
|
164
|
+
describe('Integration - Method Mapping', () => {
|
|
165
|
+
it('should handle multiple message processing', () => {
|
|
166
|
+
let callCount = 0;
|
|
167
|
+
let receiver = new Receiver({owner: mockOwner, avoidDefaults: true});
|
|
168
|
+
receiver.actions[SkillConst.ACTION_LEVEL_UP] = 'onLevelUp';
|
|
169
|
+
receiver.actions[SkillConst.ACTION_LEVEL_DOWN] = 'onLevelDown';
|
|
170
|
+
receiver.onLevelUp = () => { callCount++; };
|
|
171
|
+
receiver.onLevelDown = () => { callCount++; };
|
|
172
|
+
receiver.processMessage({act: SkillConst.ACTION_LEVEL_UP});
|
|
173
|
+
receiver.processMessage({act: SkillConst.ACTION_LEVEL_DOWN});
|
|
174
|
+
assert.strictEqual(callCount, 2);
|
|
175
|
+
});
|
|
176
|
+
|
|
177
|
+
it('should handle method override', () => {
|
|
178
|
+
let customCalled = false;
|
|
179
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
180
|
+
receiver.onLevelUp = (message) => {
|
|
181
|
+
customCalled = true;
|
|
182
|
+
};
|
|
183
|
+
let message = {act: SkillConst.ACTION_LEVEL_UP};
|
|
184
|
+
receiver.processMessage(message);
|
|
185
|
+
assert.strictEqual(customCalled, true);
|
|
186
|
+
});
|
|
187
|
+
});
|
|
188
|
+
|
|
189
|
+
describe('Edge Cases', () => {
|
|
190
|
+
it('should handle empty actions object', () => {
|
|
191
|
+
let receiver = new Receiver({owner: mockOwner, actions: {}, avoidDefaults: true});
|
|
192
|
+
assert.strictEqual(Object.keys(receiver.actions).length, 0);
|
|
193
|
+
});
|
|
194
|
+
|
|
195
|
+
it('should handle null message', () => {
|
|
196
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
197
|
+
assert.throws(() => {
|
|
198
|
+
receiver.processMessage(null);
|
|
199
|
+
});
|
|
200
|
+
});
|
|
201
|
+
|
|
202
|
+
it('should handle message without act property', () => {
|
|
203
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
204
|
+
assert.throws(() => {
|
|
205
|
+
receiver.processMessage({data: 'test'});
|
|
206
|
+
});
|
|
207
|
+
});
|
|
208
|
+
|
|
209
|
+
it('should handle empty string action', () => {
|
|
210
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
211
|
+
let message = {act: ''};
|
|
212
|
+
let result = receiver.processMessage(message);
|
|
213
|
+
assert.strictEqual(result, false);
|
|
214
|
+
});
|
|
215
|
+
});
|
|
216
|
+
|
|
217
|
+
describe('processMessage - Null/Undefined Data', () => {
|
|
218
|
+
it('should handle message with null data property', () => {
|
|
219
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
220
|
+
let message = {act: SkillConst.ACTION_LEVEL_UP, data: null};
|
|
221
|
+
receiver.processMessage(message);
|
|
222
|
+
assert.ok(receiver);
|
|
223
|
+
});
|
|
224
|
+
|
|
225
|
+
it('should handle message with undefined data property', () => {
|
|
226
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
227
|
+
let message = {act: SkillConst.ACTION_LEVEL_UP};
|
|
228
|
+
receiver.processMessage(message);
|
|
229
|
+
assert.ok(receiver);
|
|
230
|
+
});
|
|
231
|
+
});
|
|
232
|
+
|
|
233
|
+
describe('processMessage - Error Handling Consistency', () => {
|
|
234
|
+
it('should handle invalid action names gracefully', () => {
|
|
235
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
236
|
+
let message = {act: 'invalid.action', data: {}};
|
|
237
|
+
receiver.processMessage(message);
|
|
238
|
+
assert.ok(receiver);
|
|
239
|
+
});
|
|
240
|
+
});
|
|
241
|
+
|
|
242
|
+
describe('isValidMessage - Message.act Undefined', () => {
|
|
243
|
+
it('should return false when message.act is undefined', () => {
|
|
244
|
+
let receiver = new Receiver({owner: mockOwner});
|
|
245
|
+
let message = {data: {}};
|
|
246
|
+
assert.throws(() => receiver.isValidMessage(message), TypeError);
|
|
247
|
+
});
|
|
248
|
+
});
|
|
249
|
+
});
|