How to unit test error block of rxjs tap operator with jasmine mocks?

Question

Consider the following Http interceptor:

export class BusyIndicatorInterceptor implements HttpInterceptor {
    constructor(private busyIndicatorService: BusyIndicatorService) { }

    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
        this.busyIndicatorService.show();

        return next.handle(req).pipe(tap((event: HttpEvent<any>) => {
            if (event instanceof HttpResponse) {
                this.busyIndicatorService.hide();
            }
        }, err => {
            console.warn(err);
            this.busyIndicatorService.hide();
        }));
    }
}

I am trying to unit test that the busyIndicatorService.hide is called when an error occurs such as 400, 404 etc. I have written the following test but I think I am not mocking the handler properly.

    it("should set busy indicator visibility to false when HttpResponse is returned", () => {
        mockhandler.handle.and.returnValue(of(new HttpErrorResponse({ error: "Not Found", status: 404 })));
        const result = testee.intercept(mockRequest, mockhandler);
        result.subscribe(() => {
            expect(busyIndicatorService.hide).toHaveBeenCalledTimes(1);
        });
    });

Result:

Expected spy BusyIndicatorService.hide to have been called once. It was called 0 times

The following test works for testing the success block, where I mock the handler to return a new HttpResponse.

it("should set busy indicator visibility to false when HttpResponse is returned", () => {
    mockhandler.handle.and.returnValue(of(new HttpResponse()));
    const result = testee.intercept(mockRequest, mockhandler);
    result.subscribe(() => {
        expect(busyIndicatorService.hide).toHaveBeenCalledTimes(1);
    });
});

Here is the full test class:

describe("BusyIndicatorInterceptor", () => {
    let testee: BusyIndicatorInterceptor;
    let busyIndicatorService: any;
    let mockRequest: any;
    let mockhandler: any;

    beforeEach(() => {
        mockRequest = jasmine.createSpyObj("HttpRequest", [""]);
        mockhandler = jasmine.createSpyObj("HttpHandler", ["handle"]);
        busyIndicatorService = jasmine.createSpyObj("BusyIndicatorService", ["show", "hide"]);
        busyIndicatorService.visibility = jasmine.createSpyObj("BehaviourSubject<boolean>", ["next"]);
        testee = new BusyIndicatorInterceptor(busyIndicatorService);
    });

    it("should be created", () => {
        expect(testee).toBeTruthy();
    });

    describe("intercept", () => {

        it("should set busy indicator visibility to true", () => {
            mockhandler.handle.and.returnValue(of(null));
            testee.intercept(mockRequest, mockhandler);

            expect(busyIndicatorService.show).toHaveBeenCalledTimes(1);
        });

        it("should set busy indicator visibility to false when HttpResponse is returned", () => {
            mockhandler.handle.and.returnValue(of(new HttpResponse()));
            const result = testee.intercept(mockRequest, mockhandler);
            result.subscribe(() => {
                expect(busyIndicatorService.hide).toHaveBeenCalledTimes(1);
            });
        });

        it("should set busy indicator visibility to false when HttpResponse is returned", () => {
            mockhandler.handle.and.returnValue(of(new HttpErrorResponse({ error: "Not Found", status: 404 })));
            const result = testee.intercept(mockRequest, mockhandler);
            result.subscribe(() => {
                expect(busyIndicatorService.hide).toHaveBeenCalledTimes(1);
            });
        });
    });
});