src/app/services/jobs/base-data-loader.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 } from '@angular/core/testing';
import { Observable } from 'rxjs/Observable';
import { SessionContext } from '../../common/session-context';
import { Branch } from '../../model/branch';
import { CostCenter } from '../../model/cost-center';
import { Status } from '../../model/status';
import { User } from '../../model/user';
import { MessageDefines, MessageService } from '../../services/message.service';
import { USERS } from '../../test-data/users';
import { AbstractMockObservableService } from '../../testing/abstract-mock-observable.service';
import { RoleAccess } from './../../model/role-access';
import { UserDepartment } from './../../model/user-department';
import { BaseDataLoaderService } from './base-data-loader.service';
import { RoleAccessHelperService } from './role-access-helper.service';
import { BackendSettings } from './../../model/backend-settings';
import { HttpClient } from '@angular/common/http';
import { TERRITORY } from '../../test-data/territories';
import { Territory } from '../../model/territory';

describe('BaseDataLoaderService', () => {
  class MockDataService extends AbstractMockObservableService {
    public branchList: Branch[];
    public statusList: Status[];
    public departmentList: UserDepartment[];
    public costCenters: CostCenter[];
    public emailAddresses: string[];
    public responsibleOnSiteNameList: string[];
    public NetworkControlsNameList: string[];
    public areaOfSwitchingList: string[];
    public statusError;
    public branchError;
    public costCenterError;
    public departmentError;
    public responsibleOnSiteNameError;
    public NetworkControlsNameError;
    public emailAddressesError;
    public areaOfSwitchingError;

    getStatuses() {
      const newService = new MockDataService();
      newService.content = this.statusList;
      newService.error = this.statusError;
      return newService;
    }

    getResponsiblesOnSiteFromGridmeasures() {
      const newService = new MockDataService();
      newService.content = this.responsibleOnSiteNameList;
      newService.error = this.responsibleOnSiteNameError;
      return newService;
    }

    getNetworkControlsFromSingleGridmeasures() {
      const newService = new MockDataService();
      newService.content = this.NetworkControlsNameList;
      newService.error = this.NetworkControlsNameError;
      return newService;
    }

    getTerritories() {
      const newService = new MockDataService();
      newService.content = this.areaOfSwitchingList;
      newService.error = this.areaOfSwitchingError;
      return newService;
    }

    getBranches() {
      const newService = new MockDataService();
      newService.content = this.branchList;
      newService.error = this.branchError;
      return newService;
    }
    getCostCenters() {
      const newService = new MockDataService();
      newService.content = this.costCenters;
      newService.error = this.costCenterError;
      return newService;
    }
    getUserDepartments() {
      const newService = new MockDataService();
      newService.content = this.departmentList;
      newService.error = this.departmentError;
      return newService;
    }
    getEmailAddressesFromTemplates() {
      const newService = new MockDataService();
      newService.content = this.emailAddresses;
      newService.error = this.emailAddressesError;
      return newService;
    }
  }

  class MockUserService extends AbstractMockObservableService {
    public userList: User[];
    public userError;
    public http: HttpClient;
    getUsers() {
      const newService = new MockDataService();
      newService.content = this.userList;
      newService.error = this.userError;
      return newService;
    }
  }
  class MockRoleAccessService extends AbstractMockObservableService {
    public roleAccess: RoleAccess;
    public roleAccessError;
    public http: HttpClient;
    getRoleAccessDefinition(): Observable<RoleAccess> {
      const newService = new MockDataService();
      newService.content = this.roleAccess;
      newService.error = this.roleAccessError;
      return newService as any as Observable<RoleAccess>;
    }
  }

  class MockBackendSettingsService extends AbstractMockObservableService {
    public backendSettings: BackendSettings;
    public backendSettingsError;
    public http: HttpClient;
    getBackendSettings() {
      const newService = new MockDataService();
      newService.content = this.backendSettings;
      newService.error = this.backendSettingsError;
      return newService;
    }
  }


  let sessionContext: SessionContext;
  let messageService: MessageService;
  let mockRoleAccessService;
  let mockDataService;
  let loaderServer: BaseDataLoaderService;
  let mockUserService;
  let roleAccessHelper: RoleAccessHelperService;
  let mockBackendSettings;


  beforeEach(async(() => {
    mockDataService = new MockDataService();
    mockUserService = new MockUserService();
    mockRoleAccessService = new MockRoleAccessService();
    mockBackendSettings = new MockBackendSettingsService();

    sessionContext = new SessionContext();
    sessionContext.clearStorage();
    messageService = new MessageService(sessionContext);
    roleAccessHelper = new RoleAccessHelperService();

    loaderServer = new BaseDataLoaderService(mockDataService, mockUserService, messageService,
      sessionContext, mockRoleAccessService, roleAccessHelper, mockBackendSettings);

  }));


  it('should be load the base-data after MSG_LOG_IN_SUCCEEDED-Message "', fakeAsync(() => {
    mockDataService.statusList = [{ id: 1, name: 'neu' }];
    mockDataService.branchList = [{ id: 1, name: 'W', description: 'Wasser' }];
    mockDataService.departmentList = [{ id: 1, name: 'Abteilung 1' }, { id: 2, name: 'Abteilung 2' }];
    mockDataService.costCenters = [{ id: 1, name: 'cc1' }, { id: 2, name: 'cc2' }];
    mockDataService.emailAddresses = ['testpreconfmail@test.de', 'testpreconfmail2@test.de'];
    mockDataService.responsibleOnSiteNameList = ['harald', 'simon'];
    mockDataService.NetworkControlsNameList = ['test', 'mich'];
    mockDataService.areaOfSwitchingList = JSON.parse(JSON.stringify(TERRITORY));
    mockUserService.userList = USERS;
    mockBackendSettings.backendSettings = [{ reminderPeriod: 48 }];
    const roleAccessDef: RoleAccess = {
      editRoles: [
        {
          name: 'planned-policies-measureapplicant',
          gridMeasureStatusIds: [
            0
          ]
        },
        {
          name: 'planned-policies-measureplanner',
          gridMeasureStatusIds: [
            1
          ]
        },
        {
          name: 'planned-policies-measureapprover',
          gridMeasureStatusIds: [
            2
          ]
        }
      ],
      controls: [
        {
          gridMeasureStatusId: 0,
          activeButtons: [
            'save',
            'apply'
          ],
          inactiveFields: [
            'titleControl'
          ]
        }
      ],
      stornoSection:
      {
        'stornoRoles': [
          'planned-policies-measureapplicant',
          'planned-policies-measureplanner',
          'planned-policies-measureapprover',
          'planned-policies-requester',
          'planned-policies-clearance'
        ]
      },
      duplicateSection:
      {
        'duplicateRoles': [
          'planned-policies-measureapplicant'
        ]
      }
    };

    (mockRoleAccessService as any).roleAccess = roleAccessDef;
    roleAccessHelper.init(roleAccessDef);

    expect(sessionContext.getStatuses()).toBeNull();
    expect(sessionContext.getBranches()).toBeNull();
    expect(sessionContext.getAllUserDepartments()).toBeNull();
    expect(sessionContext.getAllUsers()).toBeNull();
    expect(sessionContext.getBackendsettings()).toBeNull();
    expect(sessionContext.getEmailAddressesFromTemplates()).toBeNull();

    expect(sessionContext.getResponsiblesOnSiteFromGridmeasures()).toBeNull();
    expect(sessionContext.getTerritories()).toBeNull();
    messageService.loginLogoff$.emit(MessageDefines.MSG_LOG_IN_SUCCEEDED);

    tick();

    expect(sessionContext.getAllUserDepartments().length).toBe(2);
    expect(sessionContext.getAllUserDepartments()[0].name).toBe('Abteilung 1');

    expect(sessionContext.getStatuses().length).toBe(1);
    expect(sessionContext.getStatuses()[0].name).toBe('neu');

    expect(sessionContext.getBranches().length).toBe(1);
    expect(sessionContext.getBranches()[0].description).toBe('Wasser');

    expect(sessionContext.getEmailAddressesFromTemplates().length).toBe(2);
    expect(sessionContext.getEmailAddressesFromTemplates()[0]).toBe('testpreconfmail@test.de');

    expect(sessionContext.getResponsiblesOnSiteFromGridmeasures().length).toBe(2);
    expect(sessionContext.getResponsiblesOnSiteFromGridmeasures()[0]).toBe('harald');

    expect(sessionContext.getNetworkControlsFromSingleGridmeasures().length).toBe(2);
    expect(sessionContext.getNetworkControlsFromSingleGridmeasures()[0]).toBe('test');

    expect(sessionContext.getTerritories().length).toBe(3);
    expect(sessionContext.getTerritories()[0].name).toBe('h1');

    expect(sessionContext.getEmailAddressesFromTemplates().length).toBe(2);

    expect(sessionContext.getAllUsers().length).toBe(3);

    expect(sessionContext.getBackendsettings()[0].reminderPeriod).toBe(48);
    expect(roleAccessHelper.getRoleAccessDefinitions().editRoles.length > 0).toBeTruthy();

  }));

  it('should log to the console if errors occur while loading', fakeAsync(() => {
    spyOn(console, 'log');
    mockDataService.costCenterError = 'Error in costCenter service';
    mockDataService.responsibleOnSiteNameError = 'Error in responsibleOnSiteName service';
    mockDataService.branchError = 'Error in branch service';
    mockDataService.statusError = 'Error in status service';
    mockUserService.userError = 'Error in user service';
    mockDataService.departmentError = 'Error in department service';
    mockDataService.emailAddressError = 'Error in emailAddress service';
    mockDataService.areaOfSwitchingError = 'Error in areaOfSwitching service';
    mockBackendSettings.backendSettingsError = 'Error in backendsettings service';
    (mockRoleAccessService as MockRoleAccessService).roleAccessError = 'Error in roleAcess service';
    messageService.loginLogoff$.emit(MessageDefines.MSG_LOG_IN_SUCCEEDED);
    messageService.loginLogoff$.emit(MessageDefines.MSG_LOG_OFF);

    tick();

    expect(console.log).toHaveBeenCalledTimes(9);

  }));
});