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

   1 /*-
   2  * ========================LICENSE_START=================================
   3  * O-RAN-SC
   4  * %%
   5  * Copyright (C) 2019 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 { ComponentFixture, TestBed } from '@angular/core/testing';
  21 import { BrowserAnimationsModule } from '@angular/platform-browser/animations'
  22 import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
  23 import { FormBuilder, ReactiveFormsModule } from '@angular/forms';
  24 import { HarnessLoader } from '@angular/cdk/testing';
  25 import { MatIconModule } from '@angular/material/icon';
  26 import { MatInputHarness } from '@angular/material/input/testing'
  27 import { MatTableModule } from '@angular/material/table';
  28 import { MatTableHarness } from '@angular/material/table/testing';
  29 import {TestbedHarnessEnvironment} from '@angular/cdk/testing/testbed';
  30 import { of } from 'rxjs';
  31
  32 import { EICoordinatorComponent } from './ei-coordinator.component';
  33 import { EIJobDataSource } from './ei-job.datasource';
  34 import { EIProducerDataSource } from './ei-producer.datasource';
  35 import { UiService } from '../services/ui/ui.service';
  36 import { EIJob, EIProducer } from '../interfaces/ei.types';
  37
  38 describe('EICoordinatorComponent', () => {
  39   let component: EICoordinatorComponent;
  40   let fixture: ComponentFixture<EICoordinatorComponent>;
  41   let loader: HarnessLoader;
  42   let producerDataSourceSpy: jasmine.SpyObj<EIProducerDataSource>;
  43   let jobDataSourceSpy: jasmine.SpyObj<EIJobDataSource>;
  44
  45   const producer1 = {
  46     ei_producer_id: 'producer1',
  47     ei_producer_types: [ 'type1', 'type2' ],
  48     status: 'ENABLED'
  49   } as EIProducer;
  50   const producer2 = {
  51       ei_producer_id: 'producer2',
  52       ei_producer_types: [ 'type2', 'type3' ],
  53       status: 'DISABLED'
  54   } as EIProducer;
  55
  56   const job1 = {
  57     ei_job_identity: 'job1',
  58     ei_type_identity: 'type1',
  59     owner: 'owner1',
  60     target_uri: 'http://one'
  61   } as EIJob;
  62   const job2 = {
  63     ei_job_identity: 'job2',
  64     ei_type_identity: 'type2',
  65     owner: 'owner2',
  66     target_uri: 'http://two'
  67   } as EIJob;
  68
  69   beforeEach(async () => {
  70     producerDataSourceSpy = jasmine.createSpyObj('EIProducerDataSource', [ 'loadProducers', 'eiProducers', 'eiProducersSubject' ]);
  71     jobDataSourceSpy = jasmine.createSpyObj('EIJobDataSource', [ 'loadJobs', 'eiJobs', 'eiJobsSubject' ]);
  72
  73     producerDataSourceSpy.eiProducersSubject.and.returnValue(of({ producers: [producer1, producer2] }));
  74     jobDataSourceSpy.eiJobsSubject.and.returnValue(of({ jobs: [job1, job2] }));
  75
  76     await TestBed.configureTestingModule({
  77       imports: [
  78         MatIconModule,
  79         MatTableModule,
  80         BrowserAnimationsModule,
  81         ReactiveFormsModule
  82       ],
  83       schemas: [
  84         CUSTOM_ELEMENTS_SCHEMA
  85       ],
  86       declarations: [
  87         EICoordinatorComponent
  88       ],
  89       providers: [
  90         { provide: EIJobDataSource, useValue: jobDataSourceSpy },
  91         { provide: EIProducerDataSource, useValue: producerDataSourceSpy },
  92         UiService,
  93         FormBuilder,
  94       ]
  95     })
  96     .compileComponents();
  97
  98     fixture = TestBed.createComponent(EICoordinatorComponent);
  99     component = fixture.componentInstance;
 100     fixture.detectChanges();
 101     loader = TestbedHarnessEnvironment.loader(fixture);
 102   });
 103
 104   it('should create', () => {
 105     expect(component).toBeTruthy();
 106   });
 107
 108   describe('#content', () => {
 109     it('should contain refresh button with correct icon', () => {
 110       const button = fixture.debugElement.nativeElement.querySelector('#refreshButton');
 111       expect(button).toBeTruthy();
 112       expect(button.innerHTML).toContain('refresh');
 113     });
 114
 115     it('should contain producers table with correct columns', async () => {
 116       let producersTable = await loader.getHarness(MatTableHarness.with({selector: '#producersTable'}));
 117       let headerRow = (await producersTable.getHeaderRows())[0];
 118       let headers = await headerRow.getCellTextByColumnName();
 119
 120       expect(headers).toEqual({id: 'Producer ID', types: 'Producer types', status: 'Producer status'});
 121     });
 122
 123     it('should contain jobs table with correct columns', async () => {
 124       let producersTable = await loader.getHarness(MatTableHarness.with({selector: '#jobsTable'}));
 125       let headerRow = (await producersTable.getHeaderRows())[0];
 126       let headers = await headerRow.getCellTextByColumnName();
 127
 128       expect(headers).toEqual({id: 'Job ID', typeId: 'Type ID', owner: 'Owner', targetUri: 'Target URI'});
 129     });
 130
 131     it('should set correct dark mode from UIService', () => {
 132       const uiService: UiService = TestBed.inject(UiService);
 133       expect(component.darkMode).toBeTruthy();
 134
 135       uiService.darkModeState.next(false);
 136       fixture.detectChanges();
 137       expect(component.darkMode).toBeFalsy();
 138
 139     });
 140   });
 141
 142   describe('#producersTable', () => {
 143     const expectedProducer1Row = { id: 'producer1', types: 'type1,type2', status: 'ENABLED' };
 144     beforeEach(() => {
 145       const producers: EIProducer[] =[ producer1, producer2 ];
 146       producerDataSourceSpy.eiProducersSubject.and.returnValue(of(producers));
 147     });
 148
 149     it('should contain data after initialization', async () => {
 150       component.ngOnInit();
 151       const expectedProducerRows = [
 152         expectedProducer1Row,
 153         {id: 'producer2', types: 'type2,type3', status: 'DISABLED'}
 154       ];
 155       let producersTable = await loader.getHarness(MatTableHarness.with({selector: '#producersTable'}));
 156       let producerRows = await producersTable.getRows();
 157       expect(producerRows.length).toEqual(2);
 158       producerRows.forEach(row => {
 159         row.getCellTextByColumnName().then(values => {
 160           expect(expectedProducerRows).toContain(jasmine.objectContaining(values));
 161         });
 162       });
 163     });
 164
 165     describe('should display default values for non required properties', () => {
 166       it('producer defaults', async () => {
 167         const producerMissingProperties = {
 168           ei_producer_id: 'producer1'
 169         } as EIProducer;
 170         const producers: EIProducer[] =[ producerMissingProperties ];
 171         producerDataSourceSpy.eiProducersSubject.and.returnValue(of(producers));
 172         component.ngOnInit();
 173
 174         const expectedProducerRow = { id: 'producer1', types: '< No types >', status: '< No status >' };
 175         let producersTable = await loader.getHarness(MatTableHarness.with({selector: '#producersTable'}));
 176         let producerRows = await producersTable.getRows();
 177         expect(await producerRows[0].getCellTextByColumnName()).toEqual(expectedProducerRow);
 178         });
 179
 180       it('job defaults', async () => {
 181         const jobMissingProperties = {
 182           ei_job_identity: 'job1',
 183           target_uri: 'http://one'
 184         } as EIJob;
 185         const jobs: EIJob[] =[ jobMissingProperties ];
 186         jobDataSourceSpy.eiJobsSubject.and.returnValue(of(jobs));
 187         component.ngOnInit();
 188
 189         const expectedJobRow = { id: 'job1', typeId: '< No type >', owner: '< No owner >', targetUri: 'http://one' };
 190         let jobsTable = await loader.getHarness(MatTableHarness.with({selector: '#jobsTable'}));
 191         let jobRows = await jobsTable.getRows();
 192         expect(await jobRows[0].getCellTextByColumnName()).toEqual(expectedJobRow);
 193         });
 194     });
 195
 196     it('filtering', async () => {
 197       component.ngOnInit();
 198       let producersTable = await loader.getHarness(MatTableHarness.with({selector: '#producersTable'}));
 199
 200       let idFilterInput = await loader.getHarness(MatInputHarness.with({selector: '#producerIdFilter'}));
 201       await idFilterInput.setValue("1");
 202       let producerRows = await producersTable.getRows();
 203       expect(producerRows.length).toEqual(1);
 204       expect(await producerRows[0].getCellTextByColumnName()).toEqual(expectedProducer1Row);
 205
 206       idFilterInput.setValue('');
 207       let typesFilterInput = await loader.getHarness(MatInputHarness.with({selector: '#producerTypesFilter'}));
 208       await typesFilterInput.setValue("1");
 209       producerRows = await producersTable.getRows();
 210       expect(producerRows.length).toEqual(1);
 211       expect(await producerRows[0].getCellTextByColumnName()).toEqual(expectedProducer1Row);
 212       await typesFilterInput.setValue("2");
 213       producerRows = await producersTable.getRows();
 214       expect(producerRows.length).toEqual(2);
 215
 216       typesFilterInput.setValue('');
 217       let statusFilterInput = await loader.getHarness(MatInputHarness.with({selector: '#producerStatusFilter'}));
 218       await statusFilterInput.setValue("enabled");
 219       producerRows = await producersTable.getRows();
 220       expect(producerRows.length).toEqual(1);
 221       expect(await producerRows[0].getCellTextByColumnName()).toEqual(expectedProducer1Row);
 222     });
 223   });
 224
 225   describe('#jobsTable', () => {
 226     const expectedJob1Row = { id: 'job1', typeId: 'type1', owner: 'owner1', targetUri: 'http://one' };
 227     beforeEach(() => {
 228       const jobs: EIJob[] =[ job1, job2 ];
 229       jobDataSourceSpy.eiJobsSubject.and.returnValue(of(jobs));
 230     });
 231
 232     it('should contain data after initialization', async () => {
 233       component.ngOnInit();
 234       const expectedJobRows = [
 235         expectedJob1Row,
 236         { id: 'job2', typeId: 'type2', owner: 'owner2', targetUri: 'http://two' }
 237       ];
 238       let jobsTable = await loader.getHarness(MatTableHarness.with({selector: '#jobsTable'}));
 239       let jobRows = await jobsTable.getRows();
 240       expect(jobRows.length).toEqual(2);
 241       jobRows.forEach(row => {
 242         row.getCellTextByColumnName().then(values => {
 243           expect(expectedJobRows).toContain(jasmine.objectContaining(values));
 244         });
 245       });
 246     });
 247
 248     it('filtering', async () => {
 249       component.ngOnInit();
 250       let jobsTable = await loader.getHarness(MatTableHarness.with({selector: '#jobsTable'}));
 251
 252       let idFilterInput = await loader.getHarness(MatInputHarness.with({selector: '#jobIdFilter'}));
 253       await idFilterInput.setValue("1");
 254       let jobRows = await jobsTable.getRows();
 255       expect(jobRows.length).toEqual(1);
 256       expect(await jobRows[0].getCellTextByColumnName()).toEqual(expectedJob1Row);
 257
 258       idFilterInput.setValue('');
 259       let typeIdFilterInput = await loader.getHarness(MatInputHarness.with({selector: '#jobTypeIdFilter'}));
 260       await typeIdFilterInput.setValue("1");
 261       jobRows = await jobsTable.getRows();
 262       expect(jobRows.length).toEqual(1);
 263
 264       typeIdFilterInput.setValue('');
 265       let ownerFilterInput = await loader.getHarness(MatInputHarness.with({selector: '#jobOwnerFilter'}));
 266       await ownerFilterInput.setValue("1");
 267       jobRows = await jobsTable.getRows();
 268       expect(jobRows.length).toEqual(1);
 269       expect(await jobRows[0].getCellTextByColumnName()).toEqual(expectedJob1Row);
 270
 271       ownerFilterInput.setValue('');
 272       let targetUriFilterInput = await loader.getHarness(MatInputHarness.with({selector: '#jobTargetUriFilter'}));
 273       await targetUriFilterInput.setValue("one");
 274       jobRows = await jobsTable.getRows();
 275       expect(jobRows.length).toEqual(1);
 276       expect(await jobRows[0].getCellTextByColumnName()).toEqual(expectedJob1Row);
 277     });
 278   });
 279 });