@adaas/a-concept 0.1.41 → 0.1.43

package/tests/A-Feature.test.ts

@@ -10,414 +10,414 @@ import { A_TYPES__FeatureState } from "../src";
 jest.retryTimes(0);
 
 describe('A-Feature tests', () => {
-    // it('Should Allow to create a feature from component', async () => {
-    //     const testComponent = new A_Component()
-    //     A_Context.root.register(testComponent);
-
-    //     const feature = new A_Feature({
-    //         name: 'testFeature',
-    //         component: testComponent,
-    //     });
-
-    //     expect(feature).toBeInstanceOf(A_Feature);
-    //     expect(feature.scope.parent).toBe(A_Context.root);
-
-    // });
-    // it('Should Allow to create a feature with steps', async () => {
-    //     const template = [
-    //         {
-    //             name: 'A_Component.testHandler',
-    //             component: A_Component,
-    //             handler: 'testHandler',
-    //         }
-    //     ]
-
-    //     const feature = new A_Feature({
-    //         name: 'testFeature',
-    //         scope: new A_Scope(),
-    //         template
-    //     });
-
-    //     expect(feature).toBeInstanceOf(A_Feature);
-    // });
-    // it('Should be possible to execute a feature with steps as a template on the component', async () => {
-    //     // 1) create a base component with some feature
-    //     class MyExtendedComponent extends A_Component {
-
-    //         async testHandler(
-    //             @A_Inject(A_Caller) caller: MyComponent
-    //         ) {
-    //             caller.sum = 2;
-    //         }
-    //     }
-
-    //     // 2) create a custom component with a defined template feature
-    //     class MyComponent extends A_Component {
-    //         sum: number = 0;
-
-    //         @A_Feature.Define({
-    //             invoke: true,
-    //             template: [{
-    //                 name: 'MyExtendedComponent.testHandler',
-    //                 component: MyExtendedComponent,
-    //                 handler: 'testHandler',
-    //                 behavior: 'sync',
-    //                 before: '',
-    //                 after: ''
-    //             },
-    //             {
-    //                 name: 'MyExtendedComponent.testHandler',
-    //                 component: MyExtendedComponent,
-    //                 handler: 'testHandler'
-    //             }]
-    //         })
-    //         async testHandler() { }
-    //     }
-
-
-    //     // 3) create a running scope 
-    //     const scope = new A_Scope({ name: 'TestScope' });
-    //     scope.register(MyExtendedComponent);
-    //     scope.register(MyComponent);
-
-    //     // 4) create an instance of the component from the scope
-    //     const myComponent = scope.resolve(MyComponent)!;
-    //     expect(myComponent).toBeInstanceOf(MyComponent);
-    //     expect(myComponent.sum).toBe(0);
-
-    //     // 5) call the feature caller to execute the feature
-    //     await myComponent.testHandler();
-
-    //     // 6) check the results
-    //     expect(myComponent.sum).toBe(2);
-
-    // });
-    // it('Should be possible to execute a feature with steps as a template on the component with string component declaration', async () => {
-    //     // 1) create a base component with some feature
-    //     class MyExtendedComponent2 extends A_Component {
-
-    //         async testHandler(
-    //             @A_Inject(A_Caller) caller: MyComponent2
-    //         ) {
-    //             caller.sum = 2;
-    //         }
-    //     }
-
-    //     // 2) create a custom component with a defined template feature
-    //     class MyComponent2 extends A_Component {
-    //         sum: number = 0;
-
-    //         @A_Feature.Define({
-    //             invoke: true,
-    //             template: [{
-    //                 name: 'MyExtendedComponent2.testHandler',
-    //                 component: 'MyExtendedComponent2',
-    //                 handler: 'testHandler',
-    //                 behavior: 'sync',
-    //                 before: '',
-    //                 after: ''
-    //             }]
-    //         })
-    //         async testHandler() { }
-    //     }
-
-
-    //     // 3) create a running scope 
-    //     const scope = new A_Scope({ name: 'TestScope' });
-    //     scope.register(MyExtendedComponent2);
-    //     scope.register(MyComponent2);
-
-    //     // 4) create an instance of the component from the scope
-    //     const myComponent = scope.resolve(MyComponent2)!;
-    //     expect(myComponent).toBeInstanceOf(MyComponent2);
-    //     expect(myComponent.sum).toBe(0);
-
-    //     // 5) call the feature caller to execute the feature
-    //     await myComponent.testHandler();
-
-    //     // 6) check the results
-    //     expect(myComponent.sum).toBe(2);
-
-    // });
-    // it('Should execute feature steps in base order', async () => {
-    //     const executionOrder: string[] = [];
-
-    //     // 1) create a base component with some feature
-    //     class My_Component extends A_Component {
-    //         async methodA() {
-    //             await this.call('myFeature')
-    //         }
-
-    //         @A_Feature.Extend({
-    //             name: 'myFeature',
-    //         })
-    //         async stepOne(
-    //         ) {
-    //             executionOrder.push('stepOne');
-    //         }
-
-    //         @A_Feature.Extend({
-    //             name: 'myFeature',
-    //         })
-    //         async stepTwo(
-    //         ) {
-    //             executionOrder.push('stepTwo');
-    //         }
-
-    //         @A_Feature.Extend({
-    //             name: 'myFeature',
-    //         })
-    //         async stepThree(
-    //         ) {
-    //             executionOrder.push('stepThree');
-    //         }
-    //     }
-
-
-    //     // 2) create a running scope 
-    //     const scope = new A_Scope({ name: 'TestScope', components: [My_Component] });
-
-    //     // 3) create an instance of the component from the scope
-    //     const myComponent = scope.resolve(My_Component)!;
-    //     expect(myComponent).toBeInstanceOf(My_Component);
-
-    //     // 4) call the feature caller to execute the feature
-    //     await myComponent.methodA();
-
-    //     // 5) check the results
-    //     expect(executionOrder).toEqual(['stepOne', 'stepTwo', 'stepThree']);
-    // });
-    // it('Should execute feature steps in proper order', async () => {
-    //     const executionOrder: string[] = [];
-
-    //     // 1) create a base component with some feature
-    //     class My_Component extends A_Component {
-    //         async methodA() {
-    //             await this.call('myFeature')
-    //         }
-
-    //         @A_Feature.Extend({
-    //             name: 'myFeature',
-    //             after: ['My_Component.stepTwo'],
-    //         })
-    //         async stepOne(
-    //         ) {
-    //             executionOrder.push('stepOne');
-    //         }
-
-    //         @A_Feature.Extend({
-    //             name: 'myFeature',
-    //         })
-    //         async stepTwo(
-    //         ) {
-    //             executionOrder.push('stepTwo');
-    //         }
-    //     }
-
-
-    //     // 2) create a running scope 
-    //     const scope = new A_Scope({ name: 'TestScope', components: [My_Component] });
-
-    //     // 3) create an instance of the component from the scope
-    //     const myComponent = scope.resolve(My_Component)!;
-    //     expect(myComponent).toBeInstanceOf(My_Component);
-
-    //     // 4) call the feature caller to execute the feature
-    //     await myComponent.methodA();
-
-    //     // 5) check the results
-    //     expect(executionOrder).toEqual(['stepTwo', 'stepOne']);
-    // });
-
-    // it('Should allow to define a feature', async () => {
-    //     const executionOrder: string[] = [];
-
-    //     // 1) create a base component with some feature
-    //     class My_Component extends A_Component {
-
-
-    //         @A_Feature.Define({ invoke: true })
-    //         @A_Feature.Extend({
-    //             name: 'myFeature',
-    //         })
-    //         async feature1(
-    //             @A_Inject(A_Component) component: A_Component
-    //         ) { }
-
-    //         @A_Feature.Extend({
-    //             name: 'feature1',
-    //         })
-    //         async feature1Extension() {
-    //             executionOrder.push('stepOne');
-    //         }
-
-    //         @A_Feature.Define()
-    //         async feature2() {
-    //             await this.call('feature2');
-    //         }
+    it('Should Allow to create a feature from component', async () => {
+        const testComponent = new A_Component()
+        A_Context.root.register(testComponent);
 
-    //         @A_Feature.Extend({
-    //             name: 'feature2',
-    //         })
-    //         async feature2Extension() {
-    //             executionOrder.push('stepTwo');
-    //         }
+        const feature = new A_Feature({
+            name: 'testFeature',
+            component: testComponent,
+        });
+
+        expect(feature).toBeInstanceOf(A_Feature);
+        expect(feature.scope.parent).toBe(A_Context.root);
+
+    });
+    it('Should Allow to create a feature with steps', async () => {
+        const template = [
+            {
+                name: 'A_Component.testHandler',
+                component: A_Component,
+                handler: 'testHandler',
+            }
+        ]
+
+        const feature = new A_Feature({
+            name: 'testFeature',
+            scope: new A_Scope(),
+            template
+        });
+
+        expect(feature).toBeInstanceOf(A_Feature);
+    });
+    it('Should be possible to execute a feature with steps as a template on the component', async () => {
+        // 1) create a base component with some feature
+        class MyExtendedComponent extends A_Component {
+
+            async testHandler(
+                @A_Inject(A_Caller) caller: MyComponent
+            ) {
+                caller.sum = 2;
+            }
+        }
+
+        // 2) create a custom component with a defined template feature
+        class MyComponent extends A_Component {
+            sum: number = 0;
+
+            @A_Feature.Define({
+                invoke: true,
+                template: [{
+                    name: 'MyExtendedComponent.testHandler',
+                    component: MyExtendedComponent,
+                    handler: 'testHandler',
+                    behavior: 'sync',
+                    before: '',
+                    after: ''
+                },
+                {
+                    name: 'MyExtendedComponent.testHandler',
+                    component: MyExtendedComponent,
+                    handler: 'testHandler'
+                }]
+            })
+            async testHandler() { }
+        }
+
+
+        // 3) create a running scope 
+        const scope = new A_Scope({ name: 'TestScope' });
+        scope.register(MyExtendedComponent);
+        scope.register(MyComponent);
+
+        // 4) create an instance of the component from the scope
+        const myComponent = scope.resolve(MyComponent)!;
+        expect(myComponent).toBeInstanceOf(MyComponent);
+        expect(myComponent.sum).toBe(0);
+
+        // 5) call the feature caller to execute the feature
+        await myComponent.testHandler();
+
+        // 6) check the results
+        expect(myComponent.sum).toBe(2);
+
+    });
+    it('Should be possible to execute a feature with steps as a template on the component with string component declaration', async () => {
+        // 1) create a base component with some feature
+        class MyExtendedComponent2 extends A_Component {
+
+            async testHandler(
+                @A_Inject(A_Caller) caller: MyComponent2
+            ) {
+                caller.sum = 2;
+            }
+        }
+
+        // 2) create a custom component with a defined template feature
+        class MyComponent2 extends A_Component {
+            sum: number = 0;
+
+            @A_Feature.Define({
+                invoke: true,
+                template: [{
+                    name: 'MyExtendedComponent2.testHandler',
+                    component: 'MyExtendedComponent2',
+                    handler: 'testHandler',
+                    behavior: 'sync',
+                    before: '',
+                    after: ''
+                }]
+            })
+            async testHandler() { }
+        }
+
+
+        // 3) create a running scope 
+        const scope = new A_Scope({ name: 'TestScope' });
+        scope.register(MyExtendedComponent2);
+        scope.register(MyComponent2);
+
+        // 4) create an instance of the component from the scope
+        const myComponent = scope.resolve(MyComponent2)!;
+        expect(myComponent).toBeInstanceOf(MyComponent2);
+        expect(myComponent.sum).toBe(0);
+
+        // 5) call the feature caller to execute the feature
+        await myComponent.testHandler();
+
+        // 6) check the results
+        expect(myComponent.sum).toBe(2);
+
+    });
+    it('Should execute feature steps in base order', async () => {
+        const executionOrder: string[] = [];
+
+        // 1) create a base component with some feature
+        class My_Component extends A_Component {
+            async methodA() {
+                await this.call('myFeature')
+            }
+
+            @A_Feature.Extend({
+                name: 'myFeature',
+            })
+            async stepOne(
+            ) {
+                executionOrder.push('stepOne');
+            }
+
+            @A_Feature.Extend({
+                name: 'myFeature',
+            })
+            async stepTwo(
+            ) {
+                executionOrder.push('stepTwo');
+            }
+
+            @A_Feature.Extend({
+                name: 'myFeature',
+            })
+            async stepThree(
+            ) {
+                executionOrder.push('stepThree');
+            }
+        }
+
+
+        // 2) create a running scope 
+        const scope = new A_Scope({ name: 'TestScope', components: [My_Component] });
+
+        // 3) create an instance of the component from the scope
+        const myComponent = scope.resolve(My_Component)!;
+        expect(myComponent).toBeInstanceOf(My_Component);
+
+        // 4) call the feature caller to execute the feature
+        await myComponent.methodA();
+
+        // 5) check the results
+        expect(executionOrder).toEqual(['stepOne', 'stepTwo', 'stepThree']);
+    });
+    it('Should execute feature steps in proper order', async () => {
+        const executionOrder: string[] = [];
+
+        // 1) create a base component with some feature
+        class My_Component extends A_Component {
+            async methodA() {
+                await this.call('myFeature')
+            }
+
+            @A_Feature.Extend({
+                name: 'myFeature',
+                after: ['My_Component.stepTwo'],
+            })
+            async stepOne(
+            ) {
+                executionOrder.push('stepOne');
+            }
+
+            @A_Feature.Extend({
+                name: 'myFeature',
+            })
+            async stepTwo(
+            ) {
+                executionOrder.push('stepTwo');
+            }
+        }
+
+
+        // 2) create a running scope 
+        const scope = new A_Scope({ name: 'TestScope', components: [My_Component] });
+
+        // 3) create an instance of the component from the scope
+        const myComponent = scope.resolve(My_Component)!;
+        expect(myComponent).toBeInstanceOf(My_Component);
+
+        // 4) call the feature caller to execute the feature
+        await myComponent.methodA();
+
+        // 5) check the results
+        expect(executionOrder).toEqual(['stepTwo', 'stepOne']);
+    });
 
-    //     }
+    it('Should allow to define a feature', async () => {
+        const executionOrder: string[] = [];
+
+        // 1) create a base component with some feature
+        class My_Component extends A_Component {
+
+
+            @A_Feature.Define({ invoke: true })
+            @A_Feature.Extend({
+                name: 'myFeature',
+            })
+            async feature1(
+                @A_Inject(A_Component) component: A_Component
+            ) { }
+
+            @A_Feature.Extend({
+                name: 'feature1',
+            })
+            async feature1Extension() {
+                executionOrder.push('stepOne');
+            }
+
+            @A_Feature.Define()
+            async feature2() {
+                await this.call('feature2');
+            }
+
+            @A_Feature.Extend({
+                name: 'feature2',
+            })
+            async feature2Extension() {
+                executionOrder.push('stepTwo');
+            }
+
+        }
 
 
-    //     // 2) create a running scope 
-    //     const scope = new A_Scope({ name: 'TestScope', components: [My_Component] });
+        // 2) create a running scope 
+        const scope = new A_Scope({ name: 'TestScope', components: [My_Component] });
 
-    //     // 3) create an instance of the component from the scope
-    //     const myComponent = scope.resolve(My_Component)!;
-    //     expect(myComponent).toBeInstanceOf(My_Component);
+        // 3) create an instance of the component from the scope
+        const myComponent = scope.resolve(My_Component)!;
+        expect(myComponent).toBeInstanceOf(My_Component);
 
-    //     // 4) call the feature caller to execute the feature
-    //     await myComponent.feature1(new A_Component());
+        // 4) call the feature caller to execute the feature
+        await myComponent.feature1(new A_Component());
 
-    //     await myComponent.feature2();
+        await myComponent.feature2();
 
-    //     // 5) check the results
-    //     expect(executionOrder).toEqual(['stepOne', 'stepTwo']);
-    // });
-    // it('Should inherit feature definitions & extensions', async () => {
-    //     const executionOrder: string[] = [];
+        // 5) check the results
+        expect(executionOrder).toEqual(['stepOne', 'stepTwo']);
+    });
+    it('Should inherit feature definitions & extensions', async () => {
+        const executionOrder: string[] = [];
 
-    //     // 1) create a base component with some feature
-    //     class My_Component extends A_Component {
+        // 1) create a base component with some feature
+        class My_Component extends A_Component {
 
-    //         @A_Feature.Define({ invoke: false })
-    //         async feature1() {
-    //             executionOrder.push('stepOne');
+            @A_Feature.Define({ invoke: false })
+            async feature1() {
+                executionOrder.push('stepOne');
 
-    //             await this.call('feature1');
-    //         }
+                await this.call('feature1');
+            }
 
-    //         @A_Feature.Extend({
-    //             name: 'feature1',
-    //         })
-    //         async feature1Extension(
-    //             @A_Inject(A_Scope) scope: A_Scope
-    //         ) {
-    //             executionOrder.push('stepTwo');
-    //         }
-    //     }
+            @A_Feature.Extend({
+                name: 'feature1',
+            })
+            async feature1Extension(
+                @A_Inject(A_Scope) scope: A_Scope
+            ) {
+                executionOrder.push('stepTwo');
+            }
+        }
 
 
-    //     class My_Child_Component extends My_Component { }
+        class My_Child_Component extends My_Component { }
 
 
-    //     // 2) create a running scope 
-    //     const scope = new A_Scope({ name: 'TestScope', components: [My_Child_Component] });
+        // 2) create a running scope 
+        const scope = new A_Scope({ name: 'TestScope', components: [My_Child_Component] });
 
-    //     // 3) create an instance of the component from the scope
-    //     const myComponent = scope.resolve(My_Child_Component)!;
-    //     expect(myComponent).toBeInstanceOf(My_Child_Component);
+        // 3) create an instance of the component from the scope
+        const myComponent = scope.resolve(My_Child_Component)!;
+        expect(myComponent).toBeInstanceOf(My_Child_Component);
 
-    //     await myComponent.feature1();
+        await myComponent.feature1();
 
-    //     expect(executionOrder).toEqual(['stepOne', 'stepTwo']);
-    // });
+        expect(executionOrder).toEqual(['stepOne', 'stepTwo']);
+    });
 
-    // it('Should allow override feature extension', async () => {
-    //     const executionOrder: string[] = [];
+    it('Should allow override feature extension', async () => {
+        const executionOrder: string[] = [];
 
-    //     // 1) create a base component with some feature
-    //     class My_Component extends A_Component {
+        // 1) create a base component with some feature
+        class My_Component extends A_Component {
 
-    //         @A_Feature.Define({ invoke: true })
-    //         async feature1() {
-    //             executionOrder.push('stepOne');
-    //         }
+            @A_Feature.Define({ invoke: true })
+            async feature1() {
+                executionOrder.push('stepOne');
+            }
 
-    //         @A_Feature.Extend({
-    //             name: 'feature1',
-    //         })
-    //         async feature1Extension(
-    //             @A_Inject(A_Scope) scope: A_Scope
-    //         ) {
-    //             executionOrder.push('stepTwo');
-    //         }
-    //     }
+            @A_Feature.Extend({
+                name: 'feature1',
+            })
+            async feature1Extension(
+                @A_Inject(A_Scope) scope: A_Scope
+            ) {
+                executionOrder.push('stepTwo');
+            }
+        }
 
 
-    //     class My_Child_Component extends My_Component {
+        class My_Child_Component extends My_Component {
 
-    //         async feature1Extension(
-    //             @A_Inject(A_Scope) scope: A_Scope
-    //         ) {
-    //             executionOrder.push('stepThree');
-    //         }
-    //     }
+            async feature1Extension(
+                @A_Inject(A_Scope) scope: A_Scope
+            ) {
+                executionOrder.push('stepThree');
+            }
+        }
 
 
-    //     // 2) create a running scope 
-    //     const scope = new A_Scope({ name: 'TestScope', components: [My_Child_Component] });
+        // 2) create a running scope 
+        const scope = new A_Scope({ name: 'TestScope', components: [My_Child_Component] });
 
-    //     // 3) create an instance of the component from the scope
-    //     const myComponent = scope.resolve(My_Child_Component)!;
-    //     expect(myComponent).toBeInstanceOf(My_Child_Component);
+        // 3) create an instance of the component from the scope
+        const myComponent = scope.resolve(My_Child_Component)!;
+        expect(myComponent).toBeInstanceOf(My_Child_Component);
 
-    //     await myComponent.feature1();
+        await myComponent.feature1();
 
-    //     expect(executionOrder).toEqual(['stepOne', 'stepThree']);
-    // });
+        expect(executionOrder).toEqual(['stepOne', 'stepThree']);
+    });
 
-    // it('Should allow proceed with external scope', async () => {
-    //     const executionOrder: string[] = [];
+    it('Should allow proceed with external scope', async () => {
+        const executionOrder: string[] = [];
 
-    //     class CustomComponent extends A_Component {
+        class CustomComponent extends A_Component {
 
-    //         doSomething() {
-    //             executionOrder.push('customComponentAction');
-    //         }
+            doSomething() {
+                executionOrder.push('customComponentAction');
+            }
 
-    //     }
+        }
 
-    //     // 1) create a base component with some feature
-    //     class ComponentA extends A_Component {
+        // 1) create a base component with some feature
+        class ComponentA extends A_Component {
 
-    //         @A_Feature.Define({ invoke: false })
-    //         async feature1() {
-    //             const scope = new A_Scope({ name: 'ExternalScopeCaller', components: [CustomComponent] });
+            @A_Feature.Define({ invoke: false })
+            async feature1() {
+                const scope = new A_Scope({ name: 'ExternalScopeCaller', components: [CustomComponent] });
 
-    //             executionOrder.push('stepOne');
+                executionOrder.push('stepOne');
 
-    //             await this.call('feature1', scope);
-    //         }
-    //     }
+                await this.call('feature1', scope);
+            }
+        }
 
 
-    //     class ComponentB extends A_Component {
+        class ComponentB extends A_Component {
 
-    //         @A_Feature.Extend({
-    //             name: 'feature1',
-    //         })
-    //         async feature1Extension(
-    //             @A_Inject(A_Scope) scope: A_Scope,
-    //             @A_Inject(CustomComponent) customComponent: CustomComponent
-    //         ) {
-    //             expect(customComponent).toBeInstanceOf(CustomComponent);
-    //             expect(customComponent.doSomething).toBeInstanceOf(Function);
+            @A_Feature.Extend({
+                name: 'feature1',
+            })
+            async feature1Extension(
+                @A_Inject(A_Scope) scope: A_Scope,
+                @A_Inject(CustomComponent) customComponent: CustomComponent
+            ) {
+                expect(customComponent).toBeInstanceOf(CustomComponent);
+                expect(customComponent.doSomething).toBeInstanceOf(Function);
 
-    //             executionOrder.push('stepThree');
-    //         }
-    //     }
+                executionOrder.push('stepThree');
+            }
+        }
 
 
-    //     // 2) create a running scope 
-    //     const scope = new A_Scope({ name: 'TestScope' , components: [ComponentA, ComponentB] });
+        // 2) create a running scope 
+        const scope = new A_Scope({ name: 'TestScope' , components: [ComponentA, ComponentB] });
 
 
-    //     // 3) create an instance of the component from the scope
-    //     const myComponent = scope.resolve(ComponentA)!;
-    //     expect(myComponent).toBeInstanceOf(ComponentA);
+        // 3) create an instance of the component from the scope
+        const myComponent = scope.resolve(ComponentA)!;
+        expect(myComponent).toBeInstanceOf(ComponentA);
 
-    //     await myComponent.feature1();
+        await myComponent.feature1();
 
-    //     expect(executionOrder).toEqual(['stepOne', 'stepThree']);
-    // });
+        expect(executionOrder).toEqual(['stepOne', 'stepThree']);
+    });
     it('Should allow to interrupt a new feature', async () => {
         const feature = new A_Feature({
             name: 'testFeature',
@@ -448,7 +448,7 @@ describe('A-Feature tests', () => {
                     setTimeout(() => {
                         executionOrder.push('feature1');
                         resolve();
-                    }, 2000);
+                    }, 500);
                 });
             }
 
@@ -457,7 +457,7 @@ describe('A-Feature tests', () => {
                     setTimeout(() => {
                         executionOrder.push('feature2');
                         resolve();
-                    }, 1000);
+                    }, 500);
                 });
             }
 
@@ -466,7 +466,7 @@ describe('A-Feature tests', () => {
                     setTimeout(() => {
                         executionOrder.push('feature3');
                         resolve();
-                    }, 1000);
+                    }, 500);
                 });
             }
         }
@@ -499,19 +499,21 @@ describe('A-Feature tests', () => {
         });
 
         feature.process();
-        
-        await new Promise<void>(async (resolve) => {
 
+        await new Promise<void>(async (resolve) => {
             setTimeout(() => {
                 feature.interrupt();
+            }, 1000);
+
 
+            setTimeout(() => {
                 expect(feature.state).toBe(A_TYPES__FeatureState.INTERRUPTED);
-                expect(executionOrder).toEqual(['feature1']);
+                expect(executionOrder).toEqual(['feature1', 'feature2']);
 
                 resolve();
 
-            }, 2500);
+            }, 3000);
         });
 
-    });
+    }, 5000);
 });