Attempting to test redux-observable epics in typescript

submitSignUpFormEpic.test.ts

import { submitSignUpFormEpic } from "../epics";
import { TestScheduler } from "rxjs/testing";
import { FirebaseUser } from "../logic/User";
import { submitSignUpForm } from "../actions/authActions";
import { of, from } from "rxjs";
import { ActionsObservable, StateObservable } from "redux-observable";
import { Observable } from "redux";
import { map } from "rxjs/operators";
import { push } from "connected-react-router";
var fs = require("fs");

jest.mock("../logic/user");

const testScheduler = new TestScheduler((actual, expected) => {
  // somehow assert the two objects are equal
  // e.g. with chai `expect(actual).deep.equal(expected)`
  expect(actual).toBe;
});

describe("Authentication Epics ", () => {
  test("Signup Form", (done: any) => {
    testScheduler.run((helpers) => {
      const { hot, expectObservable } = helpers;
      const user = { signUp: jest.fn() };
      const username = "jhon";
      const password = "123456";
      const email = "jhon@doe.com";
      const state$ = new StateObservable(hot("-a", {}), undefined);

      const action$ = new ActionsObservable(
        hot("-a", {
          "-a": submitSignUpForm({ email, username, password }),
        })
      );
      action$.pipe(map((action) => expect(action.type).toBe("f"))).subscribe();

      const output$ = submitSignUpFormEpic(action$, state$, { user });
      // expect(user.signUp).toBeCalledTimes(1);
      fs.writeFileSync("sync.txt", "anni", { mode: 0o755 });
      expectObservable(output$).toBe("-a", { a: push("welcome") });
      done();
    });
  });
});

export {};

submitSignUpFormEpic.ts

import { ActionType, isActionOf } from "typesafe-actions";
import { Epic } from "redux-observable";
import { from, of, Observable } from "rxjs";
import { push } from "connected-react-router";
import { switchMap, filter, map, catchError } from "rxjs/operators";
import "../../app/bootstrap";
import * as actions from "../actions/authActions";

type Action = ActionType<typeof actions>;
type Params = {
  payload: {
    email: string;
    password: string;
  };
};

export const submitSignUpFormEpic: Epic = (
  action$: Observable<Action>,
  undefined,
  { user }
) =>
  action$.pipe(
    filter(isActionOf(actions.submitSignUpForm)),
    switchMap(({ payload }: Params) => {
      return from(user.signUp(payload.email, payload.password)).pipe(
        map((user) => {
          if (user) {
            return push("/welcome");
          }
        }),
        catchError((error: Error) => of(actions.submitSignUpFormFailure(error)))
      );
    })
  );

export default submitSignUpFormEpic;