jdescopingtool/TestScripts/deprecated/playwright/tests/timespan-operator.spec.ts

import { test, expect } from '@playwright/test';
import { navigateToSearchPage } from '../helpers/navigation.helper';
import { selectSearchType, SearchTypes, enterSearchName, clickSubmitSearch, confirmSubmitSearch } from '../helpers/search-type.helper';
import { setDateRange, setMinDate, setMaxDate, clearDateRange, TestDateRanges } from '../helpers/date-picker.helper';
import {
  addOperator,
  addOperators,
  clearAutocompleteItems,
  operatorConfig,
  getAutocompleteItemCount,
  removeAutocompleteItem,
  isAutocompletePanelVisible,
  TestAutocompleteData,
} from '../helpers/autocomplete.helper';
import { assertNoErrorNotification, hasSuccessNotification } from '../helpers/radzen.helper';
import { hasValidationErrors, submitAndExpectError, ValidationMessages } from '../helpers/validation.helper';

/**
 * Test suite for Search Type 50: Time Span + Operator
 *
 * This search type allows users to find work orders within a specified
 * date range that were processed by specific operators.
 *
 * Filters Enabled: Timespan (Min Date, Max Date), Operator
 */
test.describe('Search Type 50: Time Span + Operator', () => {
  test.beforeEach(async ({ page }) => {
    await navigateToSearchPage(page);
  });

  // Valid operator test data (user IDs)
  const validOperators = [
    'ADAMSSN', 'AGNEWA', 'AGNEWL', 'ALASMARB', 'ALEXIUCG',
    'ALLENHY', 'ALLENNI', 'ALURUM', 'ALVESM1', 'APONTEVE',
    'ARCHILAHI', 'ARGUELLC', 'ASHARK', 'ASLANESA', 'AVRAAMIL',
    'AYINDED', 'AYOUBR', 'BACKL', 'BAIZEJ', 'BAKERB',
  ];

  // ============================================================================
  // POSITIVE TEST CASES
  // ============================================================================

  test.describe('Positive Tests', () => {
    test('TC-050-P01: Single operator with valid date range', async ({ page }) => {
      // Select search type
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);

      // Verify filter panels are visible
      await expect(page.locator('text=Filter by Operator')).toBeVisible();
      await expect(page.locator('text=Filter by Time Span')).toBeVisible();

      // Enter search name
      await enterSearchName(page, 'TC-050-P01 Single Operator Test');

      // Set date range
      await setDateRange(page, '2019-01-01', '2019-12-31');

      // Add operator
      await addOperator(page, 'ADAMSSN');

      // Verify operator appears in the list
      const itemCount = await getAutocompleteItemCount(page, operatorConfig);
      expect(itemCount).toBe(1);

      // Submit search
      await clickSubmitSearch(page);
      await confirmSubmitSearch(page);

      // Verify no error notification
      await assertNoErrorNotification(page);
    });

    test('TC-050-P02: Multiple operators with valid date range', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-P02 Multiple Operators Test');

      // Set date range
      await setDateRange(page, '2018-01-01', '2019-12-31');

      // Add multiple operators
      await addOperators(page, ['ADAMSSN', 'AGNEWA', 'ALEXIUCG']);

      // Verify all operators appear in the list
      const itemCount = await getAutocompleteItemCount(page, operatorConfig);
      expect(itemCount).toBe(3);

      // Submit search
      await clickSubmitSearch(page);
      await confirmSubmitSearch(page);

      await assertNoErrorNotification(page);
    });

    test('TC-050-P03: Recent date range with single operator', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-P03 Recent Date Range Test');

      // Set recent date range
      await setDateRange(page, TestDateRanges.RECENT.min, TestDateRanges.RECENT.max);

      // Add operator
      await addOperator(page, 'APONTEVE');

      // Submit search
      await clickSubmitSearch(page);
      await confirmSubmitSearch(page);

      await assertNoErrorNotification(page);
    });

    test('TC-050-P04: Historical date range with multiple operators', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-P04 Historical Range Test');

      // Set historical date range
      await setDateRange(page, TestDateRanges.HISTORICAL.min, TestDateRanges.HISTORICAL.max);

      // Add multiple operators
      await addOperators(page, ['BACKL', 'BAIZEJ']);

      // Verify operators in list
      const itemCount = await getAutocompleteItemCount(page, operatorConfig);
      expect(itemCount).toBe(2);

      // Submit search
      await clickSubmitSearch(page);
      await confirmSubmitSearch(page);

      await assertNoErrorNotification(page);
    });

    test('TC-050-P05: Same day date range', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-P05 Same Day Test');

      // Set same day date range
      await setDateRange(page, '2019-06-15', '2019-06-15');

      // Add operator
      await addOperator(page, 'ALLENHY');

      // Submit search
      await clickSubmitSearch(page);
      await confirmSubmitSearch(page);

      await assertNoErrorNotification(page);
    });

    test('TC-050-P06: Maximum number of operators', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-P06 Many Operators Test');

      // Set date range
      await setDateRange(page, '2018-01-01', '2020-09-01');

      // Add 10 operators
      const tenOperators = validOperators.slice(0, 10);
      await addOperators(page, tenOperators);

      // Verify all operators in list
      const itemCount = await getAutocompleteItemCount(page, operatorConfig);
      expect(itemCount).toBe(10);

      // Submit search
      await clickSubmitSearch(page);
      await confirmSubmitSearch(page);

      await assertNoErrorNotification(page);
    });

    test('TC-050-P07: Boundary date - start of data range', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-P07 Start Boundary');

      // Set earliest date boundary
      await setDateRange(page, TestDateRanges.START_BOUNDARY.min, TestDateRanges.START_BOUNDARY.max);

      // Add operator
      await addOperator(page, 'ADAMSSN');

      // Submit search
      await clickSubmitSearch(page);
      await confirmSubmitSearch(page);

      await assertNoErrorNotification(page);
    });

    test('TC-050-P08: Boundary date - end of data range', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-P08 End Boundary');

      // Set latest date boundary
      await setDateRange(page, TestDateRanges.END_BOUNDARY.min, TestDateRanges.END_BOUNDARY.max);

      // Add operator
      await addOperator(page, 'AGNEWA');

      // Submit search
      await clickSubmitSearch(page);
      await confirmSubmitSearch(page);

      await assertNoErrorNotification(page);
    });

    test('TC-050-P09: Operator remove and re-add', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-P09 Operator Remove Re-add');

      // Set date range
      await setDateRange(page, '2019-01-01', '2019-12-31');

      // Add operators
      await addOperator(page, 'ADAMSSN');
      await addOperator(page, 'AGNEWA');

      // Verify both are added
      let itemCount = await getAutocompleteItemCount(page, operatorConfig);
      expect(itemCount).toBe(2);

      // Remove first operator
      await removeAutocompleteItem(page, operatorConfig, 0);

      // Verify only one remains
      itemCount = await getAutocompleteItemCount(page, operatorConfig);
      expect(itemCount).toBe(1);

      // Add another operator
      await addOperator(page, 'ALEXIUCG');

      // Verify two operators in list
      itemCount = await getAutocompleteItemCount(page, operatorConfig);
      expect(itemCount).toBe(2);

      // Submit search
      await clickSubmitSearch(page);
      await confirmSubmitSearch(page);

      await assertNoErrorNotification(page);
    });
  });

  // ============================================================================
  // NEGATIVE TEST CASES
  // ============================================================================

  test.describe('Negative Tests', () => {
    test('TC-050-N01: Missing search name', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);

      // Do NOT enter search name

      // Set valid date range
      await setDateRange(page, '2019-01-01', '2019-12-31');

      // Add operator
      await addOperator(page, 'ADAMSSN');

      // Attempt to submit
      await submitAndExpectError(page);

      // Verify user remains on the page
      await expect(page.locator('text=Filter by Operator')).toBeVisible();
    });

    test('TC-050-N02: Missing operator', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-N02 Missing Operator Test');

      // Set valid date range
      await setDateRange(page, '2019-01-01', '2019-12-31');

      // Do NOT add any operators

      // Verify operator list is empty
      const itemCount = await getAutocompleteItemCount(page, operatorConfig);
      expect(itemCount).toBe(0);

      // Attempt to submit
      await submitAndExpectError(page);
    });

    test('TC-050-N03: Missing minimum date', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-N03 Missing Min Date Test');

      // Only set maximum date
      await setMaxDate(page, '2019-12-31');

      // Add operator
      await addOperator(page, 'ADAMSSN');

      // Attempt to submit
      await submitAndExpectError(page);
    });

    test('TC-050-N04: Missing maximum date', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-N04 Missing Max Date Test');

      // Only set minimum date
      await setMinDate(page, '2019-01-01');

      // Add operator
      await addOperator(page, 'ADAMSSN');

      // Attempt to submit
      await submitAndExpectError(page);
    });

    test('TC-050-N05: Invalid date range (min > max)', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-N05 Invalid Date Range Test');

      // Set invalid date range (min date after max date)
      await setDateRange(page, '2020-01-01', '2019-01-01');

      // Add operator
      await addOperator(page, 'ADAMSSN');

      // Attempt to submit
      await submitAndExpectError(page);
    });

    test('TC-050-N06: Invalid date format', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-N06 Invalid Date Format Test');

      // Try to enter invalid date format
      const minDateInput = page.locator('input[name="MinimumDt"]');
      await minDateInput.fill('13/45/2019');

      await setMaxDate(page, '2019-12-31');

      // Add operator
      await addOperator(page, 'ADAMSSN');

      // Attempt to submit
      await submitAndExpectError(page);
    });

    test('TC-050-N07: Empty operator value', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-N07 Empty Operator Test');

      // Set valid date range
      await setDateRange(page, '2019-01-01', '2019-12-31');

      // Try to add empty operator
      const panel = page.locator(`.rz-card:has-text("${operatorConfig.panelHeader}")`);
      const autocomplete = panel.locator('.rz-autocomplete input');
      await autocomplete.fill('');

      // Try to click Add button (should not add empty value)
      const addButton = panel.locator('button:has-text("Add")');
      await addButton.click();
      await page.waitForTimeout(300);

      // Verify operator list is still empty
      const itemCount = await getAutocompleteItemCount(page, operatorConfig);
      expect(itemCount).toBe(0);

      // Attempt to submit
      await submitAndExpectError(page);
    });

    test('TC-050-N08: Whitespace-only search name', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);

      // Enter whitespace-only search name
      await enterSearchName(page, '   ');

      // Set valid date range
      await setDateRange(page, '2019-01-01', '2019-12-31');

      // Add operator
      await addOperator(page, 'ADAMSSN');

      // Attempt to submit
      await submitAndExpectError(page);
    });

    test('TC-050-N09: Missing all required filters', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-N09 No Filters Test');

      // Do NOT set any dates
      // Do NOT add any operators

      // Attempt to submit
      await submitAndExpectError(page);
    });

    test('TC-050-N10: Invalid operator code', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-N10 Invalid Operator Code');

      // Set valid date range
      await setDateRange(page, '2019-01-01', '2019-12-31');

      // Try to add invalid operator
      const panel = page.locator(`.rz-card:has-text("${operatorConfig.panelHeader}")`);
      const autocomplete = panel.locator('.rz-autocomplete input');
      await autocomplete.fill('INVALIDOPERATOR123');

      // Wait for autocomplete to search
      await page.waitForTimeout(500);

      // Verify no autocomplete suggestions appear
      const dropdown = page.locator('.rz-autocomplete-list');
      const dropdownVisible = await dropdown.isVisible({ timeout: 2000 }).catch(() => false);

      if (dropdownVisible) {
        const items = dropdown.locator('.rz-autocomplete-list-item');
        const count = await items.count();
        expect(count).toBe(0);
      }

      // Verify operator list is still empty
      const itemCount = await getAutocompleteItemCount(page, operatorConfig);
      expect(itemCount).toBe(0);
    });

    test('TC-050-N11: Future date range', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-N11 Future Dates');

      // Set future date range
      await setDateRange(page, TestDateRanges.FUTURE.min, TestDateRanges.FUTURE.max);

      // Add operator
      await addOperator(page, 'ADAMSSN');

      // Submit search - may be accepted but will return no results
      await clickSubmitSearch(page);

      // Check if there's a validation error or if it proceeds
      const hasErrors = await hasValidationErrors(page);
      if (!hasErrors) {
        await confirmSubmitSearch(page);
        await assertNoErrorNotification(page);
      }
    });

    test('TC-050-N12: Duplicate operator entry', async ({ page }) => {
      await selectSearchType(page, SearchTypes.TIMESPAN_OPERATOR);
      await enterSearchName(page, 'TC-050-N12 Duplicate Operator');

      // Set valid date range
      await setDateRange(page, '2019-01-01', '2019-12-31');

      // Add operator
      await addOperator(page, 'ADAMSSN');

      // Verify one entry
      let itemCount = await getAutocompleteItemCount(page, operatorConfig);
      expect(itemCount).toBe(1);

      // Attempt to add the same operator again
      await addOperator(page, 'ADAMSSN');

      // Wait for any duplicate handling
      await page.waitForTimeout(500);

      // Verify only one entry remains (duplicate should be rejected)
      itemCount = await getAutocompleteItemCount(page, operatorConfig);
      expect(itemCount).toBe(1);
    });
  });
});