@adaas/a-concept 0.0.64 → 0.1.1

package/tests/A-Command.test.ts

@@ -1,133 +0,0 @@
-import './test.setup';
-
-import { A_CONSTANTS__A_Command_Status, A_CONSTANTS_A_Command_Features } from "@adaas/a-concept/global/A-Command/A-Command.constants";
-import { A_Command } from "@adaas/a-concept/global/A-Command/A-Command.class";
-import { A_CommandContext } from "@adaas/a-concept/global/A-Command/context/A_Command.context";
-import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
-import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
-import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
-import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
-import { A_Error } from "@adaas/a-utils";
-import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
-
-jest.retryTimes(0);
-
-describe('A-Command tests', () => {
-
-    it('Should Allow to create a command', async () => {
-        const command = new A_Command({});
-        expect(command).toBeInstanceOf(A_Command);
-        expect(command.Code).toBe('a-command');
-        expect(command.id).toBeDefined();
-        expect(command.aseid).toBeDefined();
-        expect(command.Status).toBe(A_CONSTANTS__A_Command_Status.INITIALIZED);
-        expect(command.Scope).toBeInstanceOf(A_Scope);
-        expect(command.Scope.resolve(A_CommandContext)).toBeInstanceOf(A_CommandContext);
-    });
-    it('Should allow to execute a command', async () => {
-        const command = new A_Command({});
-
-        await command.execute();
-
-        expect(command.Status).toBe(A_CONSTANTS__A_Command_Status.COMPLETED);
-        expect(command.StartedAt).toBeInstanceOf(Date);
-        expect(command.EndedAt).toBeInstanceOf(Date);
-    });
-    it('Should allow to serialize and deserialize a command', async () => {
-        const command = new A_Command({});
-
-        await command.execute();
-
-        const serialized = command.toJSON();
-        expect(serialized).toBeDefined();
-        expect(serialized.aseid).toBe(command.aseid.toString());
-        expect(serialized.code).toBe(command.Code);
-        expect(serialized.status).toBe(command.Status);
-        expect(serialized.startedAt).toBe(command.StartedAt?.toISOString());
-        expect(serialized.duration).toBe(command.Duration);
-
-
-        const deserializedCommand = new A_Command(serialized);
-        expect(deserializedCommand).toBeInstanceOf(A_Command);
-        expect(deserializedCommand.aseid.toString()).toBe(command.aseid.toString());
-        expect(deserializedCommand.Code).toBe(command.Code);
-        expect(deserializedCommand.Status).toBe(command.Status);
-        expect(deserializedCommand.StartedAt?.toISOString()).toBe(command.StartedAt?.toISOString());
-        expect(deserializedCommand.Duration).toBe(command.Duration);
-    });
-    it('Should allow to execute a command with custom logic', async () => {
-
-        // 1) create a scope 
-        A_Context.reset();
-
-        // 2) create a new command 
-        type resultType = { bar: string };
-        type invokeType = { foo: string };
-        class MyCommand extends A_Command<invokeType, resultType> { }
-
-        A_Context.root.register(MyCommand);
-
-        // 3) create a custom component with custom logic
-        class MyComponent extends A_Component {
-
-            @A_Feature.Extend({ scope: [MyCommand] })
-            async [A_CONSTANTS_A_Command_Features.EXECUTE](
-                @A_Inject(A_CommandContext) context: A_CommandContext<resultType>
-            ) {
-                context.save('bar', 'baz');
-            }
-        }
-
-        // 4) register component in the scope
-        A_Context.root.register(MyComponent);
-
-        // 5) create a new command instance within the scope
-        const command = new MyCommand({ foo: 'bar' });
-
-        // 6) execute the command
-        await command.execute();
-
-        // 7) verify that command was executed with custom logic from MyComponent
-        expect(command.Status).toBe(A_CONSTANTS__A_Command_Status.COMPLETED);
-        expect(command.Result).toBeDefined();
-        expect(command.Result).toEqual({ bar: 'baz' });
-    })
-    it('Should allow to fail a command with custom logic', async () => {
-        // 1) reset context to have a clean scope
-        A_Context.reset();
-
-        // 2) create a new command 
-        type resultType = { bar: string };
-        type invokeType = { foo: string };
-        class MyCommand extends A_Command<invokeType, resultType> { }
-
-        A_Context.root.register(MyCommand);
-
-        // 3) create a custom component with custom logic
-        class MyComponent extends A_Component {
-
-            @A_Feature.Extend({ scope: [MyCommand] })
-            async [A_CONSTANTS_A_Command_Features.EXECUTE](
-                @A_Inject(A_CommandContext) context: A_CommandContext<resultType>
-            ) {
-                context.error(new A_Error({ message: 'Test error' }));
-                //  it's optional to throw an error here, as the command may contain multiple errors that also can be a result of async operations
-                throw new A_Error({ message: 'Test error thrown' });
-            }
-        }
-
-        // 4) register component in the scope
-        A_Context.root.register(MyComponent);
-        // 5) create a new command instance within the scope
-        const command = new MyCommand({ foo: 'bar' });
-
-        // 6) execute the command
-        await command.execute();
-
-        // 7) verify that command was executed with custom logic from MyComponent
-        expect(command.Status).toBe(A_CONSTANTS__A_Command_Status.FAILED);
-        expect(command.Errors).toBeDefined();
-        expect(command.Errors?.size).toBe(1);
-        expect(Array.from(command.Errors?.values() || [])[0].message).toBe('Test error');
-    });
-});

package/tests/A-Config.test.ts

@@ -1,172 +0,0 @@
-import './test.setup';
-
-import { A_ConfigLoader } from "@adaas/a-concept/base/A-Config/A-Config.container";
-import { A_Config } from "@adaas/a-concept/base/A-Config/A-Config.context";
-import { ENVConfigReader } from "@adaas/a-concept/base/A-Config/components/ENVConfigReader.component";
-import { FileConfigReader } from "@adaas/a-concept/base/A-Config/components/FileConfigReader.component";
-import { A_CONSTANTS__DEFAULT_ENV_VARIABLES } from "@adaas/a-concept/constants/env.constants";
-import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
-import fs from 'fs';
-
-jest.retryTimes(0);
-
-describe('A-Config tests', () => {
-    it('Should Allow to create a config object', async () => {
-        const config = new A_Config({
-            variables: [],
-            defaults: {}
-        });
-    });
-    it('Should Allow to create a config object with default values', async () => {
-        const config = new A_Config({
-            variables: ['TEST_VAR1', 'TEST_VAR2'] as const,
-            defaults: {
-                TEST_VAR1: 'default1',
-            }
-        });
-
-        expect(config.get('TEST_VAR1')).toBe('default1');
-        expect(config.get('TEST_VAR2')).toBeUndefined();
-    });
-    it('Should Allow to create a config object with ENV values', async () => {
-        process.env['TEST_VAR1'] = 'env1';
-        process.env['TEST_VAR2'] = 'env2';
-
-        const config = new A_Config({
-            variables: ['TEST_VAR1', 'TEST_VAR2'] as const,
-            defaults: {
-                TEST_VAR1: 'default1',
-            }
-        });
-
-        const configLoader = new A_ConfigLoader({
-            name: 'test-config-loader',
-            fragments: [config],
-            components: [ENVConfigReader]
-        })
-
-        await configLoader.prepare(config as any);
-        await configLoader.readVariables(config as any);
-
-
-
-        expect(config.get('TEST_VAR1')).toBe('env1');
-        expect(config.get('TEST_VAR2')).toBe('env2');
-
-        delete process.env['TEST_VAR1'];
-        delete process.env['TEST_VAR2'];
-    });
-    it('Should not Change Names of default env variables', async () => {
-        process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAMESPACE] = 'my-project';
-        process.env['TEST_VAR2'] = 'env2';
-
-        A_Context.reset();
-
-
-        const config = new A_Config({
-            variables: ['TEST_VAR1', 'TEST_VAR2'] as const,
-            defaults: {
-                TEST_VAR1: 'default1',
-            }
-        });
-
-        const configLoader = new A_ConfigLoader({
-            name: 'test-config-loader',
-            fragments: [config],
-            components: [ENVConfigReader]
-        })
-
-
-        await configLoader.prepare(config as any);
-        await configLoader.readVariables(config as any);
-
-
-        expect(config.get('TEST_VAR1')).toBe('default1');
-        expect(config.get('TEST_VAR2')).toBe('env2');
-        expect(config.get('A_CONCEPT_NAMESPACE')).toBe('my-project');
-
-        delete process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAMESPACE];
-        delete process.env['TEST_VAR2'];
-
-        // then reset context root
-        A_Context.reset();
-
-    });
-    it('Should Throw an error if strict is true and variable is not defined', async () => {
-        expect(() => {
-            const config = new A_Config({
-                strict: true,
-                variables: ['TEST_VAR1', 'TEST_VAR2'] as const,
-                defaults: {
-                    TEST_VAR1: 'default1',
-                }
-            });
-
-            config.get('TEST_VAR3' as any);
-
-        }).toThrowError();
-    });
-    it('Should Allow to create a config object with variables from File', async () => {
-
-        // 1. create a config file
-        fs.writeFileSync('a-concept.conf.json', JSON.stringify({
-            testVar1: 'env1',
-            testVar2: 'env2'
-        }, null, 4));
-
-        const config = new A_Config({
-            variables: ['TEST_VAR1', 'TEST_VAR2'] as const,
-            defaults: {
-                TEST_VAR1: 'default1',
-            }
-        });
-
-        const configLoader = new A_ConfigLoader({
-            name: 'test-config-loader',
-            fragments: [config],
-            components: [FileConfigReader]
-        })
-
-        await configLoader.prepare(config as any);
-        await configLoader.readVariables(config as any);
-
-
-
-        expect(config.get('TEST_VAR1')).toBe('env1');
-        expect(config.get('TEST_VAR1')).toBe('env1');
-
-        // 3. delete the config file
-        fs.unlinkSync('a-concept.conf.json');
-    });
-      it('Should Allow to create a config object with variables from File with different variable cases', async () => {
-
-        // 1. create a config file
-        fs.writeFileSync('a-concept.conf.json', JSON.stringify({
-            testVar2: 'env2'
-        }, null, 4));
-
-        const config = new A_Config({
-            variables: ['testVar1', 'testVar2'] as const,
-            defaults: {
-                testVar1: 'default1',
-            }
-        });
-
-        const configLoader = new A_ConfigLoader({
-            name: 'test-config-loader',
-            fragments: [config],
-            components: [FileConfigReader]
-        })
-
-        await configLoader.prepare(config as any);
-        await configLoader.readVariables(config as any);
-
-
-
-        expect(config.get('testVar1')).toBe('default1');
-        expect(config.get('testVar2')).toBe('env2');
-
-        // 3. delete the config file
-        fs.unlinkSync('a-concept.conf.json');
-    });
-});