@dbg-riskit/angular-testing 9999.9999.9999-rc.171485 → 9999.9999.9999-rc.1945041

package/esm2022/lib/definitions/data.table.definition.mjs

@@ -0,0 +1,556 @@
+import { Component } from '@angular/core';
+import { MatIconAnchor, MatIconButton } from '@angular/material/button';
+import { MatButtonToggle } from '@angular/material/button-toggle';
+import { MatIcon } from '@angular/material/icon';
+import { MatTooltip } from '@angular/material/tooltip';
+import { By } from '@angular/platform-browser';
+import { secureRandom } from '@dbg-riskit/common';
+import { DataTableComponent, DataTableRowDetailExpanderComponent, HIGHLIGHTER_CLASS, PagingComponent } from '@dbg-riskit/angular-datatable';
+import { click } from '../events';
+import { Page } from './page.base';
+import * as i0 from "@angular/core";
+import * as i1 from "@dbg-riskit/angular-datatable";
+export class DataTableDefinition {
+    constructor(debugElement, page) {
+        this.debugElement = debugElement;
+        this.page = page;
+    }
+    get component() {
+        return this.debugElement.componentInstance;
+    }
+    get data() {
+        return this.component.plainData;
+    }
+    get element() {
+        return this.debugElement.query(By.css('.risk-data-table-wrapper > table'));
+    }
+    get header() {
+        return new TableHeader(this.debugElement.query((de) => de.references.mainHeader), this.page);
+    }
+    get sorting() {
+        return new TableSorting(this, this.page);
+    }
+    get body() {
+        return new TableBody(this.debugElement.query((de) => de.references.mainBody), this.page);
+    }
+    get footer() {
+        return new TableFooter(this.debugElement.query((de) => de.references.mainFooter));
+    }
+    get recordsCount() {
+        return new RecordsCount(this.debugElement.query(By.css('.risk-data-table-page-count')));
+    }
+    get pager() {
+        return new Pager(this.debugElement.query(By.directive(PagingComponent)), this.page);
+    }
+}
+// <editor-fold defaultstate="collapsed" desc="Table header">
+export class TableHeader {
+    constructor(element, page) {
+        this.element = element;
+        this.page = page;
+    }
+    get rows() {
+        return this.element.queryAll(By.css('tr')).map((element) => {
+            return new TableHeaderRow(element, this.page);
+        });
+    }
+    get cells() {
+        return this.element.queryAll(By.css('th')).map((element) => {
+            return new TableHeaderCell(element, this.page);
+        });
+    }
+}
+export class TableHeaderRow {
+    constructor(element, page) {
+        this.element = element;
+        this.page = page;
+    }
+    get cells() {
+        return this.element.queryAll(By.css('th')).map((element) => {
+            return new TableHeaderCell(element, this.page);
+        });
+    }
+}
+export class TableHeaderCell {
+    constructor(element, page) {
+        this.element = element;
+        this.page = page;
+    }
+    get sortingHandle() {
+        const handle = this.element.query(By.directive(MatIconButton));
+        if (handle) {
+            return new SortingHandle(this.page, handle);
+        }
+        return null;
+    }
+    get tooltip() {
+        const handle = this.element.query(By.directive(MatTooltip));
+        if (handle) {
+            return handle.injector.get(MatTooltip).message;
+        }
+        return null;
+    }
+    get title() {
+        const textNode = this.element.childNodes.find((node) => node.nativeNode.nodeType === Node.TEXT_NODE);
+        if (textNode != null) {
+            return textNode
+                .nativeNode.textContent.trim();
+        }
+        return '';
+    }
+    get colspan() {
+        return this.element.nativeElement.colspan;
+    }
+    get rowspan() {
+        return this.element.nativeElement.rowspan;
+    }
+}
+// <editor-fold defaultstate="collapsed" desc="Sorting">
+export class TableSorting {
+    constructor(table, page) {
+        this.table = table;
+        this.page = page;
+    }
+    get handles() {
+        const handles = this.table.debugElement.query((de) => de.references.mainHeader)
+            .queryAll(By.directive(MatIconButton));
+        if (!handles) {
+            return [];
+        }
+        return handles.map((handle) => {
+            return new SortingHandle(this.page, handle);
+        });
+    }
+    get detailRowHandles() {
+        const handles = this.table.debugElement.query(By.css('.risk-data-table-detail')).query(By.css('thead'))
+            .queryAll(By.directive(MatIconButton));
+        if (!handles) {
+            return null;
+        }
+        return handles.map((handle) => {
+            return new SortingHandle(this.page, handle);
+        });
+    }
+    get currentOrdering() {
+        return this.table.component.ordering;
+    }
+    checkSorting(firstNRows = this.table.component.rows.length, criterium) {
+        // WARN: call data once as it calls .map on all table rows
+        const data = this.table.data;
+        let ordering;
+        if (criterium) {
+            ordering = [criterium].concat(this.table.component._defaultOrdering);
+        }
+        else {
+            ordering = this.currentOrdering;
+        }
+        for (let i = 1; i < Math.min(data.length, firstNRows); i++) {
+            ordering.some((criteria) => {
+                //noinspection EqualityComparisonWithCoercionJS
+                const valueA = criteria.get(data[i - 1]);
+                const valueB = criteria.get(data[i]);
+                if (valueA == null && valueB == null) {
+                    return false;
+                }
+                expect(valueA).not.toBeNull();
+                expect(valueA).not.toBeUndefined();
+                if (valueB != null) {
+                    if (criteria.descending) {
+                        expect(valueA >= valueB)
+                            .toBeTruthy('Expect: ' + valueA + ' >= '
+                            + valueB);
+                    }
+                    else {
+                        expect(valueA <= valueB)
+                            .toBeTruthy('Expect: ' + valueA + ' <= '
+                            + valueB);
+                    }
+                }
+                return valueA !== valueB;
+            });
+        }
+    }
+}
+export class SortingHandle {
+    constructor(page, handle) {
+        this.page = page;
+        this.handle = handle;
+    }
+    click() {
+        click(this.handle);
+        this.page.detectChanges();
+    }
+}
+// </editor-fold>
+// </editor-fold>
+// <editor-fold defaultstate="collapsed" desc="Table body">
+export class TableBody {
+    constructor(element, page) {
+        this.element = element;
+        this.page = page;
+    }
+    get rows() {
+        return this.element.queryAll((de) => de.references.masterRow).map((element) => {
+            return new TableBodyRow(element, this.page);
+        });
+    }
+    get cells() {
+        let cells = [];
+        this.element.queryAll((de) => de.references.masterRow).forEach((row) => {
+            cells = cells.concat(row.queryAll(By.css('td')).map((cell) => {
+                return new TableBodyCell(cell);
+            }));
+        });
+        return cells;
+    }
+}
+export class TableBodyRow {
+    constructor(element, page) {
+        this.element = element;
+        this.page = page;
+    }
+    expandRow() {
+        click(this.element);
+        this.page.detectChanges();
+    }
+    get expander() {
+        return new RowExpander(this.element.query(By.directive(DataTableRowDetailExpanderComponent)).query(By.directive(MatIconAnchor)));
+    }
+    get cells() {
+        return this.element.queryAll(By.css('td')).map((element) => {
+            return new TableBodyCell(element);
+        });
+    }
+    get rowDetail() {
+        const parent = this.element.parent;
+        if (parent != null) {
+            const next = parent.children[parent.children.indexOf(this.element) + 1];
+            if (next && !next.references.masterRow) {
+                return new TableBodyDetail(next, this.page);
+            }
+        }
+        return null;
+    }
+    get highlighted() {
+        return this.element.nativeElement.classList.contains(HIGHLIGHTER_CLASS);
+    }
+}
+export class RowExpander {
+    constructor(element) {
+        this.element = element;
+    }
+    get icon() {
+        return this.element.query(By.directive(MatIcon)).nativeElement.textContent.trim();
+    }
+    get opened() {
+        return this.icon === 'expand_less';
+    }
+    get closed() {
+        return this.icon === 'expand_more';
+    }
+}
+export class TableBodyCell {
+    constructor(element) {
+        this.element = element;
+    }
+    get colspan() {
+        return this.element.nativeElement.colspan;
+    }
+    get rowspan() {
+        return this.element.nativeElement.rowspan;
+    }
+}
+// <editor-fold defaultstate="collapsed" desc="Row detail">
+export class TableBodyDetail {
+    constructor(element, page) {
+        this.element = element;
+        this.page = page;
+    }
+    header() {
+        return new TableHeader(this.element.query(By.css('thead')), this.page);
+    }
+    get body() {
+        return new TableBodyDetailBody(this.element.query(By.css('tbody')));
+    }
+    get highlighted() {
+        return this.element.nativeElement.classList.contains(HIGHLIGHTER_CLASS);
+    }
+    get colspan() {
+        return this.element.children[0].nativeElement.colspan;
+    }
+}
+export class TableBodyDetailBody {
+    constructor(element) {
+        this.element = element;
+    }
+    get rows() {
+        return this.element.queryAll(By.css('tr')).map((element) => {
+            return new TableBodyDetailRow(element);
+        });
+    }
+    get cells() {
+        let cells = [];
+        this.element.queryAll(By.css('tr')).forEach((row) => {
+            cells = cells.concat(row.queryAll(By.css('td')).map((cell) => {
+                return new TableBodyCell(cell);
+            }));
+        });
+        return cells;
+    }
+}
+export class TableBodyDetailRow {
+    constructor(element) {
+        this.element = element;
+    }
+    get cells() {
+        return this.element.queryAll(By.css('td')).map((element) => {
+            return new TableBodyCell(element);
+        });
+    }
+}
+// </editor-fold>
+// </editor-fold>
+// <editor-fold defaultstate="collapsed" desc="Table footer">
+export class TableFooter {
+    constructor(element) {
+        this.element = element;
+    }
+    get rows() {
+        return this.element.queryAll(By.css('tr')).map((element) => {
+            return new TableFooterRow(element);
+        });
+    }
+    get cells() {
+        let cells = [];
+        this.element.queryAll(By.css('tr')).forEach((row) => {
+            cells = cells.concat(row.queryAll(By.css('th')).map((cell) => {
+                return new TableBodyCell(cell);
+            }));
+        });
+        return cells;
+    }
+}
+export class TableFooterRow {
+    constructor(element) {
+        this.element = element;
+    }
+    get cells() {
+        return this.element.queryAll(By.css('th')).map((element) => {
+            return new TableBodyCell(element);
+        });
+    }
+}
+// </editor-fold>
+export class RecordsCount {
+    constructor(element) {
+        this.element = element;
+    }
+    get message() {
+        return this.element.nativeElement.textContent;
+    }
+}
+export class Pager {
+    constructor(element, page) {
+        this.element = element;
+        this.page = page;
+    }
+    get pageButtons() {
+        return this.element.queryAll(By.directive(MatButtonToggle));
+    }
+    expectLeadingButtonsDisabled() {
+        for (let i = 0; i < 2; i++) {
+            expect(this.pageButtons[i].classes['mat-button-toggle-disabled'])
+                .toBe(true, 'First two are disabled.');
+        }
+    }
+    expectLeadingButtonsNotDisabled() {
+        for (let i = 0; i < 2; i++) {
+            expect(this.pageButtons[i].classes['mat-button-toggle-disabled'])
+                .not.toBe(true, 'First two are not disabled.');
+        }
+    }
+    expectTrailingButtonsDisabled() {
+        for (let i = this.pageButtons.length - 1; i > this.pageButtons.length - 3; i--) {
+            expect(this.pageButtons[i].classes['mat-button-toggle-disabled'])
+                .toBe(true, 'Last two are disabled.');
+        }
+    }
+    expectTrailingButtonsNotDisabled() {
+        for (let i = this.pageButtons.length - 1; i > this.pageButtons.length - 3; i--) {
+            expect(this.pageButtons[i].classes['mat-button-toggle-disabled'])
+                .not.toBe(true, 'Last two are not disabled.');
+        }
+    }
+    expectButtonNumbers(numbers) {
+        for (let i = 0; i < numbers.length; i++) {
+            expect(this.pageButtons[i + 2].query(By.css('.mat-button-toggle-label-content'))
+                .nativeElement.textContent.trim())
+                .toEqual(numbers[i] + '', 'Button numbers are correct');
+        }
+    }
+    expectButtonActive(index) {
+        expect(this.pageButtons[index].classes['mat-button-toggle-checked'])
+            .toBe(true, 'Button is active.');
+    }
+    click(index) {
+        click(this.pageButtons[index].query(By.css('.mat-button-toggle-label-content')).nativeElement);
+        this.page.detectChanges();
+        this.page.advanceAndDetectChanges();
+    }
+}
+export function chceckSorting(page, criteria) {
+    page.dataTable.sorting.checkSorting(150);
+    page.dataTable.sorting.handles.forEach((handle, index) => {
+        // Tigger sort based on a handle
+        handle.click();
+        page.detectChanges();
+        // Check the sorting
+        page.dataTable.sorting.checkSorting(150, {
+            get: criteria[index]
+        });
+        // Tigger sort based on a handle
+        handle.click();
+        page.detectChanges();
+        // Check the sorting
+        page.dataTable.sorting.checkSorting(150, {
+            get: criteria[index],
+            descending: true
+        });
+    });
+}
+export class DataTableDefinitionHosted extends Page {
+    constructor(fixture) {
+        super(fixture);
+    }
+    get dataTable() {
+        return new DataTableDefinition(this.debugElement.query(By.directive(DataTableComponent)), this);
+    }
+}
+export class TestDataTableHostComponent {
+    constructor() {
+        this.data = [];
+        for (let i = 0; i < 500; i++) {
+            this.data.push({
+                value1: Math.floor(secureRandom() * 20) + ' - value 1',
+                value2: Math.floor(secureRandom() * 20) + ' - value 2',
+                value3: Math.floor(secureRandom() * 20) + ' - value 3'
+            });
+        }
+        this.footer = this.data[0];
+    }
+    get defaultOrdering() {
+        return [
+            {
+                get: (record) => {
+                    return record.value3;
+                },
+                descending: true
+            },
+            (record) => {
+                return record.value2;
+            }
+        ];
+    }
+    get valueGetter() {
+        return (record) => {
+            return record.value1;
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TestDataTableHostComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: TestDataTableHostComponent, selector: "ng-component", ngImport: i0, template: `
+        <risk-data-table [data]="data"
+                         [footer]="footer"
+                         [pageSize]="20"
+                         [defaultOrdering]="defaultOrdering"
+                         [striped]="true">
+            <risk-data-table-column title="Test Column 1"
+                                    [sortingKey]="valueGetter">
+                <ng-template let-record="row" risk-data-table-cell>
+                    {{record.value1}}
+                </ng-template>
+            </risk-data-table-column>
+            <risk-data-table-column>
+                <ng-template risk-data-table-cell let-record="row" let-expanded="expanded">
+                    <risk-data-table-detail-expander [expanded]="expanded"></risk-data-table-detail-expander>
+                </ng-template>
+                <ng-template risk-data-table-footer-cell let-footer="footer">
+                    {{footer.value1}}
+                </ng-template>
+            </risk-data-table-column>
+            <!-- Sub detail -->
+            <risk-data-table-detail-row>
+                <risk-data-table-column-group>
+                    <risk-data-table-column title="Test Detail Column 1"
+                                            [sortingKey]="valueGetter">
+                        <ng-template risk-data-table-cell let-record="row">
+                            {{record.value1}}
+                        </ng-template>
+                    </risk-data-table-column>
+                </risk-data-table-column-group>
+                <risk-data-table-column-group>
+                    <risk-data-table-column title="Test Detail Column 2">
+                        <ng-template risk-data-table-cell let-record="row">
+                            {{record.value2}}
+                        </ng-template>
+                    </risk-data-table-column>
+                    <risk-data-table-column title="Test Detail Column 3">
+                        <ng-template risk-data-table-cell let-record="row">
+                            {{record.value3}}
+                        </ng-template>
+                    </risk-data-table-column>
+                </risk-data-table-column-group>
+                <risk-data-table-column-group></risk-data-table-column-group>
+            </risk-data-table-detail-row>
+        </risk-data-table>`, isInline: true, dependencies: [{ kind: "component", type: i1.DataTableComponent, selector: "risk-data-table", inputs: ["footer", "pageSize", "striped", "showFooter", "allowEmpty", "trackByRowKey", "highlighting", "stickyHeader", "stickyHeaderOffsetTopPx", "data", "defaultOrdering"], exportAs: ["dataTable"] }, { kind: "directive", type: i1.ɵDataTableColumnDirective, selector: "risk-data-table-column", inputs: ["title", "sortingKey", "tooltip", "contentAlign", "headerAlign", "footerAlign", "class"] }, { kind: "directive", type: i1.ɵDataTableColumnGroupDirective, selector: "risk-data-table-column-group" }, { kind: "directive", type: i1.ɵDataTableColumnCellDirective, selector: "[risk-data-table-cell]" }, { kind: "directive", type: i1.ɵDataTableColumnFooterDirective, selector: "[risk-data-table-footer-cell]" }, { kind: "directive", type: i1.ɵDataTableRowDetailDirective, selector: "risk-data-table-detail-row" }, { kind: "component", type: i1.DataTableRowDetailExpanderComponent, selector: "risk-data-table-detail-expander", inputs: ["expanded"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TestDataTableHostComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+        <risk-data-table [data]="data"
+                         [footer]="footer"
+                         [pageSize]="20"
+                         [defaultOrdering]="defaultOrdering"
+                         [striped]="true">
+            <risk-data-table-column title="Test Column 1"
+                                    [sortingKey]="valueGetter">
+                <ng-template let-record="row" risk-data-table-cell>
+                    {{record.value1}}
+                </ng-template>
+            </risk-data-table-column>
+            <risk-data-table-column>
+                <ng-template risk-data-table-cell let-record="row" let-expanded="expanded">
+                    <risk-data-table-detail-expander [expanded]="expanded"></risk-data-table-detail-expander>
+                </ng-template>
+                <ng-template risk-data-table-footer-cell let-footer="footer">
+                    {{footer.value1}}
+                </ng-template>
+            </risk-data-table-column>
+            <!-- Sub detail -->
+            <risk-data-table-detail-row>
+                <risk-data-table-column-group>
+                    <risk-data-table-column title="Test Detail Column 1"
+                                            [sortingKey]="valueGetter">
+                        <ng-template risk-data-table-cell let-record="row">
+                            {{record.value1}}
+                        </ng-template>
+                    </risk-data-table-column>
+                </risk-data-table-column-group>
+                <risk-data-table-column-group>
+                    <risk-data-table-column title="Test Detail Column 2">
+                        <ng-template risk-data-table-cell let-record="row">
+                            {{record.value2}}
+                        </ng-template>
+                    </risk-data-table-column>
+                    <risk-data-table-column title="Test Detail Column 3">
+                        <ng-template risk-data-table-cell let-record="row">
+                            {{record.value3}}
+                        </ng-template>
+                    </risk-data-table-column>
+                </risk-data-table-column-group>
+                <risk-data-table-column-group></risk-data-table-column-group>
+            </risk-data-table-detail-row>
+        </risk-data-table>`
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data.table.definition.js","sourceRoot":"","sources":["../../../../../../pkg/dbg-riskit/angular-testing/src/lib/definitions/data.table.definition.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, DebugElement, DebugNode} from '@angular/core';\nimport {ComponentFixture} from '@angular/core/testing';\nimport {MatIconAnchor, MatIconButton} from '@angular/material/button';\nimport {MatButtonToggle} from '@angular/material/button-toggle';\nimport {MatIcon} from '@angular/material/icon';\nimport {MatTooltip} from '@angular/material/tooltip';\nimport {By} from '@angular/platform-browser';\nimport {ValueGetter, secureRandom} from '@dbg-riskit/common';\nimport {\n    DataTableComponent,\n    DataTableRowDetailExpanderComponent,\n    HIGHLIGHTER_CLASS,\n    OrderingCriteria,\n    PagingComponent\n} from '@dbg-riskit/angular-datatable';\nimport {click} from '../events';\nimport {Page} from './page.base';\n\nexport class DataTableDefinition {\n\n    public constructor(public debugElement: DebugElement,\n                       private page: { detectChanges: () => void, advanceAndDetectChanges: () => void }) {\n    }\n\n    public get component(): DataTableComponent<unknown, unknown> {\n        return this.debugElement.componentInstance;\n    }\n\n    public get data(): any[] {\n        return this.component.plainData;\n    }\n\n    public get element(): DebugElement {\n        return this.debugElement.query(By.css('.risk-data-table-wrapper > table'));\n    }\n\n    public get header(): TableHeader {\n        return new TableHeader(this.debugElement.query((de) => de.references.mainHeader), this.page);\n    }\n\n    public get sorting(): TableSorting {\n        return new TableSorting(this, this.page);\n    }\n\n    public get body(): TableBody {\n        return new TableBody(this.debugElement.query((de) => de.references.mainBody), this.page);\n    }\n\n    public get footer(): TableFooter {\n        return new TableFooter(this.debugElement.query((de) => de.references.mainFooter));\n    }\n\n    public get recordsCount(): RecordsCount {\n        return new RecordsCount(this.debugElement.query(By.css('.risk-data-table-page-count')));\n    }\n\n    public get pager(): Pager {\n        return new Pager(this.debugElement.query(By.directive(PagingComponent)), this.page);\n    }\n}\n\n// <editor-fold defaultstate=\"collapsed\" desc=\"Table header\">\n\nexport class TableHeader {\n\n    public constructor(public element: DebugElement, private page: { detectChanges: () => void }) {\n    }\n\n    public get rows(): TableHeaderRow[] {\n        return this.element.queryAll(By.css('tr')).map((element: DebugElement) => {\n            return new TableHeaderRow(element, this.page);\n        });\n    }\n\n    public get cells(): TableHeaderCell[] {\n        return this.element.queryAll(By.css('th')).map((element: DebugElement) => {\n            return new TableHeaderCell(element, this.page);\n        });\n    }\n\n}\n\nexport class TableHeaderRow {\n    public constructor(public element: DebugElement, private page: { detectChanges: () => void }) {\n    }\n\n    public get cells(): TableHeaderCell[] {\n        return this.element.queryAll(By.css('th')).map((element: DebugElement) => {\n            return new TableHeaderCell(element, this.page);\n        });\n    }\n}\n\nexport class TableHeaderCell {\n\n    public constructor(public element: DebugElement, private page: { detectChanges: () => void }) {\n    }\n\n    public get sortingHandle(): SortingHandle | null {\n        const handle = this.element.query(By.directive(MatIconButton));\n        if (handle) {\n            return new SortingHandle(this.page, handle);\n        }\n        return null;\n    }\n\n    public get tooltip(): string | null {\n        const handle = this.element.query(By.directive(MatTooltip));\n        if (handle) {\n            return handle.injector.get(MatTooltip).message;\n        }\n        return null;\n    }\n\n    public get title(): string {\n        const textNode = this.element.childNodes.find((node: DebugNode) => node.nativeNode.nodeType === Node.TEXT_NODE);\n        if (textNode != null) {\n            return textNode\n                .nativeNode.textContent.trim();\n        }\n        return '';\n    }\n\n    public get colspan(): number {\n        return this.element.nativeElement.colspan;\n    }\n\n    public get rowspan(): number {\n        return this.element.nativeElement.rowspan;\n    }\n\n}\n\n// <editor-fold defaultstate=\"collapsed\" desc=\"Sorting\">\n\nexport class TableSorting {\n\n    public constructor(private table: DataTableDefinition, private page: { detectChanges: () => void }) {\n    }\n\n    public get handles(): SortingHandle[] {\n        const handles = this.table.debugElement.query((de) => de.references.mainHeader)\n            .queryAll(By.directive(MatIconButton));\n        if (!handles) {\n            return [];\n        }\n        return handles.map((handle: DebugElement) => {\n            return new SortingHandle(this.page, handle);\n        });\n    }\n\n    public get detailRowHandles(): SortingHandle[] | null {\n        const handles = this.table.debugElement.query(By.css('.risk-data-table-detail')).query(By.css('thead'))\n            .queryAll(By.directive(MatIconButton));\n        if (!handles) {\n            return null;\n        }\n        return handles.map((handle: DebugElement) => {\n            return new SortingHandle(this.page, handle);\n        });\n    }\n\n    public get currentOrdering(): Array<OrderingCriteria<any>> {\n        return (this.table.component as any).ordering;\n    }\n\n    public checkSorting(firstNRows: number = this.table.component.rows.length,\n                        criterium?: OrderingCriteria<any>): void {\n        // WARN: call data once as it calls .map on all table rows\n        const data = this.table.data;\n\n        let ordering: Array<OrderingCriteria<any>>;\n        if (criterium) {\n            ordering = [criterium].concat((this.table.component as any)._defaultOrdering);\n        } else {\n            ordering = this.currentOrdering;\n        }\n        for (let i = 1; i < Math.min(data.length, firstNRows); i++) {\n            ordering.some((criteria: OrderingCriteria<any>) => {\n                //noinspection EqualityComparisonWithCoercionJS\n                const valueA: any = criteria.get(data[i - 1]);\n                const valueB: any = criteria.get(data[i]);\n                if (valueA == null && valueB == null) {\n                    return false;\n                }\n                expect(valueA).not.toBeNull();\n                expect(valueA).not.toBeUndefined();\n                if (valueB != null) {\n                    if (criteria.descending) {\n                        expect(valueA >= valueB)\n                            .toBeTruthy('Expect: ' + valueA + ' >= '\n                                        + valueB);\n                    } else {\n                        expect(valueA <= valueB)\n                            .toBeTruthy('Expect: ' + valueA + ' <= '\n                                        + valueB);\n                    }\n                }\n                return valueA !== valueB;\n            });\n        }\n    }\n}\n\nexport class SortingHandle {\n\n    public constructor(private page: { detectChanges: () => void }, private handle: DebugElement) {\n    }\n\n    public click() {\n        click(this.handle);\n        this.page.detectChanges();\n    }\n}\n\n// </editor-fold>\n\n// </editor-fold>\n\n// <editor-fold defaultstate=\"collapsed\" desc=\"Table body\">\n\nexport class TableBody {\n\n    public constructor(public element: DebugElement, private page: { detectChanges: () => void }) {\n    }\n\n    public get rows(): TableBodyRow[] {\n        return this.element.queryAll((de) => de.references.masterRow).map((element: DebugElement) => {\n            return new TableBodyRow(element, this.page);\n        });\n    }\n\n    public get cells(): TableBodyCell[] {\n        let cells: TableBodyCell[] = [];\n        this.element.queryAll((de) => de.references.masterRow).forEach((row: DebugElement) => {\n            cells = cells.concat(row.queryAll(By.css('td')).map((cell: DebugElement) => {\n                return new TableBodyCell(cell);\n            }));\n        });\n        return cells;\n    }\n}\n\nexport class TableBodyRow {\n\n    public constructor(public element: DebugElement, private page: { detectChanges: () => void }) {\n    }\n\n    public expandRow(): void {\n        click(this.element);\n        this.page.detectChanges();\n    }\n\n    public get expander(): RowExpander {\n        return new RowExpander(\n            this.element.query(By.directive(DataTableRowDetailExpanderComponent)).query(By.directive(MatIconAnchor)));\n    }\n\n    public get cells(): TableBodyCell[] {\n        return this.element.queryAll(By.css('td')).map((element: DebugElement) => {\n            return new TableBodyCell(element);\n        });\n    }\n\n    public get rowDetail(): TableBodyDetail | null {\n        const parent = this.element.parent;\n        if (parent != null) {\n            const next = parent.children[parent.children.indexOf(this.element) + 1];\n            if (next && !next.references.masterRow) {\n                return new TableBodyDetail(next, this.page);\n            }\n        }\n        return null;\n    }\n\n    public get highlighted(): boolean {\n        return this.element.nativeElement.classList.contains(HIGHLIGHTER_CLASS);\n    }\n}\n\nexport class RowExpander {\n    public constructor(public element: DebugElement) {\n    }\n\n    public get icon(): string {\n        return this.element.query(By.directive(MatIcon)).nativeElement.textContent.trim();\n    }\n\n    public get opened(): boolean {\n        return this.icon === 'expand_less';\n    }\n\n    public get closed(): boolean {\n        return this.icon === 'expand_more';\n    }\n}\n\nexport class TableBodyCell {\n\n    public constructor(public element: DebugElement) {\n    }\n\n    public get colspan(): number {\n        return this.element.nativeElement.colspan;\n    }\n\n    public get rowspan(): number {\n        return this.element.nativeElement.rowspan;\n    }\n}\n\n// <editor-fold defaultstate=\"collapsed\" desc=\"Row detail\">\n\nexport class TableBodyDetail {\n\n    public constructor(public element: DebugElement, private page: { detectChanges: () => void }) {\n    }\n\n    public header(): TableHeader {\n        return new TableHeader(this.element.query(By.css('thead')), this.page);\n    }\n\n    public get body(): TableBodyDetailBody {\n        return new TableBodyDetailBody(this.element.query(By.css('tbody')));\n    }\n\n    public get highlighted(): boolean {\n        return this.element.nativeElement.classList.contains(HIGHLIGHTER_CLASS);\n    }\n\n    public get colspan(): number {\n        return this.element.children[0].nativeElement.colspan;\n    }\n}\n\nexport class TableBodyDetailBody {\n\n    public constructor(public element: DebugElement) {\n    }\n\n    public get rows(): TableBodyDetailRow[] {\n        return this.element.queryAll(By.css('tr')).map((element: DebugElement) => {\n            return new TableBodyDetailRow(element);\n        });\n    }\n\n    public get cells(): TableBodyCell[] {\n        let cells: TableBodyCell[] = [];\n        this.element.queryAll(By.css('tr')).forEach((row: DebugElement) => {\n            cells = cells.concat(row.queryAll(By.css('td')).map((cell: DebugElement) => {\n                return new TableBodyCell(cell);\n            }));\n        });\n        return cells;\n    }\n}\n\nexport class TableBodyDetailRow {\n\n    public constructor(public element: DebugElement) {\n    }\n\n    public get cells(): TableBodyCell[] {\n        return this.element.queryAll(By.css('td')).map((element: DebugElement) => {\n            return new TableBodyCell(element);\n        });\n    }\n}\n\n// </editor-fold>\n\n// </editor-fold>\n\n// <editor-fold defaultstate=\"collapsed\" desc=\"Table footer\">\n\nexport class TableFooter {\n\n    public constructor(public element: DebugElement) {\n    }\n\n    public get rows(): TableFooterRow[] {\n        return this.element.queryAll(By.css('tr')).map((element: DebugElement) => {\n            return new TableFooterRow(element);\n        });\n    }\n\n    public get cells(): TableBodyCell[] {\n        let cells: TableBodyCell[] = [];\n        this.element.queryAll(By.css('tr')).forEach((row: DebugElement) => {\n            cells = cells.concat(row.queryAll(By.css('th')).map((cell: DebugElement) => {\n                return new TableBodyCell(cell);\n            }));\n        });\n        return cells;\n    }\n}\n\nexport class TableFooterRow {\n\n    public constructor(public element: DebugElement) {\n    }\n\n    public get cells(): TableBodyCell[] {\n        return this.element.queryAll(By.css('th')).map((element: DebugElement) => {\n            return new TableBodyCell(element);\n        });\n    }\n}\n\n// </editor-fold>\n\nexport class RecordsCount {\n\n    public constructor(public element: DebugElement) {\n    }\n\n    public get message(): string {\n        return this.element.nativeElement.textContent;\n    }\n}\n\nexport class Pager {\n\n    public constructor(public element: DebugElement,\n                       private page: { detectChanges: () => void, advanceAndDetectChanges: () => void }) {\n    }\n\n    public get pageButtons(): DebugElement[] {\n        return this.element.queryAll(By.directive(MatButtonToggle));\n    }\n\n    public expectLeadingButtonsDisabled() {\n        for (let i = 0; i < 2; i++) {\n            expect(this.pageButtons[i].classes['mat-button-toggle-disabled'])\n                .toBe(true, 'First two are disabled.');\n        }\n    }\n\n    public expectLeadingButtonsNotDisabled() {\n        for (let i = 0; i < 2; i++) {\n            expect(this.pageButtons[i].classes['mat-button-toggle-disabled'])\n                .not.toBe(true, 'First two are not disabled.');\n        }\n    }\n\n    public expectTrailingButtonsDisabled() {\n        for (let i = this.pageButtons.length - 1; i > this.pageButtons.length - 3; i--) {\n            expect(this.pageButtons[i].classes['mat-button-toggle-disabled'])\n                .toBe(true, 'Last two are disabled.');\n        }\n    }\n\n    public expectTrailingButtonsNotDisabled() {\n        for (let i = this.pageButtons.length - 1; i > this.pageButtons.length - 3; i--) {\n            expect(this.pageButtons[i].classes['mat-button-toggle-disabled'])\n                .not.toBe(true, 'Last two are not disabled.');\n        }\n    }\n\n    public expectButtonNumbers(numbers: number[]) {\n        for (let i = 0; i < numbers.length; i++) {\n            expect(this.pageButtons[i + 2].query(By.css('.mat-button-toggle-label-content'))\n                .nativeElement.textContent.trim())\n                .toEqual(numbers[i] + '', 'Button numbers are correct');\n        }\n    }\n\n    public expectButtonActive(index: number) {\n        expect(this.pageButtons[index].classes['mat-button-toggle-checked'])\n            .toBe(true, 'Button is active.');\n    }\n\n    public click(index: number) {\n        click(this.pageButtons[index].query(By.css('.mat-button-toggle-label-content')).nativeElement);\n        this.page.detectChanges();\n        this.page.advanceAndDetectChanges();\n    }\n}\n\nexport function chceckSorting(page: { detectChanges: () => void, dataTable: DataTableDefinition },\n                              criteria: Array<ValueGetter<any>>) {\n    page.dataTable.sorting.checkSorting(150);\n\n    page.dataTable.sorting.handles.forEach((handle: SortingHandle, index: number) => {\n        // Tigger sort based on a handle\n        handle.click();\n        page.detectChanges();\n\n        // Check the sorting\n        page.dataTable.sorting.checkSorting(150, {\n            get: criteria[index]\n        });\n\n        // Tigger sort based on a handle\n        handle.click();\n        page.detectChanges();\n\n        // Check the sorting\n        page.dataTable.sorting.checkSorting(150, {\n            get       : criteria[index],\n            descending: true\n        });\n    });\n}\n\nexport class DataTableDefinitionHosted extends Page<TestDataTableHostComponent> {\n\n    public constructor(fixture: ComponentFixture<TestDataTableHostComponent>) {\n        super(fixture);\n    }\n\n    public get dataTable(): DataTableDefinition {\n        return new DataTableDefinition(this.debugElement.query(By.directive(DataTableComponent)), this);\n    }\n}\n\n@Component({\n    template: `\n        <risk-data-table [data]=\"data\"\n                         [footer]=\"footer\"\n                         [pageSize]=\"20\"\n                         [defaultOrdering]=\"defaultOrdering\"\n                         [striped]=\"true\">\n            <risk-data-table-column title=\"Test Column 1\"\n                                    [sortingKey]=\"valueGetter\">\n                <ng-template let-record=\"row\" risk-data-table-cell>\n                    {{record.value1}}\n                </ng-template>\n            </risk-data-table-column>\n            <risk-data-table-column>\n                <ng-template risk-data-table-cell let-record=\"row\" let-expanded=\"expanded\">\n                    <risk-data-table-detail-expander [expanded]=\"expanded\"></risk-data-table-detail-expander>\n                </ng-template>\n                <ng-template risk-data-table-footer-cell let-footer=\"footer\">\n                    {{footer.value1}}\n                </ng-template>\n            </risk-data-table-column>\n            <!-- Sub detail -->\n            <risk-data-table-detail-row>\n                <risk-data-table-column-group>\n                    <risk-data-table-column title=\"Test Detail Column 1\"\n                                            [sortingKey]=\"valueGetter\">\n                        <ng-template risk-data-table-cell let-record=\"row\">\n                            {{record.value1}}\n                        </ng-template>\n                    </risk-data-table-column>\n                </risk-data-table-column-group>\n                <risk-data-table-column-group>\n                    <risk-data-table-column title=\"Test Detail Column 2\">\n                        <ng-template risk-data-table-cell let-record=\"row\">\n                            {{record.value2}}\n                        </ng-template>\n                    </risk-data-table-column>\n                    <risk-data-table-column title=\"Test Detail Column 3\">\n                        <ng-template risk-data-table-cell let-record=\"row\">\n                            {{record.value3}}\n                        </ng-template>\n                    </risk-data-table-column>\n                </risk-data-table-column-group>\n                <risk-data-table-column-group></risk-data-table-column-group>\n            </risk-data-table-detail-row>\n        </risk-data-table>`\n})\nexport class TestDataTableHostComponent {\n\n    public data: any[];\n\n    public footer: any;\n\n    public constructor() {\n        this.data = [];\n        for (let i = 0; i < 500; i++) {\n            this.data.push({\n                value1: Math.floor(secureRandom() * 20) + ' - value 1',\n                value2: Math.floor(secureRandom() * 20) + ' - value 2',\n                value3: Math.floor(secureRandom() * 20) + ' - value 3'\n            });\n        }\n        this.footer = this.data[0];\n    }\n\n    public get defaultOrdering(): Array<OrderingCriteria<any> | ValueGetter<any>> {\n        return [\n            {\n                get       : (record: any) => {\n                    return record.value3;\n                },\n                descending: true\n            },\n            (record: any) => {\n                return record.value2;\n            }\n        ];\n    }\n\n    public get valueGetter(): (record: any) => any {\n        return (record: any) => {\n            return record.value1;\n        };\n    }\n}\n"]}