jitar 0.1.1 → 0.1.2

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]');
-        });
-    });
-});

package/test/core/reflection/ReflectionHelper.spec.ts

@@ -1,128 +0,0 @@
-
-import ReflectionHelper from '../../../src/core/reflection/ReflectionHelper';
-
-import
-{
-    Person,
-    User,
-    johnDoe,
-    requiredArgedFunction,
-    optionalArgedFunction
-} from '../../_fixtures/core/reflection/ReflectionHelper.fixture';
-
-describe('core/reflection/ReflectionHelper', () =>
-{
-    describe('.getClass(object)', () =>
-    {
-        it('should get the class of an object', () =>
-        {
-            const result = ReflectionHelper.getObjectClass(johnDoe);
-
-            expect(result.name).toBe('Person');
-        });
-    });
-
-    describe('.getParentClass(object)', () =>
-    {
-        it('should get the parent of a class', () =>
-        {
-            const result = ReflectionHelper.getParentClass(Person);
-
-            expect(result.name).toBe('Human');
-        });
-    });
-
-    describe('.getFields(class)', () =>
-    {
-        it('should get all fields of a class', () =>
-        {
-            const result = ReflectionHelper.getFields(Person);
-
-            expect(result.length).toBe(4);
-
-            expect(result[0].name).toBe('id');
-            expect(result[0].canGet).toBe(true);
-            expect(result[0].canSet).toBe(true);
-
-            expect(result[1].name).toBe('fullName');
-            expect(result[1].canGet).toBe(true);
-            expect(result[1].canSet).toBe(false);
-
-            expect(result[2].name).toBe('age');
-            expect(result[2].canGet).toBe(true);
-            expect(result[2].canSet).toBe(false);
-
-            expect(result[3].name).toBe('state');
-            expect(result[3].canGet).toBe(false);
-            expect(result[3].canSet).toBe(true);
-        });
-    });
-
-    describe('.getConstructorParameters(class)', () =>
-    {
-        it('should get the constructor parameters of a class', () =>
-        {
-            const result = ReflectionHelper.getConstructorParameters(Person);
-
-            expect(result.length).toBe(4);
-
-            expect(result[0].name).toBe('id');
-            expect(result[1].name).toBe('firstName');
-            expect(result[2].name).toBe('lastName');
-            expect(result[3].name).toBe('age');
-        });
-
-        it('should get the constructor parameters of the parent class', () =>
-        {
-            const result = ReflectionHelper.getConstructorParameters(User);
-
-            expect(result.length).toBe(4);
-
-            expect(result[0].name).toBe('id');
-            expect(result[1].name).toBe('firstName');
-            expect(result[2].name).toBe('lastName');
-            expect(result[3].name).toBe('age');
-        });
-    });
-
-    describe('.getFunctionParameters(function)', () =>
-    {
-        it('should get the required parameters of a function', () =>
-        {
-            const result = ReflectionHelper.getFunctionParameters(requiredArgedFunction);
-
-            expect(result.length).toBe(3);
-
-            expect(result[0].name).toBe('a');
-            expect(result[0].isOptional).toBe(false);
-            expect(result[0].defaultValue).toBe(undefined);
-
-            expect(result[1].name).toBe('b');
-            expect(result[1].isOptional).toBe(false);
-            expect(result[1].defaultValue).toBe(undefined);
-
-            expect(result[2].name).toBe('c');
-            expect(result[2].isOptional).toBe(false);
-            expect(result[2].defaultValue).toBe(undefined);
-        });
-
-        it('should get the optional parameters of a function', () =>
-        {
-            const result = ReflectionHelper.getFunctionParameters(optionalArgedFunction);
-
-            expect(result.length).toBe(3);
-
-            expect(result[0].name).toBe('a');
-            expect(result[0].isOptional).toBe(false);
-            expect(result[0].defaultValue).toBe(undefined);
-
-            expect(result[1].name).toBe('b');
-            expect(result[1].isOptional).toBe(true);
-            expect(result[1].defaultValue).toBe(`new Person(1, 'Jane', 'Doe', 42)`);
-
-            expect(result[2].name).toBe('c');
-            expect(result[2].isOptional).toBe(true);
-            expect(result[2].defaultValue).toBe('0');
-        });
-    });
-});

package/test/core/utils/FqnBuilder.spec.ts

@@ -1,22 +0,0 @@
-
-import FqnBuilder from '../../../src/core/utils/FqnBuilder';
-
-describe('core/utils/FqnBuilder', () =>
-{
-    describe('.build(module, name)', () =>
-    {
-        it('should have its name only when no module is defined', () =>
-        {
-            const fqn = FqnBuilder.build('', 'myRootProcedure');
-
-            expect(fqn).toBe('myRootProcedure');
-        });
-
-        it('should have a combination of module and name when a module is defined', () =>
-        {
-            const fqn = FqnBuilder.build('my/module', 'myModuleProcedure');
-
-            expect(fqn).toBe('my/module/myModuleProcedure');
-        });
-    });
-});

package/test/runtime/ClientId.spec.ts

@@ -1,43 +0,0 @@
-
-import ClientId from '../../src/runtime/ClientId';
-
-describe('runtime/ClientId', () =>
-{
-    describe('.generate()', () =>
-    {
-        it('should generate a client id', () =>
-        {
-            const clientId = ClientId.generate();
-
-            expect(clientId).toMatch(/^CLIENT_\d+$/);
-        });
-
-        it('should generate a different client id each time', () =>
-        {
-            const clientId1 = ClientId.generate();
-            const clientId2 = ClientId.generate();
-
-            expect(clientId1).not.toBe(clientId2);
-        });
-    });
-
-    describe('.validate(clientId)', () =>
-    {
-        it('should return true if the client id is valid', () =>
-        {
-            expect(ClientId.validate('CLIENT_0')).toBe(true);
-            expect(ClientId.validate('CLIENT_42')).toBe(true);
-            expect(ClientId.validate('CLIENT_007')).toBe(true);
-        });
-
-        it('should return false if the client id is invalid', () =>
-        {
-            expect(ClientId.validate('CLIENT_')).toBe(false);
-            expect(ClientId.validate('CLIENT_X')).toBe(false);
-            expect(ClientId.validate('CLIENT_0a')).toBe(false);
-            expect(ClientId.validate('CLIENT_0.1')).toBe(false);
-            expect(ClientId.validate('Client_0')).toBe(false);
-            expect(ClientId.validate('SERVER_0')).toBe(false);
-        });
-    });
-});

package/test/runtime/LocalGateway.spec.ts

@@ -1,40 +0,0 @@
-
-import ProcedureNotFound from '../../src/core/errors/ProcedureNotFound';
-import Version from '../../src/core/Version';
-
-import { API_URL, gateway } from '../_fixtures/runtime/LocalGateway.fixture';
-
-describe('runtime/LocalGateway', () =>
-{
-    describe('.url', () =>
-    {
-        it('should contain an url', () =>
-        {
-            expect(gateway.url).toContain(API_URL);
-        });
-    });
-
-    describe('.run(name, version, parameters)', () =>
-    {
-        it('should find and run a procedure from a node', async () =>
-        {
-            const firstResult = await gateway.run('my/module/firstPublicTask', Version.DEFAULT, new Map());
-
-            expect(firstResult).toBe('first');
-        });
-
-        it('should find and run a procedure from a node that calls a procedure on another node', async () =>
-        {
-            const result = await gateway.run('my/module/thirdPublicTask', Version.DEFAULT, new Map());
-
-            expect(result).toBe('fourth');
-        });
-
-        it('should not run a non-existing procedure', async () =>
-        {
-            const run = async() => await gateway.run('my/module/nonExistingTask', Version.DEFAULT, new Map());
-
-            expect(run).rejects.toEqual(new ProcedureNotFound('my/module/nonExistingTask'));
-        });
-    });
-});

package/test/runtime/LocalNode.spec.ts

@@ -1,87 +0,0 @@
-
-import ProcedureNotFound from '../../src/core/errors/ProcedureNotFound';
-import Version from '../../src/core/Version';
-
-import { API_URL, node } from '../_fixtures/runtime/LocalNode.fixture';
-
-describe('runtime/LocalNode', () =>
-{
-    describe('.url', () =>
-    {
-        it('should contain an url', () =>
-        {
-            expect(node.url).toContain(API_URL);
-        });
-    });
-
-    describe('.isHealty()', () =>
-    {
-        it('should be healthy', () =>
-        {
-            const healthy = node.isHealthy();
-
-            expect(healthy).toBeTruthy();
-        });
-    });
-
-    describe('.hasProcedure(name)', () =>
-    {
-        it('should find public procedures', () =>
-        {
-            const hasFirstProcedure = node.hasProcedure('my/module/firstPublicTask');
-            const hasSecondProcedure = node.hasProcedure('my/module/secondPublicTask');
-            const hasThirdProcedure = node.hasProcedure('my/module/thirdPublicTask');
-
-            expect(hasFirstProcedure).toBeTruthy();
-            expect(hasSecondProcedure).toBeTruthy();
-            expect(hasThirdProcedure).toBeTruthy();
-        });
-
-        it('should not find private procedures', () =>
-        {
-            const hasFirstProcedure = node.hasProcedure('my/module/firstPrivateTask');
-            const hasSecondProcedure = node.hasProcedure('my/module/secondPrivateTask');
-
-            expect(hasFirstProcedure).toBeFalsy();
-            expect(hasSecondProcedure).toBeFalsy();
-        });
-
-        it('should not find non-existing procedures', () =>
-        {
-            const hasNoProcedure = node.hasProcedure('my/module/nonExistingTask');
-
-            expect(hasNoProcedure).toBeFalsy();
-        });
-    });
-
-    describe('.run(name, version, parameters)', () =>
-    {
-        it('should run a public procedure that calls a private procedure on the same segment', async () =>
-        {
-            const result = await node.run('my/module/firstPublicTask', Version.DEFAULT, new Map());
-
-            expect(result).toBe('first');
-        });
-
-        it('should run a public procedure that calls a private procedure on another segment', async () =>
-        {
-            const result = await node.run('my/module/secondPublicTask', Version.DEFAULT, new Map());
-
-            expect(result).toBe('first');
-        });
-
-        it('should run a public procedure that calls a public procedure on another segment', async () =>
-        {
-            const result = await node.run('my/module/thirdPublicTask', Version.DEFAULT, new Map());
-
-            expect(result).toBe('fourth');
-        });
-
-        it('should not run a non-existing procedure', async () =>
-        {
-            const run = async() => await node.run('my/module/nonExistingTask', Version.DEFAULT, new Map());
-
-            expect(run).rejects.toEqual(new ProcedureNotFound('my/module/nonExistingTask'));
-        });
-    });
-});