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 { Job, JobsListComponent } from './jobs-list.component';
  41
  42 let component: JobsListComponent;
  43 let fixture: ComponentFixture<JobsListComponent>;
  44
  45 const eijob1 = {
  46   ei_job_identity: 'job1',
  47   ei_type_identity: 'type1',
  48   owner: 'owner1',
  49   target_uri: 'http://one'
  50 } as EIJob;
  51 const eijob2 = {
  52   ei_job_identity: 'job2',
  53   ei_type_identity: 'type2',
  54   owner: 'owner2',
  55   target_uri: 'http://two'
  56 } as EIJob;
  57
  58 const job1 = {
  59   jobId: 'job1',
  60   typeId: 'type1',
  61   owner: 'owner1',
  62   targetUri: 'http://one',
  63   prodId: 'producer1'
  64 } as Job;
  65 const job2 = {
  66   jobId: 'job2',
  67   typeId: 'type2',
  68   owner: 'owner2',
  69   targetUri: 'http://two',
  70   prodId: 'producer1'
  71 } as Job;
  72 const job3 = {
  73   jobId: 'job1',
  74   typeId: 'type1',
  75   owner: 'owner1',
  76   targetUri: 'http://one',
  77   prodId: 'producer2'
  78 } as Job;
  79 const job4 = {
  80   jobId: 'job2',
  81   typeId: 'type2',
  82   owner: 'owner2',
  83   targetUri: 'http://two',
  84   prodId: 'producer2'
  85 } as Job;
  86
  87 describe('JobsListComponent', () => {
  88   let loader: HarnessLoader;
  89
  90   beforeEach(async(() => {
  91     const spy = jasmine.createSpyObj('EIService', ['getProducerIds', 'getJobsForProducer']);
  92
  93     TestBed.configureTestingModule({
  94       imports: [
  95         MatTableModule,
  96         MatPaginatorModule,
  97         FormsModule,
  98         MatSortModule,
  99         ReactiveFormsModule,
 100         BrowserAnimationsModule,
 101         MatFormFieldModule,
 102         MatInputModule
 103       ],
 104       schemas: [CUSTOM_ELEMENTS_SCHEMA],
 105       declarations: [JobsListComponent],
 106       providers: [
 107         { provide: EIService, useValue: spy },
 108         UiService
 109       ]
 110     })
 111       .compileComponents()
 112       .then(() => {
 113         fixture = TestBed.createComponent(JobsListComponent);
 114         component = fixture.componentInstance;
 115         loader = TestbedHarnessEnvironment.loader(fixture);
 116       });
 117   }));
 118
 119   const expectedJob1Row = { jobId: 'job1', prodId: 'producer1', typeId: 'type1', owner: 'owner1', targetUri: 'http://one' };
 120
 121   it('should create', () => {
 122     expect(component).toBeTruthy();
 123   });
 124
 125   describe('#content', () => {
 126
 127     it('should loadJobs', () => {
 128       setServiceSpy();
 129       component.loadJobs();
 130       const actualJobs: Job[] = component.jobs();
 131       expect(actualJobs.length).toEqual(4);
 132       expect(actualJobs).toEqual([job1, job2, job3, job4]);
 133     });
 134
 135     it('should contain job table with correct columns', async () => {
 136       setServiceSpy();
 137       let jobsTable = await loader.getHarness(MatTableHarness.with({ selector: '#jobsTable' }));
 138       let headerRow = (await jobsTable.getHeaderRows())[0];
 139       let headers = await headerRow.getCellTextByColumnName();
 140
 141       expect(headers).toEqual({ jobId: 'Job ID', prodId: 'Producer ID', typeId: 'Type ID', owner: 'Owner', targetUri: 'Target URI' });
 142     });
 143
 144     it('should set correct dark mode from UIService', () => {
 145       setServiceSpy();
 146       component.ngOnInit();
 147       const uiService: UiService = TestBed.inject(UiService);
 148       expect(component.darkMode).toBeTruthy();
 149
 150       uiService.darkModeState.next(false);
 151       fixture.detectChanges();
 152       expect(component.darkMode).toBeFalsy();
 153     });
 154   });
 155
 156   describe('#jobsTable', () => {
 157
 158     it('should contain data after initialization', async () => {
 159       setServiceSpy();
 160       component.ngOnInit();
 161       const expectedJobRows = [
 162         expectedJob1Row,
 163         { jobId: 'job2', prodId: 'producer1', typeId: 'type2', owner: 'owner2', targetUri: 'http://two' },
 164         { jobId: 'job1', prodId: 'producer2', typeId: 'type1', owner: 'owner1', targetUri: 'http://one' },
 165         { jobId: 'job2', prodId: 'producer2', typeId: 'type2', owner: 'owner2', targetUri: 'http://two' }
 166       ];
 167       let jobsTable = await loader.getHarness(MatTableHarness.with({ selector: '#jobsTable' }));
 168       let jobRows = await jobsTable.getRows();
 169       expect(jobRows.length).toEqual(4);
 170       jobRows.forEach(row => {
 171         row.getCellTextByColumnName().then(values => {
 172           expect(expectedJobRows).toContain(jasmine.objectContaining(values));
 173         });
 174       });
 175     });
 176
 177     it('should display default values for non required properties ', async () => {
 178
 179       const jobMissingProperties = {
 180         "ei_job_identity": "job1",
 181         "ei_job_data": {
 182           "jobparam2": "value2_job2",
 183           "jobparam3": "value3_job2",
 184           "jobparam1": "value1_job2"
 185         },
 186         "target_uri": "http://one"
 187       } as EIJob;
 188
 189       let eiServiceSpy = TestBed.inject(EIService) as jasmine.SpyObj<EIService>;
 190       eiServiceSpy.getProducerIds.and.returnValue(of(['producer1']));
 191       eiServiceSpy.getJobsForProducer.and.returnValue(of([jobMissingProperties]));
 192
 193       component.ngOnInit();
 194       const expectedJobRow = { jobId: 'job1', prodId: 'producer1', typeId: '< No type >', owner: '< No owner >', targetUri: 'http://one' };
 195       let jobsTable = await loader.getHarness(MatTableHarness.with({ selector: '#jobsTable' }));
 196       let jobRows = await jobsTable.getRows();
 197       expect(await jobRows[0].getCellTextByColumnName()).toEqual(expectedJobRow);
 198     });
 199
 200     it('filtering', async () => {
 201       setServiceSpy();
 202       component.ngOnInit();
 203       let jobsTable = await loader.getHarness(MatTableHarness.with({ selector: '#jobsTable' }));
 204
 205       let idFilterInput = await loader.getHarness(MatInputHarness.with({ selector: '#jobIdFilter' }));
 206       await idFilterInput.setValue("1");
 207       let jobRows = await jobsTable.getRows();
 208       expect(jobRows.length).toEqual(2);
 209       expect(await jobRows[0].getCellTextByColumnName()).toEqual(expectedJob1Row);
 210
 211       idFilterInput.setValue('');
 212       let typeIdFilterInput = await loader.getHarness(MatInputHarness.with({ selector: '#jobTypeIdFilter' }));
 213       await typeIdFilterInput.setValue("1");
 214       jobRows = await jobsTable.getRows();
 215       expect(jobRows.length).toEqual(2);
 216
 217       typeIdFilterInput.setValue('');
 218       let ownerFilterInput = await loader.getHarness(MatInputHarness.with({ selector: '#jobOwnerFilter' }));
 219       await ownerFilterInput.setValue("1");
 220       jobRows = await jobsTable.getRows();
 221       expect(jobRows.length).toEqual(2);
 222       expect(await jobRows[0].getCellTextByColumnName()).toEqual(expectedJob1Row);
 223
 224       ownerFilterInput.setValue('');
 225       let targetUriFilterInput = await loader.getHarness(MatInputHarness.with({ selector: '#jobTargetUriFilter' }));
 226       await targetUriFilterInput.setValue("one");
 227       jobRows = await jobsTable.getRows();
 228       expect(jobRows.length).toEqual(2);
 229       expect(await jobRows[0].getCellTextByColumnName()).toEqual(expectedJob1Row);
 230     });
 231
 232     describe('#sorting', () => {
 233
 234       it('should verify sort functionality on the table', async () => {
 235         setServiceSpy();
 236         const sort = await loader.getHarness(MatSortHarness);
 237         let headers = await sort.getSortHeaders({ sortDirection: '' });
 238         expect(headers.length).toBe(5);
 239
 240         await headers[0].click();
 241         expect(await headers[0].isActive()).toBe(true);
 242         expect(await headers[0].getSortDirection()).toBe('asc');
 243
 244         await headers[0].click();
 245         expect(await headers[0].getSortDirection()).toBe('desc');
 246
 247       });
 248
 249       it('should sort table asc and desc by first header', async () => {
 250         setServiceSpy();
 251         const sort = await loader.getHarness(MatSortHarness);
 252         let jobsTable = await loader.getHarness(MatTableHarness.with({ selector: '#jobsTable' }));
 253         const firstHeader = (await sort.getSortHeaders())[0];
 254         expect(await firstHeader.getSortDirection()).toBe('');
 255
 256         await firstHeader.click();
 257         expect(await firstHeader.getSortDirection()).toBe('asc');
 258         let jobRows = await jobsTable.getRows();
 259         jobRows = await jobsTable.getRows();
 260         expect(await jobRows[0].getCellTextByColumnName()).toEqual(expectedJob1Row);
 261
 262         await firstHeader.click();
 263         expect(await firstHeader.getSortDirection()).toBe('desc');
 264         jobRows = await jobsTable.getRows();
 265         expect(await jobRows[jobRows.length - 1].getCellTextByColumnName()).toEqual(expectedJob1Row);
 266       });
 267     });
 268
 269     describe('#paging', () => {
 270       it('should work properly on the table', async () => {
 271         let eiServiceSpy = TestBed.inject(EIService) as jasmine.SpyObj<EIService>;
 272         eiServiceSpy.getProducerIds.and.returnValue(of(['producer1', 'producer2']));
 273         eiServiceSpy.getJobsForProducer.and.returnValue(of([eijob1, eijob2, eijob1]));
 274
 275         const paging = await loader.getHarness(MatPaginatorHarness);
 276         await paging.setPageSize(5);
 277
 278         let jobsTable = await loader.getHarness(MatTableHarness.with({ selector: '#jobsTable' }));
 279         let jobRows = await jobsTable.getRows();
 280         expect(jobRows.length).toEqual(5);
 281
 282         await paging.goToNextPage();
 283         jobRows = await jobsTable.getRows();
 284         expect(jobRows.length).toEqual(1);
 285         const expectedRow = { jobId: 'job1', prodId: 'producer2', typeId: 'type1', owner: 'owner1', targetUri: 'http://one' };
 286         expect(await jobRows[jobRows.length - 1].getCellTextByColumnName()).toEqual(expectedRow);
 287       });
 288     });
 289   });
 290 });
 291
 292 function setServiceSpy() {
 293   let eiServiceSpy = TestBed.inject(EIService) as jasmine.SpyObj<EIService>;
 294   eiServiceSpy.getProducerIds.and.returnValue(of(['producer1', 'producer2']));
 295   eiServiceSpy.getJobsForProducer.and.returnValue(of([eijob1, eijob2]));
 296 }