Merge pull request #15 from cloudnc/test/improve-code-coverage

Author: zakhenry

.github/workflows/main.yml

@@ -32,7 +32,9 @@ jobs:
       - name: Test
         run: yarn lib:test:ci
       - name: Coverage
-        run: yarn codecov
+        uses: codecov/codecov-action@v1
+        with:
+          fail_ci_if_error: true # optional (default = false)
       - name: Rebuild for release
         if: contains('refs/heads/master refs/heads/next', github.ref)
         run: |

projects/ngx-observable-lifecycle/src/lib/ngx-observable-lifecycle.spec.ts

@@ -1,4 +1,4 @@
-import { Component, OnDestroy } from '@angular/core';
+import { Component, OnDestroy, OnInit } from '@angular/core';
 import { isObservable } from 'rxjs';
 import { getObservableLifecycle } from './ngx-observable-lifecycle';
 
@@ -37,5 +37,52 @@ describe('ngx-observable-lifecycle', () => {
 
       expect(() => unobservedInstance.ngOnDestroy()).not.toThrowError();
     });
+
+    it('should re-use observer subjects when a hook is observed multiple times', () => {
+      const { ngOnInit: firstObservable } = getObservableLifecycle(componentInstance);
+      const { ngOnInit: secondObservable } = getObservableLifecycle(componentInstance);
+
+      expect(firstObservable.source).toBe(secondObservable.source);
+    });
+
+    it('invokes the original method if present', () => {
+      const originalOnDestroySpy = jasmine.createSpy();
+
+      class TestClass implements OnDestroy {
+        public ngOnDestroy(): void {
+          originalOnDestroySpy();
+        }
+      }
+
+      const instance = new TestClass();
+
+      const { ngOnDestroy } = getObservableLifecycle(instance);
+
+      expect(originalOnDestroySpy).not.toHaveBeenCalled();
+
+      instance.ngOnDestroy();
+
+      expect(originalOnDestroySpy).toHaveBeenCalled();
+    });
+
+    it('does not need the original hook(s) to be defined', () => {
+      const onInitSpy = jasmine.createSpy();
+
+      class TestClass {}
+
+      const instance = new TestClass();
+
+      const { ngOnInit } = getObservableLifecycle(instance);
+
+      ngOnInit.subscribe(onInitSpy);
+
+      expect(onInitSpy).not.toHaveBeenCalled();
+
+      (instance as OnInit).ngOnInit();
+
+      expect(onInitSpy).toHaveBeenCalled();
+
+      (instance as OnDestroy).ngOnDestroy();
+    });
   });
 });

projects/ngx-observable-lifecycle/src/lib/ngx-observable-lifecycle.ts

@@ -29,12 +29,16 @@ type DecorateHookOptions = Partial<AllHookOptions>;
 export type DecoratedHooks = Record<LifecycleHookKey, Observable<void>>;
 export type DecoratedHooksSub = Record<LifecycleHookKey, Subject<void>>;
 
-type ComponentInstance = Partial<AllHooks> & {
-  [hookSubject]: Partial<DecoratedHooksSub>;
-  [hooksPatched]: Partial<DecorateHookOptions>;
+type PatchedComponentInstance<K extends LifecycleHookKey> = Pick<AllHooks, K> & {
+  [hookSubject]: Pick<DecoratedHooksSub, K>;
+  constructor: {
+    prototype: {
+      [hooksPatched]: Pick<DecorateHookOptions, K>;
+    };
+  };
 };
 
-function getSubjectForHook(componentInstance: ComponentInstance, hook: LifecycleHookKey): Subject<void> {
+function getSubjectForHook(componentInstance: PatchedComponentInstance<any>, hook: LifecycleHookKey): Subject<void> {
   if (!componentInstance[hookSubject]) {
     componentInstance[hookSubject] = {};
   }
@@ -51,13 +55,13 @@ function getSubjectForHook(componentInstance: ComponentInstance, hook: Lifecycle
   if (!proto[hooksPatched][hook]) {
     const originalHook = proto[hook];
 
-    proto[hook] = function (this: ComponentInstance) {
+    proto[hook] = function (this: PatchedComponentInstance<typeof hook>) {
       (originalHook as () => void)?.call(this);
-      this[hookSubject]?.[hook]?.next();
+      this[hookSubject][hook].next();
     };
 
     const originalOnDestroy = proto.ngOnDestroy;
-    proto.ngOnDestroy = function (this: ComponentInstance) {
+    proto.ngOnDestroy = function (this: PatchedComponentInstance<typeof hook>) {
       originalOnDestroy?.call(this);
       this[hookSubject]?.[hook]?.complete();
       delete this[hookSubject]?.[hook];