apcore-js 0.3.0 → 0.5.0

package/tests/test-errors.test.ts

@@ -3,14 +3,23 @@ import {
   ModuleError,
   ModuleNotFoundError,
   ModuleTimeoutError,
+  ModuleExecuteError,
+  ModuleLoadError,
   SchemaValidationError,
+  SchemaNotFoundError,
+  SchemaParseError,
+  SchemaCircularRefError,
   ACLDeniedError,
+  ACLRuleError,
   CallDepthExceededError,
   CircularCallError,
   CallFrequencyExceededError,
   ConfigNotFoundError,
   ConfigError,
   InvalidInputError,
+  InternalError,
+  FuncMissingTypeHintError,
+  FuncMissingReturnTypeError,
   BindingInvalidTargetError,
   BindingModuleNotFoundError,
   BindingCallableNotFoundError,
@@ -18,11 +27,7 @@ import {
   BindingSchemaMissingError,
   BindingFileInvalidError,
   CircularDependencyError,
-  ModuleLoadError,
-  SchemaNotFoundError,
-  SchemaParseError,
-  SchemaCircularRefError,
-  ACLRuleError,
+  ErrorCodes,
 } from '../src/errors.js';
 
 describe('ModuleError', () => {
@@ -202,3 +207,441 @@ describe('Error subclasses', () => {
     expect(err.code).toBe('ACL_RULE_ERROR');
   });
 });
+
+describe('ModuleError optional parameters', () => {
+  it('defaults details to empty object when not provided', () => {
+    const err = new ModuleError('X', 'msg');
+    expect(err.details).toEqual({});
+  });
+
+  it('leaves cause and traceId undefined when not provided', () => {
+    const err = new ModuleError('X', 'msg');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('passes cause to Error super constructor', () => {
+    const cause = new Error('root');
+    const err = new ModuleError('X', 'msg', {}, cause);
+    expect(err.cause).toBe(cause);
+  });
+
+  it('sets traceId when provided', () => {
+    const err = new ModuleError('X', 'msg', {}, undefined, 'trace-abc');
+    expect(err.traceId).toBe('trace-abc');
+    expect(err.cause).toBeUndefined();
+  });
+
+  it('toString returns formatted code and message', () => {
+    const err = new ModuleError('MY_CODE', 'my message');
+    expect(err.toString()).toBe('[MY_CODE] my message');
+  });
+});
+
+describe('Error subclasses with options (cause and traceId branches)', () => {
+  const cause = new Error('underlying cause');
+  const traceId = 'trace-999';
+
+  it('ConfigNotFoundError with cause and traceId', () => {
+    const err = new ConfigNotFoundError('/cfg', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+    expect(err.details['configPath']).toBe('/cfg');
+  });
+
+  it('ConfigNotFoundError without options', () => {
+    const err = new ConfigNotFoundError('/cfg');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('ConfigError with cause and traceId', () => {
+    const err = new ConfigError('bad config', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('ConfigError without options', () => {
+    const err = new ConfigError('bad config');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('ACLRuleError with cause and traceId', () => {
+    const err = new ACLRuleError('bad rule', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('ACLRuleError without options', () => {
+    const err = new ACLRuleError('bad rule');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('ACLDeniedError with cause and traceId', () => {
+    const err = new ACLDeniedError('caller.a', 'target.b', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+    expect(err.callerId).toBe('caller.a');
+    expect(err.targetId).toBe('target.b');
+  });
+
+  it('ACLDeniedError without options', () => {
+    const err = new ACLDeniedError('caller.a', 'target.b');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('ACLDeniedError with null callerId', () => {
+    const err = new ACLDeniedError(null, 'target.b');
+    expect(err.callerId).toBeNull();
+    expect(err.targetId).toBe('target.b');
+    expect(err.message).toContain('null -> target.b');
+  });
+
+  it('ModuleNotFoundError with cause and traceId', () => {
+    const err = new ModuleNotFoundError('mod.x', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('ModuleNotFoundError without options', () => {
+    const err = new ModuleNotFoundError('mod.x');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('ModuleTimeoutError with cause and traceId', () => {
+    const err = new ModuleTimeoutError('mod.x', 3000, { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+    expect(err.moduleId).toBe('mod.x');
+    expect(err.timeoutMs).toBe(3000);
+  });
+
+  it('ModuleTimeoutError without options', () => {
+    const err = new ModuleTimeoutError('mod.x', 3000);
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('SchemaValidationError with cause and traceId', () => {
+    const err = new SchemaValidationError('invalid', [{ path: '/a' }], { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('SchemaValidationError without options', () => {
+    const err = new SchemaValidationError('invalid', []);
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('SchemaValidationError uses default message when no arguments provided', () => {
+    const err = new SchemaValidationError();
+    expect(err.message).toBe('Schema validation failed');
+    expect(err.details['errors']).toEqual([]);
+  });
+
+  it('SchemaValidationError defaults errors to empty array when errors not provided', () => {
+    const err = new SchemaValidationError('custom message');
+    expect(err.details['errors']).toEqual([]);
+  });
+
+  it('SchemaNotFoundError with cause and traceId', () => {
+    const err = new SchemaNotFoundError('schema.x', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('SchemaNotFoundError without options', () => {
+    const err = new SchemaNotFoundError('schema.x');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('SchemaParseError with cause and traceId', () => {
+    const err = new SchemaParseError('bad yaml', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('SchemaParseError without options', () => {
+    const err = new SchemaParseError('bad yaml');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('SchemaCircularRefError with cause and traceId', () => {
+    const err = new SchemaCircularRefError('#/defs/A', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('SchemaCircularRefError without options', () => {
+    const err = new SchemaCircularRefError('#/defs/A');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('CallDepthExceededError with cause and traceId', () => {
+    const err = new CallDepthExceededError(5, 4, ['a', 'b'], { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+    expect(err.currentDepth).toBe(5);
+    expect(err.maxDepth).toBe(4);
+  });
+
+  it('CallDepthExceededError without options', () => {
+    const err = new CallDepthExceededError(5, 4, ['a', 'b']);
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('CircularCallError with cause and traceId', () => {
+    const err = new CircularCallError('mod.a', ['mod.a', 'mod.b'], { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+    expect(err.moduleId).toBe('mod.a');
+  });
+
+  it('CircularCallError without options', () => {
+    const err = new CircularCallError('mod.a', ['mod.a', 'mod.b']);
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('CallFrequencyExceededError with cause and traceId', () => {
+    const err = new CallFrequencyExceededError('mod.a', 4, 3, ['mod.a'], { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+    expect(err.moduleId).toBe('mod.a');
+    expect(err.count).toBe(4);
+    expect(err.maxRepeat).toBe(3);
+  });
+
+  it('CallFrequencyExceededError without options', () => {
+    const err = new CallFrequencyExceededError('mod.a', 4, 3, ['mod.a']);
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('InvalidInputError with cause and traceId', () => {
+    const err = new InvalidInputError('bad data', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('InvalidInputError without options', () => {
+    const err = new InvalidInputError('bad data');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('InvalidInputError uses default message when no arguments provided', () => {
+    const err = new InvalidInputError();
+    expect(err.message).toBe('Invalid input');
+  });
+
+  it('FuncMissingTypeHintError with cause and traceId', () => {
+    const err = new FuncMissingTypeHintError('myFunc', 'myParam', { cause, traceId });
+    expect(err.name).toBe('FuncMissingTypeHintError');
+    expect(err.code).toBe('FUNC_MISSING_TYPE_HINT');
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+    expect(err.message).toContain('myParam');
+    expect(err.message).toContain('myFunc');
+  });
+
+  it('FuncMissingTypeHintError without options', () => {
+    const err = new FuncMissingTypeHintError('myFunc', 'myParam');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('FuncMissingReturnTypeError with cause and traceId', () => {
+    const err = new FuncMissingReturnTypeError('myFunc', { cause, traceId });
+    expect(err.name).toBe('FuncMissingReturnTypeError');
+    expect(err.code).toBe('FUNC_MISSING_RETURN_TYPE');
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+    expect(err.message).toContain('myFunc');
+  });
+
+  it('FuncMissingReturnTypeError without options', () => {
+    const err = new FuncMissingReturnTypeError('myFunc');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('BindingInvalidTargetError with cause and traceId', () => {
+    const err = new BindingInvalidTargetError('bad:target', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('BindingInvalidTargetError without options', () => {
+    const err = new BindingInvalidTargetError('bad:target');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('BindingModuleNotFoundError with cause and traceId', () => {
+    const err = new BindingModuleNotFoundError('some.module', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('BindingModuleNotFoundError without options', () => {
+    const err = new BindingModuleNotFoundError('some.module');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('BindingCallableNotFoundError with cause and traceId', () => {
+    const err = new BindingCallableNotFoundError('fn', 'some.module', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('BindingCallableNotFoundError without options', () => {
+    const err = new BindingCallableNotFoundError('fn', 'some.module');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('BindingNotCallableError with cause and traceId', () => {
+    const err = new BindingNotCallableError('some:target', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('BindingNotCallableError without options', () => {
+    const err = new BindingNotCallableError('some:target');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('BindingSchemaMissingError with cause and traceId', () => {
+    const err = new BindingSchemaMissingError('some:target', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('BindingSchemaMissingError without options', () => {
+    const err = new BindingSchemaMissingError('some:target');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('BindingFileInvalidError with cause and traceId', () => {
+    const err = new BindingFileInvalidError('/file.yaml', 'parse error', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('BindingFileInvalidError without options', () => {
+    const err = new BindingFileInvalidError('/file.yaml', 'parse error');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('CircularDependencyError with cause and traceId', () => {
+    const err = new CircularDependencyError(['a', 'b', 'a'], { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('CircularDependencyError without options', () => {
+    const err = new CircularDependencyError(['a', 'b', 'a']);
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('ModuleLoadError with cause and traceId', () => {
+    const err = new ModuleLoadError('mod.a', 'file not found', { cause, traceId });
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('ModuleLoadError without options', () => {
+    const err = new ModuleLoadError('mod.a', 'file not found');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('ModuleExecuteError with cause and traceId', () => {
+    const err = new ModuleExecuteError('mod.a', 'runtime error', { cause, traceId });
+    expect(err.name).toBe('ModuleExecuteError');
+    expect(err.code).toBe('MODULE_EXECUTE_ERROR');
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+    expect(err.message).toContain('mod.a');
+    expect(err.message).toContain('runtime error');
+  });
+
+  it('ModuleExecuteError without options', () => {
+    const err = new ModuleExecuteError('mod.a', 'runtime error');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('InternalError with cause and traceId', () => {
+    const err = new InternalError('something broke', { cause, traceId });
+    expect(err.name).toBe('InternalError');
+    expect(err.code).toBe('GENERAL_INTERNAL_ERROR');
+    expect(err.cause).toBe(cause);
+    expect(err.traceId).toBe(traceId);
+  });
+
+  it('InternalError without options', () => {
+    const err = new InternalError('something broke');
+    expect(err.cause).toBeUndefined();
+    expect(err.traceId).toBeUndefined();
+  });
+
+  it('InternalError uses default message when no arguments provided', () => {
+    const err = new InternalError();
+    expect(err.message).toBe('Internal error');
+  });
+});
+
+describe('ErrorCodes', () => {
+  it('contains MIDDLEWARE_CHAIN_ERROR', () => {
+    expect(ErrorCodes.MIDDLEWARE_CHAIN_ERROR).toBe('MIDDLEWARE_CHAIN_ERROR');
+  });
+
+  it('contains all expected error codes', () => {
+    expect(ErrorCodes.CONFIG_NOT_FOUND).toBe('CONFIG_NOT_FOUND');
+    expect(ErrorCodes.CONFIG_INVALID).toBe('CONFIG_INVALID');
+    expect(ErrorCodes.ACL_RULE_ERROR).toBe('ACL_RULE_ERROR');
+    expect(ErrorCodes.ACL_DENIED).toBe('ACL_DENIED');
+    expect(ErrorCodes.MODULE_NOT_FOUND).toBe('MODULE_NOT_FOUND');
+    expect(ErrorCodes.MODULE_TIMEOUT).toBe('MODULE_TIMEOUT');
+    expect(ErrorCodes.MODULE_LOAD_ERROR).toBe('MODULE_LOAD_ERROR');
+    expect(ErrorCodes.MODULE_EXECUTE_ERROR).toBe('MODULE_EXECUTE_ERROR');
+    expect(ErrorCodes.SCHEMA_VALIDATION_ERROR).toBe('SCHEMA_VALIDATION_ERROR');
+    expect(ErrorCodes.SCHEMA_NOT_FOUND).toBe('SCHEMA_NOT_FOUND');
+    expect(ErrorCodes.SCHEMA_PARSE_ERROR).toBe('SCHEMA_PARSE_ERROR');
+    expect(ErrorCodes.SCHEMA_CIRCULAR_REF).toBe('SCHEMA_CIRCULAR_REF');
+    expect(ErrorCodes.CALL_DEPTH_EXCEEDED).toBe('CALL_DEPTH_EXCEEDED');
+    expect(ErrorCodes.CIRCULAR_CALL).toBe('CIRCULAR_CALL');
+    expect(ErrorCodes.CALL_FREQUENCY_EXCEEDED).toBe('CALL_FREQUENCY_EXCEEDED');
+    expect(ErrorCodes.GENERAL_INVALID_INPUT).toBe('GENERAL_INVALID_INPUT');
+    expect(ErrorCodes.GENERAL_INTERNAL_ERROR).toBe('GENERAL_INTERNAL_ERROR');
+    expect(ErrorCodes.FUNC_MISSING_TYPE_HINT).toBe('FUNC_MISSING_TYPE_HINT');
+    expect(ErrorCodes.FUNC_MISSING_RETURN_TYPE).toBe('FUNC_MISSING_RETURN_TYPE');
+    expect(ErrorCodes.BINDING_INVALID_TARGET).toBe('BINDING_INVALID_TARGET');
+    expect(ErrorCodes.BINDING_MODULE_NOT_FOUND).toBe('BINDING_MODULE_NOT_FOUND');
+    expect(ErrorCodes.BINDING_CALLABLE_NOT_FOUND).toBe('BINDING_CALLABLE_NOT_FOUND');
+    expect(ErrorCodes.BINDING_NOT_CALLABLE).toBe('BINDING_NOT_CALLABLE');
+    expect(ErrorCodes.BINDING_SCHEMA_MISSING).toBe('BINDING_SCHEMA_MISSING');
+    expect(ErrorCodes.BINDING_FILE_INVALID).toBe('BINDING_FILE_INVALID');
+    expect(ErrorCodes.CIRCULAR_DEPENDENCY).toBe('CIRCULAR_DEPENDENCY');
+  });
+
+  it('is frozen and cannot be mutated', () => {
+    expect(Object.isFrozen(ErrorCodes)).toBe(true);
+  });
+});