Release 1.4.0

hisorange · Dec 3, 2022 · db40355 · db40355
1 parent fed9b7c
commit db40355
Show file tree

Hide file tree

Showing 5 changed files with 485 additions and 433 deletions.
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@hisorange/kernel",
-  "version": "2.0.0",
+  "version": "1.4.0",
   "description": "Async application kernel with context and modular loading support",
   "main": "build/index.js",
   "repository": "https://github.com/hisorange/kernel",

diff --git a/src/kernel.spec.ts b/src/kernel.spec.ts
@@ -14,32 +14,38 @@ describe('Kernel', () => {
     expect(() => new Kernel()).not.toThrow();
   });
 
-  test('should create a logger', () => {
+  test('should create a logger', async () => {
     const kernel = new Kernel();
 
     expect(kernel.logger).toBeDefined();
     expect(kernel.logger).toHaveProperty('debug');
     expect(kernel.logger).toHaveProperty('info');
     expect(kernel.logger).toHaveProperty('warn');
     expect(kernel.logger).toHaveProperty('error');
+
+    await kernel.stop();
   });
 
-  test('should create a context', () => {
+  test('should create a context', async () => {
     const kernel = new Kernel();
 
     expect(kernel.context).toBeDefined();
     expect(kernel.context).toBeInstanceOf(Context);
+
+    await kernel.stop();
   });
 
-  test('should define the "' + KERNEL_BINDING + '" binding', () => {
+  test('should define the "' + KERNEL_BINDING + '" binding', async () => {
     const kernel = new Kernel();
 
     expect(kernel.context.contains(KERNEL_BINDING)).toBe(true);
     expect(kernel.context.getSync(KERNEL_BINDING)).toBe(kernel);
+
+    await kernel.stop();
   });
 
   describe('Module Registration', () => {
-    test('should register module providers', () => {
+    test('should register module providers', async () => {
       const kernel = new Kernel();
 
       @Service()
@@ -54,9 +60,11 @@ describe('Kernel', () => {
 
       expect(kernel.context.contains(MyService.name)).toBe(true);
       expect(kernel.context.getSync(MyService.name)).toBeInstanceOf(MyService);
+
+      await kernel.stop();
     });
 
-    test('should inject dependencies', () => {
+    test('should inject dependencies', async () => {
       const kernel = new Kernel();
 
       @Service()
@@ -82,6 +90,8 @@ describe('Kernel', () => {
       expect(
         kernel.context.getSync<ServiceB>(ServiceB.name).serviceA,
       ).toBeInstanceOf(ServiceA);
+
+      await kernel.stop();
     });
   });
 
@@ -93,12 +103,14 @@ describe('Kernel', () => {
       class ModuleWithOnBootHook implements IModule {
         async onBoot(injectedKernel: IKernel): Promise<void> {
           expect(injectedKernel).toBe(kernel);
-          done();
         }
       }
 
       kernel.register([ModuleWithOnBootHook]);
-      kernel.boostrap();
+      kernel
+        .boostrap()
+        .then(() => kernel.stop())
+        .then(() => done());
     });
 
     test('should call the "onStart" hook', done => {
@@ -108,12 +120,15 @@ describe('Kernel', () => {
       class ModuleWithOnStartHook implements IModule {
         async onStart(injectedKernel: IKernel): Promise<void> {
           expect(injectedKernel).toBe(kernel);
-          done();
         }
       }
 
       kernel.register([ModuleWithOnStartHook]);
-      kernel.boostrap().then(() => kernel.start());
+      kernel
+        .boostrap()
+        .then(() => kernel.start())
+        .then(() => kernel.stop())
+        .then(() => done());
     });
 
     test('should call the "onStop" hook', done => {
@@ -123,15 +138,15 @@ describe('Kernel', () => {
       class ModuleWithOnStopHook implements IModule {
         async onStop(injectedKernel: IKernel): Promise<void> {
           expect(injectedKernel).toBe(kernel);
-          done();
         }
       }
 
       kernel.register([ModuleWithOnStopHook]);
       kernel
         .boostrap()
         .then(() => kernel.start())
-        .then(() => kernel.stop());
+        .then(() => kernel.stop())
+        .then(() => done());
     });
   });
 
@@ -180,11 +195,13 @@ describe('Kernel', () => {
       expect(myClass.myService).toBeInstanceOf(MyService);
       expect(myClass.one).toBe(1);
       expect(myClass.two).toBe(2);
+
+      await kernel.stop();
     });
   });
 
   describe('Providers', () => {
-    test('should resolve a provider by value', () => {
+    test('should resolve a provider by value', async () => {
       const kernel = new Kernel();
 
       class TheProduct {}
@@ -212,6 +229,8 @@ describe('Kernel', () => {
       const resolve2 = kernel.context.getSync(TheProduct.name);
 
       expect(resolve1).toBe(resolve2);
+
+      await kernel.stop();
     });
   });
 
@@ -241,6 +260,8 @@ describe('Kernel', () => {
       expect(product.logger).toHaveProperty('info');
       expect(product.logger).toHaveProperty('warn');
       expect(product.logger).toHaveProperty('error');
+
+      await kernel.stop();
     });
   });
 

diff --git a/src/kernel.ts b/src/kernel.ts
@@ -61,16 +61,14 @@ export class Kernel implements IKernel {
     this.context.bind(KERNEL_BINDING).to(this);
 
     this.logger.info('Context is ready!');
-
-    this.registerSignalHandlers();
   }
 
   /**
    * Hook to allow the kernel to register the signals it wants to listen to.
    */
   protected registerSignalHandlers(): void {
-    process.on('SIGINT', this.handleShutdown.bind(this));
-    process.on('SIGTERM', this.handleShutdown.bind(this));
+    process.once('SIGINT', this.handleShutdown.bind(this));
+    process.once('SIGTERM', this.handleShutdown.bind(this));
   }
 
   /**
@@ -248,6 +246,8 @@ export class Kernel implements IKernel {
    * @inheritdoc
    */
   async boostrap(): Promise<void> {
+    this.registerSignalHandlers();
+
     this.logger.debug('Boostrap request received');
     this.logger.debug('Invoking the module bootstrap sequence...');
 
@@ -434,7 +434,12 @@ export class Kernel implements IKernel {
    * @inheritdoc
    */
   create<T>(concrete: Constructor<T>, params?: any[]): ValueOrPromise<T> {
-    return instantiateClass(concrete, this.context, undefined, params);
+    return instantiateClass(
+      concrete as Constructor<object>,
+      this.context,
+      undefined,
+      params,
+    ) as ValueOrPromise<T>;
   }
 
   /**

diff --git a/src/signal.spec.ts b/src/signal.spec.ts
@@ -0,0 +1,21 @@
+import { Kernel } from './kernel';
+
+describe.skip('Signal management', () => {
+  test('should register SIG handlers', async () => {
+    const sigIntListeners = process.listenerCount('SIGINT');
+    const sigTermListeners = process.listenerCount('SIGTERM');
+
+    const kernel = new Kernel();
+    await kernel.boostrap();
+
+    expect(process.listenerCount('SIGINT')).toBeGreaterThan(sigIntListeners);
+    expect(process.listenerCount('SIGTERM')).toBeGreaterThan(
+      sigTermListeners + 1,
+    );
+
+    await kernel.stop();
+
+    expect(process.listenerCount('SIGINT')).toBe(sigIntListeners);
+    expect(process.listenerCount('SIGTERM')).toBe(sigTermListeners);
+  });
+});