jitar 0.1.1 → 0.1.3

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

package/test/runtime/LocalRepository.spec.ts

@@ -1,50 +0,0 @@
-
-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_9999', '/some/file');
-
-            expect(run).rejects.toEqual(new ClientNotFound('CLIENT_9999'));
-        });
-
-        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

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

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

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

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

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

@@ -1,21 +0,0 @@
-
-import RemoteBuilder from '../../../src/runtime/caching/RemoteBuilder';
-
-import
-    {
-        segmentModule,
-        codeResult
-    } from '../../_fixtures/runtime/caching/RemoteBuilder.fixture';
-
-describe('runtime/utils/RemoteBuilder', () =>
-{
-    describe('.build(module)', () =>
-    {
-        it('should create remote implementations for all exported functions', () =>
-        {
-            const result = RemoteBuilder.build(segmentModule);
-
-            expect(result).toBe(codeResult);
-        });
-    });
-});

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

@@ -1,31 +0,0 @@
-
-import SourceAppender from '../../../src/runtime/caching/SourceAppender';
-
-import
-{
-    applicationModule,
-    emptyModule,
-    filecode,
-    filename,
-    codeResult
-} from '../../_fixtures/runtime/caching/SourceAppender.fixture';
-
-describe('runtime/utils/SourceAppender', () =>
-{
-    describe('.append(module, code, filename)', () =>
-    {
-        it('should append a source properties to all exported classes', () =>
-        {
-            const result = SourceAppender.append(applicationModule, filecode, filename);
-
-            expect(result).toBe(codeResult);
-        });
-
-        it('should not append any source', () =>
-        {
-            const result = SourceAppender.append(emptyModule, filecode, filename);
-
-            expect(result).toBe(filecode);
-        });
-    });
-});