src/app/services/jobs/reminder-caller-job.service.spec.ts

/*
******************************************************************************
* Copyright © 2018 PTA GmbH.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
*
*     http://www.eclipse.org/legal/epl-v10.html
*
******************************************************************************
*/
import { async, fakeAsync, tick, TestBed, ComponentFixture, inject, discardPeriodicTasks } from '@angular/core/testing';

import { MessageService, MessageDefines } from '../../services/message.service';
import { AbstractMockObservableService } from '../../testing/abstract-mock-observable.service';
import { SessionContext } from '../../common/session-context';
import { ReminderCallerJobService } from './reminder-caller-job.service';
import { Globals } from '../../common/globals';
import { ReminderService } from '../reminder.service';



describe('ReminderCallerJobService', () => {

  class MockReminderService extends AbstractMockObservableService {

    getCurrentReminders() {
      return this;
    }
    getExpiredReminders() {
      return this;
    }
  }


  let sessionContext: SessionContext;
  let messageService: MessageService;
  let mockReminderService;
  let injectedService;

  beforeEach(async(() => {

    mockReminderService = new MockReminderService();
    sessionContext = new SessionContext();
    sessionContext.clearStorage();
    messageService = new MessageService(sessionContext);
    injectedService = new ReminderCallerJobService(sessionContext, mockReminderService, messageService);

    TestBed.configureTestingModule({
      providers: [
        { provide: ReminderService, useValue: mockReminderService },
        { provide: SessionContext, useValue: sessionContext },
        MessageService
      ]
    }).compileComponents();

  }));

  it('should init the timer after successfully login', fakeAsync(() => {
    spyOn(injectedService, 'init').and.callThrough();
    expect(injectedService.init).toHaveBeenCalledTimes(0);

    messageService.loginLogoff$.emit(MessageDefines.MSG_LOG_IN_SUCCEEDED);
    tick();

    expect(injectedService.init).toHaveBeenCalledTimes(1);
    discardPeriodicTasks();
  }));

  it('should destroy the timer after logout', fakeAsync(() => {
    spyOn(injectedService, 'destroy').and.callThrough();
    messageService.loginLogoff$.emit(MessageDefines.MSG_LOG_IN_SUCCEEDED);
    tick();

    expect(injectedService.destroy).toHaveBeenCalledTimes(0);

    messageService.loginLogoff$.emit(MessageDefines.MSG_LOG_OFF);
    tick();

    expect(injectedService.destroy).toHaveBeenCalledTimes(1);
    discardPeriodicTasks();
  }));

  it('should set setUpcomingReminder and setOverdueReminder to true when remindernotifications exist', fakeAsync(() => {
    spyOn(injectedService, 'init').and.callThrough();
    sessionContext.setUpcomingReminder(false);
    sessionContext.setOverdueReminder(false);

    mockReminderService.content = [111];
    Globals.REMINDER_JOB_POLLING_START_DELAY = 10;
    expect(sessionContext.getUpcomingReminder()).toBeFalsy();
    expect(sessionContext.getOverdueReminder()).toBeFalsy();

    messageService.loginLogoff$.emit(MessageDefines.MSG_LOG_IN_SUCCEEDED);
    tick(15);

    expect(injectedService.init).toHaveBeenCalledTimes(1);
    expect(sessionContext.getUpcomingReminder()).toBeTruthy();
    expect(sessionContext.getOverdueReminder()).toBeTruthy();
    discardPeriodicTasks();
  }));

  it('should set setUpcomingReminder and setOverdueReminder to false when the are no remindernotifications', fakeAsync(() => {
    spyOn(injectedService, 'init').and.callThrough();
    sessionContext.setUpcomingReminder(false);
    sessionContext.setOverdueReminder(false);

    mockReminderService.content = [];
    Globals.REMINDER_JOB_POLLING_START_DELAY = 10;

    expect(sessionContext.getUpcomingReminder()).toBeFalsy();
    expect(sessionContext.getOverdueReminder()).toBeFalsy();

    messageService.loginLogoff$.emit(MessageDefines.MSG_LOG_IN_SUCCEEDED);
    tick(15);

    expect(injectedService.init).toHaveBeenCalledTimes(1);
    expect(sessionContext.getUpcomingReminder()).toBeFalsy();
    expect(sessionContext.getOverdueReminder()).toBeFalsy();
    discardPeriodicTasks();
  }));

  it('should call "setError" when an error occurs while running "doJob"', fakeAsync(() => {
    spyOn(injectedService, 'setError').and.callThrough();
    sessionContext.setUpcomingReminder(false);
    sessionContext.setOverdueReminder(false);

    Globals.REMINDER_JOB_POLLING_START_DELAY = 10;
    mockReminderService.error = 'REMINDER_MOCK_ERROR';
    expect(sessionContext.getUpcomingReminder()).toBe(false);
    expect(sessionContext.getOverdueReminder()).toBeFalsy();

    messageService.loginLogoff$.emit(MessageDefines.MSG_LOG_IN_SUCCEEDED);
    tick(15);

    expect(injectedService.setError).toHaveBeenCalledTimes(2);
    discardPeriodicTasks();
  }));


});