src/app/dialogs/entry/entry.component.spec.ts - openk-usermodules/org.eclipse.openk-usermodules.elogbookFE - Git at Google

 /**
 ******************************************************************************
 * Copyright © 2017-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
 *
 ******************************************************************************
 */
 /* tslint:disable:no-unused-variable */
 import { FormsModule } from '@angular/forms';
 import { async, fakeAsync, ComponentFixture, TestBed, tick, inject } from '@angular/core/testing';
 import { By } from '@angular/platform-browser';
 import { Injectable, DebugElement, Component } from '@angular/core';
 import { click, newEvent } from '../../testing';
 import { DaterangepickerConfig, Daterangepicker } from 'ng2-daterangepicker';
 import { AbstractMockObservableService } from '../../common/abstract-mock-observable.service';
 import { MockComponent } from '../../testing/mock.component';
 import { MdDialogRef } from '@angular/material';
 import { EntryComponent } from './entry.component';
 import { USERS } from '../../test-data/users';
 import { NotificationService } from '../../services/notification.service';
 import { StringToDatePipe } from '../../common-components/pipes/string-to-date.pipe';
 import { FormattedTimestampPipe } from '../../common-components/pipes/formatted-timestamp.pipe';
 import { Globals } from '../../common/globals';
 import { SessionContext } from '../../common/session-context';
 import { CURRENT_NOTIFICATIONS, FINISHED_NOTIFICATIONS, OPEN_NOTIFICATIONS, NOTIFICATION_VERSIONS } from '../../test-data/notifications';
 import { Notification } from '../../model/notification';
 import { StatusEn } from '../../common/enums';
 import { STATUSES } from '../../test-data/statuses';
 import { BRANCHES } from '../../test-data/branches';
 import { GRIDTERRITORIES } from '../../test-data/gridterritories';
 import { FilterMatrix } from '../../model/controller-model/filter-matrix';
 import { FILTER_MATRIX_NONE_SELECTED } from '../../test-data/filter-matrix';
 import { FILTER_MATRIX_UNIQUE_BRANCH } from '../../test-data/filter-matrix';
 import { FILTER_MATRIX_UNIQUE_GRIDTERRITORY } from '../../test-data/filter-matrix';

 import { MessageService } from '../../services/message.service';


 export class EntryComponentMocker {
   public static getComponentMocks() {
     return [
       MockComponent({ selector: 'app-entry' }),
       MockComponent({ selector: 'app-remove-button', inputs: ['nullableAttribute'], outputs: ['nullableAttribute'] }),
       MockComponent({
         selector: 'app-autocomplete',
         inputs: ['notification'],
         outputs: ['notification']
       }),
     ];

   }
 }

 describe('EntryComponent', () => {
 let component: EntryComponent;
 let fixture: ComponentFixture<EntryComponent>;
   let sessionContext: SessionContext;

   class MockDialogRef extends AbstractMockObservableService {
     close() { }
   }

   class MockNotificationService extends AbstractMockObservableService {

     createNotification(newNotification) {
       this.content = newNotification;
       return this;
     };

     updateNotification(updatedNotification) {
       this.content = updatedNotification;
       return this;
     };

     getNotificationVersions(incidentId: number) {
       return this;
     }
   }
   let mockNotificationService;
   let messageService;

   beforeEach(async(() => {
     messageService = new MessageService();
     sessionContext = new SessionContext();
     sessionContext.setBranches(BRANCHES);
     sessionContext.setGridTerritories(GRIDTERRITORIES);
     sessionContext.setfilterMatrix(FILTER_MATRIX_NONE_SELECTED);
     mockNotificationService = new MockNotificationService();

     TestBed.configureTestingModule({
       imports: [FormsModule],
       declarations: [
         EntryComponent,
         StringToDatePipe,
         FormattedTimestampPipe,
         MockComponent({ selector: 'input', inputs: ['options'] }),
         MockComponent({
           selector: 'app-autocomplete',
           inputs: ['notification'],
           outputs: ['notification']
         }),
         MockComponent({
           selector: 'app-remove-button',
           inputs: ['nullableAttribute'],
           outputs: ['nullableAttribute']
         })
       ],
       providers: [
         { provide: MdDialogRef, useClass: MockDialogRef },
         { provide: NotificationService, useValue: mockNotificationService },
         { provide: SessionContext, useClass: SessionContext },
         { provide: MessageService, useValue: messageService },
         DaterangepickerConfig,
         Daterangepicker
       ]
     })
       .compileComponents();
   }));

   beforeEach(() => {
     fixture = TestBed.createComponent(EntryComponent);
     component = fixture.componentInstance;
     component.user = USERS[1];
     component.sessionContext.setCurrUser(USERS[1]);
     component.sessionContext.setBranches(BRANCHES);
     component.sessionContext.setGridTerritories(GRIDTERRITORIES);
     component.sessionContext.setfilterMatrix(FILTER_MATRIX_NONE_SELECTED);
     component.branches = BRANCHES;
     component.gridTerritories = GRIDTERRITORIES;
   });

   it('should change the Version and set the according notification', async(() => {
     component.notificationVersions = NOTIFICATION_VERSIONS;
     component.notification = NOTIFICATION_VERSIONS[0];
     component.isReadOnlyDialog = true;
     fixture.detectChanges();

     fixture.whenStable().then(() => {
       fixture.detectChanges();
       const select = fixture.debugElement.query(By.css('select[name=notificationSelection]'));
       select.nativeElement.value = '3';
       select.nativeElement.dispatchEvent(newEvent('change'));
       fixture.detectChanges();

       fixture.whenStable().then(() => {
         fixture.detectChanges();
         expect(component.notification.version).toBe(NOTIFICATION_VERSIONS[2].version);
       });

     });
   }));

   it('should call statusChanged on changing the status (inWork)', async(() => {
     spyOn(component, 'statusChanged').and.callThrough();
     component.sessionContext.setStatuses(STATUSES);
     const currNotification: Notification = NOTIFICATION_VERSIONS[0];
     component.notification = currNotification;
     fixture.detectChanges();

     fixture.whenStable().then(() => {
       expect(component.notification.fkRefNotificationStatus).toBe(NOTIFICATION_VERSIONS[0].fkRefNotificationStatus);

       const select = fixture.debugElement.query(By.css('select[name=statusSelection]'));
       select.nativeElement.value = StatusEn.inWork;
       select.nativeElement.dispatchEvent(newEvent('change'));
       fixture.detectChanges();

       fixture.whenStable().then(() => {
         expect(component.statusChanged).toHaveBeenCalledWith(StatusEn.inWork.toString(), currNotification);
       });

     });
   }));

   it('should call statusChanged on changing the status (done)', async(() => {
     spyOn(component, 'statusChanged').and.callThrough();
     component.sessionContext.setStatuses(STATUSES);
     const currNotification: Notification = NOTIFICATION_VERSIONS[0];
     component.notification = currNotification;
     fixture.detectChanges();

     fixture.whenStable().then(() => {
       expect(component.notification.fkRefNotificationStatus).toBe(NOTIFICATION_VERSIONS[0].fkRefNotificationStatus);

       const select = fixture.debugElement.query(By.css('select[name=statusSelection]'));
       select.nativeElement.value = StatusEn.done;
       select.nativeElement.dispatchEvent(newEvent('change'));
       fixture.detectChanges();

       fixture.whenStable().then(() => {
         expect(component.statusChanged).toHaveBeenCalledWith(StatusEn.done.toString(), currNotification);
       });

     });
   }));

   it('should call setNotification service methode and return an error', async(() => {
     const currNotification: Notification = OPEN_NOTIFICATIONS[0];
     currNotification.beginDate = '';
     mockNotificationService.error = 'SETNOTIFICATION_ERROR';
     component.isReadOnlyDialog = true;
     fixture.detectChanges();
     mockNotificationService.getNotificationVersions(currNotification.id).subscribe((resp) => {

       fixture.whenStable().then(() => {
         fixture.detectChanges();
         expect(component.notification.id).toBe(currNotification.id);
         expect(component.notificationVersions.length).toBe(OPEN_NOTIFICATIONS.length);
         expect(component.sessionContext.bannerMessage.text).toEqual('Fehler beim Lesen der Versionen von der Datenbank.');
       });
     });

     component.setNotification(currNotification);
     fixture.detectChanges();

   }));

   it('should call setNotification service methode and set right notificationVersions', async(() => {
     const currNotification: Notification = OPEN_NOTIFICATIONS[0];
     mockNotificationService.content = OPEN_NOTIFICATIONS;
     component.isReadOnlyDialog = true;
     fixture.detectChanges();
     mockNotificationService.getNotificationVersions(currNotification.id).subscribe((resp) => {

       fixture.whenStable().then(() => {
         fixture.detectChanges();
         expect(component.notification.id).toBe(currNotification.id);
         expect(component.notificationVersions.length).toBe(OPEN_NOTIFICATIONS.length);
       });
     });

     component.setNotification(currNotification);
     fixture.detectChanges();

   }));

   it('should call getNotificationVersions service methode and set current user as create user', async(() => {
     const currNotification = FINISHED_NOTIFICATIONS[0];
     currNotification.createUser = '';
     mockNotificationService.content = FINISHED_NOTIFICATIONS;
     component.isReadOnlyDialog = true;

     mockNotificationService.getNotificationVersions(currNotification.id).subscribe((resp) => {
       component.notificationVersions = resp;
       fixture.whenStable().then(() => {

         fixture.detectChanges();
         const des = fixture.debugElement.queryAll(By.css('.nvo'));
         expect(des.length).toBe(FINISHED_NOTIFICATIONS.length);
       });
     });
   }));

   it('InstructionDialog: only statusSelection should be reuqired on instructionDialog', async(() => {
     component.isInstructionDialog = true;
     fixture.detectChanges();

     let de = fixture.debugElement.query(By.css('.form-control[name=statusSelection]'));
     expect(de.nativeElement.required).toBe(true);

     de = fixture.debugElement.query(By.css('.form-control[name=gridTerritorySelection]'));
     expect(de.nativeElement.required).toBe(false);

     de = fixture.debugElement.query(By.css('.form-control[name=branchSelection]'));
     expect(de.nativeElement.required).toBe(false);

   }));

   it('InstructionDialog: should call add on click button "Hinzufügen"', async(() => {
     spyOn(component, 'add').and.callThrough();
     component.isInstructionDialog = true;
     fixture.detectChanges();

     component.notification.notificationText = 'TestContent';
     component.notification.fkRefNotificationStatus = 1;
     fixture.detectChanges();

     const de = fixture.debugElement.query(By.css('.btn-success'));
     click(de);

     fixture.whenStable().then(() => {
       expect(component.notification.responsibilityControlPoint).toBe(USERS[1].name);
       expect(component.notification.adminFlag).toBe(true);
     });
   }));

   it('should call add on click button "Hinzufügen" and return an error', async(() => {
     let hasBeenCalled = false;
     spyOn(component, 'add').and.callThrough();
     component.isInstructionDialog = true;
     mockNotificationService.error = 'ADD_CLICK_ERROR';

     component.notification.notificationText = 'TestContentChanged';
     component.notification.fkRefNotificationStatus = 1;

     messageService.errorOccured$.subscribe( msg => hasBeenCalled = true);
     fixture.detectChanges();

     const de = fixture.debugElement.query(By.css('.btn-success'));
     click(de);

     fixture.whenStable().then(() => {
       expect(component.add).toHaveBeenCalled();
       expect(hasBeenCalled).toBeTruthy();
     });
   }));

   it('should call edit on click button "Ändern"', async(() => {
     spyOn(component, 'edit').and.callThrough();
     component.isInstructionDialog = true;
     component.isEditDialog = true;
     component.notification = OPEN_NOTIFICATIONS[0];
     fixture.detectChanges();

     component.notification.notificationText = 'TestContentChanged';
     component.notification.fkRefNotificationStatus = 1;
     fixture.detectChanges();

     const de = fixture.debugElement.query(By.css('.btn-success'));
     click(de);

     fixture.whenStable().then(() => {
       expect(component.edit).toHaveBeenCalled();
     });
   }));

   it('should call edit on click button "Ändern" and return an error', async(() => {
     let hasBeenCalled = false;
     spyOn(component, 'edit').and.callThrough();
     component.isInstructionDialog = true;
     component.isEditDialog = true;
     mockNotificationService.error = 'EDIT_CLICK_ERROR';

     component.notification.notificationText = 'TestContentChanged';
     component.notification.fkRefNotificationStatus = 1;
     messageService.errorOccured$.subscribe( msg => hasBeenCalled = true);
     fixture.detectChanges();

     const de = fixture.debugElement.query(By.css('.btn-success'));
     click(de);

     fixture.whenStable().then(() => {
       expect(component.edit).toHaveBeenCalled();
       expect(hasBeenCalled).toBeTruthy();
     });
   }));

   it('close dialog on cancel', async(() => {
     spyOn(component, 'cancel').and.callThrough();
     component.isInstructionDialog = true;
     fixture.detectChanges();

     const de = fixture.debugElement.query(By.css('button:nth-child(2)'));
     click(de);

     fixture.whenStable().then(() => {
       expect(component.cancel).toHaveBeenCalled();
     });
   }));

   it('should return an emty branch name for a given user if it is not unique', () => {
     let returnBranchName = '';
     returnBranchName = component.getUniqueBranchNameForUser(FILTER_MATRIX_NONE_SELECTED.responsibilityContainerMatrix, 'max');

     expect(returnBranchName).toBe('');
 });

   it('should return a branch name for a given user if it is unique', () => {
     component.sessionContext.setGridTerritories(GRIDTERRITORIES);
     let returnBranchName = '';
     let returnBranchName2 = '';

     returnBranchName = component.getUniqueBranchNameForUser(FILTER_MATRIX_UNIQUE_BRANCH.responsibilityContainerMatrix, 'max');
     returnBranchName2 = component.getUniqueBranchNameForUser(FILTER_MATRIX_UNIQUE_BRANCH.responsibilityContainerMatrix, 'pete');
     expect(returnBranchName).toBe('S');
     expect(returnBranchName2).toBe('F');

   });

   it('should return an emty gridterritory name for a given user if it is not unique', () => {
     component.sessionContext.setGridTerritories(GRIDTERRITORIES);
     let returnGridTerritoryName = '';

     returnGridTerritoryName = component.getUniqueBranchNameForUser(FILTER_MATRIX_NONE_SELECTED.responsibilityContainerMatrix, 'max');
     expect(returnGridTerritoryName).toBe('');
   });

   it('should return a gridterritory name for a given user if it is unique', () => {
     component.sessionContext.setGridTerritories(GRIDTERRITORIES);

     let returnGridTerritoryName = '';
     let returnGridTerritoryName2 = '';
     let returnGridTerritoryName3 = '';

     returnGridTerritoryName = component.getUniqueGridTerritoryNameForUser(
       FILTER_MATRIX_UNIQUE_GRIDTERRITORY.responsibilityContainerMatrix, 'max');
     expect(returnGridTerritoryName).toBe('Mannheim');

     returnGridTerritoryName2 = component.getUniqueGridTerritoryNameForUser(
       FILTER_MATRIX_UNIQUE_GRIDTERRITORY.responsibilityContainerMatrix, 'pete');
     expect(returnGridTerritoryName2).toBe('Kassel');

     returnGridTerritoryName3 = component.getUniqueGridTerritoryNameForUser(
       FILTER_MATRIX_UNIQUE_GRIDTERRITORY.responsibilityContainerMatrix, 'otto');
     expect(returnGridTerritoryName3).toBe('Offenbach 1');
   });

 });
	/**
	******************************************************************************
	* Copyright © 2017-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
	*
	******************************************************************************
	*/
	/* tslint:disable:no-unused-variable */
	import { FormsModule } from '@angular/forms';
	import { async, fakeAsync, ComponentFixture, TestBed, tick, inject } from '@angular/core/testing';
	import { By } from '@angular/platform-browser';
	import { Injectable, DebugElement, Component } from '@angular/core';
	import { click, newEvent } from '../../testing';
	import { DaterangepickerConfig, Daterangepicker } from 'ng2-daterangepicker';
	import { AbstractMockObservableService } from '../../common/abstract-mock-observable.service';
	import { MockComponent } from '../../testing/mock.component';
	import { MdDialogRef } from '@angular/material';
	import { EntryComponent } from './entry.component';
	import { USERS } from '../../test-data/users';
	import { NotificationService } from '../../services/notification.service';
	import { StringToDatePipe } from '../../common-components/pipes/string-to-date.pipe';
	import { FormattedTimestampPipe } from '../../common-components/pipes/formatted-timestamp.pipe';
	import { Globals } from '../../common/globals';
	import { SessionContext } from '../../common/session-context';
	import { CURRENT_NOTIFICATIONS, FINISHED_NOTIFICATIONS, OPEN_NOTIFICATIONS, NOTIFICATION_VERSIONS } from '../../test-data/notifications';
	import { Notification } from '../../model/notification';
	import { StatusEn } from '../../common/enums';
	import { STATUSES } from '../../test-data/statuses';
	import { BRANCHES } from '../../test-data/branches';
	import { GRIDTERRITORIES } from '../../test-data/gridterritories';
	import { FilterMatrix } from '../../model/controller-model/filter-matrix';
	import { FILTER_MATRIX_NONE_SELECTED } from '../../test-data/filter-matrix';
	import { FILTER_MATRIX_UNIQUE_BRANCH } from '../../test-data/filter-matrix';
	import { FILTER_MATRIX_UNIQUE_GRIDTERRITORY } from '../../test-data/filter-matrix';

	import { MessageService } from '../../services/message.service';


	export class EntryComponentMocker {
	public static getComponentMocks() {
	return [
	MockComponent({ selector: 'app-entry' }),
	MockComponent({ selector: 'app-remove-button', inputs: ['nullableAttribute'], outputs: ['nullableAttribute'] }),
	MockComponent({
	selector: 'app-autocomplete',
	inputs: ['notification'],
	outputs: ['notification']
	}),
	];

	}
	}

	describe('EntryComponent', () => {
	let component: EntryComponent;
	let fixture: ComponentFixture<EntryComponent>;
	let sessionContext: SessionContext;

	class MockDialogRef extends AbstractMockObservableService {
	close() { }
	}

	class MockNotificationService extends AbstractMockObservableService {

	createNotification(newNotification) {
	this.content = newNotification;
	return this;
	};

	updateNotification(updatedNotification) {
	this.content = updatedNotification;
	return this;
	};

	getNotificationVersions(incidentId: number) {
	return this;
	}
	}
	let mockNotificationService;
	let messageService;

	beforeEach(async(() => {
	messageService = new MessageService();
	sessionContext = new SessionContext();
	sessionContext.setBranches(BRANCHES);
	sessionContext.setGridTerritories(GRIDTERRITORIES);
	sessionContext.setfilterMatrix(FILTER_MATRIX_NONE_SELECTED);
	mockNotificationService = new MockNotificationService();

	TestBed.configureTestingModule({
	imports: [FormsModule],
	declarations: [
	EntryComponent,
	StringToDatePipe,
	FormattedTimestampPipe,
	MockComponent({ selector: 'input', inputs: ['options'] }),
	MockComponent({
	selector: 'app-autocomplete',
	inputs: ['notification'],
	outputs: ['notification']
	}),
	MockComponent({
	selector: 'app-remove-button',
	inputs: ['nullableAttribute'],
	outputs: ['nullableAttribute']
	})
	],
	providers: [
	{ provide: MdDialogRef, useClass: MockDialogRef },
	{ provide: NotificationService, useValue: mockNotificationService },
	{ provide: SessionContext, useClass: SessionContext },
	{ provide: MessageService, useValue: messageService },
	DaterangepickerConfig,
	Daterangepicker
	]
	})
	.compileComponents();
	}));

	beforeEach(() => {
	fixture = TestBed.createComponent(EntryComponent);
	component = fixture.componentInstance;
	component.user = USERS[1];
	component.sessionContext.setCurrUser(USERS[1]);
	component.sessionContext.setBranches(BRANCHES);
	component.sessionContext.setGridTerritories(GRIDTERRITORIES);
	component.sessionContext.setfilterMatrix(FILTER_MATRIX_NONE_SELECTED);
	component.branches = BRANCHES;
	component.gridTerritories = GRIDTERRITORIES;
	});

	it('should change the Version and set the according notification', async(() => {
	component.notificationVersions = NOTIFICATION_VERSIONS;
	component.notification = NOTIFICATION_VERSIONS[0];
	component.isReadOnlyDialog = true;
	fixture.detectChanges();

	fixture.whenStable().then(() => {
	fixture.detectChanges();
	const select = fixture.debugElement.query(By.css('select[name=notificationSelection]'));
	select.nativeElement.value = '3';
	select.nativeElement.dispatchEvent(newEvent('change'));
	fixture.detectChanges();

	fixture.whenStable().then(() => {
	fixture.detectChanges();
	expect(component.notification.version).toBe(NOTIFICATION_VERSIONS[2].version);
	});

	});
	}));

	it('should call statusChanged on changing the status (inWork)', async(() => {
	spyOn(component, 'statusChanged').and.callThrough();
	component.sessionContext.setStatuses(STATUSES);
	const currNotification: Notification = NOTIFICATION_VERSIONS[0];
	component.notification = currNotification;
	fixture.detectChanges();

	fixture.whenStable().then(() => {
	expect(component.notification.fkRefNotificationStatus).toBe(NOTIFICATION_VERSIONS[0].fkRefNotificationStatus);

	const select = fixture.debugElement.query(By.css('select[name=statusSelection]'));
	select.nativeElement.value = StatusEn.inWork;
	select.nativeElement.dispatchEvent(newEvent('change'));
	fixture.detectChanges();

	fixture.whenStable().then(() => {
	expect(component.statusChanged).toHaveBeenCalledWith(StatusEn.inWork.toString(), currNotification);
	});

	});
	}));

	it('should call statusChanged on changing the status (done)', async(() => {
	spyOn(component, 'statusChanged').and.callThrough();
	component.sessionContext.setStatuses(STATUSES);
	const currNotification: Notification = NOTIFICATION_VERSIONS[0];
	component.notification = currNotification;
	fixture.detectChanges();

	fixture.whenStable().then(() => {
	expect(component.notification.fkRefNotificationStatus).toBe(NOTIFICATION_VERSIONS[0].fkRefNotificationStatus);

	const select = fixture.debugElement.query(By.css('select[name=statusSelection]'));
	select.nativeElement.value = StatusEn.done;
	select.nativeElement.dispatchEvent(newEvent('change'));
	fixture.detectChanges();

	fixture.whenStable().then(() => {
	expect(component.statusChanged).toHaveBeenCalledWith(StatusEn.done.toString(), currNotification);
	});

	});
	}));

	it('should call setNotification service methode and return an error', async(() => {
	const currNotification: Notification = OPEN_NOTIFICATIONS[0];
	currNotification.beginDate = '';
	mockNotificationService.error = 'SETNOTIFICATION_ERROR';
	component.isReadOnlyDialog = true;
	fixture.detectChanges();
	mockNotificationService.getNotificationVersions(currNotification.id).subscribe((resp) => {

	fixture.whenStable().then(() => {
	fixture.detectChanges();
	expect(component.notification.id).toBe(currNotification.id);
	expect(component.notificationVersions.length).toBe(OPEN_NOTIFICATIONS.length);
	expect(component.sessionContext.bannerMessage.text).toEqual('Fehler beim Lesen der Versionen von der Datenbank.');
	});
	});

	component.setNotification(currNotification);
	fixture.detectChanges();

	}));

	it('should call setNotification service methode and set right notificationVersions', async(() => {
	const currNotification: Notification = OPEN_NOTIFICATIONS[0];
	mockNotificationService.content = OPEN_NOTIFICATIONS;
	component.isReadOnlyDialog = true;
	fixture.detectChanges();
	mockNotificationService.getNotificationVersions(currNotification.id).subscribe((resp) => {

	fixture.whenStable().then(() => {
	fixture.detectChanges();
	expect(component.notification.id).toBe(currNotification.id);
	expect(component.notificationVersions.length).toBe(OPEN_NOTIFICATIONS.length);
	});
	});

	component.setNotification(currNotification);
	fixture.detectChanges();

	}));

	it('should call getNotificationVersions service methode and set current user as create user', async(() => {
	const currNotification = FINISHED_NOTIFICATIONS[0];
	currNotification.createUser = '';
	mockNotificationService.content = FINISHED_NOTIFICATIONS;
	component.isReadOnlyDialog = true;

	mockNotificationService.getNotificationVersions(currNotification.id).subscribe((resp) => {
	component.notificationVersions = resp;
	fixture.whenStable().then(() => {

	fixture.detectChanges();
	const des = fixture.debugElement.queryAll(By.css('.nvo'));
	expect(des.length).toBe(FINISHED_NOTIFICATIONS.length);
	});
	});
	}));

	it('InstructionDialog: only statusSelection should be reuqired on instructionDialog', async(() => {
	component.isInstructionDialog = true;
	fixture.detectChanges();

	let de = fixture.debugElement.query(By.css('.form-control[name=statusSelection]'));
	expect(de.nativeElement.required).toBe(true);

	de = fixture.debugElement.query(By.css('.form-control[name=gridTerritorySelection]'));
	expect(de.nativeElement.required).toBe(false);

	de = fixture.debugElement.query(By.css('.form-control[name=branchSelection]'));
	expect(de.nativeElement.required).toBe(false);

	}));

	it('InstructionDialog: should call add on click button "Hinzufügen"', async(() => {
	spyOn(component, 'add').and.callThrough();
	component.isInstructionDialog = true;
	fixture.detectChanges();

	component.notification.notificationText = 'TestContent';
	component.notification.fkRefNotificationStatus = 1;
	fixture.detectChanges();

	const de = fixture.debugElement.query(By.css('.btn-success'));
	click(de);

	fixture.whenStable().then(() => {
	expect(component.notification.responsibilityControlPoint).toBe(USERS[1].name);
	expect(component.notification.adminFlag).toBe(true);
	});
	}));

	it('should call add on click button "Hinzufügen" and return an error', async(() => {
	let hasBeenCalled = false;
	spyOn(component, 'add').and.callThrough();
	component.isInstructionDialog = true;
	mockNotificationService.error = 'ADD_CLICK_ERROR';

	component.notification.notificationText = 'TestContentChanged';
	component.notification.fkRefNotificationStatus = 1;

	messageService.errorOccured$.subscribe( msg => hasBeenCalled = true);
	fixture.detectChanges();

	const de = fixture.debugElement.query(By.css('.btn-success'));
	click(de);

	fixture.whenStable().then(() => {
	expect(component.add).toHaveBeenCalled();
	expect(hasBeenCalled).toBeTruthy();
	});
	}));

	it('should call edit on click button "Ändern"', async(() => {
	spyOn(component, 'edit').and.callThrough();
	component.isInstructionDialog = true;
	component.isEditDialog = true;
	component.notification = OPEN_NOTIFICATIONS[0];
	fixture.detectChanges();

	component.notification.notificationText = 'TestContentChanged';
	component.notification.fkRefNotificationStatus = 1;
	fixture.detectChanges();

	const de = fixture.debugElement.query(By.css('.btn-success'));
	click(de);

	fixture.whenStable().then(() => {
	expect(component.edit).toHaveBeenCalled();
	});
	}));

	it('should call edit on click button "Ändern" and return an error', async(() => {
	let hasBeenCalled = false;
	spyOn(component, 'edit').and.callThrough();
	component.isInstructionDialog = true;
	component.isEditDialog = true;
	mockNotificationService.error = 'EDIT_CLICK_ERROR';

	component.notification.notificationText = 'TestContentChanged';
	component.notification.fkRefNotificationStatus = 1;
	messageService.errorOccured$.subscribe( msg => hasBeenCalled = true);
	fixture.detectChanges();

	const de = fixture.debugElement.query(By.css('.btn-success'));
	click(de);

	fixture.whenStable().then(() => {
	expect(component.edit).toHaveBeenCalled();
	expect(hasBeenCalled).toBeTruthy();
	});
	}));

	it('close dialog on cancel', async(() => {
	spyOn(component, 'cancel').and.callThrough();
	component.isInstructionDialog = true;
	fixture.detectChanges();

	const de = fixture.debugElement.query(By.css('button:nth-child(2)'));
	click(de);

	fixture.whenStable().then(() => {
	expect(component.cancel).toHaveBeenCalled();
	});
	}));

	it('should return an emty branch name for a given user if it is not unique', () => {
	let returnBranchName = '';
	returnBranchName = component.getUniqueBranchNameForUser(FILTER_MATRIX_NONE_SELECTED.responsibilityContainerMatrix, 'max');

	expect(returnBranchName).toBe('');
	});

	it('should return a branch name for a given user if it is unique', () => {
	component.sessionContext.setGridTerritories(GRIDTERRITORIES);
	let returnBranchName = '';
	let returnBranchName2 = '';

	returnBranchName = component.getUniqueBranchNameForUser(FILTER_MATRIX_UNIQUE_BRANCH.responsibilityContainerMatrix, 'max');
	returnBranchName2 = component.getUniqueBranchNameForUser(FILTER_MATRIX_UNIQUE_BRANCH.responsibilityContainerMatrix, 'pete');
	expect(returnBranchName).toBe('S');
	expect(returnBranchName2).toBe('F');

	});

	it('should return an emty gridterritory name for a given user if it is not unique', () => {
	component.sessionContext.setGridTerritories(GRIDTERRITORIES);
	let returnGridTerritoryName = '';

	returnGridTerritoryName = component.getUniqueBranchNameForUser(FILTER_MATRIX_NONE_SELECTED.responsibilityContainerMatrix, 'max');
	expect(returnGridTerritoryName).toBe('');
	});

	it('should return a gridterritory name for a given user if it is unique', () => {
	component.sessionContext.setGridTerritories(GRIDTERRITORIES);

	let returnGridTerritoryName = '';
	let returnGridTerritoryName2 = '';
	let returnGridTerritoryName3 = '';

	returnGridTerritoryName = component.getUniqueGridTerritoryNameForUser(
	FILTER_MATRIX_UNIQUE_GRIDTERRITORY.responsibilityContainerMatrix, 'max');
	expect(returnGridTerritoryName).toBe('Mannheim');

	returnGridTerritoryName2 = component.getUniqueGridTerritoryNameForUser(
	FILTER_MATRIX_UNIQUE_GRIDTERRITORY.responsibilityContainerMatrix, 'pete');
	expect(returnGridTerritoryName2).toBe('Kassel');

	returnGridTerritoryName3 = component.getUniqueGridTerritoryNameForUser(
	FILTER_MATRIX_UNIQUE_GRIDTERRITORY.responsibilityContainerMatrix, 'otto');
	expect(returnGridTerritoryName3).toBe('Offenbach 1');
	});

	});