Joseph Doherty
470 lines
16 KiB
TypeScript
470 lines
16 KiB
TypeScript
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);
|
|
});
|
|
});
|
|
});
|