jitar 0.1.0

package/test/core/SegmentBuilder.spec.ts

@@ -0,0 +1,39 @@
+
+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

@@ -0,0 +1,103 @@
+
+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

@@ -0,0 +1,32 @@
+
+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

@@ -0,0 +1,128 @@
+
+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

@@ -0,0 +1,22 @@
+
+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/LocalGateway.spec.ts

@@ -0,0 +1,40 @@
+
+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

@@ -0,0 +1,87 @@
+
+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'));
+        });
+    });
+});

package/test/runtime/LocalRepository.spec.ts

@@ -0,0 +1,50 @@
+
+import InvalidClientId from '../../src/runtime/errors/InvalidClientId';
+import ClientNotFound from '../../src/runtime/errors/ClientNotFound';
+
+import
+{
+    repository, client,
+    UNSEGMENTED_FILE, LOCAL_FILE, REMOTE_FILE
+} from '../_fixtures/runtime/LocalRepository.fixture';
+
+describe('runtime/LocalRepository', () =>
+{
+    describe('.loadModule(clientId, filename)', () =>
+    {
+        it('should not accept an invalid client id', () =>
+        {
+            const run = async () => await repository.loadModule('INVALID', '/some/file');
+
+            expect(run).rejects.toEqual(new InvalidClientId('INVALID'));
+        });
+
+        it('should not accept an unknown client id', () =>
+        {
+            const run = async () => await repository.loadModule('CLIENT_X', '/some/file');
+
+            expect(run).rejects.toEqual(new ClientNotFound('CLIENT_X'));
+        });
+
+        it('should return an unsegmented module file', async () =>
+        {
+            const result = await repository.loadModule(client.id, UNSEGMENTED_FILE);
+
+            expect(result.content.toString()).toContain('fourthPrivateTask()');
+        });
+
+        it('should return the actual module file', async () =>
+        {
+            const result = await repository.loadModule(client.id, LOCAL_FILE);
+
+            expect(result.content).toContain('firstPublicTask()');
+        });
+
+        it('should return a remote module file', async () =>
+        {
+            const result = await repository.loadModule(client.id, REMOTE_FILE);
+
+            expect(result.content.toString()).toContain('runProcedure()');
+        });
+    });
+});

package/test/runtime/NodeBalancer.spec.ts

@@ -0,0 +1,39 @@
+
+import NoNodeAvailable from '../../src/runtime/errors/NoNodeAvailable';
+import Version from '../../src/core/Version';
+
+import {
+    balancer,
+    emptyBalancer,
+    firstNode,
+    secondNode
+} from '../_fixtures/runtime/NodeBalancer.fixture';
+
+describe('runtime/LocalGateway', () =>
+{
+    describe('.getNextNode()', () =>
+    {
+        it('should select nodes round robin', async () =>
+        {
+            const firstSelectedNode = balancer.getNextNode();
+            const secondSelectedNode = balancer.getNextNode();
+            const thirdSelectedNode = balancer.getNextNode();
+            const fouthSelectedNode = balancer.getNextNode();
+
+            expect(firstSelectedNode).toBe(firstNode);
+            expect(secondSelectedNode).toBe(secondNode);
+            expect(thirdSelectedNode).toBe(firstNode);
+            expect(fouthSelectedNode).toBe(secondNode);
+        });
+    });
+
+    describe('.run(name, version, parameters)', () =>
+    {
+        it('throw a node not available error', async () =>
+        {
+            const run = async() => await emptyBalancer.run('NoProcedure', Version.DEFAULT, new Map());
+
+            expect(run).rejects.toEqual(new NoNodeAvailable('NoProcedure'));
+        });
+    });
+});

package/test/runtime/NodeMonitor.spec.ts

@@ -0,0 +1,31 @@
+
+import {
+    goodNode,
+    badNode,
+    gateway,
+    monitor
+} from '../_fixtures/runtime/NodeMonitor.fixture';
+
+describe('runtime/LocalGateway', () =>
+{
+    describe('.monitor()', () =>
+    {
+        it('should keep a node and remove a node', async () =>
+        {
+            const beforeNodes = gateway.nodes;
+
+            expect(beforeNodes.length).toBe(2);
+            expect(beforeNodes[0]).toBe(goodNode);
+            expect(beforeNodes[1]).toBe(badNode);
+
+            monitor.start();
+            await new Promise(resolve => setTimeout(resolve, 300));
+            monitor.stop();
+
+            const afterNodes = gateway.nodes;
+
+            expect(afterNodes.length).toBe(1);
+            expect(afterNodes[0]).toBe(goodNode);
+        });
+    });
+});

package/test/runtime/RemoteNode.spec.ts

@@ -0,0 +1,43 @@
+
+import { API_URL, node } from '../_fixtures/runtime/RemoteNode.fixture';
+
+describe('runtime/LocalGateway', () =>
+{
+    describe('.url', () =>
+    {
+        it('should contain an url', () =>
+        {
+            expect(node.url).toContain(API_URL);
+        });
+    });
+
+    describe('.getProcedureNames()', () =>
+    {
+        it('should contain all registered procedure', () =>
+        {
+            const names = node.getProcedureNames();
+
+            expect(names).toContain('FirstProcedure');
+            expect(names).toContain('SecondProcedure');
+        });
+    });
+    
+    describe('.hasProcedure(name)', () =>
+    {
+        it('should find a procedure', () =>
+        {
+            const hasFirstProcedure = node.hasProcedure('FirstProcedure');
+            const hasSecondProcedure = node.hasProcedure('FirstProcedure');
+
+            expect(hasFirstProcedure).toBeTruthy();
+            expect(hasSecondProcedure).toBeTruthy();
+        });
+
+        it('should not find a procedure', () =>
+        {
+            const hasNoProcedure = node.hasProcedure('NoProcedure');
+
+            expect(hasNoProcedure).toBeFalsy();
+        });
+    });
+});

package/test/runtime/caching/ImportRewriter.spec.ts

@@ -0,0 +1,68 @@
+
+import ImportRewriter from '../../../src/runtime/caching/ImportRewriter';
+
+import
+{
+    noSystemImports, noSystemImportsResult,
+    hasSystemImports, hasSystemImportsResult,
+    hasJitarImports, hasJitarImportsResult,
+    hasMixedImports, hasMixedImportsResult,
+    hasDynamicImports, hasDynamicImportsResult,
+    hasImportsAndContent, hasImportsAndContentResult,
+    hasImportsNoSemicolon, hasImportsResultNoSemicolon
+} from '../../_fixtures/runtime/caching/ImportRewriter.fixture';
+
+describe('runtime/utils/ImportRewriter', () =>
+{
+    describe('.rewrite(module)', () =>
+    {
+        it('should not rewrite non-system imports', () =>
+        {
+            const result = ImportRewriter.rewrite(noSystemImports);
+
+            expect(result).toBe(noSystemImportsResult);
+        });
+
+        it('should rewrite all system imports', () =>
+        {
+            const result = ImportRewriter.rewrite(hasSystemImports);
+
+            expect(result).toBe(hasSystemImportsResult);
+        });
+
+        it('should rewrite all jitar imports', () =>
+        {
+            const result = ImportRewriter.rewrite(hasJitarImports);
+
+            expect(result).toBe(hasJitarImportsResult);
+        });
+
+        it('should rewrite all imports without semicolon', () =>
+        {
+            const result = ImportRewriter.rewrite(hasImportsNoSemicolon);
+
+            expect(result).toBe(hasImportsResultNoSemicolon);
+        });
+
+        it('should rewrite mixed system and jitar imports', () =>
+        {
+            const result = ImportRewriter.rewrite(hasMixedImports);
+
+            expect(result).toBe(hasMixedImportsResult);
+        });
+
+        it('should not rewrite dynamic imports', () =>
+        {
+            const result = ImportRewriter.rewrite(hasDynamicImports);
+
+            expect(result).toBe(hasDynamicImportsResult);
+        });
+
+        it('should not modify any content', () =>
+        {
+            const result = ImportRewriter.rewrite(hasImportsAndContent);
+
+            expect(result).toBe(hasImportsAndContentResult);
+        });
+    });
+});