Merge pull request #95 from aquality-automation/feature/tests_for_milestome

Feature/tests for milestome

Author: VladislavKostyukevich

e2e/api/base.api.ts

@@ -11,7 +11,7 @@ export class BaseAPI {
         this.token = token;
     }
 
-    public async assertNegativeresponse(promise: Promise<object>, expectedError: string): Promise<void> {
+    public async assertNegativeResponse(promise: Promise<object>, expectedError: string): Promise<void> {
         let atError: ATError;
         try {
             await promise;

e2e/elements/autocomplete.element.ts

@@ -44,4 +44,9 @@ export class Autocomplete extends BaseElement implements WithSearch {
     async isEnabled() {
         return !(await this.disabledElement.isPresent());
     }
+
+    async hasOption(value: string) {
+        await this.enterValue(value);
+        return this.findOption(value).isPresent();
+    }
 }

e2e/elements/datepicker.element.ts

@@ -1,12 +1,77 @@
-import { ElementFinder, Locator } from 'protractor';
+import { ElementFinder, Locator, by } from 'protractor';
 import { BaseElement } from './base.element';
+import { Input } from './input.element';
 
 export class DatePicker extends BaseElement {
     constructor(locatorOrElement: Locator | ElementFinder) {
         super(locatorOrElement);
     }
+    monthNames = ['January', 'February', 'March', 'April', 'May', 'June',
+        'July', 'August', 'September', 'October', 'November', 'December'
+    ];
+
+    linkInput = new Input(this.element.element(by.css('.ngx-datepicker-input')));
+    topBarTitle = this.element.element(by.css('.topbar-title'));
+    prevMonth = this.element.element(by.id('prevMonth'));
+    nextMonth = this.element.element(by.id('nextMonth'));
+    yearButton = (year: number) => this.element
+        .element(by.xpath(
+            `.//*[contains(@class, 'main-calendar-years')]//*[contains(@class, 'year-unit') and normalize-space(text())='${year}']`))
+    dayButton = (day: number) => this.element
+        .element(by.xpath(
+            `.//*[contains(@class, 'main-calendar-days')]//*[contains(@class, 'day-unit') and normalize-space(text())='${day}']`))
+
+    openCalendar() {
+        return this.linkInput.click();
+    }
 
     async select(date: Date) {
-        throw new Error('Date Picker is not implemented.');
+        const selectDate = new Date(date);
+        const month = this.monthNames[selectDate.getMonth()];
+        const year = selectDate.getFullYear();
+        const day = selectDate.getDate();
+
+        await this.openCalendar();
+        await this.selectYear(year);
+        await this.selectMonth(month);
+        return this.dayButton(day).click();
+    }
+
+    isEditable(): Promise<boolean> {
+        return this.linkInput.isPresent();
+    }
+
+    private async selectMonth(month: string): Promise<void> {
+        for (let i = 0; i < this.monthNames.length; i++) {
+            const currentMonth = await this.getCurrentMonth();
+            if (currentMonth !== month) {
+                if (this.monthNames.indexOf(currentMonth) < this.monthNames.indexOf(month)) {
+                    await this.nextMonth.click();
+                }
+                if (this.monthNames.indexOf(currentMonth) > this.monthNames.indexOf(month)) {
+                    await this.prevMonth.click();
+                }
+            } else {
+                return;
+            }
+        }
+    }
+
+    private async selectYear(year: number): Promise<void> {
+        const currentYear = await this.getCurrentYear();
+        if (currentYear !== year) {
+            await this.topBarTitle.click();
+            return this.yearButton(year).click();
+        }
+    }
+
+    private async getCurrentMonth(): Promise<string> {
+        const currentMonthYear = await this.topBarTitle.getText();
+        return currentMonthYear.split(' ')[0];
+    }
+
+    private async getCurrentYear(): Promise<number> {
+        const currentMonthYear = await this.topBarTitle.getText();
+        return +currentMonthYear.split(' ')[1];
     }
 }

e2e/elements/multiselect.element.ts

@@ -1,4 +1,4 @@
-import { by, Locator, ElementFinder } from 'protractor';
+import { by, Locator, ElementFinder, protractor } from 'protractor';
 import { BaseElement } from './base.element';
 import { WithSearch } from './interfaces/elementWithSearch';
 
@@ -28,11 +28,17 @@ export class Multiselect extends BaseElement implements WithSearch {
 
     public async select(value: string) {
         await this.enterValue(value);
-        return this.selectOption(value);
+        await this.selectOption(value);
+        if (await this.isOpened()) {
+            return this.search.sendKeys(protractor.Key.ESCAPE);
+        }
     }
 
-    public remove(name: string) {
-        return this.removeMsBox(name).click();
+    public async remove(name: string) {
+        await this.removeMsBox(name).click();
+        if (await this.isOpened()) {
+            return this.search.sendKeys(protractor.Key.ESCAPE);
+        }
     }
 
     public async isEditable() {
@@ -52,6 +58,10 @@ export class Multiselect extends BaseElement implements WithSearch {
         return (await this.disabledElement.getText()).split(', ');
     }
 
+    private isOpened() {
+        return this.search.isPresent();
+    }
+
     private findOption(value: string) {
         return this.element.element(by.css(`.selector-suggestions li[title="${value}"]`));
     }

e2e/elements/smartTable.element/index.ts

@@ -212,7 +212,7 @@ export class SmartTable extends BaseElement {
         return rightClick(cell);
     }
 
-    public async editRow(value: string | boolean, column: string, searchValue: string, searchColumn: string) {
+    public async editRow(value: string | boolean | Date, column: string, searchValue: string, searchColumn: string) {
         const row = await this.getRow(searchValue, searchColumn);
         const columnIndex = await this.getColumnIndex(column);
         return row.editRowCellValueByColumnIndex(value, columnIndex);

e2e/elements/smartTable.element/row.element.ts

@@ -9,6 +9,7 @@ import { logger } from '../../utils/log.util';
 import { InlineAttach } from '../inlineAttach.element';
 import { Multiselect } from '../multiselect.element';
 import { Dots } from '../dots.element';
+import { DatePicker } from '../datepicker.element';
 
 export class Row extends BaseElement {
     constructor(locator: ElementFinder | Locator) {
@@ -60,13 +61,17 @@ export class Row extends BaseElement {
             lookup: () => new Lookup(cell.element(by.xpath('.//lookup-colored'))),
             inlineAttachment: () => new InlineAttach(cell.element(by.xpath('.//attachment-inline'))),
             multiselect: () => new Multiselect(cell.element(by.xpath('.//lookup-autocomplete-multiselect'))),
+            date: () => new DatePicker(cell.element(by.xpath('.//ng-datepicker'))),
             dots: () => new Dots(cell.element(by.xpath('.//app-color-dots')))
         };
     }
 
-    public async editRowCellValueByColumnIndex(value: string | boolean | number, columnIndex: number) {
+    public async editRowCellValueByColumnIndex(value: string | boolean | number | Date, columnIndex: number) {
         const rowElements = await this.getRowElements(columnIndex);
         if (await this.isCellContainsEditableElement(columnIndex)) {
+            if (await rowElements.date().element.isPresent()) {
+                return rowElements.date().select(new Date(value as Date));
+            }
             if (await rowElements.inlineEditor().element.isPresent()) {
                 return rowElements.inlineEditor().changeAndSetValue(value as string);
             }
@@ -85,6 +90,9 @@ export class Row extends BaseElement {
             if (await rowElements.coloredLookup().element.isPresent()) {
                 return rowElements.coloredLookup().select(value as string);
             }
+            if (await rowElements.multiselect().element.isPresent()) {
+                return rowElements.multiselect().select(value as string);
+            }
         }
 
         throw new Error(`You are trying to edit not editable ${columnIndex} column!`);
@@ -199,4 +207,5 @@ export class CellElements {
     inlineAttachment: () => InlineAttach;
     multiselect: () => Multiselect;
     dots: () => Dots;
+    date: () => DatePicker;
 }

e2e/elements/ui-switch.ts

@@ -28,4 +28,9 @@ export class UiSwitch extends BaseElement {
             return this.element.click();
         }
     }
+
+    async isEnabled() {
+        const elementClass = await this.element.element(by.tagName('span')).getAttribute('class');
+        return !elementClass.includes('disabled');
+    }
 }

e2e/pages/milestone/list.po/constants.ts

@@ -14,5 +14,8 @@ export const names = {
 
 export const columns = {
     name: 'Name',
-    action: 'Action'
+    action: 'Action',
+    active: 'Active',
+    suites: 'Suites',
+    dueDate: 'Due Date'
 };

e2e/pages/milestone/list.po/index.ts

@@ -46,14 +46,30 @@ class MilestoneList extends BasePage {
     }
 
     openMilestone(name: string) {
-        return elements.milestonesTable.clickRow(name, columns.name);
+        return elements.milestonesTable.clickCell(columns.name, name, columns.name);
+    }
+
+    addMilestoneSuite(suiteName: string, name: string) {
+        return elements.milestonesTable.editRow(suiteName, columns.suites, name, columns.name);
+    }
+
+    updateMilestoneDueDate(date: Date, name: string) {
+        return elements.milestonesTable.editRow(date, columns.dueDate, name, columns.name);
+    }
+
+    updateMilestoneActive(value: boolean, name: string) {
+        return elements.milestonesTable.editRow(value, columns.active, name, columns.name);
     }
 
     async isTableEditable(): Promise<boolean> {
         const isActionColumnExist = await elements.milestonesTable.isColumnExist(columns.action);
         const isRowContainEditableElements = await elements.milestonesTable.isRowEditableByIndex(0);
         return isActionColumnExist || isRowContainEditableElements;
     }
+
+    async isRowEditable(name: string) {
+        return elements.milestonesTable.isRowEditableByValue(name, columns.name);
+    }
 }
 
 export const milestoneList = new MilestoneList();

e2e/pages/milestone/view.po/constants.ts

@@ -3,6 +3,8 @@ import { SmartTable } from '../../../elements/smartTable.element';
 import { UiSwitch } from '../../../elements/ui-switch';
 import { ResultPieChart } from '../../../elements/charts/resultPie.element';
 import { ResolutionPieChart } from '../../../elements/charts/resolution.Pie.element';
+import { Multiselect } from '../../../elements/multiselect.element';
+import { DatePicker } from '../../../elements/datepicker.element';
 
 export const baseUrl = (projectId: number, milestoneId: number) => `/project/${projectId}/milestone/${milestoneId}`;
 
@@ -11,7 +13,13 @@ export const elements = {
     milestonesTable: new SmartTable(by.id('suite-results')),
     distinctTest: new UiSwitch(by.css('#stack-suites ui-switch')),
     resultsChart: new ResultPieChart(by.id('finalResultsChart')),
-    resolutionsChart: new ResolutionPieChart(by.id('resultResolutionsChart'))
+    resolutionsChart: new ResolutionPieChart(by.id('resultResolutionsChart')),
+    suites: new Multiselect(by.id('suites')),
+    notExecutedSuites: element(by.id('not-executed-suites')),
+    dueDate: new DatePicker(by.id('milestone-due-date')),
+    warning: element(by.css('#milestone-view fa-icon.warning-icon')),
+    warningTitle: element(by.css('#milestone-view fa-icon.warning-icon title')),
+    activeSwitch: new UiSwitch(by.css('#active-switch ui-switch'))
 };
 
 export const names = {