git.apps.os.sepia.ceph.com Git - ceph.git/blob

   1 import { ComponentFixture, TestBed } from '@angular/core/testing';
   2 import { FormsModule } from '@angular/forms';
   3 import { RouterTestingModule } from '@angular/router/testing';
   4
   5 import { NgxDatatableModule } from '@swimlane/ngx-datatable';
   6 import { BsDropdownModule } from 'ngx-bootstrap/dropdown';
   7
   8 import { configureTestBed } from '../../../../testing/unit-test-helper';
   9 import { ComponentsModule } from '../../components/components.module';
  10 import { CellTemplate } from '../../enum/cell-template.enum';
  11 import { CdTableColumn } from '../../models/cd-table-column';
  12 import { CdDatePipe } from '../../pipes/cd-date.pipe';
  13 import { PipesModule } from '../../pipes/pipes.module';
  14 import { TableComponent } from '../table/table.component';
  15 import { TableKeyValueComponent } from './table-key-value.component';
  16
  17 describe('TableKeyValueComponent', () => {
  18   let component: TableKeyValueComponent;
  19   let fixture: ComponentFixture<TableKeyValueComponent>;
  20
  21   configureTestBed({
  22     declarations: [TableComponent, TableKeyValueComponent],
  23     imports: [
  24       FormsModule,
  25       NgxDatatableModule,
  26       ComponentsModule,
  27       RouterTestingModule,
  28       BsDropdownModule.forRoot(),
  29       PipesModule
  30     ]
  31   });
  32
  33   beforeEach(() => {
  34     fixture = TestBed.createComponent(TableKeyValueComponent);
  35     component = fixture.componentInstance;
  36   });
  37
  38   it('should create', () => {
  39     fixture.detectChanges();
  40     expect(component).toBeTruthy();
  41   });
  42
  43   it('should make key value object pairs out of arrays with length two', () => {
  44     component.data = [['someKey', 0], ['arrayKey', [1, 2, 3]], [3, 'something']];
  45     component.ngOnInit();
  46     const expected: any = [
  47       { key: 'arrayKey', value: '1, 2, 3' },
  48       { key: 'someKey', value: 0 },
  49       { key: 3, value: 'something' }
  50     ];
  51     expect(component.tableData).toEqual(expected);
  52   });
  53
  54   it('should not show data supposed to be have hidden by key', () => {
  55     component.data = [['a', 1], ['b', 2]];
  56     component.hideKeys = ['a'];
  57     component.ngOnInit();
  58     expect(component.tableData).toEqual([{ key: 'b', value: 2 }]);
  59   });
  60
  61   it('should remove items with objects as values', () => {
  62     component.data = [[3, 'something'], ['will be removed', { a: 3, b: 4, c: 5 }]];
  63     component.ngOnInit();
  64     expect(component.tableData).toEqual(<any>[{ key: 3, value: 'something' }]);
  65   });
  66
  67   it('makes key value object pairs out of an object', () => {
  68     component.data = { 3: 'something', someKey: 0 };
  69     component.ngOnInit();
  70     expect(component.tableData).toEqual([
  71       { key: '3', value: 'something' },
  72       { key: 'someKey', value: 0 }
  73     ]);
  74   });
  75
  76   it('does nothing if data does not need to be converted', () => {
  77     component.data = [{ key: 3, value: 'something' }, { key: 'someKey', value: 0 }];
  78     component.ngOnInit();
  79     expect(component.tableData).toEqual(component.data);
  80   });
  81
  82   it('throws errors if data cannot be converted', () => {
  83     component.data = 38;
  84     expect(() => component.ngOnInit()).toThrowError('Wrong data format');
  85     component.data = [['someKey', 0, 3]];
  86     expect(() => component.ngOnInit()).toThrowError(
  87       'Array contains too many elements (3). Needs to be of type [string, any][]'
  88     );
  89   });
  90
  91   it('tests makePairs()', () => {
  92     const makePairs = (data: any) => component['makePairs'](data);
  93     expect(makePairs([['dash', 'board']])).toEqual([{ key: 'dash', value: 'board' }]);
  94     const pair = [{ key: 'dash', value: 'board' }, { key: 'ceph', value: 'mimic' }];
  95     const pairInverse = [{ key: 'ceph', value: 'mimic' }, { key: 'dash', value: 'board' }];
  96     expect(makePairs(pair)).toEqual(pairInverse);
  97     expect(makePairs({ dash: 'board' })).toEqual([{ key: 'dash', value: 'board' }]);
  98     expect(makePairs({ dash: 'board', ceph: 'mimic' })).toEqual(pairInverse);
  99   });
 100
 101   it('tests makePairsFromArray()', () => {
 102     const makePairsFromArray = (data: any[]) => component['makePairsFromArray'](data);
 103     expect(makePairsFromArray([['dash', 'board']])).toEqual([{ key: 'dash', value: 'board' }]);
 104     const pair = [{ key: 'dash', value: 'board' }, { key: 'ceph', value: 'mimic' }];
 105     expect(makePairsFromArray(pair)).toEqual(pair);
 106   });
 107
 108   it('tests makePairsFromObject()', () => {
 109     const makePairsFromObject = (data: object) => component['makePairsFromObject'](data);
 110     expect(makePairsFromObject({ dash: 'board' })).toEqual([{ key: 'dash', value: 'board' }]);
 111     expect(makePairsFromObject({ dash: 'board', ceph: 'mimic' })).toEqual([
 112       { key: 'dash', value: 'board' },
 113       { key: 'ceph', value: 'mimic' }
 114     ]);
 115   });
 116
 117   describe('tests convertValue()', () => {
 118     const convertValue = (data: any) => component['convertValue'](data);
 119     const expectConvertValue = (value: any, expectation: any) =>
 120       expect(convertValue(value)).toBe(expectation);
 121
 122     it('should not convert strings', () => {
 123       expectConvertValue('something', 'something');
 124     });
 125
 126     it('should not convert integers', () => {
 127       expectConvertValue(29, 29);
 128     });
 129
 130     it('should convert arrays with any type to strings', () => {
 131       expectConvertValue([1, 2, 3], '1, 2, 3');
 132       expectConvertValue([{ sth: 'something' }], '{"sth":"something"}');
 133       expectConvertValue([1, 'two', { 3: 'three' }], '1, two, {"3":"three"}');
 134     });
 135
 136     it('should only convert objects if renderObjects is set to true', () => {
 137       expect(convertValue({ sth: 'something' })).toBe(null);
 138       component.renderObjects = true;
 139       expect(convertValue({ sth: 'something' })).toEqual({ sth: 'something' });
 140     });
 141   });
 142
 143   describe('automatically pipe UTC dates through cdDate', () => {
 144     let datePipe: CdDatePipe;
 145
 146     beforeEach(() => {
 147       datePipe = TestBed.get(CdDatePipe);
 148       spyOn(datePipe, 'transform').and.callThrough();
 149     });
 150
 151     const expectTimeConversion = (date: string) => {
 152       component.data = { dateKey: date };
 153       component.ngOnInit();
 154       expect(datePipe.transform).toHaveBeenCalledWith(date);
 155       expect(component.tableData[0].key).not.toBe(date);
 156     };
 157
 158     it('converts some date', () => {
 159       expectTimeConversion('2019-04-15 12:26:52.305285');
 160     });
 161
 162     it('converts UTC date', () => {
 163       expectTimeConversion('2019-04-16T12:35:46.646300974Z');
 164     });
 165   });
 166
 167   describe('render objects', () => {
 168     beforeEach(() => {
 169       component.data = {
 170         options: {
 171           numberKey: 38,
 172           stringKey: 'somethingElse',
 173           objectKey: {
 174             sub1: 12,
 175             sub2: 34,
 176             sub3: 56
 177           }
 178         },
 179         otherOptions: {
 180           sub1: {
 181             x: 42
 182           },
 183           sub2: {
 184             y: 555
 185           }
 186         },
 187         additionalKeyContainingObject: { type: 'none' },
 188         keyWithEmptyObject: {}
 189       };
 190       component.renderObjects = true;
 191     });
 192
 193     it('with parent key', () => {
 194       component.ngOnInit();
 195       expect(component.tableData).toEqual([
 196         { key: 'additionalKeyContainingObject type', value: 'none' },
 197         { key: 'keyWithEmptyObject', value: '' },
 198         { key: 'options numberKey', value: 38 },
 199         { key: 'options objectKey sub1', value: 12 },
 200         { key: 'options objectKey sub2', value: 34 },
 201         { key: 'options objectKey sub3', value: 56 },
 202         { key: 'options stringKey', value: 'somethingElse' },
 203         { key: 'otherOptions sub1 x', value: 42 },
 204         { key: 'otherOptions sub2 y', value: 555 }
 205       ]);
 206     });
 207
 208     it('without parent key', () => {
 209       component.appendParentKey = false;
 210       component.ngOnInit();
 211       expect(component.tableData).toEqual([
 212         { key: 'keyWithEmptyObject', value: '' },
 213         { key: 'numberKey', value: 38 },
 214         { key: 'stringKey', value: 'somethingElse' },
 215         { key: 'sub1', value: 12 },
 216         { key: 'sub2', value: 34 },
 217         { key: 'sub3', value: 56 },
 218         { key: 'type', value: 'none' },
 219         { key: 'x', value: 42 },
 220         { key: 'y', value: 555 }
 221       ]);
 222     });
 223   });
 224
 225   describe('subscribe fetchData', () => {
 226     it('should not subscribe fetchData of table', () => {
 227       component.ngOnInit();
 228       expect(component.table.fetchData.observers.length).toBe(0);
 229     });
 230
 231     it('should call fetchData', () => {
 232       let called = false;
 233       component.fetchData.subscribe(() => {
 234         called = true;
 235       });
 236       component.ngOnInit();
 237       expect(component.table.fetchData.observers.length).toBe(1);
 238       component.table.fetchData.emit();
 239       expect(called).toBeTruthy();
 240     });
 241   });
 242
 243   describe('hide empty items', () => {
 244     beforeEach(() => {
 245       component.data = {
 246         booleanFalse: false,
 247         booleanTrue: true,
 248         string: '',
 249         array: [],
 250         object: {},
 251         emptyObject: {
 252           string: '',
 253           array: [],
 254           object: {}
 255         },
 256         someNumber: 0,
 257         someDifferentNumber: 1,
 258         someArray: [0, 1],
 259         someString: '0',
 260         someObject: {
 261           empty: {},
 262           something: 0.1
 263         }
 264       };
 265       component.renderObjects = true;
 266     });
 267
 268     it('should show all items as default', () => {
 269       expect(component.hideEmpty).toBe(false);
 270       component.ngOnInit();
 271       expect(component.tableData).toEqual([
 272         { key: 'array', value: '' },
 273         { key: 'booleanFalse', value: false },
 274         { key: 'booleanTrue', value: true },
 275         { key: 'emptyObject array', value: '' },
 276         { key: 'emptyObject object', value: '' },
 277         { key: 'emptyObject string', value: '' },
 278         { key: 'object', value: '' },
 279         { key: 'someArray', value: '0, 1' },
 280         { key: 'someDifferentNumber', value: 1 },
 281         { key: 'someNumber', value: 0 },
 282         { key: 'someObject empty', value: '' },
 283         { key: 'someObject something', value: 0.1 },
 284         { key: 'someString', value: '0' },
 285         { key: 'string', value: '' }
 286       ]);
 287     });
 288
 289     it('should hide all empty items', () => {
 290       component.hideEmpty = true;
 291       component.ngOnInit();
 292       expect(component.tableData).toEqual([
 293         { key: 'booleanFalse', value: false },
 294         { key: 'booleanTrue', value: true },
 295         { key: 'someArray', value: '0, 1' },
 296         { key: 'someDifferentNumber', value: 1 },
 297         { key: 'someNumber', value: 0 },
 298         { key: 'someObject something', value: 0.1 },
 299         { key: 'someString', value: '0' }
 300       ]);
 301     });
 302   });
 303
 304   describe('columns set up', () => {
 305     let columns: CdTableColumn[];
 306
 307     beforeEach(() => {
 308       columns = [
 309         { prop: 'key', flexGrow: 1, cellTransformation: CellTemplate.bold },
 310         { prop: 'value', flexGrow: 3 }
 311       ];
 312     });
 313
 314     it('should have the following default column set up', () => {
 315       component.ngOnInit();
 316       expect(component.columns).toEqual(columns);
 317     });
 318
 319     it('should have the following column set up if customCss is defined', () => {
 320       component.customCss = { 'class-name': 42 };
 321       component.ngOnInit();
 322       columns[1].cellTransformation = CellTemplate.classAdding;
 323       expect(component.columns).toEqual(columns);
 324     });
 325   });
 326 });