it('should return a new CancellationFailedAction on error', () => {
            const cancellationData: CancellationData = {
                id: 'id',
                accessToken: 'token',
                cancellationReason: {
                    positionOccupied: true,
                    occupiedWith: {
                        jobCenter: true,
                        privateAgency: false,
                        self: false
                    }
                }
            };

            const action = new SubmitCancellationAction(cancellationData);
            actions$ = hot('-a', { a: action });

            const response = cold('-#|', {}, 'error');
            mockJobPublicationService.cancelJobPublication.and.returnValue(response);

            const cancellationFailedAction = new CancellationFailedAction('error');
            const expected = cold('--b', { b: cancellationFailedAction });

            expect(effects.cancelJobPublication$).toBeObservable(expected);
        });

    it('should populate occupationLabels', () => {
        // GIVEN
        const occupation$ = cold('-a', {
            a: {
                male: 'Text-M',
                female: 'Text-F'
            }
        });
        mockOccupationOccupationPresentationService.findOccupationLabelsByAvamCode.and.returnValue(occupation$);

        // WHEN
        fixture.detectChanges();

        // THEN
        const expected = cold('-b', {
            b: [{
                occupation: {
                    avamCode: 22222,
                    bfsCode: 22,
                    sbn3Code: 222,
                    sbn5Code: 22222
                },
                occupationLabels: {
                    male: 'Text-M',
                    female: 'Text-F'
                },
                occupationLabel: 'Text-M',
                wanted: true
            }]
        });

        expect(component.jobExperiences$).toBeObservable(expected);
    });

    it('should emit ActionStockMarketRetrieveError on error', () => {
      const retrieveAction = new ActionStockMarketRetrieve({
        symbol
      });
      const error = 'ERROR';
      const errorAction = new ActionStockMarketRetrieveError({
        error
      } as any);
      const values = {
        a: retrieveAction,
        e: errorAction
      };
      const source = cold('a', values);
      const expected = cold('--e', values);
      const actions = new Actions(source);

      stockMarket.retrieveStock.and.returnValue(throwError(error));

      const effects = new StockMarketEffects(
        actions,
        localStorage,
        stockMarket
      );

      expect(
        effects.retrieveStock({
          debounce: 20,
          scheduler: getTestScheduler()
        })
      ).toBeObservable(expected);
    });

        it('should return new JobListLoadedAction if store is in initial state', () => {
            const jobList = [
                {
                    id: '0',
                    externalId: 'extId0',
                    title: 'title-0',
                    source: 'api',
                    publicationEndDate: new Date()
                }
            ];
            const responseWrapper = new ResponseWrapper(new Headers({ 'X-Total-Count': '100' }), jobList, 200);

            actions$ = hot('-a', { a: action });
            const response = cold('-a|', { a: responseWrapper });
            mockJobService.search.and.returnValue(response);

            const jobListLoadedAction = new actions.JobListLoadedAction({
                jobList,
                totalCount: 100,
                page: 0
            });
            const expected = cold('--b|', { b: jobListLoadedAction });

            expect(effects.initJobSearch$).toBeObservable(expected);
        });

      it('should re-evaluate when formula changes', () => {
        service.evaluate.and.callFake(v => v.toUpperCase());
        component.ngOnInit();

        cold(data.formula).subscribe(v => component.formula.setValue(v));

        expect(component.value$).toBeObservable(cold(data.value$));
      });

    it('DeleteReport should delete the current report', () => {
      actions = hot('a-', { a: new Actions.DeleteReport(4) });

      const response = cold('-b', { b: { id: 4 } });

      service.deleteReport.and.returnValue(response);

      const expected = cold('-c', { c: new Actions.DeleteReportSuccess(4) });
      expect(effects.deleteReport$).toBeObservable(expected);
    });

        it('should return new CandidateSearchToolCountedAction with zero totalCount on exception', () => {
            actions$ = hot('-a', { a: action });
            const response = cold('-#', {}, 'numberFormatException');
            mockCandidateService.count.and.returnValue(response);

            const countUpdatedAction = new CandidateSearchToolCountedAction(0);
            const expected = cold('--b', { b: countUpdatedAction });

            expect(effects.candidateSearchToolCount$).toBeObservable(expected);
        })

  it('should call the search api and return the search results', () => {
    const response = cold('-a|', { a: books });
    const expected = cold('-b|', { b: books.items });
    http.get = jest.fn(() => response);

    expect(service.searchBooks(queryTitle)).toBeObservable(expected);
    expect(http.get).toHaveBeenCalledWith(
      `https://www.googleapis.com/books/v1/volumes?q=${queryTitle}`
    );
  });