@adaas/a-concept 0.1.31 → 0.1.32

package/tests/A-Abstraction.test.ts

@@ -1,204 +1,201 @@
 import { A_Component } from '@adaas/a-concept/global/A-Component/A-Component.class';
-import './test.setup'
 import { A_Concept } from '@adaas/a-concept/global/A-Concept/A-Concept.class';
 import { A_Container } from '@adaas/a-concept/global/A-Container/A-Container.class';
 import { A_Context } from '@adaas/a-concept/global/A-Context/A-Context.class';
-import { A_Scope } from '@adaas/a-concept/global/A-Scope/A-Scope.class';
-import { A_TYPES__ConceptAbstractions } from '@adaas/a-concept/global/A-Concept/A-Concept.constants';
 import { A_Inject } from '@adaas/a-concept/global/A-Inject/A-Inject.decorator';
 import { A_Feature } from '@adaas/a-concept/global/A-Feature/A-Feature.class';
 
 jest.retryTimes(0);
 
 describe('A-Abstraction Tests', () => {
-    // it('It should be possible to extend abstraction on A-Component level', async () => {
-    //     class MyComponent extends A_Component {
-    //         private _test: number = 0
-
-    //         @A_Concept.Load()
-    //         myMethod() {
-    //             this._test++;
-    //         }
-    //     }
-    // });
-
-    // it('It should be possible to extend abstraction on A-Container level', async () => {
-    //     class MyContainer extends A_Container {
-    //         private _test: number = 0
-
-    //         @A_Concept.Load()
-    //         myMethod() {
-    //             this._test++;
-    //         }
-    //     }
-    // });
-
-
-    // it('It should be possible to proceed Concept Abstraction', async () => {
-    //     class MyComponent extends A_Component {
-    //         _test2: number = 0
-
-    //         @A_Concept.Load()
-    //         myMethod() {
-    //             this._test2++;
-    //         }
-    //     }
-
-    //     class MyContainer extends A_Container {
-    //         _test: number = 0
-
-    //         @A_Concept.Load()
-    //         myMethod() {
-    //             this._test++;
-    //         }
-    //     }
-
-    //     const myContainer = new MyContainer({
-    //         name: 'MyContainer',
-    //         components: [MyComponent]
-    //     });
-
-    //     const testConcept = new A_Concept({
-    //         name: 'TestConcept',
-    //         containers: [myContainer]
-    //     });
-
-    //     await testConcept.load();
-
-
-    //     const resolvedComponent = myContainer.scope.resolve(MyComponent);
-
-    //     expect(resolvedComponent).toBeInstanceOf(MyComponent);
-    //     expect(myContainer._test).toBe(1);
-    //     expect(resolvedComponent._test2).toBe(1);
-
-    // });
-    // it('Should allow to extend abstraction with multiple containers', async () => {
-    //     A_Context.reset();
-
-    //     class MyContainerA extends A_Container {
-    //         _test: number = 0
-
-    //         @A_Concept.Load()
-    //         myMethod() {
-    //             this._test++;
-    //         }
-    //     }
-    //     class MyContainerB extends A_Container {
-    //         _test: number = 0
-
-    //         @A_Concept.Load()
-    //         myMethod() {
-    //             this._test++;
-    //         }
-    //     }
-
-    //     const containerA = new MyContainerA({ name: 'ContainerA' });
-    //     const containerB = new MyContainerB({ name: 'ContainerB' });
-
-    //     const concept = new A_Concept({
-    //         name: 'TestConcept',
-    //         containers: [
-    //             containerA,
-    //             containerB
-    //         ]
-    //     });
-
-    //     await concept.load();
-
-    //     expect(containerA.scope.resolve(MyContainerA)).toBeInstanceOf(MyContainerA);
-    //     expect(containerB.scope.resolve(MyContainerB)).toBeInstanceOf(MyContainerB);
-
-    //     expect(containerA._test).toBe(1);
-    //     expect(containerB._test).toBe(1);
-
-    // })
-    // it('Should allow to define an async abstraction extension', async () => {
-    //     A_Context.reset();
-
-    //     class MyContainerA extends A_Container {
-    //         _test: number = 0
-
-    //         @A_Concept.Load()
-    //         async myMethod() {
-    //             this._test = 5;
-    //         }
-    //     }
-    //     class MyContainerB extends A_Container {
-    //         _test: number = 0
-
-    //         @A_Concept.Load()
-    //         myMethod() {
-    //             this._test++;
-    //         }
-    //     }
+    it('It should be possible to extend abstraction on A-Component level', async () => {
+        class MyComponent extends A_Component {
+            private _test: number = 0
 
+            @A_Concept.Load()
+            myMethod() {
+                this._test++;
+            }
+        }
+    });
+
+    it('It should be possible to extend abstraction on A-Container level', async () => {
+        class MyContainer extends A_Container {
+            private _test: number = 0
+
+            @A_Concept.Load()
+            myMethod() {
+                this._test++;
+            }
+        }
+    });
+
+
+    it('It should be possible to proceed Concept Abstraction', async () => {
+        class MyComponent extends A_Component {
+            _test2: number = 0
+
+            @A_Concept.Load()
+            myMethod() {
+                this._test2++;
+            }
+        }
+
+        class MyContainer extends A_Container {
+            _test: number = 0
+
+            @A_Concept.Load()
+            myMethod() {
+                this._test++;
+            }
+        }
+
+        const myContainer = new MyContainer({
+            name: 'MyContainer',
+            components: [MyComponent]
+        });
+
+        const testConcept = new A_Concept({
+            name: 'TestConcept',
+            containers: [myContainer]
+        });
+
+        await testConcept.load();
+
+
+        const resolvedComponent = myContainer.scope.resolve(MyComponent)!;
+
+        expect(resolvedComponent).toBeInstanceOf(MyComponent);
+        expect(myContainer._test).toBe(1);
+        expect(resolvedComponent._test2).toBe(1);
+
+    });
+    it('Should allow to extend abstraction with multiple containers', async () => {
+        A_Context.reset();
+
+        class MyContainerA extends A_Container {
+            _test: number = 0
+
+            @A_Concept.Load()
+            myMethod() {
+                this._test++;
+            }
+        }
+        class MyContainerB extends A_Container {
+            _test: number = 0
+
+            @A_Concept.Load()
+            myMethod() {
+                this._test++;
+            }
+        }
+
+        const containerA = new MyContainerA({ name: 'ContainerA' });
+        const containerB = new MyContainerB({ name: 'ContainerB' });
+
+        const concept = new A_Concept({
+            name: 'TestConcept',
+            containers: [
+                containerA,
+                containerB
+            ]
+        });
+
+        await concept.load();
+
+        expect(containerA.scope.resolve(MyContainerA)).toBeInstanceOf(MyContainerA);
+        expect(containerB.scope.resolve(MyContainerB)).toBeInstanceOf(MyContainerB);
+
+        expect(containerA._test).toBe(1);
+        expect(containerB._test).toBe(1);
+
+    })
+    it('Should allow to define an async abstraction extension', async () => {
+        A_Context.reset();
+
+        class MyContainerA extends A_Container {
+            _test: number = 0
+
+            @A_Concept.Load()
+            async myMethod() {
+                this._test = 5;
+            }
+        }
+        class MyContainerB extends A_Container {
+            _test: number = 0
+
+            @A_Concept.Load()
+            myMethod() {
+                this._test++;
+            }
+        }
+
+
+        const containerA = new MyContainerA({ name: 'ContainerA' });
+        const containerB = new MyContainerB({ name: 'ContainerB' });
+
+        const concept = new A_Concept({
+            name: 'TestConcept',
+            containers: [
+                containerA,
+                containerB
+            ]
+        });
+
+        await concept.load();
+
+        expect(containerA.scope.resolve(MyContainerA)).toBeInstanceOf(MyContainerA);
+        expect(containerB.scope.resolve(MyContainerB)).toBeInstanceOf(MyContainerB);
+
+        expect(containerA._test).toBe(5);
+        expect(containerB._test).toBe(1);
+    })
+    it('Should execute abstraction in a proper order', async () => {
+        A_Context.reset();
+
+        const order: string[] = [];
+
+        class MyContainerA extends A_Container {
+
+            @A_Concept.Load()
+            async step1() {
+                order.push('step1');
+            }
+
+            @A_Concept.Load()
+            async step2() {
+                order.push('step2');
+            }
+        }
+        class MyContainerB extends A_Container {
+
+            @A_Concept.Load()
+            async step3() {
+                order.push('step3');
+            }
+
+            @A_Concept.Load()
+            async step4() {
+                order.push('step4');
+            }
+        }
 
-    //     const containerA = new MyContainerA({ name: 'ContainerA' });
-    //     const containerB = new MyContainerB({ name: 'ContainerB' });
-
-    //     const concept = new A_Concept({
-    //         name: 'TestConcept',
-    //         containers: [
-    //             containerA,
-    //             containerB
-    //         ]
-    //     });
-
-    //     await concept.load();
-
-    //     expect(containerA.scope.resolve(MyContainerA)).toBeInstanceOf(MyContainerA);
-    //     expect(containerB.scope.resolve(MyContainerB)).toBeInstanceOf(MyContainerB);
-
-    //     expect(containerA._test).toBe(5);
-    //     expect(containerB._test).toBe(1);
-    // })
-    // it('Should execute abstraction in a proper order', async () => {
-    //     A_Context.reset();
-
-    //     const order: string[] = [];
-
-    //     class MyContainerA extends A_Container {
-
-    //         @A_Concept.Load()
-    //         async step1() {
-    //             order.push('step1');
-    //         }
 
-    //         @A_Concept.Load()
-    //         async step2() {
-    //             order.push('step2');
-    //         }
-    //     }
-    //     class MyContainerB extends A_Container {
-
-    //         @A_Concept.Load()
-    //         async step3() {
-    //             order.push('step3');
-    //         }
-
-    //         @A_Concept.Load()
-    //         async step4() {
-    //             order.push('step4');
-    //         }
-    //     }
-
-
-    //     const containerA = new MyContainerA({ name: 'ContainerA' });
-    //     const containerB = new MyContainerB({ name: 'ContainerB' });
-
-    //     const concept = new A_Concept({
-    //         name: 'TestConcept',
-    //         containers: [
-    //             containerA,
-    //             containerB
-    //         ]
-    //     });
-
-    //     await concept.load();
-
-    //     expect(order).toEqual(['step1', 'step2', 'step3', 'step4']);
-    // })
+        const containerA = new MyContainerA({ name: 'ContainerA' });
+        const containerB = new MyContainerB({ name: 'ContainerB' });
+
+        const concept = new A_Concept({
+            name: 'TestConcept',
+            containers: [
+                containerA,
+                containerB
+            ]
+        });
+
+        await concept.load();
+
+        expect(order).toEqual(['step1', 'step2', 'step3', 'step4']);
+    })
     it('Should execute abstraction in order with dependencies', async () => {
         A_Context.reset();
 
@@ -274,69 +271,69 @@ describe('A-Abstraction Tests', () => {
 
         expect(order).toEqual(['step1', 'step3', 'step2', 'step5', 'step4']);
     })
-    // it('Should inherit abstraction extensions', async () => {
-    //     const executionOrder: string[] = [];
-
-    //     // 1) create a base component with some abstraction
-    //     class My_Component extends A_Component {
-
-    //         @A_Concept.Load()
-    //         async feature1() {
-    //             executionOrder.push('stepOne');
-    //         }
-    //     }
-
-
-    //     class My_Child_Component extends My_Component { }
-
-    //     const concept = new A_Concept({
-    //         name: 'TestConcept',
-    //         containers: [
-    //             new A_Container({
-    //                 name: 'TestContainer',
-    //                 components: [My_Child_Component],
-    //             })
-    //         ]
-    //     });
-
-    //     await concept.load();
-
-    //     expect(executionOrder).toEqual(['stepOne']);
-    // });
-    // it('Should allow to override abstraction extensions', async () => {
-    //     const executionOrder: string[] = [];
-
-    //     // 1) create a base component with some abstraction
-    //     class My_Component extends A_Component {
-
-    //         @A_Concept.Load()
-    //         async feature1() {
-    //             executionOrder.push('stepOne');
-    //         }
-    //     }
-
-
-    //     class My_Child_Component extends My_Component {
-    //         @A_Concept.Load()
-    //         async feature1() {
-    //             // do nothing
-    //             executionOrder.push('stepTwo');
-
-    //         }
-    //     }
-
-    //     const concept = new A_Concept({
-    //         name: 'TestConcept',
-    //         containers: [
-    //             new A_Container({
-    //                 name: 'TestContainer',
-    //                 components: [My_Child_Component],
-    //             })
-    //         ]
-    //     });
-
-    //     await concept.load();
-
-    //     expect(executionOrder).toEqual(['stepTwo']);
-    // });
+    it('Should inherit abstraction extensions', async () => {
+        const executionOrder: string[] = [];
+
+        // 1) create a base component with some abstraction
+        class My_Component extends A_Component {
+
+            @A_Concept.Load()
+            async feature1() {
+                executionOrder.push('stepOne');
+            }
+        }
+
+
+        class My_Child_Component extends My_Component { }
+
+        const concept = new A_Concept({
+            name: 'TestConcept',
+            containers: [
+                new A_Container({
+                    name: 'TestContainer',
+                    components: [My_Child_Component],
+                })
+            ]
+        });
+
+        await concept.load();
+
+        expect(executionOrder).toEqual(['stepOne']);
+    });
+    it('Should allow to override abstraction extensions', async () => {
+        const executionOrder: string[] = [];
+
+        // 1) create a base component with some abstraction
+        class My_Component extends A_Component {
+
+            @A_Concept.Load()
+            async feature1() {
+                executionOrder.push('stepOne');
+            }
+        }
+
+
+        class My_Child_Component extends My_Component {
+            @A_Concept.Load()
+            async feature1() {
+                // do nothing
+                executionOrder.push('stepTwo');
+
+            }
+        }
+
+        const concept = new A_Concept({
+            name: 'TestConcept',
+            containers: [
+                new A_Container({
+                    name: 'TestContainer',
+                    components: [My_Child_Component],
+                })
+            ]
+        });
+
+        await concept.load();
+
+        expect(executionOrder).toEqual(['stepTwo']);
+    });
 });

package/tests/A-Common.test.ts

@@ -1,4 +1,3 @@
-import './test.setup'
 import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
 import { A_IdentityHelper } from "@adaas/a-concept/helpers/A_Identity.helper";
 import { A_TYPES__DeepPartial } from "@adaas/a-concept/types/A_Common.types";

package/tests/A-Component.test.ts

@@ -1,6 +1,4 @@
 import { A_Inject } from '@adaas/a-concept/global/A-Inject/A-Inject.decorator';
-import './test.setup';
-
 import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
 import { A_Context } from '@adaas/a-concept/global/A-Context/A-Context.class';
 import { A_Concept } from '@adaas/a-concept/global/A-Concept/A-Concept.class';

package/tests/A-Concept.test.ts

@@ -1,11 +1,9 @@
 import { A_Caller } from '@adaas/a-concept/global/A-Caller/A_Caller.class';
-import './test.setup';
 import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
 import { A_Concept } from "@adaas/a-concept/global/A-Concept/A-Concept.class";
 import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
 import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
 import { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class";
-import { A_TYPES__Entity_Init, A_TYPES__Entity_Serialized } from '@adaas/a-concept/global/A-Entity/A-Entity.types';
 import { A_Fragment } from "@adaas/a-concept/global/A-Fragment/A-Fragment.class";
 import { A_Inject } from '@adaas/a-concept/global/A-Inject/A-Inject.decorator';
 import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";

package/tests/A-Container.test.ts

@@ -1,5 +1,4 @@
 import { A_Container } from '@adaas/a-concept/global/A-Container/A-Container.class';
-import './test.setup';
 import { A_Scope } from '@adaas/a-concept/global/A-Scope/A-Scope.class';
 
 

package/tests/A-Entity.test.ts

@@ -1,5 +1,3 @@
-import './test.setup';
-
 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 { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class";

package/tests/A-Feature.test.ts

@@ -1,5 +1,3 @@
-import './test.setup';
-
 import { A_Inject } from "@adaas/a-concept/global/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";

package/tests/A-Inject.test.ts

@@ -0,0 +1,53 @@
+import { A_Component, A_Error, A_Inject, A_Scope } from "../src";
+
+jest.retryTimes(0);
+
+describe('A-Inject tests', () => {
+
+    it('Should to Inject Error into constructor', async () => {
+
+        class testComponent extends A_Component {
+
+            constructor(
+                @A_Inject(A_Error) public error: A_Error
+            ) {
+                super();
+            }
+
+        }
+
+        const scope = new A_Scope({ name: 'TestScope', components: [testComponent] });
+
+        scope.register(new A_Error('Test Error'));
+
+        const resolvedComponent = scope.resolve(testComponent)!;
+
+        expect(resolvedComponent).toBeInstanceOf(testComponent);
+        expect(resolvedComponent.error).toBeInstanceOf(A_Error);
+        expect(resolvedComponent.error.message).toBe('Test Error');
+    });
+
+
+    it('Should to Inject another component into constructor', async () => {
+
+        class componentA extends A_Component {
+        }
+
+        class componentB extends A_Component {
+
+            constructor(
+                @A_Inject(componentA) public component: componentA
+            ) {
+                super();
+            }
+
+        }
+
+        const scope = new A_Scope({ name: 'TestScope', components: [componentA, componentB] });
+
+        const resolvedComponent = scope.resolve(componentB)!;
+
+        expect(resolvedComponent).toBeInstanceOf(componentB);
+        expect(resolvedComponent.component).toBeInstanceOf(componentA);
+    });
+})

package/tests/A-Scope.test.ts

@@ -1,6 +1,3 @@
-import './test.setup';
-
-import { A_Command } from "@adaas/a-concept/base/A-Command/A-Command.entity";
 import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
 import { A_Concept } from '@adaas/a-concept/global/A-Concept/A-Concept.class';
 import { A_Container } from '@adaas/a-concept/global/A-Container/A-Container.class';
@@ -10,6 +7,7 @@ import { A_Feature } from '@adaas/a-concept/global/A-Feature/A-Feature.class';
 import { A_Fragment } from '@adaas/a-concept/global/A-Fragment/A-Fragment.class';
 import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
 import { ASEID } from '@adaas/a-concept/global/ASEID/ASEID.class';
+import { A_Error } from '../src';
 
 jest.retryTimes(0);
 
@@ -326,4 +324,17 @@ describe('A-Scope tests', () => {
         expect(container.scope.issuer()).toBe(container);
     });
 
+    it('Should be able to resolve Error in scope', async () => {
+
+        const container = new A_Container();
+
+        container.scope.register(new A_Error('Test Error'));
+
+        const resolved = container.scope.resolve(A_Error);
+        expect(resolved).toBeInstanceOf(A_Error);
+        expect(resolved?.message).toBe('Test Error');
+
+        expect(container.scope.issuer()).toBe(container);
+    });
+
 });

package/tests/ASEID.test.ts

@@ -1,4 +1,3 @@
-import './test.setup';
 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 { ASEID } from "@adaas/a-concept/global/ASEID/ASEID.class";