[ACA-3590]Created process-instance-header, info-drawer and task-header POs (#5894)

* Created process-instance-header and info-drawer POs

* Refactor ADF tests to use ProcessInstanceHeaderPage

* Fix lint

* Fix card-view-date-item PO

* Add task-header PO

* no message

* Add set and get for due date property

* Changed how it was previously

* Exclude attach folder and attach file tests

* Bugs already fixed, remove excludes

* Modify data-table-item for cases when column title is empty

* Add new methods to datatable PO

e2e/process-services/pages/process-details.page.ts

@@ -16,19 +16,12 @@
  */
 
 import { by, element, protractor } from 'protractor';
-import { BrowserVisibility, BrowserActions } from '@alfresco/adf-testing';
+import { BrowserVisibility, BrowserActions, ProcessInstanceHeaderPage } from '@alfresco/adf-testing';
 
 export class ProcessDetailsPage {
+    processInstanceHeaderPage = new ProcessInstanceHeaderPage();
     processTitle = element(by.css('.mat-card-title'));
     processDetailsMessage = element(by.css('adf-process-instance-details div'));
-    processStatusField = element(by.css('[data-automation-id="card-textitem-value-status"]'));
-    processEndDateField = element(by.css('span[data-automation-id="card-dateitem-ended"]'));
-    processCategoryField = element(by.css('[data-automation-id="card-textitem-value-category"]'));
-    processBusinessKeyField = element(by.css('[data-automation-id="card-textitem-value-businessKey"]'));
-    processCreatedByField = element(by.css('[data-automation-id="card-textitem-value-createdBy"]'));
-    processCreatedField = element(by.css('span[data-automation-id="card-dateitem-created"]'));
-    processIdField = element(by.css('[data-automation-id="card-textitem-value-id"]'));
-    processDescription = element(by.css('[data-automation-id="card-textitem-value-description"]'));
     showDiagramButtonDisabled = element(by.css('button[id="show-diagram-button"][disabled]'));
     propertiesList = element(by.css('.adf-property-list'));
     showDiagramButton = element(by.id('show-diagram-button'));
@@ -42,22 +35,6 @@ export class ProcessDetailsPage {
     completedTask = element(by.css('div[data-automation-id="completed-tasks"]'));
     taskTitle = element(by.css('.adf-activiti-task-details__header'));
 
-    async checkDetailsAreDisplayed(): Promise<void> {
-        await BrowserVisibility.waitUntilElementIsVisible(this.processStatusField);
-        await BrowserVisibility.waitUntilElementIsVisible(this.processEndDateField);
-        await BrowserVisibility.waitUntilElementIsVisible(this.processCategoryField);
-        await BrowserVisibility.waitUntilElementIsVisible(this.processBusinessKeyField);
-        await BrowserVisibility.waitUntilElementIsVisible(this.processCreatedByField);
-        await BrowserVisibility.waitUntilElementIsVisible(this.processCreatedField);
-        await BrowserVisibility.waitUntilElementIsVisible(this.processIdField);
-        await BrowserVisibility.waitUntilElementIsVisible(this.processDescription);
-        await BrowserVisibility.waitUntilElementIsVisible(this.showDiagramButton);
-        await BrowserVisibility.waitUntilElementIsVisible(this.activeTask);
-        await BrowserVisibility.waitUntilElementIsVisible(this.cancelProcessButton);
-        await BrowserVisibility.waitUntilElementIsVisible(this.commentInput);
-        await BrowserVisibility.waitUntilElementIsVisible(this.auditLogButton);
-    }
-
     checkProcessTitleIsDisplayed(): Promise<string> {
         return BrowserActions.getText(this.processTitle);
     }
@@ -66,36 +43,40 @@ export class ProcessDetailsPage {
         return BrowserActions.getText(this.processDetailsMessage);
     }
 
+    async checkProcessHeaderDetailsAreVisible(): Promise<void> {
+        await this.processInstanceHeaderPage.checkDetailsAreDisplayed();
+    }
+
     getProcessStatus(): Promise<string> {
-        return BrowserActions.getInputValue(this.processStatusField);
+        return this.processInstanceHeaderPage.getStatusFieldValue();
     }
 
     getEndDate(): Promise<string> {
-        return BrowserActions.getText(this.processEndDateField);
+        return this.processInstanceHeaderPage.getEndDateFieldValue();
     }
 
     getProcessCategory(): Promise<string> {
-        return BrowserActions.getInputValue(this.processCategoryField);
+        return this.processInstanceHeaderPage.getCategoryFieldValue();
     }
 
     getBusinessKey(): Promise<string> {
-        return BrowserActions.getInputValue(this.processBusinessKeyField);
+        return this.processInstanceHeaderPage.getBusinessKeyFieldValue();
     }
 
     getCreatedBy(): Promise<string> {
-        return BrowserActions.getInputValue(this.processCreatedByField);
+        return this.processInstanceHeaderPage.getStartedByFieldValue();
     }
 
     getCreated(): Promise<string> {
-        return BrowserActions.getText(this.processCreatedField);
+        return this.processInstanceHeaderPage.getStartDateFieldValue();
     }
 
     getId(): Promise<string> {
-        return BrowserActions.getInputValue(this.processIdField);
+        return this.processInstanceHeaderPage.getIdFieldValue();
     }
 
     getProcessDescription(): Promise<string> {
-        return BrowserActions.getInputValue(this.processDescription);
+        return this.processInstanceHeaderPage.getDescriptionFieldValue();
     }
 
     async clickShowDiagram(): Promise<void> {

e2e/process-services/process-instance-details.e2e.ts

@@ -70,7 +70,7 @@ describe('Process Instance Details', () => {
    });
 
     it('[C307031] Should display the created date in the default format', async () => {
-        await processDetailsPage.checkDetailsAreDisplayed();
+        await processDetailsPage.checkProcessHeaderDetailsAreVisible();
         await expect(await processDetailsPage.getCreated()).toEqual(moment(process.started).format(PROCESS_DATE_FORMAT));
     });
 });

e2e/process-services/start-process-component.e2e.ts

@@ -194,7 +194,9 @@ describe('Start Process Component', () => {
                 await startProcessPage.enterProcessName('Test');
                 await startProcessPage.selectFromProcessDropdown(browser.params.resources.Files.APP_WITH_PROCESSES.process_se_name);
                 await startProcessPage.clickFormStartProcessButton();
-                await processDetailsPage.checkDetailsAreDisplayed();
+
+                await processDetailsPage.checkProcessHeaderDetailsAreVisible();
+
                 const processId = await processDetailsPage.getId();
                 const response = await apiService.getInstance().activiti.processApi.getProcessInstance(processId);
 

e2e/protractor.excludes.json

@@ -1,7 +1,7 @@
 {
   "C290180": "https://issues.alfresco.com/jira/browse/ACS-364",
   "C277201": "Investigate after NG10",
-  "C362240": "Include once ADF starts using ACS 7, https://issues.alfresco.com/jira/browse/ADF-5182",
+  "C362240": "Include once ADF starts using ACS 7 , https://issues.alfresco.com/jira/browse/ADF-5182",
   "C362241": "Include once ADF starts using ACS 7, https://issues.alfresco.com/jira/browse/ADF-5182",
   "C362242": "Include once ADF starts using ACS 7, https://issues.alfresco.com/jira/browse/ADF-5182",
   "C362265": "Include once ADF starts using ACS 7, https://issues.alfresco.com/jira/browse/ADF-5182"

lib/testing/src/lib/core/pages/card-view/card-view-date-item.page.ts

@@ -18,6 +18,7 @@
 import { element, by, ElementFinder } from 'protractor';
 import { DateTimePickerPage } from '../material/date-time-picker.page';
 import { DatePickerPage } from '../material/date-picker.page';
+import { BrowserVisibility } from '../../utils/browser-visibility';
 
 export class CardDateItemPage {
 
@@ -25,7 +26,7 @@ export class CardDateItemPage {
     dateTimePickerPage: DateTimePickerPage;
     datePickerPage = new DatePickerPage();
 
-    labelLocator = by.css('div[data-automation-id*="card-date-label"]');
+    labelLocator = by.css('div[data-automation-id*="card-dateitem-label"]');
     valueLocator = by.css('span[data-automation-id*="card-date"]');
     dateTimePicker = element.all(by.css('.mat-datetimepicker-toggle')).first();
     saveButton = by.css('button[data-automation-id*="card-dateitem-update"]');
@@ -46,4 +47,9 @@ export class CardDateItemPage {
     async getDateValue(): Promise<string> {
         return this.rootElement.element(this.valueLocator).getText();
     }
+
+    async checkLabelIsVisible(): Promise<void> {
+        const labelElement = this.rootElement.element(this.labelLocator);
+        await BrowserVisibility.waitUntilElementIsVisible(labelElement);
+    }
 }

lib/testing/src/lib/core/pages/card-view/card-view-text-item.page.ts

@@ -34,7 +34,7 @@ export class CardTextItemPage {
     }
 
     async getFieldValue(): Promise<string> {
-        const fieldElement = this.rootElement.all(this.field).first();
+        const fieldElement = this.rootElement.element(this.field);
         return BrowserActions.getInputValue(fieldElement);
     }
 
@@ -43,6 +43,11 @@ export class CardTextItemPage {
         await BrowserVisibility.waitUntilElementIsPresent(labelElement);
     }
 
+    async checkLabelIsVisible(): Promise<void> {
+        const labelElement = this.rootElement.element(this.labelLocator);
+        await BrowserVisibility.waitUntilElementIsVisible(labelElement);
+    }
+
     async enterTextField(text: string): Promise<void> {
         await BrowserVisibility.waitUntilElementIsVisible(this.rootElement.element(this.textField));
         await BrowserActions.clearSendKeys(this.rootElement.element(this.textField), text);

lib/testing/src/lib/core/pages/data-table/column.ts

@@ -27,4 +27,8 @@ export abstract class Column {
     createLocator(columnValue: string): string {
         return `//div[@data-automation-id="${this.columnType}_${columnValue}"]`;
     }
+
+    getColumnName(): string {
+        return this.columnName;
+    }
 }

lib/testing/src/lib/core/pages/data-table/data-table-item.ts

@@ -33,15 +33,15 @@ export class DataTableItem {
         this.columns.push(column);
     }
 
-    getColumn(columnName: string): Column {
+    async getColumn(columnName: string): Promise<Column> {
         return this.columns.find(
-            (column) => column.columnName === columnName
+            (column) =>  column.getColumnName() === columnName
         );
     }
 
-    getRow(columnName: string, columnValue: string): ElementFinder {
-        const column = this.getColumn(columnName);
-        const locator = `//div[@title="${columnName}"]` + column.createLocator(columnValue) + `//ancestor::adf-datatable-row[contains(@class, 'adf-datatable-row')]`;
+    async getRow(columnName: string, columnValue: string): Promise<ElementFinder> {
+        const column = await this.getColumn(columnName);
+        const locator = `//div[@title="${column.columnName}"]` + column.createLocator(columnValue) + `//ancestor::adf-datatable-row[contains(@class, 'adf-datatable-row')]`;
         return this.rootElement.element(by.xpath(locator));
     }
 
@@ -52,7 +52,7 @@ export class DataTableItem {
     }
 
     async rightClickOnRow(columnName: string, columnValue: string): Promise<void> {
-        const row = this.getRow(columnName, columnValue);
+        const row = await this.getRow(columnName, columnValue);
         await BrowserActions.rightClick(row);
     }
 
@@ -61,8 +61,27 @@ export class DataTableItem {
     }
 
     async clickAndEnterOnRow(columnName: string, columnValue: string): Promise<void> {
-        const row = this.getRow(columnName, columnValue);
+        const row = await this.getRow(columnName, columnValue);
         await BrowserActions.click(row);
         await browser.actions().sendKeys(protractor.Key.ENTER).perform();
     }
+
+    async getColumnValueForRow(identifyingColumnName: string, identifyingColumnValue: string, columnName: string): Promise<string> {
+        const row = await this.getRow(identifyingColumnName, identifyingColumnValue);
+        await BrowserVisibility.waitUntilElementIsVisible(row);
+        const rowColumn = row.element(by.css(`div[title="${columnName}"] span`));
+        return BrowserActions.getText(rowColumn);
+    }
+
+    async checkRowIsSelected(columnName: string, columnValue: string): Promise<void> {
+        const column = await this.getColumn(columnName);
+        const locator = `//div[@title="${column.columnName}"]` + column.createLocator(columnValue) + `//ancestor::adf-datatable-row[contains(@class, 'is-selected')]`;
+        await BrowserVisibility.waitUntilElementIsVisible(element(by.xpath(locator)));
+    }
+
+    async checkRowIsNotSelected(columnName: string, columnValue: string): Promise<void> {
+        const column = await this.getColumn(columnName);
+        const locator = `//div[@title="${column.columnName}"]` + column.createLocator(columnValue) + `//ancestor::adf-datatable-row[contains(@class, 'is-selected')]`;
+        await BrowserVisibility.waitUntilElementIsNotVisible(element(by.xpath(locator)));
+    }
 }

lib/testing/src/lib/core/pages/info-drawer.page.ts

@@ -0,0 +1,75 @@
+/*!
+ * @license
+ * Copyright 2019 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { element, by, ElementFinder } from 'protractor';
+import { BrowserVisibility } from './../utils/browser-visibility';
+import { TabsPage } from './material/tabs.page';
+
+export class InfoDrawerPage {
+
+    rootElement: ElementFinder;
+    infoDrawerHeader = by.css('adf-info-drawer-layout-header');
+    tabsPage: TabsPage = new TabsPage();
+
+    constructor(classLocator: string = 'adf-info-drawer') {
+        this.rootElement = element(by.css(`adf-info-drawer[class*='${classLocator}']`));
+    }
+
+    async isInfoDrawerDisplayed(): Promise<boolean> {
+        try {
+            await BrowserVisibility.waitUntilElementIsVisible(this.rootElement);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async isInfoDrawerNotDisplayed(): Promise<boolean> {
+        try {
+            await BrowserVisibility.waitUntilElementIsNotVisible(this.rootElement);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async isInfoDrawerHeaderDisplayed(): Promise<boolean> {
+        try {
+            await BrowserVisibility.waitUntilElementIsVisible(this.rootElement.element(this.infoDrawerHeader));
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async isInfoDrawerHeaderNotDisplayed(): Promise<boolean> {
+        try {
+            await BrowserVisibility.waitUntilElementIsNotVisible(this.rootElement.element(this.infoDrawerHeader));
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async getNoOfTabs(): Promise<Number> {
+        return this.tabsPage.getNoOfTabs();
+    }
+
+    async getTabsLabels(): Promise<string> {
+        return this.tabsPage.getTabsLabels();
+    }
+}

lib/testing/src/lib/core/pages/material/tabs.page.ts

@@ -17,9 +17,12 @@
 
 import { element, by } from 'protractor';
 import { BrowserActions } from '../../utils/browser-actions';
+import { BrowserVisibility } from '../../utils/browser-visibility';
 
 export class TabsPage {
 
+    tabs = element.all(by.css("div[id*='mat-tab-label']"));
+
     async clickTabByTitle(tabTitle): Promise<void> {
         const tab = element(by.cssContainingText("div[id*='mat-tab-label']", tabTitle));
         await BrowserActions.click(tab);
@@ -30,4 +33,14 @@ export class TabsPage {
         const result = await tab.getAttribute('aria-selected');
         await expect(result).toBe('true');
     }
+
+    async getNoOfTabs(): Promise<number> {
+        BrowserVisibility.waitUntilElementIsVisible(this.tabs.first());
+        return this.tabs.count();
+    }
+
+    async getTabsLabels(): Promise<string> {
+        BrowserVisibility.waitUntilElementIsVisible(this.tabs.first());
+        return this.tabs.getText();
+    }
 }

lib/testing/src/lib/core/pages/public-api.ts

@@ -36,3 +36,4 @@ export * from './about.page';
 export * from './snackbar.page';
 export * from './data-table/public-api';
 export * from './context-menu.page';
+export * from './info-drawer.page';

lib/testing/src/lib/process-services/pages/process-instance-header.page.ts

@@ -0,0 +1,146 @@
+/*!
+ * @license
+ * Copyright 2019 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { CardTextItemPage } from '../../core/pages/card-view/card-view-text-item.page';
+import { CardDateItemPage } from '../../core/pages/card-view/card-view-date-item.page';
+
+export class ProcessInstanceHeaderPage {
+
+    status = new CardTextItemPage('status');
+    endDate = new CardDateItemPage('ended');
+    category = new CardTextItemPage('category');
+    businessKey = new CardTextItemPage('businessKey');
+    startedBy = new CardTextItemPage('createdBy');
+    startDate = new CardDateItemPage('created');
+    id = new CardTextItemPage('id');
+    description = new CardTextItemPage('description');
+
+    async isIdFieldDisplayed(): Promise<boolean> {
+        try {
+            await this.id.checkLabelIsVisible();
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    async getIdFieldValue(): Promise<string> {
+        return this.id.getFieldValue();
+    }
+
+    async isStatusFieldDisplayed(): Promise<boolean> {
+        try {
+            await this.status.checkLabelIsVisible();
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    async getStatusFieldValue(): Promise<string> {
+        return this.status.getFieldValue();
+    }
+
+    async isEndDateFieldDisplayed(): Promise<boolean> {
+        try {
+            await this.endDate.checkLabelIsVisible();
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    async getEndDateFieldValue(): Promise<string> {
+        return this.endDate.getDateValue();
+    }
+
+    async isCategoryFieldDisplayed(): Promise<boolean> {
+        try {
+            await this.category.checkLabelIsVisible();
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    async getCategoryFieldValue(): Promise<string> {
+        return this.category.getFieldValue();
+    }
+
+    async isBusinessKeyFieldDisplayed(): Promise<boolean> {
+        try {
+            await this.businessKey.checkLabelIsVisible();
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    async getBusinessKeyFieldValue(): Promise<string> {
+        return this.businessKey.getFieldValue();
+    }
+
+    async isStartedByFieldDisplayed(): Promise<boolean> {
+        try {
+            await this.startedBy.checkLabelIsVisible();
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    async getStartedByFieldValue(): Promise<string> {
+        return this.startedBy.getFieldValue();
+    }
+
+    async isStartDateFieldDisplayed(): Promise<boolean> {
+        try {
+            await this.startDate.checkLabelIsVisible();
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    async getStartDateFieldValue(): Promise<string> {
+        return this.startDate.getDateValue();
+    }
+
+    async isDescriptionFieldDisplayed(): Promise<boolean> {
+        try {
+            await this.description.checkLabelIsVisible();
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    async getDescriptionFieldValue(): Promise<string> {
+        return this.description.getFieldValue();
+    }
+
+    async checkDetailsAreDisplayed(): Promise<void> {
+        await this.status.checkLabelIsVisible();
+        await this.endDate.checkLabelIsVisible();
+        await this.category.checkLabelIsVisible();
+        await this.businessKey.checkLabelIsVisible();
+        await this.startedBy.checkLabelIsVisible();
+        await this.startDate.checkLabelIsVisible();
+        await this.id.checkLabelIsVisible();
+        await this.description.checkLabelIsVisible();
+    }
+}

lib/testing/src/lib/process-services/pages/public-api.ts

@@ -21,7 +21,9 @@ export * from './process-filters.page';
 export * from './process-list.page';
 export * from './task-list.page';
 export * from './task-filters.page';
+export * from './task-header.page';
 export * from './process-instance-tasks.page';
+export * from './process-instance-header.page';
 export * from './start-process.page';
 export * from './select-apps-dialog.page';
 export * from './external-node-selector-dialog.page';

lib/testing/src/lib/process-services/pages/task-header.page.ts

@@ -0,0 +1,91 @@
+/*!
+ * @license
+ * Copyright 2019 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { CardTextItemPage } from '../../core/pages/card-view/card-view-text-item.page';
+import { CardDateItemPage } from '../../core/pages/card-view/card-view-date-item.page';
+
+export class TaskHeaderPage {
+
+    assignee = new CardTextItemPage('assignee');
+    status = new CardTextItemPage('status');
+    priority = new CardTextItemPage('priority');
+    dueDate = new CardDateItemPage('dueDate');
+    category = new CardTextItemPage('category');
+    parentName = new CardDateItemPage('parentName');
+    createdDate = new CardDateItemPage('created');
+    duration = new CardTextItemPage('duration');
+    parentTaskId = new CardTextItemPage('parentTaskId');
+    endDate = new CardDateItemPage('endDate');
+    id = new CardTextItemPage('id');
+    description = new CardTextItemPage('description');
+    formName = new CardTextItemPage('formName');
+
+    async isIdFieldDisplayed(): Promise<boolean> {
+        try {
+            await this.id.checkLabelIsVisible();
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    async getIdFieldValue(): Promise<string> {
+        return this.id.getFieldValue();
+    }
+
+    async isStatusFieldDisplayed(): Promise<boolean> {
+        try {
+            await this.status.checkLabelIsVisible();
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    async getStatusFieldValue(): Promise<string> {
+        return this.status.getFieldValue();
+    }
+
+    async isPriorityFieldDisplayed(): Promise<boolean> {
+        try {
+            await this.priority.checkLabelIsVisible();
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    async getPriorityFieldValue(): Promise<string> {
+        return this.priority.getFieldValue();
+    }
+
+    async setPriorityFieldValue(priority): Promise<void> {
+        await this.priority.enterTextField(priority);
+    }
+
+    async getDueDateFieldValue(): Promise<string> {
+        return this.dueDate.getDateValue();
+    }
+
+    async setDueDateFieldValue(date): Promise<void> {
+        await this.dueDate.setDateValue(date);
+    }
+
+    async setDueDateFieldValueToCurrentDate(): Promise<void> {
+        await this.dueDate.setTodayDateValue();
+    }
+}

scripts/test-e2e-lib.sh

@@ -199,7 +199,7 @@ if [ "$CI" = "true" ]; then
     webdriver-manager update --gecko=false --versions.chrome=$chrome
 else
     echo "Updating wedriver-manager with latest chromedriver, be sure to use evergreen Chrome."
-    webdriver-manager update --gecko=false
+    ./node_modules/protractor/bin/webdriver-manager update --gecko=false
 fi
 
 export DEBUG_OPTION=''