jitar 0.1.1 → 0.1.3

package/test/_fixtures/runtime/serialization/ValueSerializer.fixture.ts

@@ -1,134 +0,0 @@
-
-import Component from "../../../../src/core/types/Component";
-
-const IMPORT_URL = '../../../test/_fixtures/runtime/serialization/ValueSerializer.fixture';
-
-export class Data
-{
-    a?: number;
-    b?: boolean;
-}
-
-(Data as Component).source = IMPORT_URL;
-
-export class Constructed
-{
-    #a: number;
-    #b: boolean;
-    #c?: string;
-
-    constructor(a: number, b: boolean)
-    {
-        this.#a = a;
-        this.#b = b;
-    }
-
-    get a() { return this.#a; }
-
-    get b() { return this.#b; }
-
-    get c() { return this.#c; }
-
-    set c(c) { this.#c = c; }
-}
-
-(Constructed as Component).source = IMPORT_URL;
-
-export class Nested
-{
-    name: string;
-    #constructed: Constructed;
-
-    constructor(name: string, constructed: Constructed)
-    {
-        this.name = name;
-        this.#constructed = constructed;
-    }
-
-    get constructed() { return this.#constructed; }
-}
-
-(Nested as Component).source = IMPORT_URL;
-
-export class PrivateFieldClass
-{
-    #a: number;
-    #b: boolean;
-    c?: string;
-
-    constructor(a: number, b: boolean)
-    {
-        this.#a = a;
-        this.#b = b;
-    }
-
-    get d() { return this.#a; }
-}
-
-(PrivateFieldClass as Component).source = IMPORT_URL;
-
-const errorClass = new Error('hello');
-errorClass.stack = 'stacktrace';
-
-const numberValue = 1;
-const boolValue = true;
-const stringValue = 'hello';
-const nullValue = null;
-const undefinedValue = undefined;
-
-const emptyArray: unknown[] = [];
-const mixedArray: unknown[] = ['a', 1, true];
-const nestedArray: unknown[] = ['b', 2, ['c', false], true];
-
-const emptyObject: unknown = {};
-const mixedObject: unknown = { a: 1, b: true, c: 'hello' };
-const nestedObject: unknown = { a: 1, b: true, c: { d: false, e: true } };
-
-const emptyMap: Map<unknown, unknown> = new Map();
-const mixedMap: Map<unknown, unknown> = new Map().set('a', 1).set('b', true);
-const nestedMap: Map<unknown, unknown> = new Map().set('b', 'hello').set('c', new Map().set('d', false));
-
-const serializedEmptyMap = { serialized: true, name: 'Map', entries: { keys: [], values: [] } };
-const serializedMixedMap = { serialized: true, name: 'Map', entries: { keys: ['a', 'b'], values: [1, true] } }
-const serializedNestedMap = { serialized: true, name: 'Map', entries: { keys: ['b', 'c'], values: ['hello', { serialized: true, name: 'Map', entries: { keys: ['d'], values: [false] } }] } }
-
-const emptySet: Set<unknown> = new Set();
-const mixedSet: Set<unknown> = new Set().add(1).add(true);
-const nestedSet: Set<unknown> = new Set().add('hello').add(new Set().add(false));
-
-const serializedEmptySet = { serialized: true, name: 'Set', values: [] };
-const serializedMixedSet = { serialized: true, name: 'Set', values: [1, true] };
-const serializedNestedSet = { serialized: true, name: 'Set', values: ['hello', { serialized: true, name: 'Set', values: [false] }] };
-
-const serializedError = { serialized: true, name: 'Error', source: null, args: [], fields: { stack: 'stacktrace', message: 'hello' } };
-
-const dataClass = new Data();
-dataClass.a = 1;
-dataClass.b = true;
-
-const constructedClass = new Constructed(1, true);
-constructedClass.c = 'hello';
-
-const nestedClass = new Nested('hello', constructedClass);
-const privateClass = new PrivateFieldClass(1, true);
-
-const serializedDataClass = { serialized: true, name: 'Data', source: IMPORT_URL, args: [], fields: { a: 1, b: true } };
-const serializedConstructedClass = { serialized: true, name: 'Constructed', source: IMPORT_URL, args: [1, true], fields: { c: 'hello' } };
-const serializedNestedClass = { serialized: true, name: 'Nested', source: IMPORT_URL, args: ['hello', { serialized: true, name: 'Constructed', source: IMPORT_URL, args: [1, true], fields: { c: 'hello' } }], fields: {} };
-const serializedPrivateClass = { serialized: true, name: 'PrivateFieldClass', source: IMPORT_URL, args: [], fields: { c: undefined } };
-
-const serializedInvalidClass = { serialized: true, name: 'Invalid', source: null, args: [], fields: {} };
-const serializedUnserializableClass = { serialized: true, name: 'Infinity', source: null, args: [], fields: {} };
-
-export
-{
-    numberValue, boolValue, stringValue, nullValue, undefinedValue,
-    emptyArray, mixedArray, nestedArray,
-    emptyObject, mixedObject, nestedObject,
-    emptyMap, mixedMap, nestedMap, serializedEmptyMap, serializedMixedMap, serializedNestedMap,
-    emptySet, mixedSet, nestedSet, serializedEmptySet, serializedMixedSet, serializedNestedSet,
-    dataClass, constructedClass, nestedClass, serializedDataClass, serializedConstructedClass, serializedNestedClass,
-    serializedInvalidClass, serializedUnserializableClass,
-    privateClass, serializedPrivateClass,
-    errorClass, serializedError
-}

package/test/_fixtures/runtime/utils/ModuleAnaliser.fixture.ts

@@ -1,26 +0,0 @@
-
-import Module from '../../../../src/core/types/Module';
-
-const string = 'Hello World';
-
-const pojo = { a: 10, b: 20 }
-
-function realFunction(a: number, b: number): number
-{
-    return a + b;
-}
-
-class realClass {}
-
-const theModule: Module = {};
-theModule.string = string;
-theModule.pojo = pojo;
-theModule.realFunction = realFunction;
-theModule.realClass = realClass;
-
-export {
-    theModule,
-    pojo,
-    realFunction,
-    realClass
-}

package/test/core/Implementation.spec.ts

@@ -1,89 +0,0 @@
-
-import MissingParameterValue from '../../src/core/errors/MissingParameterValue';
-
-import
-{
-    privateImplementation,
-    publicImplementation,
-    parameterImplementation
-} from '../_fixtures/core/Implementation.fixture';
-
-describe('core/Implementation', () =>
-{
-    describe('.version', () =>
-    {
-        it('should have a version', () =>
-        {
-            expect(privateImplementation.version.toString()).toBe('0.0.0');
-        });
-    });
-
-    describe('.public', () =>
-    {
-        it('should be private', () =>
-        {
-            expect(privateImplementation.public).toBe(false);
-        });
-
-        it('should be public', () =>
-        {
-            expect(publicImplementation.public).toBe(true);
-        });
-    });
-
-    describe('.parameters', () =>
-    {
-        it('should have no parameters', () =>
-        {
-            const parameters = publicImplementation.parameters;
-
-            expect(parameters.length).toBe(0);
-        });
-
-        it('should have parameters', () =>
-        {
-            const parameters = parameterImplementation.parameters;
-
-            expect(parameters.length).toBe(2);
-
-            expect(parameters[0].name).toBe('mandatory');
-            expect(parameters[0].isOptional).toBe(false);
-
-            expect(parameters[1].name).toBe('optional');
-            expect(parameters[1].isOptional).toBe(true);
-        });
-    });
-
-    describe('.run(name, version, args)', () =>
-    {
-        it('should run a procedure without parameters', async () =>
-        {
-            const result = await publicImplementation.run(new Map());
-
-            expect(result).toBe('public');
-        });
-
-        it('should run a procedure with parameter values', async () =>
-        {
-            const args = new Map().set('mandatory', 'mandatory').set('optional', 'optional');
-            const result = await parameterImplementation.run(args);
-
-            expect(result).toBe('mandatory optional');
-        });
-
-        it('should run a procedure without an optional parameter value', async () =>
-        {
-            const args = new Map().set('mandatory', 'mandatory');
-            const result = await parameterImplementation.run(args);
-
-            expect(result).toBe('mandatory default');
-        });
-
-        it('should not run a procedure without a mandatory parameter value', async () =>
-        {
-            const run = async () => await parameterImplementation.run(new Map());
-
-            expect(run).rejects.toEqual(new MissingParameterValue('mandatory'));
-        });
-    });
-});

package/test/core/Procedure.spec.ts

@@ -1,108 +0,0 @@
-
-import Version from '../../src/core/Version';
-import ImplementationNotFound from '../../src/core/errors/ImplementationNotFound';
-
-import
-{
-    rootProcedure,
-    moduleProcedure,
-    privateProcedure
-} from '../_fixtures/core/Procedure.fixture';
-
-describe('core/Procedure', () =>
-{
-    describe('.module', () =>
-    {
-        it('should have an empty module', () =>
-        {
-            expect(rootProcedure.module).toBe('');
-        });
-
-        it('should have a defined module', () =>
-        {
-            expect(moduleProcedure.module).toBe('my/module');
-        });
-    });
-
-    describe('.name', () =>
-    {
-        it('should have the defined name', () =>
-        {
-            expect(rootProcedure.name).toBe('myRootProcedure');
-            expect(moduleProcedure.name).toBe('myModuleProcedure');
-        });
-    });
-
-    describe('.fqn', () =>
-    {
-        it('should have its name only when no module is defined', () =>
-        {
-            expect(rootProcedure.fqn).toBe('myRootProcedure');
-        });
-
-        it('should have a combination of module and name when a module is defined', () =>
-        {
-            expect(moduleProcedure.fqn).toBe('my/module/myModuleProcedure');
-        });
-    });
-
-    describe('.public', () =>
-    {
-        it('should have public implementations', () =>
-        {
-            expect(rootProcedure.public).toBeTruthy();
-        });
-
-        it('should not have public implementations', () =>
-        {
-            expect(privateProcedure.public).toBeFalsy();
-        });
-    });
-
-    describe('.getImplementation(version)', () =>
-    {
-        it('should not get a lower implementation version than the lowest registered version', () =>
-        {
-            const implementation = rootProcedure.getImplementation(new Version(0, 0, 1));
-
-            expect(implementation).toBeUndefined();
-        });
-
-        it('should get an exact version of an implementation', () =>
-        {
-            const implementation = rootProcedure.getImplementation(new Version(1, 0, 0));
-
-            expect(implementation).not.toBeUndefined();
-            expect(implementation?.version.toString()).toBe('1.0.0');
-        });
-
-        it('should get a lower version of an implementation if no exact version is found', () =>
-        {
-            const implementation = rootProcedure.getImplementation(new Version(1, 0, 3));
-
-            expect(implementation).not.toBeNull();
-            expect(implementation?.version.toString()).toBe('1.0.0');
-        });
-    });
-
-    describe('.run(name, version)', () =>
-    {
-        it('should run a procedure', async () =>
-        {
-            const v1_0_0 = await rootProcedure.run(new Version(1, 0, 0), new Map());
-            const v1_0_5 = await rootProcedure.run(new Version(1, 0, 5), new Map());
-            const v1_1_0 = await rootProcedure.run(new Version(1, 1, 0), new Map());
-
-            expect(v1_0_0).toBe('1.0.0');
-            expect(v1_0_5).toBe('1.0.5');
-            expect(v1_1_0).toBe('1.1.0');
-        });
-
-        it('throw a implementation not found error', async () =>
-        {
-            const run = async () => await rootProcedure.run(new Version(0, 0, 1), new Map());
-
-            expect(run).rejects.toEqual(new ImplementationNotFound('myRootProcedure', '0.0.1'));
-        });
-    });
-});

package/test/core/Segment.spec.ts

@@ -1,74 +0,0 @@
-
-import ProcedureNotFound from '../../src/core/errors/ProcedureNotFound';
-import Version from '../../src/core/Version';
-
-import { segment } from '../_fixtures/core/Segment.fixture';
-
-describe('core/Segment', () =>
-{
-    describe('.hasProcedure', () =>
-    {
-        it('should have a public procedure', async () =>
-        {
-            const hasProcedure = segment.hasProcedure('getPublic');
-
-            expect(hasProcedure).toBeTruthy();
-        });
-
-        it('should have a private procedure', async () =>
-        {
-            const hasProcedure = segment.hasProcedure('getPrivate');
-
-            expect(hasProcedure).toBeTruthy();
-        });
-
-        it('should have modulerized procedures', async () =>
-        {
-            const hasProcedure = segment.hasProcedure('my/module/getModule');
-
-            expect(hasProcedure).toBeTruthy();
-        });
-    });
-
-    describe('.getPublicProcedures()', () =>
-    {
-        it('should return public procedures only', async () =>
-        {
-            const procedures = segment.getPublicProcedures();
-
-            expect(procedures.length).toBe(1);
-            expect(procedures[0].fqn).toBe('getPublic');
-        });
-    });
-
-    describe('.run(name, version, args)', () =>
-    {
-        it('should run a public procedure', async () =>
-        {
-            const result = await segment.run('getPublic', Version.DEFAULT, new Map());
-
-            expect(result).toBe('public');
-        });
-
-        it('should run a private procedure', async () =>
-        {
-            const result = await segment.run('getPrivate', Version.DEFAULT, new Map());
-
-            expect(result).toBe('private');
-        });
-
-        it('should not run a non-existing procedure', async () =>
-        {
-            const run = async () => await segment.run('noImplementation', Version.DEFAULT, new Map());
-
-            expect(run).rejects.toEqual(new ProcedureNotFound('noImplementation'));
-        });
-
-        it('should not run a broken procedure', async () =>
-        {
-            const run = async () => await segment.run('throwError', Version.DEFAULT, new Map());
-
-            expect(run).rejects.toEqual(new Error('broken\n[throwError | v0.0.0]'));
-        });
-    });
-});

package/test/core/SegmentBuilder.spec.ts

@@ -1,39 +0,0 @@
-
-import { segmentModule } from '../_fixtures/core/SegmentBuilder.fixture';
-
-import SegmentBuilder from '../../src/core/SegmentBuilder';
-import Version from '../../src/core/Version';
-
-describe('core/SegmentBuilder', () =>
-{
-    describe('.build(module)', () =>
-    {
-        const segment = SegmentBuilder.build('test', segmentModule);
-
-        it('should have an id', () =>
-        {
-            expect(segment.id).toBe('test');
-        });
-
-        it('should have procedures', async () =>
-        {
-            const hasDefaultFunction = segment.hasProcedure('defaultFunction');
-            const hasAnotherFunction = segment.hasProcedure('anotherFunction');
-
-            expect(hasDefaultFunction).toBeTruthy();
-            expect(hasAnotherFunction).toBeTruthy();
-        });
-
-        it('should have implementations', async () =>
-        {
-            const defaultFunction = segment.getProcedure('defaultFunction');
-            const anotherFunction = segment.getProcedure('anotherFunction');
-
-            const defaultImplementation = defaultFunction?.getImplementation(new Version(0, 0, 0));
-            const anotherImplementation = anotherFunction?.getImplementation(new Version(1, 0, 0));
-
-            expect(defaultImplementation).toBeDefined();
-            expect(anotherImplementation).toBeDefined();
-        });
-    });
-});

package/test/core/Version.spec.ts

@@ -1,103 +0,0 @@
-
-import Version from '../../src/core/Version';
-import InvalidVersionNumber from '../../src/core/errors/InvalidVersionNumber';
-
-import {
-    actualVersion,
-    equalVersion,
-    greaterVersion,
-    lesserVersion,
-    majorMinorVersion,
-    majorVersion
-} from '../_fixtures/core/Version.fixture';
-
-describe('core/Version', () =>
-{
-    describe('.equals(version)', () =>
-    {
-        it('should be equal', () =>
-        {
-            const equal = actualVersion.equals(equalVersion);
-
-            expect(equal).toBeTruthy();
-        });
-
-        it('should not be equal', () =>
-        {
-            const greaterEqual = actualVersion.equals(greaterVersion);
-            const lesserEqual = actualVersion.equals(lesserVersion);
-
-            expect(greaterEqual).toBeFalsy();
-            expect(lesserEqual).toBeFalsy();
-        });
-    });
-
-    describe('.greater(version)', () =>
-    {
-        it('should be greater', () =>
-        {
-            const equal = actualVersion.greater(lesserVersion);
-
-            expect(equal).toBeTruthy();
-        });
-
-        it('should not be greater', () =>
-        {
-            const equalEqual = actualVersion.greater(equalVersion);
-            const greaterEqual = actualVersion.greater(greaterVersion);
-
-            expect(equalEqual).toBeFalsy();
-            expect(greaterEqual).toBeFalsy();
-        });
-    });
-
-    describe('.less(version)', () =>
-    {
-        it('should be less', () =>
-        {
-            const equal = actualVersion.less(greaterVersion);
-
-            expect(equal).toBeTruthy();
-        });
-
-        it('should not be less', () =>
-        {
-            const equalEqual = actualVersion.less(equalVersion);
-            const lesserEqual = actualVersion.less(lesserVersion);
-
-            expect(equalEqual).toBeFalsy();
-            expect(lesserEqual).toBeFalsy();
-        });
-    });
-
-    describe('.parse(number)', () =>
-    {
-        it('should parse a major number', () =>
-        {
-            const version = Version.parse('1');
-
-            expect(version).toEqual(majorVersion);
-        });
-
-        it('should parse a major.minor number', () =>
-        {
-            const version = Version.parse('1.2');
-
-            expect(version).toEqual(majorMinorVersion);
-        });
-
-        it('should parse a major.minor.patch number', () =>
-        {
-            const version = Version.parse('1.2.3');
-
-            expect(version).toEqual(actualVersion);
-        });
-
-        it('should not parse an invalid number', () =>
-        {
-            const run = () => Version.parse('1.2.3.4');
-
-            expect(run).toThrow(new InvalidVersionNumber('1.2.3.4'));
-        });
-    });
-});

package/test/core/errors/ErrorManager.spec.ts

@@ -1,32 +0,0 @@
-
-import ErrorManager from '../../../src/core/ErrorManager';
-
-describe('core/errors/ErrorManager', () =>
-{
-    describe('.handle(error, name, version)', () =>
-    {
-        it('should contain the only message for non errors', () =>
-        {
-            const result = ErrorManager.handle('Hello world', 'Test', '1.0.0');
-
-            expect(result.message).toBe('Hello world\n[Test | v1.0.0]');
-        });
-
-        it('should contain the error message', () =>
-        {
-            const parentError = new Error('Hello world');
-            const result = ErrorManager.handle(parentError, 'Test', '1.0.0');
-
-            expect(result.message).toBe('Hello world\n[Test | v1.0.0]');
-        });
-
-        it('should only stack the procedure trace for run error parents', () =>
-        {
-            const first = new Error('Hello world');
-            const second = ErrorManager.handle(first, 'Sub procedure', '1.0.0');
-            const result = ErrorManager.handle(second, 'Root procedure', '1.1.0');
-
-            expect(result.message).toBe('Hello world\n[Sub procedure | v1.0.0]\n[Root procedure | v1.1.0]');
-        });
-    });
-});