[ADF-3335] Added automation tests for task filter sorting (#3724)

* [ADF-3335] Added automation tests for task filter sorting

* [ADF-3335] Removed excluded describe

e2e/pages/adf/process_services/dialog/startTaskDialog.js

@@ -20,6 +20,7 @@ var Util = require('../../../../util/util');
 var StartTaskDialog = function () {
 
     var name = element(by.css("input[id='name_id']"));
+    var dueDate = element(by.css("input[id='date_id']"));
     var description = element(by.css("textarea[id='description_id']"));
     var assignee = element(by.css("div#people-widget-content input"));
     var formDropDown = element(by.css("mat-select[id='form_id']"));
@@ -40,6 +41,12 @@ var StartTaskDialog = function () {
         return this;
     };
 
+    this.addDueDate = function (date) {
+        Util.waitUntilElementIsVisible(dueDate);
+        dueDate.sendKeys(date);
+        return this;
+    };
+
     this.addAssignee = function (name) {
         Util.waitUntilElementIsVisible(assignee);
         assignee.sendKeys(name);

e2e/pages/adf/process_services/taskDetailsPage.js

@@ -44,6 +44,7 @@ var TaskDetailsPage = function () {
     var taskDetailsSection = element(by.css("div[data-automation-id='adf-tasks-details']"));
     var taskDetailsEmptySection = element(by.css("div[data-automation-id='adf-tasks-details--empty']"));
     var completeTask = element(by.css("button[id='adf-no-form-complete-button']"));
+    var taskDetailsTitle = element(by.css('h2[class="activiti-task-details__header"] span'));
     var auditLogButton = element(by.css("button[adf-task-audit]"));
     var noPeopleInvolved = element(by.id('no-people-label'));
     var cancelInvolvePeopleButton = element(by.id('close-people-search'));
@@ -58,6 +59,11 @@ var TaskDetailsPage = function () {
     var removeAttachForm = element(by.id("adf-no-form-remove-button"));
     var attachFormName = element(by.css("span[class='adf-form-title ng-star-inserted']"));
 
+    this.getTaskDetailsTitle = function () {
+        Util.waitUntilElementIsVisible(taskDetailsTitle);
+        return taskDetailsTitle.getText();
+    };
+    
     this.checkSelectedForm = function (formName) {
         Util.waitUntilElementIsVisible(attachFormName);
         expect(formName).toEqual(attachFormName.getText());

e2e/pages/adf/process_services/taskFiltersPage.js

@@ -19,54 +19,72 @@ var Util = require('../../../util/util');
 
 var TaskFiltersPage = function () {
 
-    var myTasks = element(by.css("span[data-automation-id='My Tasks_filter']"));
+    var myTasks = element(by.css('span[data-automation-id="My Tasks_filter"]'));
-    var queuedTask = element(by.css("span[data-automation-id='Queued Tasks_filter']"));
+    var queuedTask = element(by.css('span[data-automation-id="Queued Tasks_filter"]'));
-    var completedTask = element(by.css("span[data-automation-id='Completed Tasks_filter']"));
+    var completedTask = element(by.css('span[data-automation-id="Completed Tasks_filter"]'));
-    var involvedTask = element(by.css("span[data-automation-id='Involved Tasks_filter']"));
+    var involvedTask = element(by.css('span[data-automation-id="Involved Tasks_filter"]'));
-    var tasksAccordionButton = element(by.css("div[data-automation-id='adf-panel-heading']"));
+    var tasksAccordionButton = element(by.css('div[class="adf-panel-heading adf-panel-heading-selected"]'));
-    var tasksAccordionExpanded = element(by.css(`mat-expansion-panel[class*="mat-expanded"]`));
+    var tasksAccordionExpanded = element(by.css("mat-expansion-panel[class*='mat-expanded']"));
-    var startTaskButton = element(by.css("button[id='button-start']"));
+    var startTaskButton = element(by.css('button[id="button-start"]'));
-    var newTaskButton = element(by.css("button[data-automation-id='btn-start-task']"));
+    var newTaskButton = element(by.css('button[data-automation-id="btn-start-task"]'));
-    var activeFilter = element(by.css(`mat-list-item[class*="active"]`));
+    var activeFilter = element(by.css("mat-list-item[class*='active']"));
-    var emptyTaskDetails = element(by.css("adf-task-details > div > div"));
+    var emptyTaskList = element(by.css('p[class="adf-empty-content__title"]'));
-    var emptyTaskList = element(by.css("p[class='adf-empty-content__title']"));
+    var emptyTaskDetails = element(by.css('adf-task-details > div > div'));
-    
+
-    this.checkMyTasksItem = function() {
+    this.checkTaskFilterDisplayed = function(name) {
+        var customTask = element(by.css(`span[data-automation-id="${name}_filter"]`));
+        Util.waitUntilElementIsVisible(customTask);
+        return customTask;
+    };
+
+    this.clickTaskFilter = function(name) {
+        var customTask = element(by.css(`span[data-automation-id="${name}_filter"]`));
+        Util.waitUntilElementIsVisible(customTask);
+        return customTask.click();
+    };
+
+    this.checkTaskFilterNotDisplayed = function(name) {
+        var customTask = element(by.css(`span[data-automation-id="${name}_filter"]`));
+        Util.waitUntilElementIsNotVisible(customTask);
+        return customTask;
+    };
+
+    this.checkMyTasksFilter = function() {
         Util.waitUntilElementIsVisible(myTasks);
         return myTasks;
     };
 
-    this.checkQueuedTaskItem = function() {
+    this.checkQueuedTaskFilter = function() {
         Util.waitUntilElementIsVisible(queuedTask);
         return queuedTask;
     };
     
-    this.clickMyTaskTaskItem = function() {
+    this.clickMyTaskTaskFilter = function() {
         Util.waitUntilElementIsVisible(myTasks);
         return myTasks.click();
     };
 
-    this.clickCompletedTaskItem = function() {
+    this.clickCompletedTaskFilter = function() {
         Util.waitUntilElementIsVisible(completedTask);
         return completedTask.click();
     };
 
-    this.checkCompletedTaskItem = function() {
+    this.checkCompletedTaskFilter = function() {
         Util.waitUntilElementIsVisible(completedTask);
         return completedTask;
     };
 
-    this.clickQueuedTaskItem = function() {
+    this.clickQueuedTaskFilter = function() {
         Util.waitUntilElementIsVisible(queuedTask);
         return queuedTask.click();
     };
 
-    this.clickInvolvedTaskItem = function() {
+    this.clickInvolvedTaskFilter = function() {
         Util.waitUntilElementIsVisible(involvedTask);
         return involvedTask.click();
     };
 
-    this.checkInvolvedTaskItem = function() {
+    this.checkInvolvedTaskFilter = function() {
         Util.waitUntilElementIsVisible(involvedTask);
         return involvedTask;
     };
@@ -110,6 +128,10 @@ var TaskFiltersPage = function () {
         Util.waitUntilElementIsVisible(emptyTaskDetails);
         return emptyTaskDetails.getText();
     }
+
+    this.getCurrentUrl = function() {
+        return browser.getCurrentUrl();
+    }
 };
 
 module.exports = TaskFiltersPage;

e2e/pages/adf/process_services/tasksListPage.js

@@ -23,6 +23,7 @@ var TasksListPage = function () {
     var tableBody = element.all(by.css("adf-datatable div[class='adf-datatable-body']")).first();
     var sortByName = element(by.css('div[data-automation-id="auto_id_name"]'));
     var firstTaskOnTaskList = element.all(by.css('div[class="adf-datatable-body"] span')).first();
+    var taskOnTaskList = element.all(by.css('div[class="adf-datatable-body"] span'));
     var spinner = element(by.css('mat-progress-spinner'));
 
     this.clickSortByName = function () {
@@ -69,6 +70,11 @@ var TasksListPage = function () {
         return firstTaskOnTaskList.getText();
     };
 
+    this.taskOnTaskListInPosition = function (position){
+        Util.waitUntilElementIsVisible(taskOnTaskList);
+        return taskOnTaskList.get(position -1).getText();
+    };
+
     this.checkSpinnerIsDisplayed = function () {
         Util.waitUntilElementIsPresent(spinner);
     };

e2e/process-services/task_filters_component.e2e.ts

@@ -29,6 +29,7 @@ import TaskDetailsPage = require('../pages/adf/process_services/taskDetailsPage'
 import AlfrescoApi = require('alfresco-js-api-node');
 import { AppsActions } from '../actions/APS/apps.actions';
 import { UsersActions } from '../actions/users.actions';
+import { browser } from 'protractor';
 
 describe('Task Filters Test', () => {
 
@@ -91,66 +92,73 @@ describe('Task Filters Test', () => {
         done();
     });
 
+    it('[C279967] Should display default filters when an app is deployed', () => {
+        taskFiltersPage.checkTaskFilterDisplayed('Involved Tasks');
+        taskFiltersPage.checkTaskFilterDisplayed('My Tasks');
+        taskFiltersPage.checkTaskFilterDisplayed('Queued Tasks');
+        taskFiltersPage.checkTaskFilterDisplayed('Completed Tasks');
+    });
+
     it('[C260330] Should display Task Filter List when app is in Task Tab', () => {
         tasksPage.clickOnCreateButton();
         taskFiltersPage.clickNewTaskButton();
         tasksPage.createNewTask().addName('Test').clickStartButton();
-        taskFiltersPage.clickMyTaskTaskItem();
+        taskFiltersPage.clickMyTaskTaskFilter();
         tasksListPage.checkTaskIsDisplayedInTasksList('Test');
         expect(taskFiltersPage.checkActiveFilterActive()).toBe('My Tasks');
         expect(taskDetailsPage.checkTaskDetailsDisplayed()).toBeDefined();
 
-        taskFiltersPage.clickQueuedTaskItem();
+        taskFiltersPage.clickQueuedTaskFilter();
         expect(taskFiltersPage.checkActiveFilterActive()).toBe('Queued Tasks');
         tasksListPage.checkTaskIsNotDisplayedInTasksList('Test');
         expect(taskDetailsPage.checkTaskDetailsEmpty()).toBeDefined();
 
-        taskFiltersPage.clickInvolvedTaskItem();
+        taskFiltersPage.clickInvolvedTaskFilter();
         expect(taskFiltersPage.checkActiveFilterActive()).toBe('Involved Tasks');
         tasksListPage.checkTaskIsDisplayedInTasksList('Test');
         expect( taskDetailsPage.checkTaskDetailsDisplayed()).toBeDefined();
 
-        taskFiltersPage.clickCompletedTaskItem();
+        taskFiltersPage.clickCompletedTaskFilter();
         expect(taskFiltersPage.checkActiveFilterActive()).toBe('Completed Tasks');
         tasksListPage.checkTaskIsNotDisplayedInTasksList('Test');
         expect(taskDetailsPage.checkTaskDetailsEmpty()).toBeDefined();
     });
 
     it('[C260348] Should display task in Complete Tasks List when task is completed', () => {
-        expect(taskFiltersPage.checkMyTasksItem()).toBeDefined();
+        expect(taskFiltersPage.checkMyTasksFilter()).toBeDefined();
-        expect(taskFiltersPage.checkQueuedTaskItem()).toBeDefined();
+        expect(taskFiltersPage.checkQueuedTaskFilter()).toBeDefined();
-        expect(taskFiltersPage.checkInvolvedTaskItem()).toBeDefined();
+        expect(taskFiltersPage.checkInvolvedTaskFilter()).toBeDefined();
-        expect(taskFiltersPage.checkCompletedTaskItem()).toBeDefined();
+        expect(taskFiltersPage.checkCompletedTaskFilter()).toBeDefined();
         expect(taskFiltersPage.checkTasksAccordionExtended()).toBeDefined();
 
         taskFiltersPage.clickTasksAccordionButton();
         expect(taskFiltersPage.checkTasksAccordionClosed()).toBeDefined();
 
         taskFiltersPage.clickTasksAccordionButton();
-        expect(taskFiltersPage.checkMyTasksItem()).toBeDefined();
+        expect(taskFiltersPage.checkMyTasksFilter()).toBeDefined();
-        expect(taskFiltersPage.checkQueuedTaskItem()).toBeDefined();
+        expect(taskFiltersPage.checkQueuedTaskFilter()).toBeDefined();
-        expect(taskFiltersPage.checkInvolvedTaskItem()).toBeDefined();
+        expect(taskFiltersPage.checkInvolvedTaskFilter()).toBeDefined();
-        expect(taskFiltersPage.checkCompletedTaskItem()).toBeDefined();
+        expect(taskFiltersPage.checkCompletedTaskFilter()).toBeDefined();
 
         tasksPage.clickOnCreateButton();
         taskFiltersPage.clickNewTaskButton();
         tasksPage.createNewTask().addName('Test').clickStartButton();
-        taskFiltersPage.clickMyTaskTaskItem();
+        taskFiltersPage.clickMyTaskTaskFilter();
         tasksListPage.checkTaskIsDisplayedInTasksList('Test');
         expect(taskFiltersPage.checkActiveFilterActive()).toBe('My Tasks');
         expect(taskDetailsPage.checkTaskDetailsDisplayed()).toBeDefined();
 
-        taskFiltersPage.clickQueuedTaskItem();
+        taskFiltersPage.clickQueuedTaskFilter();
         expect(taskFiltersPage.checkActiveFilterActive()).toBe('Queued Tasks');
         expect(taskFiltersPage.checkEmptyTaskList()).toBe('No Tasks Found');
         expect(taskFiltersPage.checkEmptyTaskDetails()).toBe('No task details found');
 
-        taskFiltersPage.clickInvolvedTaskItem();
+        taskFiltersPage.clickInvolvedTaskFilter();
         expect(taskFiltersPage.checkActiveFilterActive()).toBe('Involved Tasks');
         tasksListPage.checkTaskIsDisplayedInTasksList('Test');
         expect(taskDetailsPage.checkTaskDetailsDisplayed()).toBeDefined();
 
-        taskFiltersPage.clickCompletedTaskItem();
+        taskFiltersPage.clickCompletedTaskFilter();
         expect(taskFiltersPage.checkActiveFilterActive()).toBe('Completed Tasks');
         expect(taskFiltersPage.checkEmptyTaskList()).toBe('No Tasks Found');
         expect(taskFiltersPage.checkEmptyTaskDetails()).toBe('No task details found');
@@ -182,7 +190,7 @@ describe('Task Filters Test', () => {
         tasksListPage.clickSortByName();
         expect(tasksListPage.firstTaskOnTaskList()).toBe('Test4');
 
-        taskFiltersPage.clickCompletedTaskItem();
+        taskFiltersPage.clickCompletedTaskFilter();
         tasksListPage.checkTaskIsDisplayedInTasksList('Test1');
         tasksListPage.checkTaskIsDisplayedInTasksList('Test2');
         expect(tasksListPage.firstTaskOnTaskList()).toBe('Test2');
@@ -190,9 +198,175 @@ describe('Task Filters Test', () => {
         tasksListPage.clickSortByName();
         expect(tasksListPage.firstTaskOnTaskList()).toBe('Test1');
 
-        taskFiltersPage.clickInvolvedTaskItem();
+        taskFiltersPage.clickInvolvedTaskFilter();
         tasksListPage.checkTaskIsDisplayedInTasksList('Test3');
         tasksListPage.checkTaskIsDisplayedInTasksList('Test4');
     });
 
-});
+    it('[C260355] Should display task list when app is in task section', () => {
+        taskFiltersPage.clickQueuedTaskFilter();
+        expect(taskFiltersPage.checkActiveFilterActive()).toBe('Queued Tasks');
+    });
+
+    it('[C277264] Should display task filter results when task filter is selected', () => {
+        tasksPage.clickOnCreateButton();
+        taskFiltersPage.clickNewTaskButton();
+        tasksPage.createNewTask().addName('Test').clickStartButton();
+
+        taskFiltersPage.clickTaskFilter('My Tasks');
+        tasksListPage.checkTaskIsDisplayedInTasksList('Test');
+        expect(taskDetailsPage.getTaskDetailsTitle()).toBe('Test');
+    });
+});
+
+describe('Custom Filters Test', () => {
+
+    let loginPage = new LoginPage();
+    let navigationBarPage = new NavigationBarPage();
+    let processServicesPage = new ProcessServicesPage();
+    let tasksPage = new TasksPage();
+    let tasksListPage = new TasksListPage();
+    let taskFiltersPage = new TaskFiltersPage();
+    let taskDetailsPage = new TaskDetailsPage();
+
+    let tenantId;
+    let user;
+    let appId;
+    let importedApp;
+
+    let taskFilterId;
+
+    let app = resources.Files.APP_WITH_PROCESSES;
+
+    beforeAll(async (done) => {
+        let apps = new AppsActions();
+        let users = new UsersActions();
+
+        this.alfrescoJsApi = new AlfrescoApi({
+            provider: 'BPM',
+            hostBpm: TestConfig.adf.url
+        });
+
+        await this.alfrescoJsApi.login(TestConfig.adf.adminEmail, TestConfig.adf.adminPassword);
+
+        user = await users.createTenantAndUser(this.alfrescoJsApi);
+        tenantId = user.tenantId;
+
+        await this.alfrescoJsApi.login(user.email, user.password);
+
+        importedApp = await apps.importPublishDeployApp(this.alfrescoJsApi, app.file_location);
+
+        let appDefinitions = await this.alfrescoJsApi.activiti.appsApi.getAppDefinitions();
+
+        appId = appDefinitions.data.find((currentApp) => {
+            return currentApp.modelId === importedApp.id;
+        }).id;
+
+        await loginPage.loginToProcessServicesUsingUserModel(user);
+
+        done();
+
+    });
+
+    // afterAll(async(done) => {
+    //     await this.alfrescoJsApi.activiti.adminTenantsApi.deleteTenant(tenantId);
+    //     done();
+    // });
+    beforeEach(async () => {
+        navigationBarPage.clickProcessServicesButton();
+        processServicesPage.checkApsContainer();
+        processServicesPage.goToApp(app.title);
+    });
+
+    it('[C260350] Should display a new filter when a filter is added', () => {
+        browser.controlFlow().execute(async () => {
+            let newFilter = new this.alfrescoJsApi.activiti.UserProcessInstanceFilterRepresentation();
+            newFilter.name = 'New Task Filter';
+            newFilter.appId = appId;
+            newFilter.icon = 'glyphicon-filter';
+            newFilter.filter = { sort: 'created-desc', state: 'completed', assignment: 'involved' };
+
+            let result = await this.alfrescoJsApi.activiti.userFiltersApi.createUserTaskFilter(newFilter);
+
+            taskFilterId = result.id;
+            return result;
+        });
+
+        browser.refresh();
+
+        taskFiltersPage.checkTaskFilterDisplayed('New Task Filter');
+
+        browser.controlFlow().execute(() => {
+            let result = this.alfrescoJsApi.activiti.userFiltersApi.deleteUserTaskFilter(taskFilterId);
+            return result;
+        });
+    });
+
+    it('[C260353] Should display changes on a filter when this filter is edited', () => {
+        browser.controlFlow().execute(async () => {
+            let newFilter = new this.alfrescoJsApi.activiti.UserProcessInstanceFilterRepresentation();
+            newFilter.name = 'New Task Filter';
+            newFilter.appId = appId;
+            newFilter.icon = 'glyphicon-filter';
+            newFilter.filter = { sort: 'created-desc', state: 'completed', assignment: 'involved' };
+
+            let result = await this.alfrescoJsApi.activiti.userFiltersApi.createUserTaskFilter(newFilter);
+
+            taskFilterId = result.id;
+            return result;
+        });
+
+        browser.refresh();
+
+        taskFiltersPage.checkTaskFilterDisplayed('New Task Filter');
+
+        browser.controlFlow().execute(() => {
+            let newFilter = new this.alfrescoJsApi.activiti.UserProcessInstanceFilterRepresentation();
+            newFilter.name = 'Task Filter Edited';
+            newFilter.appId = appId;
+            newFilter.icon = 'glyphicon-filter';
+            newFilter.filter = { sort: 'created-desc', state: 'completed', assignment: 'involved' };
+
+            let result = this.alfrescoJsApi.activiti.userFiltersApi.updateUserTaskFilter(taskFilterId, newFilter);
+            return result;
+        });
+
+        browser.refresh();
+
+        taskFiltersPage.checkTaskFilterDisplayed('Task Filter Edited');
+
+        browser.controlFlow().execute(() => {
+            let result = this.alfrescoJsApi.activiti.userFiltersApi.deleteUserTaskFilter(taskFilterId);
+            return result;
+        });
+    });
+
+    it('[C260354] Should not display task filter when this filter is deleted', () => {
+        browser.controlFlow().execute(async () => {
+            let newFilter = new this.alfrescoJsApi.activiti.UserProcessInstanceFilterRepresentation();
+            newFilter.name = 'New Task Filter';
+            newFilter.appId = appId;
+            newFilter.icon = 'glyphicon-filter';
+            newFilter.filter = { sort: 'created-desc', state: 'completed', assignment: 'involved' };
+
+            let result = await this.alfrescoJsApi.activiti.userFiltersApi.createUserTaskFilter(newFilter);
+
+            taskFilterId = result.id;
+            return result;
+        });
+
+        browser.refresh();
+
+        taskFiltersPage.checkTaskFilterDisplayed('New Task Filter');
+
+        browser.controlFlow().execute(() => {
+            let result = this.alfrescoJsApi.activiti.userFiltersApi.deleteUserTaskFilter(taskFilterId);
+            return result;
+        });
+
+        browser.refresh();
+
+        taskFiltersPage.checkTaskFilterNotDisplayed('New Task Filter');
+    });
+
+});

e2e/process-services/task_filters_sorting.e2e.ts

@@ -0,0 +1,296 @@
+/*!
+ * @license
+ * Copyright 2016 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 resources = require('../util/resources');
+import LoginPage = require('../pages/adf/loginPage');
+import NavigationBarPage = require('../pages/adf/navigationBarPage');
+import ProcessServicesPage = require('../pages/adf/process_services/processServicesPage');
+import TasksPage = require('../pages/adf/process_services/tasksPage');
+import TasksListPage = require('../pages/adf/process_services/tasksListPage');
+import TaskFiltersPage = require('../pages/adf/process_services/taskFiltersPage');
+import TaskDetailsPage = require('../pages/adf/process_services/taskDetailsPage');
+
+import AlfrescoApi = require('alfresco-js-api-node');
+import { AppsActions } from '../actions/APS/apps.actions';
+import { UsersActions } from '../actions/users.actions';
+import { browser } from 'protractor';
+
+describe('Task Filters Sorting', () => {
+
+    let loginPage = new LoginPage();
+    let navigationBarPage = new NavigationBarPage();
+    let processServicesPage = new ProcessServicesPage();
+    let tasksPage = new TasksPage();
+    let tasksListPage = new TasksListPage();
+    let taskFiltersPage = new TaskFiltersPage();
+    let taskDetailsPage = new TaskDetailsPage();
+
+    let tenantId;
+    let user;
+    let appId;
+    let importedApp;
+
+    let taskFilterId;
+
+    let app = resources.Files.APP_WITH_PROCESSES;
+
+    let tasks = [
+        { name: 'Task 1 Completed', dueDate: '01/01/2019' },
+        { name: 'Task 2 Completed', dueDate: '02/01/2019' },
+        { name: 'Task 3 Completed', dueDate: '03/01/2019' },
+        { name: 'Task 4', dueDate: '01/01/2019' },
+        { name: 'Task 5', dueDate: '02/01/2019' },
+        { name: 'Task 6', dueDate: '03/01/2019' }];
+
+    beforeAll(async (done) => {
+        let apps = new AppsActions();
+        let users = new UsersActions();
+
+        this.alfrescoJsApi = new AlfrescoApi({
+            provider: 'BPM',
+            hostBpm: TestConfig.adf.url
+        });
+
+        await this.alfrescoJsApi.login(TestConfig.adf.adminEmail, TestConfig.adf.adminPassword);
+
+        user = await users.createTenantAndUser(this.alfrescoJsApi);
+        tenantId = user.tenantId;
+
+        await this.alfrescoJsApi.login(user.email, user.password);
+
+        importedApp = await apps.importPublishDeployApp(this.alfrescoJsApi, app.file_location);
+
+        let appDefinitions = await this.alfrescoJsApi.activiti.appsApi.getAppDefinitions();
+
+        appId = appDefinitions.data.find((currentApp) => {
+            return currentApp.modelId === importedApp.id;
+        }).id;
+
+        await loginPage.loginToProcessServicesUsingUserModel(user);
+
+        navigationBarPage.clickProcessServicesButton();
+        processServicesPage.checkApsContainer();
+        processServicesPage.goToApp(app.title);
+
+        tasksPage.createNewTask().addName(tasks[0].name).addDueDate(tasks[0].dueDate).clickStartButton();
+        taskDetailsPage.clickCompleteTask();
+
+        tasksPage.createNewTask().addName(tasks[1].name).addDueDate(tasks[1].dueDate).clickStartButton();
+        taskDetailsPage.clickCompleteTask();
+
+        tasksPage.createNewTask().addName(tasks[2].name).addDueDate(tasks[2].dueDate).clickStartButton();
+        taskDetailsPage.clickCompleteTask();
+
+        tasksPage.createNewTask().addName(tasks[3].name).addDueDate(tasks[3].dueDate).clickStartButton();
+        tasksPage.createNewTask().addName(tasks[4].name).addDueDate(tasks[4].dueDate).clickStartButton();
+        tasksPage.createNewTask().addName(tasks[5].name).addDueDate(tasks[5].dueDate).clickStartButton();
+
+        done();
+
+    });
+
+    // afterAll(async(done) => {
+    //     await this.alfrescoJsApi.activiti.adminTenantsApi.deleteTenant(tenantId);
+    //     done();
+    // });
+    it('[C277254] Should display tasks under new filter from newest to oldest when they are completed', () => {
+        browser.controlFlow().execute(async () => {
+            let newFilter = new this.alfrescoJsApi.activiti.UserProcessInstanceFilterRepresentation();
+            newFilter.name = 'Newest first';
+            newFilter.appId = appId;
+            newFilter.icon = 'glyphicon-filter';
+            newFilter.filter = { sort: 'created-desc', state: 'completed', assignment: 'involved' };
+
+            let result = await this.alfrescoJsApi.activiti.userFiltersApi.createUserTaskFilter(newFilter);
+
+            taskFilterId = result.id;
+            return result;
+        });
+
+        browser.refresh();
+
+        taskFiltersPage.clickTaskFilter('Newest first');
+
+        expect(tasksListPage.taskOnTaskListInPosition(1)).toBe(tasks[2].name);
+        expect(tasksListPage.taskOnTaskListInPosition(2)).toBe(tasks[1].name);
+        expect(tasksListPage.taskOnTaskListInPosition(3)).toBe(tasks[0].name);
+
+    });
+
+    it('[C277255] Should display tasks under new filter from oldest to newest when they are completed', () => {
+        browser.controlFlow().execute(async () => {
+            let newFilter = new this.alfrescoJsApi.activiti.UserProcessInstanceFilterRepresentation();
+            newFilter.name = 'Newest last';
+            newFilter.appId = appId;
+            newFilter.icon = 'glyphicon-filter';
+            newFilter.filter = { sort: 'created-asc', state: 'completed', assignment: 'involved' };
+
+            let result = await this.alfrescoJsApi.activiti.userFiltersApi.createUserTaskFilter(newFilter);
+
+            taskFilterId = result.id;
+            return result;
+        });
+
+        browser.refresh();
+
+        taskFiltersPage.clickTaskFilter('Newest last');
+
+        expect(tasksListPage.taskOnTaskListInPosition(1)).toBe(tasks[0].name);
+        expect(tasksListPage.taskOnTaskListInPosition(2)).toBe(tasks[1].name);
+        expect(tasksListPage.taskOnTaskListInPosition(3)).toBe(tasks[2].name);
+    });
+
+    it('[C277256] Should display tasks under new filter from closest due date to farthest when they are completed', () => {
+        browser.controlFlow().execute(async () => {
+            let newFilter = new this.alfrescoJsApi.activiti.UserProcessInstanceFilterRepresentation();
+            newFilter.name = 'Due first';
+            newFilter.appId = appId;
+            newFilter.icon = 'glyphicon-filter';
+            newFilter.filter = { sort: 'due-desc', state: 'completed', assignment: 'involved' };
+
+            let result = await this.alfrescoJsApi.activiti.userFiltersApi.createUserTaskFilter(newFilter);
+
+            taskFilterId = result.id;
+            return result;
+        });
+
+        browser.refresh();
+
+        taskFiltersPage.clickTaskFilter('Due first');
+
+        expect(tasksListPage.taskOnTaskListInPosition(1)).toBe(tasks[2].name);
+        expect(tasksListPage.taskOnTaskListInPosition(2)).toBe(tasks[1].name);
+        expect(tasksListPage.taskOnTaskListInPosition(3)).toBe(tasks[0].name);
+    });
+
+    it('[C277257] Should display tasks under new filter from oldest to newest when they are completed', () => {
+        browser.controlFlow().execute(async () => {
+            let newFilter = new this.alfrescoJsApi.activiti.UserProcessInstanceFilterRepresentation();
+            newFilter.name = 'Due last';
+            newFilter.appId = appId;
+            newFilter.icon = 'glyphicon-filter';
+            newFilter.filter = { sort: 'due-asc', state: 'completed', assignment: 'involved' };
+
+            let result = await this.alfrescoJsApi.activiti.userFiltersApi.createUserTaskFilter(newFilter);
+
+            taskFilterId = result.id;
+            return result;
+        });
+
+        browser.refresh();
+
+        taskFiltersPage.clickTaskFilter('Due last');
+
+        expect(tasksListPage.taskOnTaskListInPosition(1)).toBe(tasks[0].name);
+        expect(tasksListPage.taskOnTaskListInPosition(2)).toBe(tasks[1].name);
+        expect(tasksListPage.taskOnTaskListInPosition(3)).toBe(tasks[2].name);
+    });
+
+    it('[C277258] Should display tasks under new filter from newest to oldest when they are open  ', () => {
+        browser.controlFlow().execute(async () => {
+            let newFilter = new this.alfrescoJsApi.activiti.UserProcessInstanceFilterRepresentation();
+            newFilter.name = 'Newest first Open';
+            newFilter.appId = appId;
+            newFilter.icon = 'glyphicon-filter';
+            newFilter.filter = { sort: 'created-desc', state: 'open', assignment: 'involved' };
+
+            let result = await this.alfrescoJsApi.activiti.userFiltersApi.createUserTaskFilter(newFilter);
+
+            taskFilterId = result.id;
+            return result;
+        });
+
+        browser.refresh();
+
+        taskFiltersPage.clickTaskFilter('Newest first Open');
+
+        expect(tasksListPage.taskOnTaskListInPosition(1)).toBe(tasks[5].name);
+        expect(tasksListPage.taskOnTaskListInPosition(2)).toBe(tasks[4].name);
+        expect(tasksListPage.taskOnTaskListInPosition(3)).toBe(tasks[3].name);
+    });
+
+    it('[C277259] Should display tasks under new filter from oldest to newest when they are open', () => {
+        browser.controlFlow().execute(async () => {
+            let newFilter = new this.alfrescoJsApi.activiti.UserProcessInstanceFilterRepresentation();
+            newFilter.name = 'Newest last Open';
+            newFilter.appId = appId;
+            newFilter.icon = 'glyphicon-filter';
+            newFilter.filter = { sort: 'created-asc', state: 'open', assignment: 'involved' };
+
+            let result = await this.alfrescoJsApi.activiti.userFiltersApi.createUserTaskFilter(newFilter);
+
+            taskFilterId = result.id;
+            return result;
+        });
+
+        browser.refresh();
+
+        taskFiltersPage.clickTaskFilter('Newest last Open');
+
+        expect(tasksListPage.taskOnTaskListInPosition(1)).toBe(tasks[3].name);
+        expect(tasksListPage.taskOnTaskListInPosition(2)).toBe(tasks[4].name);
+        expect(tasksListPage.taskOnTaskListInPosition(3)).toBe(tasks[5].name);
+    });
+
+    it('[C277260] Should display tasks under new filter from closest due date to farthest when they are open', () => {
+        browser.controlFlow().execute(async () => {
+            let newFilter = new this.alfrescoJsApi.activiti.UserProcessInstanceFilterRepresentation();
+            newFilter.name = 'Due first Open';
+            newFilter.appId = appId;
+            newFilter.icon = 'glyphicon-filter';
+            newFilter.filter = { sort: 'due-desc', state: 'open', assignment: 'involved' };
+
+            let result = await this.alfrescoJsApi.activiti.userFiltersApi.createUserTaskFilter(newFilter);
+
+            taskFilterId = result.id;
+            return result;
+        });
+
+        browser.refresh();
+
+        taskFiltersPage.clickTaskFilter('Due first Open');
+
+        expect(tasksListPage.taskOnTaskListInPosition(1)).toBe(tasks[5].name);
+        expect(tasksListPage.taskOnTaskListInPosition(2)).toBe(tasks[4].name);
+        expect(tasksListPage.taskOnTaskListInPosition(3)).toBe(tasks[3].name);
+    });
+
+    it('[C277261] Should display tasks under new filter from oldest to newest when they are open', () => {
+        browser.controlFlow().execute(async () => {
+            let newFilter = new this.alfrescoJsApi.activiti.UserProcessInstanceFilterRepresentation();
+            newFilter.name = 'Due last Open';
+            newFilter.appId = appId;
+            newFilter.icon = 'glyphicon-filter';
+            newFilter.filter = { sort: 'due-asc', state: 'open', assignment: 'involved' };
+
+            let result = await this.alfrescoJsApi.activiti.userFiltersApi.createUserTaskFilter(newFilter);
+
+            taskFilterId = result.id;
+            return result;
+        });
+
+        browser.refresh();
+
+        taskFiltersPage.clickTaskFilter('Due last Open');
+
+        expect(tasksListPage.taskOnTaskListInPosition(1)).toBe(tasks[3].name);
+        expect(tasksListPage.taskOnTaskListInPosition(2)).toBe(tasks[4].name);
+        expect(tasksListPage.taskOnTaskListInPosition(3)).toBe(tasks[5].name);
+
+    });
+});