jitar 0.1.1 → 0.1.2

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

package/test/runtime/serialization/ValueSerializer.spec.ts

@@ -1,203 +0,0 @@
-
-import
-{
-    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
-} from '../../_fixtures/runtime/serialization/ValueSerializer.fixture';
-
-import ValueSerializer from '../../../src/runtime/serialization/ValueSerializer';
-import ClassNotFound from '../../../src/runtime/serialization/errors/ClassNotFound';
-import InvalidClass from '../../../src/runtime/serialization/errors/InvalidClass';
-
-describe('serialization/ValueSerializer', () =>
-{
-    describe('.serialize(value)', () =>
-    {
-        it('should serialize primitive values', () =>
-        {
-            const number = ValueSerializer.serialize(numberValue);
-            const bool = ValueSerializer.serialize(numberValue);
-            const string = ValueSerializer.serialize(stringValue);
-            const none = ValueSerializer.serialize(nullValue);
-            const notset = ValueSerializer.serialize(undefinedValue);
-
-            expect(number).toBe(numberValue);
-            expect(bool).toBe(numberValue);
-            expect(string).toBe(stringValue);
-            expect(none).toBe(nullValue);
-            expect(notset).toBe(undefinedValue);
-        });
-
-        it('should serialize arrays', () =>
-        {
-            const empty = ValueSerializer.serialize(emptyArray);
-            const mixed = ValueSerializer.serialize(mixedArray);
-            const nested = ValueSerializer.serialize(nestedArray);
-
-            expect(empty).toEqual(emptyArray);
-            expect(mixed).toEqual(mixedArray);
-            expect(nested).toEqual(nestedArray);
-        });
-
-        it('should serialize objects', () =>
-        {
-            const empty = ValueSerializer.serialize(emptyObject);
-            const mixed = ValueSerializer.serialize(mixedObject);
-            const nested = ValueSerializer.serialize(nestedObject);
-
-            expect(empty).toEqual(emptyObject);
-            expect(mixed).toEqual(mixedObject);
-            expect(nested).toEqual(nestedObject);
-        });
-
-        it('should serialize maps', () =>
-        {
-            const empty = ValueSerializer.serialize(emptyMap);
-            const mixed = ValueSerializer.serialize(mixedMap);
-            const nested = ValueSerializer.serialize(nestedMap);
-
-            expect(empty).toEqual(serializedEmptyMap);
-            expect(mixed).toEqual(serializedMixedMap);
-            expect(nested).toEqual(serializedNestedMap);
-        });
-
-        it('should serialize sets', () =>
-        {
-            const empty = ValueSerializer.serialize(emptySet);
-            const mixed = ValueSerializer.serialize(mixedSet);
-            const nested = ValueSerializer.serialize(nestedSet);
-
-            expect(empty).toEqual(serializedEmptySet);
-            expect(mixed).toEqual(serializedMixedSet);
-            expect(nested).toEqual(serializedNestedSet);
-        });
-
-        it('should serialize error', () =>
-        {
-            const error = ValueSerializer.serialize(errorClass) as unknown;
-
-            expect(error).toEqual(serializedError);
-        });
-
-        it('should serialize instances', () =>
-        {
-            const data = ValueSerializer.serialize(dataClass);
-            const constructed = ValueSerializer.serialize(constructedClass);
-            const nested = ValueSerializer.serialize(nestedClass);
-
-            expect(data).toEqual(serializedDataClass);
-            expect(constructed).toEqual(serializedConstructedClass);
-            expect(nested).toEqual(serializedNestedClass);
-
-        });
-
-        it('should not serialize set or get only variables', () =>
-        {
-            const clazz = ValueSerializer.serialize(privateClass);
-
-            expect(clazz).toEqual(serializedPrivateClass);
-
-        });
-    });
-
-    describe('.deserialize(value)', () =>
-    {
-        it('should deserialize primitive values', async () =>
-        {
-            const number = await ValueSerializer.deserialize(numberValue);
-            const bool = await ValueSerializer.deserialize(boolValue);
-            const string = await ValueSerializer.deserialize(undefinedValue);
-            const none = await ValueSerializer.deserialize(nullValue);
-            const notset = await ValueSerializer.deserialize(undefinedValue);
-
-            expect(number).toBe(numberValue);
-            expect(bool).toBe(boolValue);
-            expect(string).toBe(undefinedValue);
-            expect(none).toBe(nullValue);
-            expect(notset).toBe(undefinedValue);
-        });
-
-        it('should deserialize arrays', async () =>
-        {
-            const empty = await ValueSerializer.deserialize(emptyArray);
-            const mixed = await ValueSerializer.deserialize(mixedArray);
-            const nested = await ValueSerializer.deserialize(nestedArray);
-
-            expect(empty).toEqual(emptyArray);
-            expect(mixed).toEqual(mixedArray);
-            expect(nested).toEqual(nestedArray);
-        });
-
-        it('should deserialize plain objects', async () =>
-        {
-            const empty = await ValueSerializer.deserialize(emptyObject);
-            const mixed = await ValueSerializer.deserialize(mixedObject);
-            const nested = await ValueSerializer.deserialize(nestedObject);
-
-            expect(empty).toEqual(emptyObject);
-            expect(mixed).toEqual(mixedObject);
-            expect(nested).toEqual(nestedObject);
-        });
-
-        it('should deserialize maps', async () =>
-        {
-            const empty = await ValueSerializer.deserialize(serializedEmptyMap);
-            const mixed = await ValueSerializer.deserialize(serializedMixedMap);
-            const nested = await ValueSerializer.deserialize(serializedNestedMap);
-
-            expect(empty).toEqual(emptyMap);
-            expect(mixed).toEqual(mixedMap);
-            expect(nested).toEqual(nestedMap);
-        });
-
-        it('should deserialize sets', async () =>
-        {
-            const empty = await ValueSerializer.deserialize(serializedEmptySet);
-            const mixed = await ValueSerializer.deserialize(serializedMixedSet);
-            const nested = await ValueSerializer.deserialize(serializedNestedSet);
-
-            expect(empty).toEqual(emptySet);
-            expect(mixed).toEqual(mixedSet);
-            expect(nested).toEqual(nestedSet);
-        });
-
-        it('should deserialize error', async () =>
-        {
-            const empty = await ValueSerializer.deserialize(serializedError);
-
-            expect(empty).toEqual(errorClass);
-        });
-
-        it('should deserialize instances', async () =>
-        {
-            const data = await ValueSerializer.deserialize(serializedDataClass);
-            const constructed = await ValueSerializer.deserialize(serializedConstructedClass);
-            const nested = await ValueSerializer.deserialize(serializedNestedClass);
-
-            expect(data).toEqual(dataClass);
-            expect(constructed).toEqual(constructedClass);
-            expect(nested).toEqual(nestedClass);
-        });
-
-        it('should not deserialize invalid objects', async () =>
-        {
-            const deserialize = async () => await ValueSerializer.deserialize(serializedInvalidClass);
-
-            expect(deserialize).rejects.toEqual(new ClassNotFound('Invalid'));
-        });
-
-        it('should not deserialize non-function instances', async () =>
-        {
-            const deserialize = async () => await ValueSerializer.deserialize(serializedUnserializableClass);
-
-            expect(deserialize).rejects.toEqual(new InvalidClass('Infinity'));
-        });
-    });
-});

package/test/runtime/utils/ModuleAnalyser.spec.ts

@@ -1,54 +0,0 @@
-
-import ModuleAnalyser from '../../../src/runtime/utils/ModuleAnalyser';
-
-import {
-    theModule,
-    pojo,
-    realFunction,
-    realClass
-} from '../../_fixtures/runtime/utils/ModuleAnaliser.fixture';
-
-describe('runtime/utils/ModuleAnaliser', () =>
-{
-    describe('.filterObjects(module)', () =>
-    {
-        it('should filter all object types', () =>
-        {
-            const result = ModuleAnalyser.filterObjects(theModule);
-
-            expect(result.size).toBe(3);
-            expect(result.get('string')).toBe(undefined);
-            expect(result.get('pojo')).toBe(pojo);
-            expect(result.get('realFunction')).toBe(realFunction);
-            expect(result.get('realClass')).toBe(realClass);
-        });
-    });
-
-    describe('.filterFunctions(module)', () =>
-    {
-        it('should filter all actual functions', () =>
-        {
-            const result = ModuleAnalyser.filterFunctions(theModule);
-
-            expect(result.size).toBe(1);
-            expect(result.get('string')).toBe(undefined);
-            expect(result.get('pojo')).toBe(undefined);
-            expect(result.get('realFunction')).toBe(realFunction);
-            expect(result.get('realClass')).toBe(undefined);
-        });
-    });
-
-    describe('.filterClasses(module)', () =>
-    {
-        it('should filter all actual classes', () =>
-        {
-            const result = ModuleAnalyser.filterClasses(theModule);
-
-            expect(result.size).toBe(1);
-            expect(result.get('string')).toBe(undefined);
-            expect(result.get('pojo')).toBe(undefined);
-            expect(result.get('realFunction')).toBe(undefined);
-            expect(result.get('realClass')).toBe(realClass);
-        });
-    });
-});

package/test/runtime/utils/UrlRewriter.spec.ts

@@ -1,57 +0,0 @@
-
-import UrlRewriter from '../../../src/runtime/utils/UrlRewriter';
-
-describe('runtime/utils/UrlRewriter', () =>
-{
-    describe('.addBase(url, base)', () =>
-    {
-        it('should add the base to the url', () =>
-        {
-            const result = UrlRewriter.addBase('sub/my-file.ext', '/base/path/');
-
-            expect(result).toBe('/base/path/sub/my-file.ext');
-        });
-
-        it('should add the base to the url without a slash', () =>
-        {
-            const result = UrlRewriter.addBase('sub/my-file.ext', '/base/path');
-
-            expect(result).toBe('/base/path/sub/my-file.ext');
-        });
-
-        it('should add the base to the url with trailing base slash', () =>
-        {
-            const result = UrlRewriter.addBase('/sub/my-file.ext', '/base/path/');
-
-            expect(result).toBe('/base/path/sub/my-file.ext');
-        });
-
-        it('should remove last path part from the base', () =>
-        {
-            const result = UrlRewriter.addBase('../sub/my-file.ext', '/base/path/');
-
-            expect(result).toBe('/base/sub/my-file.ext');
-        });
-
-        it('should remove last path parts from the base', () =>
-        {
-            const result = UrlRewriter.addBase('../../../sub/my-file.ext', '/base/path/to/folder');
-
-            expect(result).toBe('/base/sub/my-file.ext');
-        });
-
-        it('should remove all parts from the base', () =>
-        {
-            const result = UrlRewriter.addBase('../../../sub/my-file.ext', '/base/path/');
-
-            expect(result).toBe('sub/my-file.ext');
-        });
-
-        it('should add the base to the url', () =>
-        {
-            const result = UrlRewriter.addBase('./sub/my-file.ext', '/base/path/');
-
-            expect(result).toBe('/base/path/sub/my-file.ext');
-        });
-    });
-});

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2022",
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "module": "es2022",
-    "rootDir": "./src/",
-    "moduleResolution": "node",
-    "declaration": true,
-    "outDir": "./dist",
-    "removeComments": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "skipLibCheck": true
-  },
-  "exclude": [
-    "node_modules",
-    "test",
-    "dist",
-    "examples"
-  ]
-}