[ADF-4015] Implementing edit task filter automated tests (#4337)

* Added a few test cases to cover task list and edit task filters cloud components properties.

* Add tests for task name property.

* Add processInstanceId tests

* Added lastModifiedTo and lastModifiedFrom tests.

* Added tests for all the properties

* Add selectionMode tests.

* Add selectionMode tests

* Update task-list-selection.e2e.ts

* [ADF-4015] Fix lint issues

* Using clearField

* Modified selection tests

* Fixing selection tests

* no message

* Fix spelling

* Removed a sleep from the test

* Fix siteListDropDown locator

demo-shell/src/app/components/app-layout/cloud/cloud-settings.component.html

@@ -8,7 +8,7 @@
     <mat-slide-toggle [color]="'primary'" [checked]="taskDetailsRedirection" (change)="toggleTaskDetailsRedirection()" data-automation-id="taskDetailsRedirection">
         {{ 'SETTINGS_CLOUD.TASK_DETAILS_REDIRECTION' | translate }}
     </mat-slide-toggle>
-    <mat-form-field>
+    <mat-form-field data-automation-id="selectionMode">
         <mat-label>
             {{ 'SETTINGS_CLOUD.SELECTION_MODE' | translate }}
         </mat-label>

e2e/actions/APS-cloud/tasks.ts

@@ -89,11 +89,11 @@ export class Tasks {
         return data;
     }
 
-    async createStandaloneSubtask(taskId, appName, name) {
+    async createStandaloneSubtask(parentTaskId, appName, name) {
-        const path = '/' + appName + '-rb/v1/tasks/' + taskId + '/subtask';
+        const path = '/' + appName + '-rb/v1/tasks';
         const method = 'POST';
 
-        const queryParams = {}, postBody = {'name': name, 'payloadType': 'CreateTaskPayload'};
+        const queryParams = {}, postBody = {'name': name, 'parentTaskId': parentTaskId, 'payloadType': 'CreateTaskPayload'};
 
         const data = await this.api.performBpmOperation(path, method, queryParams, postBody);
         return data;

e2e/pages/adf/configEditorPage.ts

@@ -76,4 +76,18 @@ export class ConfigEditorPage {
         Util.waitUntilElementIsClickable(button);
         return button.click();
     }
+
+    clickEditTaskConfiguration() {
+        let button = element(by.id('adf-edit-task-filter-conf'));
+        Util.waitUntilElementIsVisible(button);
+        Util.waitUntilElementIsClickable(button);
+        return button.click();
+    }
+
+    clickTaskListCloudConfiguration() {
+        let button = element(by.id('adf-task-list-cloud-conf'));
+        Util.waitUntilElementIsVisible(button);
+        Util.waitUntilElementIsClickable(button);
+        return button.click();
+    }
 }

e2e/pages/adf/contentServicesPage.ts

@@ -66,7 +66,7 @@ export class ContentServicesPage {
     copyButton = element(by.css('button[data-automation-id="content-node-selector-actions-choose"]'));
     searchInputElement = element(by.css('input[data-automation-id="content-node-selector-search-input"]'));
     shareNodeButton = element(by.cssContainingText('mat-icon', ' share '));
-    siteListDropdown = element(by.css(`mat-select[data-automation-id='site-my-files-select']`));
+    siteListDropdown = element(by.css(`mat-select[data-automation-id='site-my-files-option']`));
 
     getUploadAreaDocumentList() {
         return new ContentListPage(element(by.css('adf-upload-drag-area')));

e2e/pages/adf/dataTablePage.ts

@@ -29,7 +29,7 @@ export class DataTablePage {
     selectionDropDown = element(by.css(`div[class*='ng-trigger-transformPanel']`));
     allSelectedRows = element.all(by.css(`div[class*='is-selected']`));
     selectedRowNumber = element(by.css(`div[class*='is-selected'] div[data-automation-id*='text_']`));
-    selectAll = element(by.css(`div[class*='header'] label`));
+    selectAll = element(by.css(`div[class*='header'] mat-checkbox`));
     addRowElement = element(by.xpath(`//span[contains(text(),'Add row')]/..`));
     replaceRowsElement = element(by.xpath(`//span[contains(text(),'Replace rows')]/..`));
     reset = element(by.xpath(`//span[contains(text(),'Reset to default')]/..`));
@@ -89,6 +89,24 @@ export class DataTablePage {
         checkbox.click();
     }
 
+    clickCheckboxByName(rowName) {
+        let checkbox = this.getRowsName(rowName).element(by.xpath(`ancestor::div[contains(@class, 'adf-datatable-row')]//mat-checkbox/label`));
+        Util.waitUntilElementIsVisible(checkbox);
+        checkbox.click();
+    }
+
+    getRowCheckboxByName(rowName) {
+        return this.getRowsName(rowName).element(by.xpath(`ancestor::div/div/mat-checkbox[contains(@class, 'mat-checkbox-checked')]`));
+    }
+
+    checkRowIsNotCheckedByName(rowName) {
+        Util.waitUntilElementIsNotOnPage(this.getRowCheckboxByName(rowName));
+    }
+
+    checkRowIsCheckedByName(rowName) {
+        Util.waitUntilElementIsVisible(this.getRowCheckboxByName(rowName));
+    }
+
     selectRow(rowNumber) {
         return this.getRowByRowNumber(rowNumber).click();
     }
@@ -105,6 +123,30 @@ export class DataTablePage {
         selectMode.click();
     }
 
+    selectRowByRowName(rowName) {
+        let row = element(by.cssContainingText(`[data-automation-id*="${rowName}"]`, rowName));
+        Util.waitUntilElementIsVisible(row);
+        Util.waitUntilElementIsClickable(row);
+        return row.click();
+    }
+
+    checkRowIsSelectedByName(rowName) {
+        let row = element(by.cssContainingText(`[data-automation-id*="${rowName}"]`, rowName));
+        let isRowSelected = row.element(by.xpath(`ancestor::div[contains(@class, 'is-selected')]`));
+        Util.waitUntilElementIsVisible(isRowSelected);
+    }
+
+    checkRowIsNotSelectedByName(rowName) {
+        let row = element(by.cssContainingText(`[data-automation-id*="${rowName}"]`, rowName));
+        let isRowSelected = row.element(by.xpath(`ancestor::div[contains(@class, 'is-selected')]`));
+        Util.waitUntilElementIsNotOnPage(isRowSelected);
+    }
+
+    selectRowByNameWithKeyboard(rowName) {
+        let row = element(by.cssContainingText(`[data-automation-id*="${rowName}"]`, rowName));
+        browser.actions().sendKeys(protractor.Key.COMMAND).click(row).perform();
+    }
+
     checkRowIsSelected(rowNumber) {
         let isRowSelected = this.getRowByRowNumber(rowNumber).element(by.xpath(`ancestor::div[contains(@class, 'is-selected')]`));
         Util.waitUntilElementIsVisible(isRowSelected);
@@ -120,8 +162,15 @@ export class DataTablePage {
         Util.waitUntilElementIsNotOnPage(this.selectedRowNumber);
     }
 
+    checkAllRowsButtonIsDisplayed() {
+        Util.waitUntilElementIsVisible(this.selectAll);
+        Util.waitUntilElementIsVisible(this.selectAll);
+        return this;
+    }
+
     checkAllRows() {
         Util.waitUntilElementIsVisible(this.selectAll);
+        Util.waitUntilElementIsClickable(this.selectAll);
         this.selectAll.click();
     }
 
@@ -265,6 +314,12 @@ export class DataTablePage {
         return element.all(by.css(`div[title='Name'][filename="${filename}"]`)).count();
     }
 
+    getNumberOfRowsDisplayedByName(filename) {
+        let rowLocator = by.cssContainingText(`[data-automation-id*="${filename}"]`, filename);
+        Util.waitUntilElementIsVisible(element(rowLocator));
+        return element.all(by.css(`div[title='Name'] div[data-automation-id*="${filename}"]`)).count();
+    }
+
     checkColumnIsDisplayed(column) {
         Util.waitUntilElementIsVisible(element(by.css(`div[data-automation-id="auto_id_entry.${column}"]`)));
         return this;

e2e/pages/adf/demo-shell/process-services/tasksCloudDemoPage.ts

@@ -20,6 +20,8 @@ import { Util } from '../../../../util/util';
 import { TaskFiltersCloudComponent } from '../../process-cloud/taskFiltersCloudComponent';
 import { TaskListCloudComponent } from '../../process-cloud/taskListCloudComponent';
 import { EditTaskFilterCloudComponent } from '../../process-cloud/editTaskFilterCloudComponent';
+import { FormControllersPage } from '../../material/formControllersPage';
+
 import { element, by } from 'protractor';
 
 export class TasksCloudDemoPage {
@@ -30,10 +32,29 @@ export class TasksCloudDemoPage {
 
     taskFilters = element(by.css("mat-expansion-panel[data-automation-id='Task Filters']"));
     defaultActiveFilter = element.all(by.css('.adf-filters__entry')).first();
-    editTaskFilterCloud = new EditTaskFilterCloudComponent();
 
     createButton = element(by.css('button[data-automation-id="create-button"'));
     newTaskButton = element(by.css('button[data-automation-id="btn-start-task"]'));
+    settingsButton = element.all(by.cssContainingText('div[class*="mat-tab-label"] .mat-tab-labels div', 'Settings')).first();
+    appButton = element.all(by.cssContainingText('div[class*="mat-tab-label"] .mat-tab-labels div', 'App')).first();
+    modeDropDownArrow = element(by.css('mat-form-field[data-automation-id="selectionMode"] div[class*="arrow-wrapper"]'));
+    modeSelector = element(by.css("div[class*='mat-select-panel']"));
+    displayTaskDetailsToggle = element(by.css('mat-slide-toggle[data-automation-id="taskDetailsRedirection"]'));
+    multiSelectionToggle = element(by.css('mat-slide-toggle[data-automation-id="multiSelection"]'));
+
+    formControllersPage = new FormControllersPage();
+
+    editTaskFilterCloud = new EditTaskFilterCloudComponent();
+
+    disableDisplayTaskDetails() {
+        this.formControllersPage.disableToggle(this.displayTaskDetailsToggle);
+        return this;
+    }
+
+    enableMultiSelection() {
+        this.formControllersPage.enableToggle(this.multiSelectionToggle);
+        return this;
+    }
 
     taskFiltersCloudComponent(filter) {
         return new TaskFiltersCloudComponent(filter);
@@ -68,6 +89,10 @@ export class TasksCloudDemoPage {
         return new TaskListCloudComponent().getAllRowsByColumn('Id');
     }
 
+    getAllRowsByProcessDefIdColumn() {
+        return new TaskListCloudComponent().getAllRowsByColumn('Process Definition Id');
+    }
+
     clickOnTaskFilters() {
         Util.waitUntilElementIsVisible(this.taskFilters);
         return this.taskFilters.click();
@@ -101,4 +126,35 @@ export class TasksCloudDemoPage {
         return this.defaultActiveFilter.getAttribute('class').then((value) => value.includes('adf-active'));
     }
 
+    clickSettingsButton() {
+        this.settingsButton.click();
+        browser.driver.sleep(400);
+        Util.waitUntilElementIsVisible(this.multiSelectionToggle);
+        Util.waitUntilElementIsVisible(this.modeDropDownArrow);
+        Util.waitUntilElementIsClickable(this.modeDropDownArrow);
+        return this;
+    }
+
+    clickAppButton() {
+        this.appButton.click();
+        this.createButtonIsDisplayed();
+        return this;
+    }
+
+    selectSelectionMode(mode) {
+        this.clickOnSelectionModeDropDownArrow();
+
+        let modeElement = element.all(by.cssContainingText('mat-option span', mode)).first();
+        Util.waitUntilElementIsClickable(modeElement);
+        Util.waitUntilElementIsVisible(modeElement);
+        modeElement.click();
+        return this;
+    }
+
+    clickOnSelectionModeDropDownArrow() {
+        Util.waitUntilElementIsVisible(this.modeDropDownArrow);
+        Util.waitUntilElementIsClickable(this.modeDropDownArrow);
+        this.modeDropDownArrow.click();
+        Util.waitUntilElementIsVisible(this.modeSelector);
+    }
 }

e2e/pages/adf/process-cloud/editTaskFilterCloudComponent.ts

@@ -24,6 +24,14 @@ export class EditTaskFilterCloudComponent {
     customiseFilter = element(by.id('adf-edit-task-filter-title-id'));
     selectedOption = element(by.css('mat-option[class*="mat-selected"]'));
     assignment = element(by.css('input[data-automation-id="adf-cloud-edit-task-property-assignment"]'));
+    priority = element(by.css('input[data-automation-id="adf-cloud-edit-task-property-priority"]'));
+    taskName = element(by.css('input[data-automation-id="adf-cloud-edit-task-property-taskName"]'));
+    processDefinitionId = element(by.css('input[data-automation-id="adf-cloud-edit-task-property-processDefinitionId"]'));
+    processInstanceId = element(by.css('input[data-automation-id="adf-cloud-edit-task-property-processInstanceId"]'));
+    lastModifiedFrom = element(by.css('input[data-automation-id="adf-cloud-edit-task-property-lastModifiedFrom"]'));
+    lastModifiedTo = element(by.css('input[data-automation-id="adf-cloud-edit-task-property-lastModifiedTo"]'));
+    parentTaskId = element(by.css('input[data-automation-id="adf-cloud-edit-task-property-parentTaskId"]'));
+    owner = element(by.css('input[data-automation-id="adf-cloud-edit-task-property-owner"]'));
     saveButton = element(by.css('button[id="adf-save-id"]'));
     saveAsButton = element(by.css('button[id="adf-save-as-id"]'));
     deleteButton = element(by.css('button[id="adf-delete-id"]'));
@@ -92,17 +100,55 @@ export class EditTaskFilterCloudComponent {
     }
 
     setAssignment(option) {
-        Util.waitUntilElementIsVisible(this.assignment);
+        return this.setProperty('assignment', option);
-        this.assignment.clear();
-        this.assignment.sendKeys(option);
-        this.assignment.sendKeys(protractor.Key.ENTER);
-        return this;
     }
 
     getAssignment() {
         return this.assignment.getText();
     }
 
+    setPriority(option) {
+        return this.setProperty('priority', option);
+    }
+
+    getPriority() {
+        return this.priority.getText();
+    }
+
+    setParentTaskId(option) {
+        return this.setProperty('parentTaskId', option);
+    }
+
+    getParentTaskId() {
+        return this.parentTaskId.getText();
+    }
+
+    setOwner(option) {
+        return this.setProperty('owner', option);
+    }
+
+    getOwner() {
+        return this.owner.getText();
+    }
+
+    setLastModifiedFrom(option) {
+        this.clearField(this.lastModifiedFrom);
+        return this.setProperty('lastModifiedFrom', option);
+    }
+
+    getLastModifiedFrom() {
+        return this.lastModifiedFrom.getText();
+    }
+
+    setLastModifiedTo(option) {
+        this.clearField(this.lastModifiedTo);
+        return this.setProperty('lastModifiedTo', option);
+    }
+
+    getLastModifiedTo() {
+        return this.lastModifiedTo.getText();
+    }
+
     checkSaveButtonIsDisplayed() {
         Util.waitUntilElementIsVisible(this.saveButton);
         return this;
@@ -166,4 +212,53 @@ export class EditTaskFilterCloudComponent {
         });
     }
 
+    setAppNameDropDown(option) {
+        this.clickOnDropDownArrow('appName');
+
+        let appNameElement = element.all(by.cssContainingText('mat-option span', option)).first();
+        Util.waitUntilElementIsClickable(appNameElement);
+        Util.waitUntilElementIsVisible(appNameElement);
+        appNameElement.click();
+        return this;
+    }
+
+    getAppNameDropDownValue() {
+        let locator = element(by.css("mat-select[data-automation-id='adf-cloud-edit-task-property-appName'] span"));
+        Util.waitUntilElementIsVisible(locator);
+        return locator.getText();
+    }
+
+    setTaskName(option) {
+        return this.setProperty('taskName', option);
+    }
+
+    getTaskName() {
+        return this.taskName.getAttribute('value');
+    }
+
+    setProcessDefinitionId(option) {
+        return this.setProperty('processDefinitionId', option);
+    }
+
+    getProcessDefinitionId() {
+        return this.processDefinitionId.getAttribute('value');
+    }
+
+    setProcessInstanceId(option) {
+        return this.setProperty('processInstanceId', option);
+    }
+
+    setProperty(property, option) {
+        let locator = element(by.css('input[data-automation-id="adf-cloud-edit-task-property-' + property + '"]'));
+        Util.waitUntilElementIsVisible(locator);
+        locator.clear();
+        locator.sendKeys(option);
+        locator.sendKeys(protractor.Key.ENTER);
+        return this;
+    }
+
+    getProcessInstanceId() {
+        return this.processInstanceId.getAttribute('value');
+    }
+
 }

e2e/process-services-cloud/task-list-properties.e2e.ts

@@ -0,0 +1,315 @@
+/*!
+ * @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 TestConfig = require('../test.config');
+
+import { LoginSSOPage } from '../pages/adf/loginSSOPage';
+import { SettingsPage } from '../pages/adf/settingsPage';
+import { NavigationBarPage } from '../pages/adf/navigationBarPage';
+import { TasksCloudDemoPage } from '../pages/adf/demo-shell/process-services/tasksCloudDemoPage';
+import { AppListCloudComponent } from '../pages/adf/process-cloud/appListCloudComponent';
+import { ConfigEditorPage } from '../pages/adf/configEditorPage';
+import { TaskListCloudConfiguration } from './taskListCloud.config';
+
+import { Util } from '../util/util';
+import moment = require('moment');
+import { DateUtil } from '../util/dateUtil';
+
+import { Tasks } from '../actions/APS-cloud/tasks';
+import { ProcessDefinitions } from '../actions/APS-cloud/process-definitions';
+import { ProcessInstances } from '../actions/APS-cloud/process-instances';
+import { NotificationPage } from '../pages/adf/notificationPage';
+
+describe('Edit task filters and task list properties', () => {
+
+    describe('Edit task filters and task list properties', () => {
+        const configEditorPage = new ConfigEditorPage();
+        const settingsPage = new SettingsPage();
+        const loginSSOPage = new LoginSSOPage();
+        const navigationBarPage = new NavigationBarPage();
+        let appListCloudComponent = new AppListCloudComponent();
+        let tasksCloudDemoPage = new TasksCloudDemoPage();
+
+        const tasksService: Tasks = new Tasks();
+        const processDefinitionService: ProcessDefinitions = new ProcessDefinitions();
+        const processInstancesService: ProcessInstances = new ProcessInstances();
+        let notificationPage = new NotificationPage();
+
+        let silentLogin;
+        const simpleApp = 'simple-app';
+        const candidateUserApp = 'candidateuserapp';
+        let noTasksFoundMessage = 'No Tasks Found';
+        const user = TestConfig.adf.adminEmail, password = TestConfig.adf.adminPassword;
+        let createdTask, notAssigned, notDisplayedTask, processDefinition, processInstance, priorityTask, subTask;
+        let priority = 30;
+
+        let beforeDate = moment().add(-1, 'days').format('DD/MM/YYYY');
+        let currentDate = DateUtil.formatDate('DD/MM/YYYY');
+        let afterDate = moment().add(1, 'days').format('DD/MM/YYYY');
+
+        beforeAll(async (done) => {
+            silentLogin = false;
+            let jsonFile = new TaskListCloudConfiguration().getConfiguration();
+            settingsPage.setProviderBpmSso(TestConfig.adf.hostBPM, TestConfig.adf.hostSso, TestConfig.adf.hostIdentity, silentLogin);
+            loginSSOPage.clickOnSSOButton();
+            loginSSOPage.loginAPS(user, password);
+
+            navigationBarPage.clickConfigEditorButton();
+
+            configEditorPage.clickTaskListCloudConfiguration();
+            configEditorPage.clickClearButton();
+            configEditorPage.enterBigConfigurationText(JSON.stringify(jsonFile)).clickSaveButton();
+            notificationPage.checkNotificationSnackBarIsDisplayedWithMessage('Save');
+            notificationPage.checkNotificationSnackBarIsNotDisplayed();
+
+            configEditorPage.clickEditTaskConfiguration();
+            configEditorPage.clickClearButton();
+            browser.driver.sleep(5000);
+            configEditorPage.enterConfiguration('{' +
+                '"properties": [' +
+                '"appName",' + '"state",' + '"assignment",' +
+                '"taskName",' + '"parentTaskId",' + '"priority",' +
+                '"standAlone",' + '"owner",' + '"processDefinitionId",' + '"processInstanceId",' +
+                '"lastModifiedFrom",' + '"lastModifiedTo",' + '"sort",' + '"order"' +
+                ']' +
+                '}');
+            configEditorPage.clickSaveButton();
+
+            await tasksService.init(user, password);
+            createdTask = await tasksService.createStandaloneTask(Util.generateRandomString(), simpleApp);
+            await tasksService.claimTask(createdTask.entry.id, simpleApp);
+            notAssigned = await tasksService.createStandaloneTask(Util.generateRandomString(), simpleApp);
+            priorityTask = await tasksService.createStandaloneTask(Util.generateRandomString(), simpleApp, {priority: priority});
+            await tasksService.claimTask(priorityTask.entry.id, simpleApp);
+            notDisplayedTask = await tasksService.createStandaloneTask(Util.generateRandomString(), candidateUserApp);
+            await tasksService.claimTask(notDisplayedTask.entry.id, candidateUserApp);
+
+            await processDefinitionService.init(user, password);
+            processDefinition = await processDefinitionService.getProcessDefinitions(simpleApp);
+            await processInstancesService.init(user, password);
+            processInstance = await processInstancesService.createProcessInstance(processDefinition.list.entries[0].entry.key, simpleApp);
+
+            subTask = await tasksService.createStandaloneSubtask(createdTask.entry.id, simpleApp, Util.generateRandomString());
+            await tasksService.claimTask(subTask.entry.id, simpleApp);
+
+            done();
+        });
+
+        beforeEach((done) => {
+            navigationBarPage.navigateToProcessServicesCloudPage();
+            appListCloudComponent.checkApsContainer();
+            appListCloudComponent.goToApp(simpleApp);
+            tasksCloudDemoPage.editTaskFilterCloudComponent().clickCustomiseFilterHeader();
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            done();
+        });
+
+        it('[C292004] Filter by appName', () => {
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            expect(tasksCloudDemoPage.editTaskFilterCloudComponent().getAppNameDropDownValue()).toEqual(simpleApp);
+
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(createdTask.entry.name);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(notDisplayedTask.entry.name);
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setAppNameDropDown(candidateUserApp);
+            expect(tasksCloudDemoPage.editTaskFilterCloudComponent().getAppNameDropDownValue()).toEqual(candidateUserApp);
+
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(notDisplayedTask.entry.name);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(createdTask.entry.name);
+        });
+
+        it('[C297476] Filter by taskName', () => {
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setTaskName(createdTask.entry.name);
+            expect(tasksCloudDemoPage.editTaskFilterCloudComponent().getTaskName()).toEqual(createdTask.entry.name);
+
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(createdTask.entry.name);
+            expect(tasksCloudDemoPage.taskListCloudComponent().getDataTable().getNumberOfRowsDisplayedByName(createdTask.entry.name)).toEqual(1);
+        });
+
+        it('[C297613] Should be able to see No tasks found when typing a task name that does not exist', () => {
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setTaskName('invalidName');
+            expect(tasksCloudDemoPage.editTaskFilterCloudComponent().getTaskName()).toEqual('invalidName');
+
+            expect(tasksCloudDemoPage.taskListCloudComponent().getNoTasksFoundMessage()).toEqual(noTasksFoundMessage);
+        });
+
+        it('[C297480] Should be able to see only tasks that are part of a specific process when processInstanceId is set', () => {
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setProcessInstanceId(processInstance.entry.id)
+                .setStateFilterDropDown('ALL').clearAssignment();
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkSpinnerIsDisplayed();
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkSpinnerIsNotDisplayed();
+
+            expect(tasksCloudDemoPage.taskListCloudComponent().getDataTable().getAllDisplayedRows()).toBe(1);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(processInstance.entry.id);
+        });
+
+        it('[C297684] Should be able to see No tasks found when typing an invalid processInstanceId', () => {
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setProcessInstanceId('invalidTaskId');
+
+            expect(tasksCloudDemoPage.taskListCloudComponent().getNoTasksFoundMessage()).toEqual(noTasksFoundMessage);
+        });
+
+        it('[C297478] Should be able to see only tasks that are assigned to a specific user when assignee is set', () => {
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setAssignment('admin.adf');
+
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(createdTask.entry.name);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(notAssigned.entry.name);
+        });
+
+        it('[C297686] Should be able to see No tasks found when typing an invalid user to assignee field', () => {
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setAssignment('invalid');
+
+            expect(tasksCloudDemoPage.taskListCloudComponent().getNoTasksFoundMessage()).toEqual(noTasksFoundMessage);
+        });
+
+        it('[C297482] Should be able to see only tasks with specific priority when priority is set', () => {
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setPriority(priority);
+
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(priorityTask.entry.name);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(createdTask.entry.name);
+        });
+
+        it('[C297687] Should be able to see No tasks found when typing unused value for priority field', () => {
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setPriority('70');
+
+            expect(tasksCloudDemoPage.taskListCloudComponent().getNoTasksFoundMessage()).toEqual(noTasksFoundMessage);
+        });
+
+        it('[C297481] Should be able to see only tasks with specific parentTaskId when parentTaskId is set', () => {
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setParentTaskId(subTask.entry.parentTaskId);
+
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(subTask.entry.name);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(createdTask.entry.name);
+        });
+
+        it('[C297486] Filter by Owner', () => {
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setStateFilterDropDown('ALL').clearAssignment().setOwner('admin.adf');
+
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(notAssigned.entry.name);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(createdTask.entry.name);
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setOwner('invalid');
+
+            expect(tasksCloudDemoPage.taskListCloudComponent().getNoTasksFoundMessage()).toEqual(noTasksFoundMessage);
+        });
+
+        it('[C297484] Task is displayed when typing into lastModifiedFrom field a date before the task created date', function () {
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setLastModifiedFrom(beforeDate);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(createdTask.entry.name);
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setLastModifiedFrom(afterDate);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(createdTask.entry.name);
+        });
+
+        it('[C297689] Task is not displayed when typing into lastModifiedFrom field the same date as tasks created date', function () {
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setLastModifiedFrom(currentDate);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(createdTask.entry.name);
+        });
+
+        it('[C297485] Task is displayed when typing into lastModifiedTo field a date after the task created date', function () {
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setLastModifiedTo(afterDate);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(createdTask.entry.name);
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setLastModifiedTo(beforeDate);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(createdTask.entry.name);
+        });
+
+        it('[C297690] Task is not displayed when typing into lastModifiedTo field the same date as tasks created date', function () {
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setLastModifiedTo(currentDate);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(createdTask.entry.name);
+        });
+
+        it('[C297691] Task is not displayed when typing into lastModifiedFrom field a date before the task due date  ' +
+            'and into lastModifiedTo a date before task due date', function () {
+
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setLastModifiedFrom(beforeDate);
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setLastModifiedTo(beforeDate);
+            expect(tasksCloudDemoPage.taskListCloudComponent().getNoTasksFoundMessage()).toEqual(noTasksFoundMessage);
+        });
+
+        it('[C297692] Task is displayed when typing into lastModifiedFrom field a date before the tasks due date ' +
+            'and into lastModifiedTo a date after', function () {
+
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setLastModifiedFrom(beforeDate);
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setLastModifiedTo(afterDate);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(createdTask.entry.name);
+        });
+
+        it('[C297693] Task is not displayed when typing into lastModifiedFrom field a date after the tasks due date ' +
+            'and into lastModifiedTo a date after', function () {
+
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            expect(tasksCloudDemoPage.getActiveFilterName()).toBe('My Tasks');
+
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setLastModifiedFrom(afterDate);
+            tasksCloudDemoPage.editTaskFilterCloudComponent().setLastModifiedTo(afterDate);
+            expect(tasksCloudDemoPage.taskListCloudComponent().getNoTasksFoundMessage()).toEqual(noTasksFoundMessage);
+        });
+
+    });
+
+});

e2e/process-services-cloud/task-list-selection.e2e.ts

@@ -0,0 +1,128 @@
+/*!
+ * @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 TestConfig = require('../test.config');
+
+import { LoginSSOPage } from '../pages/adf/loginSSOPage';
+import { SettingsPage } from '../pages/adf/settingsPage';
+import { NavigationBarPage } from '../pages/adf/navigationBarPage';
+import { TasksCloudDemoPage } from '../pages/adf/demo-shell/process-services/tasksCloudDemoPage';
+import { AppListCloudComponent } from '../pages/adf/process-cloud/appListCloudComponent';
+import { TaskListCloudConfiguration } from './taskListCloud.config';
+
+import { Util } from '../util/util';
+import moment = require('moment');
+
+import { Tasks } from '../actions/APS-cloud/tasks';
+describe('Task list cloud - selection', () => {
+
+    describe('Task list cloud - selection', () => {
+        const settingsPage = new SettingsPage();
+        const loginSSOPage = new LoginSSOPage();
+        const navigationBarPage = new NavigationBarPage();
+        let appListCloudComponent = new AppListCloudComponent();
+        let tasksCloudDemoPage = new TasksCloudDemoPage();
+
+        const tasksService: Tasks = new Tasks();
+
+        let silentLogin;
+        const simpleApp = 'simple-app';
+        const user = TestConfig.adf.adminEmail, password = TestConfig.adf.adminPassword;
+        let noOfTasks = 3, response;
+        let tasks = [];
+
+        beforeAll(async (done) => {
+            silentLogin = false;
+            settingsPage.setProviderBpmSso(TestConfig.adf.hostBPM, TestConfig.adf.hostSso, TestConfig.adf.hostIdentity, silentLogin);
+            loginSSOPage.clickOnSSOButton();
+            loginSSOPage.loginAPS(user, password);
+
+            await tasksService.init(user, password);
+            for (let i = 0; i < noOfTasks; i++) {
+                response = await tasksService.createStandaloneTask(Util.generateRandomString(), simpleApp);
+                await tasksService.claimTask(response.entry.id, simpleApp);
+                tasks.push(response.entry.name);
+            }
+
+            navigationBarPage.navigateToProcessServicesCloudPage();
+            appListCloudComponent.checkApsContainer();
+            appListCloudComponent.goToApp(simpleApp);
+            tasksCloudDemoPage.myTasksFilter().checkTaskFilterIsDisplayed();
+            tasksCloudDemoPage.clickSettingsButton().disableDisplayTaskDetails();
+            tasksCloudDemoPage.clickAppButton();
+            done();
+        });
+
+        it('[C291914] Should not be able to select any row when selection mode is set to None', () => {
+            tasksCloudDemoPage.clickSettingsButton().selectSelectionMode('None');
+            tasksCloudDemoPage.clickAppButton();
+
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().selectRowByRowName(tasks[0]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkNoRowIsSelected();
+        });
+
+        it('[C291918] Should be able to select only one row when selection mode is set to Single', () => {
+            tasksCloudDemoPage.clickSettingsButton().selectSelectionMode('Single');
+            tasksCloudDemoPage.clickAppButton();
+
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().selectRowByRowName(tasks[0]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkRowIsSelectedByName(tasks[0]);
+            expect(tasksCloudDemoPage.taskListCloudComponent().getDataTable().getNumberOfSelectedRows()).toEqual(1);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().selectRowByRowName(tasks[1]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkRowIsSelectedByName(tasks[1]);
+            expect(tasksCloudDemoPage.taskListCloudComponent().getDataTable().getNumberOfSelectedRows()).toEqual(1);
+        });
+
+        it('[C291919] Should be able to select only one row when selection mode is set to Multiple', () => {
+            tasksCloudDemoPage.clickSettingsButton().selectSelectionMode('Multiple');
+            tasksCloudDemoPage.clickAppButton();
+
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().selectRowByRowName(tasks[0]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkRowIsSelectedByName(tasks[0]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().selectRowByNameWithKeyboard(tasks[1]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkRowIsSelectedByName(tasks[0]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkRowIsSelectedByName(tasks[1]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkRowIsNotSelectedByName(tasks[2]);
+        });
+
+        it('[C291916] Should be able to select multiple row when multiselect is true', () => {
+            tasksCloudDemoPage.clickSettingsButton().enableMultiSelection();
+            tasksCloudDemoPage.clickAppButton();
+
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().clickCheckboxByName(tasks[0]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkRowIsCheckedByName(tasks[0]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().clickCheckboxByName(tasks[1]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkRowIsCheckedByName(tasks[1]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkRowIsNotCheckedByName(tasks[2]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().clickCheckboxByName(tasks[1]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkRowIsNotCheckedByName(tasks[1]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkRowIsCheckedByName(tasks[0]);
+        });
+
+        it('[C291915] Should be possible select all the rows when multiselect is true', () => {
+            tasksCloudDemoPage.clickSettingsButton().enableMultiSelection();
+            tasksCloudDemoPage.clickAppButton();
+
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkAllRowsButtonIsDisplayed().checkAllRows();
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkRowIsCheckedByName(tasks[0]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().clickCheckboxByName(tasks[1]);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkRowIsCheckedByName(tasks[2]);
+        });
+
+    });
+
+});

e2e/process-services-cloud/taskListCloud.config.ts

@@ -0,0 +1,84 @@
+/*!
+ * @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.
+ */
+
+export class TaskListCloudConfiguration {
+
+    constructor() {
+    }
+
+    getConfiguration() {
+        return {
+            'presets': {
+            'default': [
+                {
+                    'key': 'entry.id',
+                    'type': 'text',
+                    'title': 'ADF_CLOUD_TASK_LIST.PROPERTIES.ID',
+                    'sortable': true
+                },
+                {
+                    'key': 'entry.name',
+                    'type': 'text',
+                    'title': 'ADF_CLOUD_TASK_LIST.PROPERTIES.NAME',
+                    'sortable': true,
+                    'cssClass': 'full-width name-column ellipsis-cell'
+                },
+                {
+                    'key': 'entry.processDefinitionId',
+                    'type': 'text',
+                    'title': 'ADF_CLOUD_EDIT_TASK_FILTER.LABEL.PROCESS_DEF_ID',
+                    'sortable': true,
+                    'cssClass': 'full-width name-column ellipsis-cell'
+                },
+                {
+                    'key': 'entry.processInstanceId',
+                    'type': 'text',
+                    'title': 'ADF_CLOUD_EDIT_TASK_FILTER.LABEL.PROCESS_INSTANCE_ID',
+                    'sortable': true,
+                    'cssClass': 'full-width name-column ellipsis-cell'
+                },
+                {
+                    'key': 'entry.status',
+                    'type': 'text',
+                    'title': 'ADF_CLOUD_TASK_LIST.PROPERTIES.STATUS',
+                    'sortable': true
+                },
+                {
+                    'key': 'entry.priority',
+                    'type': 'text',
+                    'title': 'ADF_CLOUD_TASK_LIST.PROPERTIES.PRIORITY',
+                    'sortable': true
+                },
+                {
+                    'key': 'entry.createdDate',
+                    'type': 'date',
+                    'title': 'ADF_CLOUD_TASK_LIST.PROPERTIES.CREATED_DATE',
+                    'sortable': true,
+                    'format': 'timeAgo'
+                },
+                {
+                    'key': 'entry.lastModified',
+                    'type': 'date',
+                    'title': 'ADF_CLOUD_TASK_LIST.PROPERTIES.LAST_MODIFIED',
+                    'sortable': true,
+                    'format': 'timeAgo'
+                }
+            ]
+        }
+        };
+    }
+}

e2e/process-services-cloud/tasks-custom-filters.e2e.ts

@@ -16,16 +16,13 @@
  */
 
 import TestConfig = require('../test.config');
-import resources = require('../util/resources');
 
 import { LoginSSOPage } from '../pages/adf/loginSSOPage';
 import { SettingsPage } from '../pages/adf/settingsPage';
 import { NavigationBarPage } from '../pages/adf/navigationBarPage';
-import { TasksListPage } from '../pages/adf/process_services/tasksListPage';
 import { TasksCloudDemoPage } from '../pages/adf/demo-shell/process-services/tasksCloudDemoPage';
 import { AppListCloudComponent } from '../pages/adf/process-cloud/appListCloudComponent';
 
-import AlfrescoApi = require('alfresco-js-api-node');
 import { Tasks } from '../actions/APS-cloud/tasks';
 import { ProcessDefinitions } from '../actions/APS-cloud/process-definitions';
 import { ProcessInstances } from '../actions/APS-cloud/process-instances';
@@ -115,13 +112,30 @@ describe('Task filters cloud', () => {
         it('[C290139] Should display only tasks with all states when All is selected from state dropdown', () => {
             tasksCloudDemoPage.editTaskFilterCloudComponent().clickCustomiseFilterHeader().clearAssignment()
                 .setStateFilterDropDown('ALL');
-
             tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(deletedTaskName);
             tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(assignedTaskName);
             tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(createdTaskName);
             tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(completedTaskName);
         });
 
+        it('[C290154] Should display only tasks with suspended states when Suspended is selected from state dropdown', () => {
+            tasksCloudDemoPage.editTaskFilterCloudComponent().clickCustomiseFilterHeader().clearAssignment()
+                .setStateFilterDropDown('SUSPENDED');
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(suspendedTasks.list.entries[0].entry.id);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(deletedTaskName);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(createdTaskName);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(completedTaskName);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(assignedTaskName);
+         });
+
+        it('[C290060] Should display only tasks with Created state when Created is selected from state dropdown', () => {
+            tasksCloudDemoPage.editTaskFilterCloudComponent().clickCustomiseFilterHeader().clearAssignment().setStateFilterDropDown('CREATED');
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsDisplayed(createdTaskName);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(assignedTaskName);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(completedTaskName);
+            tasksCloudDemoPage.taskListCloudComponent().getDataTable().checkContentIsNotDisplayed(deletedTaskName);
+        });
+
         it('[C290069] Should display tasks ordered by name when Name is selected from sort dropdown', () => {
             tasksCloudDemoPage.editTaskFilterCloudComponent().clickCustomiseFilterHeader().setStateFilterDropDown('ASSIGNED')
                 .setSortFilterDropDown('NAME').setOrderFilterDropDown('ASC');
@@ -174,7 +188,5 @@ describe('Task filters cloud', () => {
                 expect(JSON.stringify(initialList) === JSON.stringify(list)).toEqual(true);
             });
         });
-
     });
-
 });