feat(observables): added returnSubject to observable

now it's possible to get the underlying subject behind Observables returning methods

src/create-spy-from-class.types.ts

@@ -1,3 +1,5 @@
+import { Subject } from 'rxjs';
+
 export interface SpyFunctionReturnValueContainer {
   value: any;
 }
@@ -12,4 +14,5 @@ export interface CalledWithObject {
   nextOneTimeWith?(value?: any): void;
   throwWith?(value: any): void;
   complete?(): void;
+  returnSubject?<R = any>(): Subject<R>;
 }

src/observables/observable-spy-utils.spec.ts

@@ -3,6 +3,7 @@ import { FakeChildClass, FakeClass } from '../test-utils/fake-classes-to-test';
 import { take } from 'rxjs/operators';
 import { Spy } from '../spy.types';
 import * as errorHandling from '../errors/error-handling';
+import { Subject } from 'rxjs';
 
 let fakeClassSpy: Spy<FakeClass>;
 let fakeChildClassSpy: Spy<FakeChildClass>;
@@ -86,6 +87,27 @@ describe('createSpyFromClass', () => {
           expect(completed).toBe(true);
         });
       });
+
+      describe('GIVEN returnSubject is configured THEN do not emit', () => {
+        let subject: Subject<any>;
+        Given(() => {
+          subject = fakeClassSpy.observableMethod.and.returnSubject();
+        });
+
+        Then(() => {
+          expect(actualResult).toBeNull();
+        });
+
+        describe('GIVEN subject emits THEN capture the emitted message', () => {
+          Given(() => {
+            subject.next(fakeValue);
+          });
+
+          Then(() => {
+            expect(actualResult).toBe(fakeValue);
+          });
+        });
+      });
     });
 
     describe('WHEN Observable returning method is called with exact params', () => {
@@ -261,7 +283,7 @@ describe('createSpyFromClass', () => {
         });
       });
 
-      describe('GIVEN calledWith of complete is configured with the wrong params THEN throw an error', () => {
+      describe('GIVEN mustBeCalledWith of complete is configured with the wrong params THEN throw an error', () => {
         Given(() => {
           fakeClassSpy.observableMethod.mustBeCalledWith(WRONG_VALUE).complete();
         });
@@ -272,6 +294,42 @@ describe('createSpyFromClass', () => {
           });
         });
       });
+
+      describe('GIVEN calledWith of returnSubject is configured with the right params THEN emit successfully', () => {
+        Given(() => {
+          const subject = fakeClassSpy.observableMethod
+            .calledWith(...fakeArgs)
+            .returnSubject();
+          subject.next(fakeValue);
+        });
+
+        Then(() => {
+          expect(actualResult).toEqual(fakeValue);
+        });
+      });
+
+      describe('GIVEN calledWith of returnSubject is configured with wrong params THEN do not throw an error', () => {
+        Given(() => {
+          fakeClassSpy.observableMethod.calledWith(WRONG_VALUE).returnSubject();
+        });
+
+        Then(() => {
+          expect(throwArgumentsErrorSpyFunction).not.toHaveBeenCalled();
+        });
+      });
+
+      describe(`GIVEN mustBeCalledWith of returnSubject is configured with the wrong params
+                THEN throw an error`, () => {
+        Given(() => {
+          fakeClassSpy.observableMethod.mustBeCalledWith(WRONG_VALUE).returnSubject();
+        });
+
+        Then(() => {
+          verifyArgumentsErrorWasThrown({
+            actualArgs: fakeArgs
+          });
+        });
+      });
     });
 
     describe('WHEN calling a Subject returning method', () => {

src/observables/observable-spy-utils.ts

@@ -30,6 +30,11 @@ export function observablifySpyFunction(
     valueContainer.value = subject;
     subject.complete();
   };
+
+  spyFunction.and.returnSubject = function complete() {
+    valueContainer.value = subject;
+    return subject;
+  };
 }
 
 export function addObservableHandlingToCalledWith(
@@ -59,5 +64,10 @@ export function addObservableHandlingToCalledWith(
     calledWithObject.argsToValuesMap.set(calledWithArgs, subject);
   };
 
+  calledWithObject.returnSubject = function() {
+    calledWithObject.argsToValuesMap.set(calledWithArgs, subject);
+    return subject;
+  };
+
   return calledWithObject;
 }

src/spy.types.ts

@@ -1,5 +1,5 @@
 /// <reference types="jasmine" />
-import { Observable } from 'rxjs';
+import { Observable, Subject } from 'rxjs';
 
 export type Spy<T> = { [k in keyof T]: AddSpyTypes<T[k]> };
 
@@ -25,6 +25,7 @@ export interface ObservableSpyMethod<T> {
   nextOneTimeWith(value?: T): void; // emit one value and completes
   throwWith(value: any): void;
   complete(): void;
+  returnSubject<R = any>(): Subject<R>;
 }
 
 export interface SpyMethod {