webapp-frontend/src/app/ei-coordinator/jobs-list/jobs-list.component.spec.ts

   1 /*-
   2  * ========================LICENSE_START=================================
   3  * O-RAN-SC
   4  * %%
   5  * Copyright (C) 2021 Nordix Foundation
   6  * %%
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ========================LICENSE_END===================================
  19  */
  20 import { HarnessLoader } from '@angular/cdk/testing';
  21 import { TestbedHarnessEnvironment } from '@angular/cdk/testing/testbed';
  22 import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
  23 import { async, ComponentFixture, TestBed } from '@angular/core/testing';
  24 import { FormsModule, ReactiveFormsModule } from '@angular/forms';
  25 import { MatFormFieldModule } from '@angular/material/form-field';
  26 import { MatInputModule } from '@angular/material/input';
  27 import { MatInputHarness } from '@angular/material/input/testing';
  28 import { MatPaginatorModule } from '@angular/material/paginator';
  29 import { MatSortModule } from '@angular/material/sort';
  30 import { MatSortHarness } from '@angular/material/sort/testing';
  31 import { MatPaginatorHarness } from '@angular/material/paginator/testing';
  32 import { MatTableModule } from '@angular/material/table';
  33 import { MatTableHarness } from '@angular/material/table/testing';
  34 import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
  35 import { of } from 'rxjs/observable/of';
  36 import { EIJob } from '../../interfaces/ei.types';
  37 import { EIService } from '../../services/ei/ei.service';
  38 import { UiService } from '../../services/ui/ui.service';
  39
  40 import { JobsListComponent } from './jobs-list.component';
  41
  42 let component: JobsListComponent;
  43 let fixture: ComponentFixture<JobsListComponent>;
  44
  45 const job1 = {
  46   ei_job_identity: 'job1',
  47   ei_type_identity: 'type1',
  48   owner: 'owner1',
  49   target_uri: 'http://one'
  50 } as EIJob;
  51 const job2 = {
  52   ei_job_identity: 'job2',
  53   ei_type_identity: 'type2',
  54   owner: 'owner2',
  55   target_uri: 'http://two'
  56 } as EIJob;
  57
  58 describe('JobsListComponent', () => {
  59   let loader: HarnessLoader;
  60
  61   beforeEach(async(() => {
  62     const spy = jasmine.createSpyObj('EIService', ['getProducerIds', 'getJobsForProducer']);
  63
  64     TestBed.configureTestingModule({
  65       imports: [
  66         MatTableModule,
  67         MatPaginatorModule,
  68         FormsModule,
  69         MatSortModule,
  70         ReactiveFormsModule,
  71         BrowserAnimationsModule,
  72         MatFormFieldModule,
  73         MatInputModule
  74       ],
  75       schemas: [CUSTOM_ELEMENTS_SCHEMA],
  76       declarations: [JobsListComponent],
  77       providers: [
  78         { provide: EIService, useValue: spy },
  79         UiService
  80       ]
  81     })
  82       .compileComponents()
  83       .then(() => {
  84         fixture = TestBed.createComponent(JobsListComponent);
  85         component = fixture.componentInstance;
  86         loader = TestbedHarnessEnvironment.loader(fixture);
  87       });
  88   }));
  89
  90   const expectedJob1Row = { id: 'job1', typeId: 'type1', owner: 'owner1', targetUri: 'http://one' };
  91
  92   it('should create', () => {
  93     expect(component).toBeTruthy();
  94   });
  95
  96   describe('#content', () => {
  97
  98     it('should loadJobs', () => {
  99       setServiceSpy();
 100       component.loadJobs();
 101       const actualJobs: EIJob[] = component.jobs();
 102       expect(actualJobs.length).toEqual(4);
 103       expect(actualJobs).toEqual([job1, job2, job1, job2]);
 104     });
 105
 106     it('should contain job table with correct columns', async () => {
 107       setServiceSpy();
 108       let jobsTable = await loader.getHarness(MatTableHarness.with({ selector: '#jobsTable' }));
 109       let headerRow = (await jobsTable.getHeaderRows())[0];
 110       let headers = await headerRow.getCellTextByColumnName();
 111
 112       expect(headers).toEqual({ id: 'Job ID', typeId: 'Type ID', owner: 'Owner', targetUri: 'Target URI' });
 113     });
 114
 115     it('should set correct dark mode from UIService', () => {
 116       setServiceSpy();
 117       component.ngOnInit();
 118       const uiService: UiService = TestBed.inject(UiService);
 119       expect(component.darkMode).toBeTruthy();
 120
 121       uiService.darkModeState.next(false);
 122       fixture.detectChanges();
 123       expect(component.darkMode).toBeFalsy();
 124     });
 125   });
 126
 127   describe('#jobsTable', () => {
 128
 129     it('should contain data after initialization', async () => {
 130       setServiceSpy();
 131       component.ngOnInit();
 132       const expectedJobRows = [
 133         expectedJob1Row,
 134         { id: 'job2', typeId: 'type2', owner: 'owner2', targetUri: 'http://two' }
 135       ];
 136       let jobsTable = await loader.getHarness(MatTableHarness.with({ selector: '#jobsTable' }));
 137       let jobRows = await jobsTable.getRows();
 138       expect(jobRows.length).toEqual(4);
 139       jobRows.forEach(row => {
 140         row.getCellTextByColumnName().then(values => {
 141           expect(expectedJobRows).toContain(jasmine.objectContaining(values));
 142         });
 143       });
 144     });
 145
 146     it('should display default values for non required properties ', async () => {
 147
 148       const jobMissingProperties = {
 149         "ei_job_identity": "job1",
 150         "ei_job_data": {
 151           "jobparam2": "value2_job2",
 152           "jobparam3": "value3_job2",
 153           "jobparam1": "value1_job2"
 154         },
 155         "target_uri": "http://one"
 156       } as EIJob;
 157
 158       let eiServiceSpy = TestBed.inject(EIService) as jasmine.SpyObj<EIService>;
 159       eiServiceSpy.getProducerIds.and.returnValue(of(['producer1']));
 160       eiServiceSpy.getJobsForProducer.and.returnValue(of([jobMissingProperties]));
 161
 162       component.ngOnInit();
 163       const expectedJobRow = { id: 'job1', typeId: '< No type >', owner: '< No owner >', targetUri: 'http://one' };
 164       let jobsTable = await loader.getHarness(MatTableHarness.with({ selector: '#jobsTable' }));
 165       let jobRows = await jobsTable.getRows();
 166       expect(await jobRows[0].getCellTextByColumnName()).toEqual(expectedJobRow);
 167     });
 168
 169     it('filtering', async () => {
 170       setServiceSpy();
 171       component.ngOnInit();
 172       let jobsTable = await loader.getHarness(MatTableHarness.with({ selector: '#jobsTable' }));
 173
 174       let idFilterInput = await loader.getHarness(MatInputHarness.with({ selector: '#jobIdFilter' }));
 175       await idFilterInput.setValue("1");
 176       let jobRows = await jobsTable.getRows();
 177       expect(jobRows.length).toEqual(2);
 178       expect(await jobRows[0].getCellTextByColumnName()).toEqual(expectedJob1Row);
 179
 180       idFilterInput.setValue('');
 181       let typeIdFilterInput = await loader.getHarness(MatInputHarness.with({ selector: '#jobTypeIdFilter' }));
 182       await typeIdFilterInput.setValue("1");
 183       jobRows = await jobsTable.getRows();
 184       expect(jobRows.length).toEqual(2);
 185
 186       typeIdFilterInput.setValue('');
 187       let ownerFilterInput = await loader.getHarness(MatInputHarness.with({ selector: '#jobOwnerFilter' }));
 188       await ownerFilterInput.setValue("1");
 189       jobRows = await jobsTable.getRows();
 190       expect(jobRows.length).toEqual(2);
 191       expect(await jobRows[0].getCellTextByColumnName()).toEqual(expectedJob1Row);
 192
 193       ownerFilterInput.setValue('');
 194       let targetUriFilterInput = await loader.getHarness(MatInputHarness.with({ selector: '#jobTargetUriFilter' }));
 195       await targetUriFilterInput.setValue("one");
 196       jobRows = await jobsTable.getRows();
 197       expect(jobRows.length).toEqual(2);
 198       expect(await jobRows[0].getCellTextByColumnName()).toEqual(expectedJob1Row);
 199     });
 200
 201     describe('#sorting', () => {
 202
 203       it('should verify sort functionality on the table', async () => {
 204         setServiceSpy();
 205         const sort = await loader.getHarness(MatSortHarness);
 206         let headers = await sort.getSortHeaders({ sortDirection: '' });
 207         expect(headers.length).toBe(4);
 208
 209         await headers[0].click();
 210         expect(await headers[0].isActive()).toBe(true);
 211         expect(await headers[0].getSortDirection()).toBe('asc');
 212
 213         await headers[0].click();
 214         expect(await headers[0].getSortDirection()).toBe('desc');
 215
 216       });
 217
 218       it('should sort table asc and desc by first header', async () => {
 219         setServiceSpy();
 220         const sort = await loader.getHarness(MatSortHarness);
 221         let jobsTable = await loader.getHarness(MatTableHarness.with({ selector: '#jobsTable' }));
 222         const firstHeader = (await sort.getSortHeaders())[0];
 223         expect(await firstHeader.getSortDirection()).toBe('');
 224
 225         await firstHeader.click();
 226         expect(await firstHeader.getSortDirection()).toBe('asc');
 227         let jobRows = await jobsTable.getRows();
 228         jobRows = await jobsTable.getRows();
 229         expect(await jobRows[0].getCellTextByColumnName()).toEqual(expectedJob1Row);
 230
 231         await firstHeader.click();
 232         expect(await firstHeader.getSortDirection()).toBe('desc');
 233         jobRows = await jobsTable.getRows();
 234         expect(await jobRows[jobRows.length - 1].getCellTextByColumnName()).toEqual(expectedJob1Row);
 235       });
 236     });
 237
 238     describe('#paging', () => {
 239       it('should work properly on the table', async () => {
 240         let eiServiceSpy = TestBed.inject(EIService) as jasmine.SpyObj<EIService>;
 241         eiServiceSpy.getProducerIds.and.returnValue(of(['producer1', 'producer2']));
 242         eiServiceSpy.getJobsForProducer.and.returnValue(of([job1, job2, job1]));
 243
 244         const paging = await loader.getHarness(MatPaginatorHarness);
 245         await paging.setPageSize(5);
 246
 247         let jobsTable = await loader.getHarness(MatTableHarness.with({ selector: '#jobsTable' }));
 248         let jobRows = await jobsTable.getRows();
 249         expect(jobRows.length).toEqual(5);
 250
 251         await paging.goToNextPage();
 252         jobRows = await jobsTable.getRows();
 253         expect(jobRows.length).toEqual(1);
 254         expect(await jobRows[jobRows.length - 1].getCellTextByColumnName()).toEqual(expectedJob1Row);
 255       });
 256     });
 257   });
 258 });
 259
 260 function setServiceSpy() {
 261   let eiServiceSpy = TestBed.inject(EIService) as jasmine.SpyObj<EIService>;
 262   eiServiceSpy.getProducerIds.and.returnValue(of(['producer1', 'producer2']));
 263   eiServiceSpy.getJobsForProducer.and.returnValue(of([job1, job2]));
 264 }