FAT-24721 Implement e2e for C594361 (#7149)

Author: usavkov-epam

cypress/e2e/consortia/orders/filter-purchase-orders-and-lines-by-fund-code-and-donor.cy.js

@@ -18,8 +18,10 @@ Cypress.Commands.add('getUsers', (searchParams) => {
     });
 });
 
-Cypress.Commands.add('getAdminUserDetails', () => {
-  if (!Cypress.env('adminUserDetails')) {
+Cypress.Commands.add('getAdminUserDetails', (options = {}) => {
+  const { force = false } = options;
+
+  if (force || !Cypress.env('adminUserDetails')) {
     return cy
       .getUsers({ limit: 1, query: `"username"="${Cypress.env('diku_login')}"` })
       .then((users) => {

cypress/support/api/users.js

@@ -1779,12 +1779,14 @@ export const COMMON_BUTTON_LABELS = {
   ACTIONS: 'Actions',
   APPLY: 'Apply',
   CANCEL: 'Cancel',
+  CLOSE: 'Close',
   CONFIRM: 'Confirm',
   NEXT: 'Next',
   PREVIOUS: 'Previous',
   REMOVE: 'Remove',
   RESET_ALL: 'Reset all',
   SAVE: 'Save',
+  SEARCH: 'Search',
   YES: 'Yes',
   NO: 'No',
 };

cypress/support/constants/constants.js

@@ -563,4 +563,42 @@ export default {
   collapseFilterAccordion(filtersPane, filterLabel) {
     this.setFilterAccordionExpanded(filtersPane, filterLabel, false);
   },
+
+  /* Helpers */
+
+  buildMultiSelectFilterValuesAssertion(filtersPane) {
+    return (filterLabel, expectedValues, options = {}) => {
+      this.assertMultiSelectFilterValues(filtersPane, filterLabel, expectedValues, options);
+    };
+  },
+
+  buildMultiSelectFilterOptionsValuesAssertion(filtersPane) {
+    return (filterLabel, expectedOptions, options = {}) => {
+      this.assertMultiSelectFilterOptionsValues(filtersPane, filterLabel, expectedOptions, options);
+    };
+  },
+
+  buildCheckboxFilterValuesAssertion(filtersPane) {
+    return (filterLabel, labels, options = {}) => {
+      this.assertCheckboxFilterValues(filtersPane, filterLabel, labels, options);
+    };
+  },
+
+  buildSelectFilterValueAssertion(filtersPane) {
+    return (filterLabel, expectedValue, options = {}) => {
+      this.assertSelectFilterValue(filtersPane, filterLabel, expectedValue, options);
+    };
+  },
+
+  buildSelectionFilterValueAssertion(filtersPane) {
+    return (filterLabel, expectedValue, options = {}) => {
+      this.assertSelectionFilterValue(filtersPane, filterLabel, expectedValue, options);
+    };
+  },
+
+  buildDateRangeFilterValuesAssertion(filtersPane) {
+    return (filterLabel, expectedDates, options = {}) => {
+      this.assertDateRangeFilterValues(filtersPane, filterLabel, expectedDates, options);
+    };
+  },
 };

cypress/support/fragments/filtersPane.js

@@ -0,0 +1,77 @@
+import {
+  Button,
+  Checkbox,
+  Modal,
+  MultiColumnList,
+  MultiColumnListCell,
+  Pane,
+  SearchField,
+  including,
+} from '../../../../../interactors';
+import { COMMON_BUTTON_LABELS, DEFAULT_WAIT_TIME, LIST_ASSERTION_MODES } from '../../../constants';
+import MCLHelper from '../../multiColumnList';
+
+const selectOrganizationModal = Modal(including('Add donors'));
+const filtersPane = selectOrganizationModal.find(Pane('Search & filter'));
+const searchField = filtersPane.find(SearchField({ id: 'input-record-search' }));
+const resetAllButton = filtersPane.find(Button(COMMON_BUTTON_LABELS.RESET_ALL));
+const searchButton = filtersPane.find(Button(COMMON_BUTTON_LABELS.SEARCH));
+const saveButton = selectOrganizationModal.find(Button(COMMON_BUTTON_LABELS.SAVE));
+const closeButton = selectOrganizationModal.find(Button(COMMON_BUTTON_LABELS.CLOSE));
+const resultsList = selectOrganizationModal.find(MultiColumnList());
+
+const NAME_COLUMN = 'Name';
+
+export default {
+  waitLoading() {
+    cy.expect(selectOrganizationModal.exists());
+    cy.expect(filtersPane.exists());
+    cy.expect(resultsList.exists());
+    cy.expect(closeButton.has({ disabled: false }));
+    cy.expect(saveButton.has({ disabled: true }));
+    this.assertSelectedDonors(0);
+  },
+
+  selectDonors(names = []) {
+    const sorted = names.toSorted((a, b) => a.localeCompare(b));
+
+    sorted.forEach((name) => {
+      cy.do([searchField.fillIn(name), searchButton.click()]);
+      MCLHelper.waitLoadingComplete(resultsList);
+      cy.wait(DEFAULT_WAIT_TIME);
+      cy.do(
+        resultsList
+          .find(MultiColumnListCell({ row: 0, columnIndex: 0 }))
+          .find(Checkbox())
+          .click(),
+      );
+    });
+    cy.do(resetAllButton.click());
+    MCLHelper.sortListBy(resultsList, NAME_COLUMN);
+    this.assertSelectedDonors(names.length);
+  },
+
+  submitSelectedDonors() {
+    cy.do(saveButton.click());
+  },
+
+  assertSelectedDonors(count = 0) {
+    cy.expect(selectOrganizationModal.has({ footer: including(`Total selected: ${count}`) }));
+  },
+
+  assertModalClosed() {
+    cy.expect(selectOrganizationModal.absent());
+  },
+
+  assertDonorsListIncludes(names = [], options = {}) {
+    const { mode = LIST_ASSERTION_MODES.EXISTS } = options;
+
+    names.forEach((name) => {
+      const assertion = resultsList.find(
+        MultiColumnListCell({ column: NAME_COLUMN, content: including(name) }),
+      )[mode];
+
+      cy.expect(assertion());
+    });
+  },
+};

cypress/support/fragments/orders/modals/selectDonorModal.js

@@ -33,6 +33,7 @@ import {
   ORDER_EXPORT_CSV_FIELDS,
   ORDER_LINE_EXPORT_CSV_FIELDS,
   ORDER_LINE_FILTER_LABELS,
+  RESULTS_PANE_CHOOSE_FILTER_MESSAGE,
 } from '../../constants';
 import InteractorsTools from '../../utils/interactorsTools';
 import getRandomPostfix from '../../utils/stringTools';
@@ -41,6 +42,7 @@ import SearchHelper from '../finance/financeHelper';
 import MultiColumnListHelper from '../multiColumnList';
 import SelectInstanceModal from './modals/selectInstanceModal';
 import SelectLocationModal from './modals/selectLocationModal';
+import SelectDonorModal from './modals/selectDonorModal';
 import OrderLineDetails from './orderLineDetails';
 
 const path = require('path');
@@ -140,6 +142,11 @@ const submitOrderLine = () => {
     }
   });
 };
+
+// Filters
+const donorFilterAccordion = Accordion(ORDER_LINE_FILTER_LABELS.DONOR);
+const donorLookUpTrigger = donorFilterAccordion.find(Button('Donor look-up'));
+
 const checkQuantityPhysical = (quantity) => {
   cy.expect(Accordion('Cost details').find(KeyValue('Quantity physical')).has({ value: quantity }));
 };
@@ -2782,6 +2789,10 @@ export default {
     MultiColumnListHelper.sortListBy(searchResultsPane, columnName);
   },
 
+  clearFilter(filterLabel) {
+    FiltersPaneHelper.clearFilter(filtersPane, filterLabel);
+  },
+
   filterByCheckboxOptions(filterLabel, options = []) {
     FiltersPaneHelper.filterByCheckboxes(filtersPane, filterLabel, options);
   },
@@ -2798,6 +2809,25 @@ export default {
     this.filterByMultiSelectOptions(ORDER_LINE_FILTER_LABELS.FUND_CODE, codes);
   },
 
+  removeMultiSelectChips(filterLabel, values = []) {
+    FiltersPaneHelper.removeMultiSelectChips(filtersPane, filterLabel, values);
+  },
+
+  filterByDonors(names = []) {
+    FiltersPaneHelper.expandFilterAccordion(filtersPane, ORDER_LINE_FILTER_LABELS.DONOR);
+    cy.expect(donorLookUpTrigger.exists());
+    cy.do(donorLookUpTrigger.click());
+    SelectDonorModal.waitLoading();
+    SelectDonorModal.assertDonorsListIncludes(names);
+    SelectDonorModal.selectDonors(names);
+    SelectDonorModal.submitSelectedDonors();
+    SelectDonorModal.assertModalClosed();
+  },
+
+  assertNoFiltersApplied() {
+    cy.expect(searchResultsPane.find(HTML(including(RESULTS_PANE_CHOOSE_FILTER_MESSAGE))).exists());
+  },
+
   assertResultsCount(expectedCount) {
     searchResultsPane
       .find(
@@ -2806,11 +2836,34 @@ export default {
       .exists();
   },
 
+  assertOrderLinesResults(rowsConfig) {
+    cy.expect(searchResultsPane.exists());
+    MultiColumnListHelper.assertRowsCellsContent(searchResultsPane, rowsConfig);
+    this.assertResultsCount(rowsConfig.length);
+  },
+
   assertResultsActionIsDisabled(actionButtonName, expectedDisabledState = true) {
     const actionsBtn = searchResultsPane.find(actionsButton);
 
     cy.do(actionsBtn.click());
     cy.do(Button(actionButtonName).has({ disabled: expectedDisabledState }));
     cy.do(actionsBtn.click());
   },
+
+  assertMultiSelectFilterValues:
+    FiltersPaneHelper.buildMultiSelectFilterValuesAssertion(filtersPane),
+  assertMultiSelectFilterOptions:
+    FiltersPaneHelper.buildMultiSelectFilterOptionsValuesAssertion(filtersPane),
+
+  assertFundCodeFilterValues(expectedValues, options = {}) {
+    this.assertMultiSelectFilterValues(ORDER_LINE_FILTER_LABELS.FUND_CODE, expectedValues, options);
+  },
+
+  assertFundCodeFilterOptions(expectedOptions, options = {}) {
+    this.assertMultiSelectFilterOptions(
+      ORDER_LINE_FILTER_LABELS.FUND_CODE,
+      expectedOptions,
+      options,
+    );
+  },
 };

cypress/support/fragments/orders/orderLines.js

@@ -1047,23 +1047,10 @@ export default {
     FiltersPaneHelper.collapseFilterAccordion(ordersFiltersPane, filterLabel);
   },
 
-  assertMultiSelectFilterValues(filterLabel, expectedValues, options = {}) {
-    FiltersPaneHelper.assertMultiSelectFilterValues(
-      ordersFiltersPane,
-      filterLabel,
-      expectedValues,
-      options,
-    );
-  },
-
-  assertMultiSelectFilterOptions(filterLabel, expectedOptions, options = {}) {
-    FiltersPaneHelper.assertMultiSelectFilterOptionsValues(
-      ordersFiltersPane,
-      filterLabel,
-      expectedOptions,
-      options,
-    );
-  },
+  assertMultiSelectFilterValues:
+    FiltersPaneHelper.buildMultiSelectFilterValuesAssertion(ordersFiltersPane),
+  assertMultiSelectFilterOptions:
+    FiltersPaneHelper.buildMultiSelectFilterOptionsValuesAssertion(ordersFiltersPane),
 
   assertFundCodeFilterValues(expectedValues, options = {}) {
     this.assertMultiSelectFilterValues(ORDER_FILTER_LABELS.FUND_CODE, expectedValues, options);

cypress/support/fragments/orders/orders.js

@@ -21,27 +21,109 @@ export default {
     );
   },
 
+  /* Request interceptors */
+
   interceptGetOrders() {
     cy.intercept('GET', '/orders/composite-orders*').as('waiterForOrdersQueryCompleted');
   },
-
   waitForOrdersQueryCompleted() {
     cy.wait('@waiterForOrdersQueryCompleted');
   },
 
   interceptGetOrderLines() {
     cy.intercept('GET', '/orders/order-lines*').as('waiterForOrderLinesQueryCompleted');
   },
-
   waitForOrderLinesQueryCompleted() {
     cy.wait('@waiterForOrderLinesQueryCompleted');
   },
 
   interceptCustomFields() {
     cy.intercept('GET', '/custom-fields*').as('waiterForCustomFieldsQueryCompleted');
   },
-
   waitForCustomFieldsQueryCompleted() {
     cy.wait('@waiterForCustomFieldsQueryCompleted');
   },
+
+  interceptGetAcquisitionUnits() {
+    cy.intercept('GET', '/acquisition-units/units*').as('waiterForAcquisitionUnitsQueryCompleted');
+  },
+  waitForAcquisitionUnitsQueryCompleted() {
+    cy.wait('@waiterForAcquisitionUnitsQueryCompleted');
+  },
+
+  interceptGetOrganizations() {
+    cy.intercept('GET', '/organizations/organizations*').as('waiterForOrganizationsQueryCompleted');
+  },
+  waitForOrganizationsQueryCompleted() {
+    cy.wait('@waiterForOrganizationsQueryCompleted');
+  },
+
+  interceptGetPrefixes() {
+    cy.intercept('GET', '/orders/configuration/prefixes*').as('waiterForPrefixesQueryCompleted');
+  },
+  waitForPrefixesQueryCompleted() {
+    cy.wait('@waiterForPrefixesQueryCompleted');
+  },
+
+  interceptGetSuffixes() {
+    cy.intercept('GET', '/orders/configuration/suffixes*').as('waiterForSuffixesQueryCompleted');
+  },
+  waitForSuffixesQueryCompleted() {
+    cy.wait('@waiterForSuffixesQueryCompleted');
+  },
+
+  interceptGetReasonsForClosure() {
+    cy.intercept('GET', '/orders/configuration/reasons-for-closure*').as(
+      'waiterForReasonsForClosureQueryCompleted',
+    );
+  },
+  waitForReasonsForClosureQueryCompleted() {
+    cy.wait('@waiterForReasonsForClosureQueryCompleted');
+  },
+
+  interceptGetTenantAddresses() {
+    cy.intercept('GET', '/tenant-addresses*').as('waiterForTenantAddressesQueryCompleted');
+  },
+  waitForTenantAddressesQueryCompleted() {
+    cy.wait('@waiterForTenantAddressesQueryCompleted');
+  },
+
+  interceptGetSettingsEntries() {
+    cy.intercept('GET', '/settings/entries*').as('waiterForSettingsEntriesQueryCompleted');
+  },
+  waitForSettingsEntriesQueryCompleted() {
+    cy.wait('@waiterForSettingsEntriesQueryCompleted');
+  },
+
+  interceptGetTags() {
+    cy.intercept('GET', '/tags*').as('waiterForTagsQueryCompleted');
+  },
+  waitForTagsQueryCompleted() {
+    cy.wait('@waiterForTagsQueryCompleted');
+  },
+
+  interceptGetAcquisitionMethods() {
+    cy.intercept('GET', '/orders/acquisition-methods*').as(
+      'waiterForAcquisitionMethodsQueryCompleted',
+    );
+  },
+  waitForAcquisitionMethodsQueryCompleted() {
+    cy.wait('@waiterForAcquisitionMethodsQueryCompleted');
+  },
+
+  interceptGetMaterialTypes() {
+    cy.intercept('GET', '/material-types*').as('waiterForMaterialTypesQueryCompleted');
+  },
+  waitForMaterialTypesQueryCompleted() {
+    cy.wait('@waiterForMaterialTypesQueryCompleted');
+  },
+
+  interceptGetOrdersStorageSettings() {
+    cy.intercept('GET', '/orders-storage/settings*').as(
+      'waiterForOrdersStorageSettingsQueryCompleted',
+    );
+  },
+  waitForOrdersStorageSettingsQueryCompleted() {
+    cy.wait('@waiterForOrdersStorageSettingsQueryCompleted');
+  },
 };