| import { FORM_ID } from '@grid-failure-information-app/shared/store/reducers/grid-failures/grid-failure-details-form.reducer'; |
| import { INITIAL_STATE } from './../../../shared/store/reducers/grid-failures/grid-failure-details-form.reducer'; |
| /******************************************************************************** |
| * Copyright (c) 2020 Contributors to the Eclipse Foundation |
| * |
| * See the NOTICE file(s) distributed with this work for additional |
| * information regarding copyright ownership. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0. |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| ********************************************************************************/ |
| import { Router } from '@angular/router'; |
| import { GridFailureDetailsSandbox } from '@grid-failure-information-app/pages/grid-failure/grid-failure-details/grid-failure-details.sandbox'; |
| import { StateEnum } from '@grid-failure-information-app/shared/constants/enums'; |
| import { FailureBranch, FailureHousenumber, FailureStation, GridFailure } from '@grid-failure-information-app/shared/models'; |
| import { State } from '@grid-failure-information-app/shared/store'; |
| import * as gridFailureActions from '@grid-failure-information-app/shared/store/actions/grid-failures.action'; |
| import { UtilService } from '@grid-failure-information-app/shared/utility/utility.service'; |
| import { NgbModal } from '@ng-bootstrap/ng-bootstrap'; |
| import { ActionsSubject, Store } from '@ngrx/store'; |
| import { of } from 'rxjs'; |
| import { createFormGroupState, EnableAction, DisableAction } from 'ngrx-forms'; |
| |
| describe('GridFailureDetailsSandbox', () => { |
| let service: GridFailureDetailsSandbox; |
| let appState: Store<State>; |
| let actionSubject: ActionsSubject; |
| let utilService: UtilService; |
| let router: Router; |
| let modalService: NgbModal; |
| let dispatchSpy: any; |
| |
| beforeEach(() => { |
| appState = { dispatch: () => {}, pipe: () => of(true), select: () => of(true), userDefinedProperties: { controlId: '' } } as any; |
| actionSubject = { pipe: () => of(true), map: () => ({}) } as any; |
| utilService = { displayNotification() {} } as any; |
| router = { navigateByUrl() {} } as any; |
| modalService = { open() {} } as any; |
| dispatchSpy = spyOn(appState, 'dispatch').and.callFake(() => {}); |
| |
| service = new GridFailureDetailsSandbox(appState, actionSubject, router, utilService, modalService); |
| const gridFailureDetailsFormState = createFormGroupState<GridFailure>( |
| FORM_ID, |
| new GridFailure({ |
| branchId: '123', |
| addressPolygonPoints: [1.24, 1.24], |
| }) |
| ); |
| service.gridFailureDetailsFormState$ = of(gridFailureDetailsFormState as any); |
| service.currentFormState = gridFailureDetailsFormState; |
| service.noBranchId = '123'; |
| }); |
| |
| it('should create GridFailureDetailsSandbox service', () => { |
| expect(service).toBeTruthy(); |
| }); |
| |
| it('should dispatch loadGridFailure Action via loadGridFailure(id)', () => { |
| service.loadGridFailure('id'); |
| expect(appState.dispatch).toHaveBeenCalledWith(gridFailureActions.loadGridFailureDetail({ payload: 'id' })); |
| }); |
| |
| it('should dispatch loadGridFailureBranches Action via loadGridFailureBranches()', () => { |
| service.loadGridFailureBranches(); |
| expect(appState.dispatch).toHaveBeenCalledWith(gridFailureActions.loadGridFailureBranches()); |
| }); |
| |
| it('should dispatch loadGridFailureClassifications Action via loadGridFailureClassifications()', () => { |
| service.loadGridFailureClassifications(); |
| expect(appState.dispatch).toHaveBeenCalledWith(gridFailureActions.loadGridFailureClassifications()); |
| }); |
| |
| it('should dispatch loadGridFailureTypes Action via loadGridFailureTypes()', () => { |
| service.loadGridFailureTypes(); |
| expect(appState.dispatch).toHaveBeenCalledWith(gridFailureActions.loadGridFailureTypes()); |
| }); |
| |
| it('should dispatch loadGridFailureStates Action via loadGridFailureStates()', () => { |
| service.loadGridFailureStates(); |
| expect(appState.dispatch).toHaveBeenCalledWith(gridFailureActions.loadGridFailureStates()); |
| }); |
| |
| it('should dispatch loadGridFailureRadii Action via loadGridFailureRadii()', () => { |
| service.loadGridFailureRadii(); |
| expect(appState.dispatch).toHaveBeenCalledWith(gridFailureActions.loadGridFailureRadii()); |
| }); |
| |
| it('should dispatch loadGridFailureExpectedReasons Action via loadGridFailureExpectedReasons()', () => { |
| service.loadGridFailureExpectedReasons(); |
| expect(appState.dispatch).toHaveBeenCalledWith(gridFailureActions.loadGridFailureExpectedReasons()); |
| }); |
| |
| it('should dispatch loadGridFailureVersions Action via loadGridFailureVersions(id)', () => { |
| service.loadGridFailureVersions('id'); |
| expect(appState.dispatch).toHaveBeenCalledWith(gridFailureActions.loadGridFailureVersions({ payload: 'id' })); |
| }); |
| |
| it('should dispatch loadGridFailureVersion Action via loadGridFailureVersion(VsNo)', () => { |
| service['gridFailureId'] = 'id'; |
| service.loadGridFailureVersion(1); |
| expect(appState.dispatch).toHaveBeenCalledTimes(2); |
| }); |
| |
| it('should dispatch loadGridFailureVersion Action via loadGridFailureVersion(VsNo)', () => { |
| service['gridFailureId'] = 'id'; |
| service.maxVersionNumber = 2; |
| service.loadGridFailureVersion(1); |
| expect(appState.dispatch).toHaveBeenCalledTimes(2); |
| }); |
| |
| it('should clear form state when current change is canceled and form state is pristine', () => { |
| const spy: any = spyOn(service as any, '_clear').and.callThrough(); |
| service.currentFormState = { isPristine: true } as any; |
| service.cancel(); |
| expect(spy).toHaveBeenCalled(); |
| }); |
| |
| it('should open modal when current change is canceled and form state is not pristine', () => { |
| spyOn(service['_modalService'], 'open').and.returnValue({ componentInstance: { title: '' }, result: { then: () => of(true) } } as any); |
| service.currentFormState = { isPristine: false } as any; |
| service.cancel(); |
| expect(modalService.open).toHaveBeenCalled(); |
| }); |
| |
| it('should dispatch actions to clear the form', () => { |
| service['_clear'](); |
| expect(appState.dispatch).toHaveBeenCalledTimes(3); |
| }); |
| |
| it('should call dispatch and clear if save a valid grid failure detail', () => { |
| const spy1 = spyOn(service as any, '_clear'); |
| const gfdetail = new GridFailure(); |
| gfdetail.id = 'id'; |
| gfdetail.responsibility = 'test'; |
| gfdetail.postcode = '00000'; |
| |
| service.currentFormState = { |
| ...service.currentFormState, |
| isValid: true, |
| value: gfdetail, |
| userDefinedProperties: { controlId: '' }, |
| }; |
| service.saveGridFailure(); |
| expect(dispatchSpy).toHaveBeenCalledWith(Object({ payload: gfdetail, type: gridFailureActions.saveGridFailure.type })); |
| expect(spy1).toHaveBeenCalled(); |
| }); |
| |
| it('should display a notification if the grid failure detail is invalid', () => { |
| const spy1 = spyOn(utilService, 'displayNotification'); |
| const gfdetail = new GridFailure(); |
| gfdetail.id = 'id'; |
| gfdetail.responsibility = 'test'; |
| gfdetail.postcode = '00000'; |
| |
| service.currentFormState = { |
| ...service.currentFormState, |
| isValid: false, |
| value: gfdetail, |
| userDefinedProperties: { controlId: '' }, |
| }; |
| service.saveGridFailure(); |
| expect(spy1).toHaveBeenCalled(); |
| }); |
| |
| it('should register events', () => { |
| let gridFailureDetailsFormResponse: any = { |
| value: { |
| failureBegin: 'test1', |
| failureEndPlanned: 'test2', |
| failureEndResupplied: 'test3', |
| postcode: '00000', |
| }, |
| userDefinedProperties: { controlId: '' }, |
| }; |
| service.gridFailureDetailsFormState$ = of(gridFailureDetailsFormResponse); |
| const gridFailure: GridFailure = new GridFailure(); |
| gridFailure.versionNumber = 3; |
| const gridFailureVersions: GridFailure[] = [gridFailure]; |
| spyOn(actionSubject, 'pipe').and.returnValue(of({ payload: gridFailureVersions })); |
| const spy = spyOn(service as any, '_showButtonsByState'); |
| |
| service.registerEvents(); |
| expect(service.currentFormState).toBeDefined(); |
| expect(spy).toHaveBeenCalled(); |
| }); |
| |
| it('should dispatch action in response to controlId = gridFailureDetailsForm', () => { |
| let formState: any = { |
| id: 'gridFailureDetailsForm', |
| value: { |
| statusIntern: StateEnum.CREATED, |
| postcode: '00000', |
| }, |
| userDefinedProperties: { controlId: 'gridFailureDetailsForm' }, |
| controls: { |
| postcode: { id: 'gridFailureDetailsForm.postcode' }, |
| }, |
| }; |
| spyOn(service.gridFailureDetailsFormState$, 'pipe').and.returnValue(of(formState)); |
| service.registerEvents(); |
| expect(appState.dispatch).toHaveBeenCalled(); |
| }); |
| |
| it('should dispatch action in response to controlId = gridFailureDetailsForm.postcode', () => { |
| let formState: any = { |
| value: { |
| statusIntern: StateEnum.CREATED, |
| postcode: '00000', |
| }, |
| userDefinedProperties: { controlId: 'gridFailureDetailsForm.postcode' }, |
| controls: { |
| postcode: { id: 'gridFailureDetailsForm.postcode' }, |
| }, |
| }; |
| spyOn(service.gridFailureDetailsFormState$, 'pipe').and.returnValue(of(formState)); |
| service.registerEvents(); |
| expect(appState.dispatch).toHaveBeenCalled(); |
| }); |
| |
| it('should dispatch action in response to controlId = gridFailureDetailsForm.city', () => { |
| let formState: any = { |
| value: { |
| statusIntern: StateEnum.CREATED, |
| postcode: '00000', |
| city: 'S', |
| }, |
| userDefinedProperties: { controlId: 'gridFailureDetailsForm.city' }, |
| controls: { |
| postcode: { id: 'gridFailureDetailsForm.postcode' }, |
| city: { id: 'gridFailureDetailsForm.city' }, |
| }, |
| }; |
| spyOn(service.gridFailureDetailsFormState$, 'pipe').and.returnValue(of(formState)); |
| service.registerEvents(); |
| expect(appState.dispatch).toHaveBeenCalled(); |
| }); |
| |
| it('should dispatch action in response to controlId = gridFailureDetailsForm.district', () => { |
| let formState: any = { |
| value: { |
| statusIntern: StateEnum.CREATED, |
| postcode: '00000', |
| city: 'X', |
| district: 'Y', |
| }, |
| userDefinedProperties: { controlId: 'gridFailureDetailsForm.district' }, |
| controls: { |
| postcode: { id: 'gridFailureDetailsForm.postcode' }, |
| city: { id: 'gridFailureDetailsForm.city' }, |
| district: { id: 'gridFailureDetailsForm.district' }, |
| }, |
| }; |
| spyOn(service.gridFailureDetailsFormState$, 'pipe').and.returnValue(of(formState)); |
| service.registerEvents(); |
| expect(appState.dispatch).toHaveBeenCalled(); |
| }); |
| |
| it('should dispatch action in response to controlId = gridFailureDetailsForm.street', () => { |
| let formState: any = { |
| value: { |
| statusIntern: StateEnum.CREATED, |
| postcode: '00000', |
| city: 'X', |
| district: 'Y', |
| street: 'Z', |
| }, |
| userDefinedProperties: { controlId: 'gridFailureDetailsForm.street' }, |
| controls: { |
| postcode: { id: 'gridFailureDetailsForm.postcode' }, |
| city: { id: 'gridFailureDetailsForm.city' }, |
| district: { id: 'gridFailureDetailsForm.district' }, |
| street: { id: 'gridFailureDetailsForm.street' }, |
| }, |
| }; |
| spyOn(service.gridFailureDetailsFormState$, 'pipe').and.returnValue(of(formState)); |
| service.registerEvents(); |
| expect(appState.dispatch).toHaveBeenCalled(); |
| }); |
| |
| it('should show qualify button state is applied', () => { |
| const state = StateEnum.CREATED; |
| (service as any)._showButtonsByState(state); |
| expect(service.showQualifyButton).toBeTruthy(); |
| }); |
| |
| it('should show qualify button state is updated', () => { |
| const state = StateEnum.UPDATED; |
| (service as any)._showButtonsByState(state); |
| expect(service.showQualifyButton).toBeTruthy(); |
| }); |
| |
| it('should show storno button state is applied', () => { |
| const state = StateEnum.CREATED; |
| (service as any)._showButtonsByState(state); |
| expect(service.showStornoButton).toBeTruthy(); |
| }); |
| |
| it('should show storno button state is updated', () => { |
| const state = StateEnum.UPDATED; |
| (service as any)._showButtonsByState(state); |
| expect(service.showStornoButton).toBeTruthy(); |
| }); |
| |
| it('should not show storno button or qualify button if other state', () => { |
| const state = StateEnum.COMPLETED; |
| (service as any)._showButtonsByState(state); |
| expect(service.showQualifyButton).toBeFalsy(); |
| expect(service.showStornoButton).toBeFalsy(); |
| }); |
| |
| it('should show update button if qualified', () => { |
| let state = StateEnum.QUALIFIED; |
| (service as any)._showButtonsByState(state); |
| expect(service.showUpdateButton).toBeTruthy(); |
| }); |
| |
| it('should show create button if state is NEW', () => { |
| const state = StateEnum.NEW; |
| (service as any)._showButtonsByState(state); |
| expect(service.showCreatedButton).toBeTruthy(); |
| }); |
| |
| it('should not show state buttons if state is an empty string', () => { |
| (service as any)._showButtonsByState(''); |
| expect(service.showCreatedButton).toBeFalsy(); |
| expect(service.showStornoButton).toBeFalsy(); |
| expect(service.showQualifyButton).toBeFalsy(); |
| }); |
| |
| it('should set the state in form to qualify and call save fuction', () => { |
| service.gridFailureInternalStates$ = { pipe: () => of({}), map: () => of({}) } as any; |
| spyOn(service.gridFailureInternalStates$, 'pipe').and.returnValue(of([{ status: StateEnum.QUALIFIED, id: '123' }])); |
| const spySave = spyOn(service, 'saveGridFailure'); |
| service.setState(StateEnum.QUALIFIED); |
| expect(spySave).toHaveBeenCalled(); |
| expect(dispatchSpy).toHaveBeenCalled(); |
| }); |
| |
| it('should set the state in form to canceled and call save fuction', () => { |
| service.gridFailureInternalStates$ = { pipe: () => of({}), map: () => of({}) } as any; |
| spyOn(service.gridFailureInternalStates$, 'pipe').and.returnValue(of([{ status: StateEnum.CANCELED, id: '123' }])); |
| const spySave = spyOn(service, 'saveGridFailure'); |
| service.setState(StateEnum.CANCELED); |
| expect(spySave).toHaveBeenCalled(); |
| expect(dispatchSpy).toHaveBeenCalled(); |
| }); |
| it('should set the state in form to qualify and call save fuction', () => { |
| service.gridFailureInternalStates$ = { pipe: () => of({}), map: () => of({}) } as any; |
| spyOn(service.gridFailureInternalStates$, 'pipe').and.returnValue(of([{ status: StateEnum.QUALIFIED, id: '123' }])); |
| const spySave = spyOn(service, 'saveGridFailure'); |
| service.setState(StateEnum.QUALIFIED); |
| expect(spySave).toHaveBeenCalled(); |
| expect(dispatchSpy).toHaveBeenCalled(); |
| }); |
| |
| it('should set the state in form to canceled and call save fuction', () => { |
| service.gridFailureInternalStates$ = { pipe: () => of({}), map: () => of({}) } as any; |
| spyOn(service.gridFailureInternalStates$, 'pipe').and.returnValue(of([{ status: StateEnum.CANCELED, id: '123' }])); |
| const spySave = spyOn(service, 'saveGridFailure'); |
| service.setState(StateEnum.CANCELED); |
| expect(spySave).toHaveBeenCalled(); |
| expect(dispatchSpy).toHaveBeenCalled(); |
| }); |
| |
| it('should set the state in form to updated and call save fuction', () => { |
| service.gridFailureInternalStates$ = { pipe: () => of({}), map: () => of({}) } as any; |
| spyOn(service.gridFailureInternalStates$, 'pipe').and.returnValue(of([{ status: StateEnum.UPDATED, id: '123' }])); |
| const spySave = spyOn(service, 'saveGridFailure'); |
| service.setState(StateEnum.UPDATED); |
| expect(spySave).toHaveBeenCalled(); |
| expect(dispatchSpy).toHaveBeenCalled(); |
| }); |
| |
| it('should load GridFailureStations', () => { |
| service.loadGridFailureStations(); |
| expect(dispatchSpy).toHaveBeenCalledWith(Object({ type: gridFailureActions.loadGridFailureStations.type })); |
| }); |
| |
| it('should map lon and lat values', () => { |
| const gfdetail = new GridFailure(); |
| gfdetail.id = 'id'; |
| gfdetail.responsibility = 'test'; |
| |
| service.currentFormState = { |
| ...service.currentFormState, |
| isValid: true, |
| value: gfdetail, |
| }; |
| |
| service.latLonMapping(null); |
| expect(dispatchSpy).not.toHaveBeenCalled(); |
| |
| const event = new FailureStation(); |
| event.latitude = 1.24; |
| event.longitude = 1.23; |
| |
| service.latLonMapping(event); |
| |
| expect(dispatchSpy).toHaveBeenCalled(); |
| }); |
| |
| it('should dispatch loadAddressPostalcodes Action via loadAddressPostalcodes()', () => { |
| service.loadAddressPostalcodes(); |
| expect(appState.dispatch).toHaveBeenCalledWith(gridFailureActions.loadAddressPostalcodes()); |
| }); |
| |
| it('should map stationId to gridFailure object', () => { |
| const gfdetail = new GridFailure(); |
| gfdetail.id = 'id'; |
| gfdetail.stationId = '1'; |
| |
| service.currentFormState = { |
| ...service.currentFormState, |
| isValid: true, |
| value: gfdetail, |
| }; |
| |
| const stationId = '2'; |
| |
| service.setStationId(stationId); |
| |
| expect(dispatchSpy).toHaveBeenCalled(); |
| }); |
| |
| it('should reset Coords', () => { |
| const gfdetail = new GridFailure(); |
| gfdetail.id = 'id'; |
| gfdetail.longitude = 1.0; |
| gfdetail.latitude = 1.0; |
| |
| service.currentFormState = { |
| ...service.currentFormState, |
| isValid: true, |
| value: gfdetail, |
| }; |
| |
| service.resetCoords(); |
| |
| expect(dispatchSpy).toHaveBeenCalled(); |
| }); |
| |
| it('should reset stationId', () => { |
| const gfdetail = new GridFailure(); |
| gfdetail.id = 'id'; |
| gfdetail.stationId = 'test'; |
| |
| service.currentFormState = { |
| ...service.currentFormState, |
| isValid: true, |
| value: gfdetail, |
| }; |
| |
| service.resetStationId(); |
| |
| expect(dispatchSpy).toHaveBeenCalled(); |
| }); |
| |
| it('should trigger formatter and check if the right value was returned', () => { |
| const failureStation: FailureStation = new FailureStation(); |
| failureStation.stationName = 'test'; |
| failureStation.stationId = 'test'; |
| const result1 = service.formatter(failureStation); |
| const result2 = service.formatter('test'); |
| |
| expect(result1).toBe('test (test)'); |
| expect(result2).toBe('test'); |
| }); |
| |
| it('should dispatch Action after loadPostalCodes', () => { |
| service.loadAddressPostalcodes(); |
| expect(appState.dispatch).toHaveBeenCalledWith(gridFailureActions.loadAddressPostalcodes()); |
| }); |
| |
| it('should trigger searchForAddressPostalcodes and check if the right value was returned', () => { |
| (service as any)._addressPostalcodes = ['test', 'test1', 'test2', 'hello']; |
| const text$ = of('hello'); |
| const result = service.searchForAddressPostalcodes(text$); |
| |
| result.subscribe(item => { |
| expect(item).toEqual(['hello']); |
| }); |
| }); |
| |
| it('should trigger searchForAddressPostalcodes and check if the right value was returned if length is under 2', () => { |
| (service as any)._addressPostalcodes = ['test', 'test1', 'test2', 'hello']; |
| const text$ = of('h'); |
| const result = service.searchForAddressPostalcodes(text$); |
| |
| result.subscribe(item => { |
| expect(item).toEqual([]); |
| }); |
| }); |
| |
| it('should trigger searchForStation and check if the right value was returned', () => { |
| const failureStation: FailureStation = new FailureStation(); |
| failureStation.stationName = 'hello'; |
| (service as any)._gridFailureStations = [new FailureStation(), new FailureStation(), failureStation]; |
| const text$ = of('hello'); |
| const result = service.searchForStation(text$); |
| |
| result.subscribe(item => { |
| expect(item).toEqual([failureStation]); |
| }); |
| }); |
| |
| it('should trigger searchForStation and check if the right value was returned if length is under 2', () => { |
| const failureStation: FailureStation = new FailureStation(); |
| failureStation.stationName = 'hello'; |
| (service as any)._gridFailureStations = [new FailureStation(), new FailureStation(), failureStation]; |
| const text$ = of('h'); |
| const result = service.searchForStation(text$); |
| |
| result.subscribe(item => { |
| expect(item).toEqual([]); |
| }); |
| }); |
| |
| it('should call setLatLong and dispatch loadGridFailureAddress()', () => { |
| const failureHousenumber = new FailureHousenumber(); |
| failureHousenumber.housenumber = 'test'; |
| failureHousenumber.uuid = 'hello'; |
| service.addressHouseNumbers = [failureHousenumber]; |
| const hsnr = 'test'; |
| service.setLatLong(hsnr); |
| |
| expect(appState.dispatch).toHaveBeenCalledWith(gridFailureActions.loadGridFailureAddress({ payload: failureHousenumber.uuid })); |
| }); |
| |
| it('should set the required values false if the brnach id is the right', () => { |
| service.noBranchId = '123'; |
| service.currentFormState = { controls: { branchId: { value: '123' } as any } as any } as any; |
| (service as any).setDynamicRequired(); |
| expect(service.isFieldRequiredDependingOnBranchId).toBeFalsy(); |
| }); |
| |
| it('should set the required values true if the brnach id is the not right', () => { |
| service.noBranchId = '456'; |
| service.currentFormState = { controls: { branchId: { value: '123' } as any } as any } as any; |
| (service as any).setDynamicRequired(); |
| expect(service.isFieldRequiredDependingOnBranchId).toBeTruthy(); |
| }); |
| |
| it('should set the noBranchId value if found OS Brnach', () => { |
| const branch: FailureBranch = new FailureBranch(); |
| branch.id = '123'; |
| branch.name = 'OS'; |
| branch.description = 'ohne Sparte'; |
| const branches: FailureBranch[] = [branch]; |
| service.gridFailureBranches$ = of(branches); |
| service.noBranchId = '123'; |
| (service as any).setNoBranchId(); |
| expect(service.noBranchId).toBe('123'); |
| }); |
| |
| it('should not set the noBranchId value null if not found OS Brnach', () => { |
| const branch: FailureBranch = new FailureBranch(); |
| branch.id = '123'; |
| branch.name = 'W'; |
| branch.description = 'Wasser'; |
| const branches: FailureBranch[] = [branch]; |
| service.gridFailureBranches$ = of(branches); |
| service.noBranchId = '123'; |
| (service as any).setNoBranchId(); |
| expect(service.noBranchId).toBe(null); |
| }); |
| |
| it('should call resetFailureLocationValues and dispatch an setValueAction', () => { |
| const gfdetail = new GridFailure(); |
| gfdetail.id = 'id'; |
| gfdetail.responsibility = 'test'; |
| gfdetail.stationId = 'test'; |
| |
| service.currentFormState = { |
| ...service.currentFormState, |
| isValid: true, |
| value: gfdetail, |
| }; |
| |
| service.resetFailureLocationValues(); |
| expect(dispatchSpy).toHaveBeenCalled(); |
| }); |
| |
| it('should call saveFailureLocationSpecificParts', () => { |
| let part: string = 'NS'; |
| service.disableUnnecessaryRequiredProperties(part); |
| expect(appState.dispatch).toHaveBeenCalledWith(new EnableAction(INITIAL_STATE.controls.postcode.id)); |
| expect(appState.dispatch).toHaveBeenCalledWith(new DisableAction(INITIAL_STATE.controls.radiusId.id)); |
| |
| part = 'MS'; |
| service.disableUnnecessaryRequiredProperties(part); |
| expect(appState.dispatch).toHaveBeenCalledWith(new EnableAction(INITIAL_STATE.controls.postcode.id)); |
| expect(appState.dispatch).toHaveBeenCalledWith(new DisableAction(INITIAL_STATE.controls.radiusId.id)); |
| |
| part = 'map'; |
| service.disableUnnecessaryRequiredProperties(part); |
| expect(appState.dispatch).toHaveBeenCalledWith(new DisableAction(INITIAL_STATE.controls.postcode.id)); |
| expect(appState.dispatch).toHaveBeenCalledWith(new DisableAction(INITIAL_STATE.controls.radiusId.id)); |
| }); |
| |
| it('should call saveFailureLocationSpecificParts', () => { |
| const subject = service.isAddressLoaded(); |
| subject.subscribe(item => { |
| expect(item).toBeTruthy(); |
| }); |
| }); |
| }); |