transit-core-taf 1.0.26 → 1.0.28

package/dist/baseui/basepagevalidations.js

@@ -37,6 +37,7 @@ class BasePageValidations {
      * await validateElementCountToBe(page.locator('.item'), 3);
      * */
     async validateElementCountToBe(locator, expectedCount) {
+        this.logger.info(`Validating element count to be: ${expectedCount}`);
         await (0, test_1.expect)(locator).toHaveCount(expectedCount);
     }
     /**
@@ -45,6 +46,7 @@ class BasePageValidations {
      * @param element2 The second locator.
      */
     async validateElementsDoNotOverlap(element1, element2) {
+        this.logger.info(`Validating elements do not overlap`);
         const box1 = await element1.boundingBox();
         const box2 = await element2.boundingBox();
         if (!box1 || !box2) {
@@ -64,6 +66,7 @@ class BasePageValidations {
      * @param timeout - Maximum time to wait for the element to appear (in milliseconds). Defaults to 10 seconds.
      */
     async validateElementToBeVisibleById(id, timeout = 10000) {
+        this.logger.info(`Validating element with ID '${id}' is visible`);
         await this.page.locator(`#${id}`).waitFor({ timeout });
         await (0, test_1.expect)(this.page.locator(`#${id}`)).toBeVisible();
     }
@@ -94,6 +97,7 @@ class BasePageValidations {
      * @param expectedText The expected text of the element.
      */
     async validateTextNotToBe(actualText, expectedText) {
+        this.logger.info(`Validating text: ${actualText} not to be ${expectedText}`);
         await (0, test_1.expect)(actualText).not.toBe(expectedText);
     }
     /**
@@ -101,6 +105,7 @@ class BasePageValidations {
      * @param element The locator of the element to validate.
      */
     async validateElementToBeEnabled(element) {
+        this.logger.info(`Validating element is enabled: ${element}`);
         await (0, test_1.expect)(element).toBeEnabled();
     }
     /**
@@ -108,6 +113,7 @@ class BasePageValidations {
      * @param element The locator of the element to validate.
      */
     async validateElementToBeHidden(element) {
+        this.logger.info(`Validating element is hidden: ${element}`);
         await (0, test_1.expect)(element).toBeHidden();
     }
     /**
@@ -115,6 +121,7 @@ class BasePageValidations {
      * @param elements Array of Playwright locators to validate.
      */
     async validateElementsToBeHidden(elements) {
+        this.logger.info(`Validating ${elements.length} elements are hidden`);
         for (const element of elements) {
             await (0, test_1.expect)(element).toBeHidden();
         }
@@ -127,6 +134,7 @@ class BasePageValidations {
      * @param timeout - Optional timeout in milliseconds (default: 10s).
      */
     async validateElementToHaveAttribute(element, attr, value, timeout = 10000) {
+        this.logger.info(`Validating element has attribute '${attr}' with value '${value}'`);
         const target = typeof element === 'string' ? this.page.locator(`#${element}`) : element;
         await (0, test_1.expect)(target).toBeVisible({ timeout });
         await (0, test_1.expect)(target).toHaveAttribute(attr, value, { timeout });
@@ -138,6 +146,7 @@ class BasePageValidations {
     * @param timeout Maximum time to wait for the element to become visible and contain the text (default: 60s).
     */
     async validateElementToContainText(element, expectedText, timeout = 60000) {
+        this.logger.info(`Validating element contains text: ${expectedText}`);
         const locator = typeof element === 'string' ? this.page.locator(`#${element}`) : element;
         await (0, test_1.expect)(locator).toBeVisible({ timeout });
         await (0, test_1.expect)(locator).toContainText(expectedText, { timeout });
@@ -169,6 +178,7 @@ class BasePageValidations {
      * @param timeout - The maximum time to wait for the element to become visible (in ms). Default is 5000 ms.
      */
     async validateElementVisibleById(elementId, timeout = 60000) {
+        this.logger.info(`Validating element with ID '${elementId}' is visible`);
         const locator = this.page.locator(`#${elementId}`);
         await (0, test_1.expect)(locator).toBeVisible({ timeout });
     }
@@ -177,6 +187,7 @@ class BasePageValidations {
     * @param actual The actual value to check.
     */
     async validateValueToBeNull(actual) {
+        this.logger.info(`Validating value is null: ${actual}`);
         await (0, test_1.expect)(actual).toBeNull();
     }
     /**
@@ -184,6 +195,7 @@ class BasePageValidations {
      * @param actual The actual value to check.
      */
     async validateValueNotToBeNull(actual) {
+        this.logger.info(`Validating value is not null: ${actual}`);
         await (0, test_1.expect)(actual).not.toBeNull();
     }
     /**
@@ -201,6 +213,7 @@ class BasePageValidations {
      * @param expected The number to compare against.
      */
     async validateValueToBeLessThanOrEqual(actual, expected) {
+        this.logger.info(`Validating value ${actual} is less than or equal to ${expected}`);
         await (0, test_1.expect)(actual).toBeLessThanOrEqual(expected);
     }
     /**
@@ -210,6 +223,7 @@ class BasePageValidations {
     * @param message - Optional custom message for assertion failure.
     */
     async validateValueToEqual(actual, expected, message) {
+        this.logger.info(`Validating value ${actual} equals ${expected}`);
         await (0, test_1.expect)(actual, message).toEqual(expected);
     }
     /**
@@ -219,6 +233,7 @@ class BasePageValidations {
      * @param message - Optional custom message for assertion failure.
      */
     async validateValueNotToEqual(actual, expected, message) {
+        this.logger.info(`Validating value ${actual} does not equal ${expected}`);
         await (0, test_1.expect)(actual, message).not.toEqual(expected);
     }
     /**
@@ -243,6 +258,7 @@ class BasePageValidations {
      * @param actual - The value to validate.
      */
     async validateValueToBeFalsy(actual) {
+        this.logger.info(`Validating value is falsy: ${actual}`);
         await (0, test_1.expect)(actual).toBeFalsy();
     }
     /**
@@ -260,6 +276,7 @@ class BasePageValidations {
      * @param expected - The regular expression or substring.
      */
     async validateValueToMatch(actual, expected) {
+        this.logger.info(`Validating value matches pattern: ${expected}`);
         await (0, test_1.expect)(actual).toMatch(expected);
     }
     /**
@@ -269,6 +286,7 @@ class BasePageValidations {
      * @param message Optional message for error context.
      */
     async validateArrayTextValues(expected, actual, message = 'Array mismatch') {
+        this.logger.info(`Validating array values - expected length: ${expected.length}, actual length: ${actual.length}`);
         test_1.expect.soft(actual.length, `${message} - length`).toBe(expected.length);
         for (let i = 0; i < expected.length; i++) {
             test_1.expect.soft(actual[i], `${message} - index ${i}`).toBe(expected[i]);
@@ -282,6 +300,7 @@ class BasePageValidations {
      * @param message Optional message for error context.
      */
     async validateObjectOfArrayTextValues(expected, actual, message = 'Object of arrays mismatch') {
+        this.logger.info(`Validating object of arrays with ${Object.keys(expected).length} keys`);
         for (const key of Object.keys(expected)) {
             const expectedArray = expected[key];
             const actualArray = actual[key];
@@ -299,6 +318,7 @@ class BasePageValidations {
      * @param expectedUrl - The expected substring to be present in the current URL.
      */
     async validateUrlToMatch(endpoint) {
+        this.logger.info(`Validating URL matches pattern: ${endpoint}`);
         await (0, test_1.expect)(this.page).toHaveURL(endpoint);
     }
     /**
@@ -307,6 +327,7 @@ class BasePageValidations {
      * @param expectedUrl - The expected base URL (without query params).
      */
     async validateUrlToContain(expectedUrl) {
+        this.logger.info(`Validating URL contains: ${expectedUrl}`);
         const currentUrl = this.page.url();
         await (0, test_1.expect)(currentUrl.includes(expectedUrl)).toBeTruthy();
     }
@@ -316,6 +337,7 @@ class BasePageValidations {
      * @param expected - The class name to match (string or RegExp).
      */
     async validateLocatorToHaveClass(locator, expected) {
+        this.logger.info(`Validating locator has class: ${expected}`);
         await (0, test_1.expect)(locator).toHaveClass(expected);
     }
     /** Validates all visible crop drag handles have correct accessibility attributes.
@@ -323,6 +345,7 @@ class BasePageValidations {
      * @param page - Playwright Page instance
      */
     async validateCropDragHandles(page) {
+        this.logger.info(`Validating crop drag handles`);
         const directions = ['nw', 'n', 'ne', 'e', 'se', 's', 'sw', 'w'];
         for (const dir of directions) {
             const handle = page.locator(`.ReactCrop__drag-handle.ord-${dir}`);
@@ -337,6 +360,7 @@ class BasePageValidations {
      * @param message - Optional custom error message on failure.
      */
     async validateToBeBoolean(actual, expected, message) {
+        this.logger.info(`Validating boolean value to be: ${expected}`);
         const resolvedActual = typeof actual === 'function' ? await actual() : actual;
         if (expected) {
             (0, test_1.expect)(resolvedActual, message ?? 'Expected value to be true').toBeTruthy();
@@ -368,6 +392,7 @@ class BasePageValidations {
      * @param expectedClass The class name expected to be present on the element.
      */
     async validateElementToContainClass(element, expectedClass) {
+        this.logger.info(`Validating element contains class: ${expectedClass}`);
         const classAttr = await element.getAttribute('class');
         (0, test_1.expect)(classAttr).toContain(expectedClass);
     }
@@ -377,6 +402,7 @@ class BasePageValidations {
     * @param timeout The timeout for the condition to pass.
     */
     async validateAsyncCondition(condition, timeout) {
+        this.logger.info(`Validating async condition with timeout: ${timeout}ms`);
         await (0, test_1.expect)(condition).toPass({ timeout });
     }
     /**
@@ -386,6 +412,7 @@ class BasePageValidations {
      * @param expectedValue The expected value of the CSS property.
      */
     async validateElementToHaveCSS(locator, cssProperty, expectedValue) {
+        this.logger.info(`Validating element has CSS property '${cssProperty}' with value: ${expectedValue}`);
         await (0, test_1.expect)(locator).toHaveCSS(cssProperty, expectedValue);
     }
     /**
@@ -394,6 +421,7 @@ class BasePageValidations {
      * @param expected - The expected value to compare.
      */
     async validateValueToBe(actual, expected) {
+        this.logger.info(`Validating value ${actual} to be ${expected}`);
         await (0, test_1.expect)(actual).toBe(expected);
     }
     /**
@@ -414,6 +442,7 @@ class BasePageValidations {
      * @param value Attribute value that should NOT be present
      */
     async validateElementNotToHaveAttributeValue(element, attr, value) {
+        this.logger.info(`Validating element does not have attribute '${attr}' with value '${value}'`);
         await (0, test_1.expect)(element).not.toHaveAttribute(attr, value);
     }
     /**
@@ -424,6 +453,7 @@ class BasePageValidations {
      * by checking that every layered file originates from the photo tray.
      */
     async validateValuesToContain(photoTrayFileNames, layeredFileNames) {
+        this.logger.info(`Validating ${layeredFileNames.length} layered files exist in photo tray`);
         for (const fileName of layeredFileNames) {
             await (0, test_1.expect)(photoTrayFileNames).toContain(fileName);
         }
@@ -434,6 +464,7 @@ class BasePageValidations {
      * @returns {Promise<void>} Resolves when all elements are confirmed visible.
      */
     async validateElementsToBeVisible(elements) {
+        this.logger.info(`Validating ${elements.length} elements are visible`);
         for (const element of elements) {
             await (0, test_1.expect)(element).toBeVisible();
         }
@@ -443,6 +474,7 @@ class BasePageValidations {
      * @param timeout - Optional timeout in ms (default: 10s).
      */
     async waitForElementVisible(element, timeout = 10000) {
+        this.logger.info(`Waiting for element to be visible with timeout: ${timeout}ms`);
         await element.waitFor({ state: 'visible', timeout });
     }
     /**
@@ -450,6 +482,7 @@ class BasePageValidations {
      * Accepts either locator or string ID.
      */
     async validateElementsToHaveText(locators, expectedTexts) {
+        this.logger.info(`Validating ${locators.length} elements have expected text`);
         for (let i = 0; i < locators.length; i++) {
             const locator = locators[i];
             await this.validateElementToHaveText(locator, expectedTexts[i]);
@@ -461,6 +494,7 @@ class BasePageValidations {
      * @returns {Promise<void>} Resolves when the element is confirmed disabled.
      */
     async validateElementToBeDisabled(element) {
+        this.logger.info(`Validating element is disabled: ${element}`);
         await (0, test_1.expect)(element).toBeDisabled();
     }
     /**
@@ -470,6 +504,7 @@ class BasePageValidations {
      * @returns {Promise<void>} Resolves when all elements are confirmed disabled.
      */
     async validateElementsToBeDisabled(elements) {
+        this.logger.info(`Validating ${elements.length} elements are disabled`);
         for (const el of elements) {
             await (0, test_1.expect)(el).toBeDisabled();
         }

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export * from './baseui/commonpagewaits';
 export * from './baseui/logger';
 export * from './utils/Utils';
 export * from './utils/excel/excel-utils';
+export * from './test-data';
 export * from './baseapi/baseapihelpers';
 export * from './baseapi/apiutils';
 export * from './constants/test-tags';

package/dist/index.js

@@ -27,6 +27,8 @@ __exportStar(require("./baseui/commonpagewaits"), exports);
 __exportStar(require("./baseui/logger"), exports);
 __exportStar(require("./utils/Utils"), exports);
 __exportStar(require("./utils/excel/excel-utils"), exports);
+// Test Data utilities
+__exportStar(require("./test-data"), exports);
 __exportStar(require("./baseapi/baseapihelpers"), exports);
 __exportStar(require("./baseapi/apiutils"), exports);
 __exportStar(require("./constants/test-tags"), exports);

package/dist/specs/test-data-loader.spec.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Test Data Loader Tests
+ * Validates the functionality of the test data loading utilities
+ */
+export {};

package/dist/specs/test-data-loader.spec.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * Test Data Loader Tests
+ * Validates the functionality of the test data loading utilities
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@playwright/test");
+const test_data_1 = require("../test-data");
+const path = __importStar(require("path"));
+test_1.test.describe('Test Data Loader', () => {
+    const testDataPath = path.resolve(__dirname, '../testdata/bookTripData.xlsx');
+    (0, test_1.test)('should load test data from Excel file', () => {
+        const result = (0, test_data_1.loadTestData)({
+            filePath: testDataPath,
+            sheetName: 'TripData'
+        });
+        console.log(result.message);
+        (0, test_1.expect)(result.success).toBe(true);
+        (0, test_1.expect)(result.data).toBeDefined();
+        (0, test_1.expect)(Array.isArray(result.data)).toBe(true);
+        (0, test_1.expect)(result.data.length).toBeGreaterThan(0);
+        (0, test_1.expect)(result.error).toBeUndefined();
+    });
+    (0, test_1.test)('should handle missing file gracefully', () => {
+        const result = (0, test_data_1.loadTestData)({
+            filePath: './non-existent-file.xlsx',
+            sheetName: 'TestData'
+        });
+        console.log(result.message);
+        (0, test_1.expect)(result.success).toBe(false);
+        (0, test_1.expect)(result.data.length).toBe(0);
+        (0, test_1.expect)(result.error).toBeDefined();
+        (0, test_1.expect)(result.message).toContain('Error loading test data');
+    });
+    (0, test_1.test)('should handle missing sheet name gracefully', () => {
+        const result = (0, test_data_1.loadTestData)({
+            filePath: testDataPath,
+            sheetName: 'NonExistentSheet'
+        });
+        console.log(result.message);
+        (0, test_1.expect)(result.success).toBe(false);
+        (0, test_1.expect)(result.error).toBeDefined();
+    });
+    (0, test_1.test)('should validate required file path', () => {
+        const result = (0, test_data_1.loadTestData)({
+            filePath: '',
+            sheetName: 'TestData'
+        });
+        (0, test_1.expect)(result.success).toBe(false);
+        (0, test_1.expect)(result.error).toBe('File path is required');
+        (0, test_1.expect)(result.message).toContain('No file path provided');
+    });
+    (0, test_1.test)('should validate required sheet name', () => {
+        const result = (0, test_data_1.loadTestData)({
+            filePath: testDataPath,
+            sheetName: ''
+        });
+        (0, test_1.expect)(result.success).toBe(false);
+        (0, test_1.expect)(result.error).toBe('Sheet name is required');
+        (0, test_1.expect)(result.message).toContain('No sheet name provided');
+    });
+    (0, test_1.test)('should deduplicate test data when requested', () => {
+        const result = (0, test_data_1.loadTestData)({
+            filePath: testDataPath,
+            sheetName: 'TripData',
+            deduplicate: true
+        });
+        console.log(result.message);
+        (0, test_1.expect)(result.success).toBe(true);
+        // Check for unique test case IDs
+        const testCaseIds = result.data.map(d => d.testcaseid).filter(Boolean);
+        const uniqueIds = new Set(testCaseIds);
+        (0, test_1.expect)(testCaseIds.length).toBe(uniqueIds.size);
+    });
+    (0, test_1.test)('should load data without deduplication by default', () => {
+        const result = (0, test_data_1.loadTestData)({
+            filePath: testDataPath,
+            sheetName: 'TripData'
+        });
+        (0, test_1.expect)(result.success).toBe(true);
+        (0, test_1.expect)(result.data.length).toBeGreaterThan(0);
+    });
+});
+test_1.test.describe('Test Data Validation', () => {
+    (0, test_1.test)('should validate test data with required fields', () => {
+        const testData = [
+            { testcaseid: 'TC001', name: 'Test 1' },
+            { testcaseid: 'TC002', name: 'Test 2' }
+        ];
+        const errors = (0, test_data_1.validateTestData)(testData, ['testcaseid', 'name']);
+        (0, test_1.expect)(errors.length).toBe(0);
+    });
+    (0, test_1.test)('should detect missing required fields', () => {
+        const testData = [
+            { testcaseid: 'TC001' }, // missing 'name'
+            { testcaseid: 'TC002', name: 'Test 2' }
+        ];
+        const errors = (0, test_data_1.validateTestData)(testData, ['testcaseid', 'name']);
+        (0, test_1.expect)(errors.length).toBeGreaterThan(0);
+        (0, test_1.expect)(errors[0]).toContain('missing required field: name');
+    });
+    (0, test_1.test)('should handle empty data array', () => {
+        const errors = (0, test_data_1.validateTestData)([], ['testcaseid']);
+        (0, test_1.expect)(errors.length).toBe(1);
+        (0, test_1.expect)(errors[0]).toBe('Test data array is empty');
+    });
+    (0, test_1.test)('should handle non-array input', () => {
+        const errors = (0, test_data_1.validateTestData)({}, ['testcaseid']);
+        (0, test_1.expect)(errors.length).toBe(1);
+        (0, test_1.expect)(errors[0]).toBe('Test data must be an array');
+    });
+    (0, test_1.test)('should detect non-object records', () => {
+        const testData = [
+            { testcaseid: 'TC001' },
+            'invalid',
+            { testcaseid: 'TC003' }
+        ];
+        const errors = (0, test_data_1.validateTestData)(testData, ['testcaseid']);
+        (0, test_1.expect)(errors.length).toBeGreaterThan(0);
+        (0, test_1.expect)(errors.some(e => e.includes('not an object'))).toBe(true);
+    });
+});
+test_1.test.describe('Test Data Deduplication', () => {
+    (0, test_1.test)('should remove duplicate test cases', () => {
+        const testData = [
+            { testcaseid: 'TC001', value: 'first' },
+            { testcaseid: 'TC002', value: 'second' },
+            { testcaseid: 'TC001', value: 'duplicate' }, // duplicate
+            { testcaseid: 'TC003', value: 'third' }
+        ];
+        const { data, stats } = (0, test_data_1.deduplicateTestData)(testData);
+        (0, test_1.expect)(data.length).toBe(3);
+        (0, test_1.expect)(stats.originalCount).toBe(4);
+        (0, test_1.expect)(stats.deduplicatedCount).toBe(3);
+        (0, test_1.expect)(stats.removedCount).toBe(1);
+        // Should keep first occurrence
+        const tc001 = data.find(d => d.testcaseid === 'TC001');
+        (0, test_1.expect)(tc001?.value).toBe('first');
+    });
+    (0, test_1.test)('should handle different test case ID field names', () => {
+        const testData = [
+            { TestCaseId: 'TC001', value: 'first' },
+            { TestCaseId: 'TC002', value: 'second' },
+            { TestCaseId: 'TC001', value: 'duplicate' }
+        ];
+        const { data, stats } = (0, test_data_1.deduplicateTestData)(testData, ['TestCaseId']);
+        (0, test_1.expect)(data.length).toBe(2);
+        (0, test_1.expect)(stats.removedCount).toBe(1);
+    });
+    (0, test_1.test)('should handle records without test case IDs', () => {
+        const testData = [
+            { testcaseid: 'TC001', value: 'first' },
+            { value: 'no id' }, // no test case ID
+            { testcaseid: 'TC002', value: 'second' }
+        ];
+        const { data, stats } = (0, test_data_1.deduplicateTestData)(testData);
+        (0, test_1.expect)(data.length).toBe(3); // All records kept
+        (0, test_1.expect)(stats.removedCount).toBe(0);
+    });
+    (0, test_1.test)('should return correct statistics for no duplicates', () => {
+        const testData = [
+            { testcaseid: 'TC001' },
+            { testcaseid: 'TC002' },
+            { testcaseid: 'TC003' }
+        ];
+        const { data, stats } = (0, test_data_1.deduplicateTestData)(testData);
+        (0, test_1.expect)(data.length).toBe(3);
+        (0, test_1.expect)(stats.originalCount).toBe(3);
+        (0, test_1.expect)(stats.deduplicatedCount).toBe(3);
+        (0, test_1.expect)(stats.removedCount).toBe(0);
+    });
+});

package/dist/test-data/deduplicator.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Test Data Deduplication Utilities
+ * Provides functions for removing duplicate test cases based on test case IDs
+ */
+import { DeduplicationStats } from './types';
+/**
+ * Deduplicates test data based on test case ID
+ * Keeps the first occurrence of each unique test case ID
+ *
+ * @param data - Array of test data records
+ * @param testCaseIdFields - Field names to check for test case ID
+ * @returns Object containing deduplicated data and statistics
+ *
+ * @example
+ * ```typescript
+ * const { data, stats } = deduplicateTestData(testData, ['testcaseid']);
+ * console.log(`Removed ${stats.removedCount} duplicates`);
+ * ```
+ */
+export declare function deduplicateTestData<T = any>(data: T[], testCaseIdFields?: string[]): {
+    data: T[];
+    stats: DeduplicationStats;
+};

package/dist/test-data/deduplicator.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Test Data Deduplication Utilities
+ * Provides functions for removing duplicate test cases based on test case IDs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduplicateTestData = deduplicateTestData;
+/**
+ * Deduplicates test data based on test case ID
+ * Keeps the first occurrence of each unique test case ID
+ *
+ * @param data - Array of test data records
+ * @param testCaseIdFields - Field names to check for test case ID
+ * @returns Object containing deduplicated data and statistics
+ *
+ * @example
+ * ```typescript
+ * const { data, stats } = deduplicateTestData(testData, ['testcaseid']);
+ * console.log(`Removed ${stats.removedCount} duplicates`);
+ * ```
+ */
+function deduplicateTestData(data, testCaseIdFields = ['testcaseid', 'testCaseId', 'TestCaseId']) {
+    const seen = new Set();
+    const deduplicated = [];
+    for (const record of data) {
+        // Try different possible test case ID property names
+        let testCaseId;
+        for (const field of testCaseIdFields) {
+            if (record[field]) {
+                testCaseId = String(record[field]);
+                break;
+            }
+        }
+        if (testCaseId) {
+            if (!seen.has(testCaseId)) {
+                seen.add(testCaseId);
+                deduplicated.push(record);
+            }
+        }
+        else {
+            // If no test case ID found, include the record
+            deduplicated.push(record);
+        }
+    }
+    const stats = {
+        originalCount: data.length,
+        deduplicatedCount: deduplicated.length,
+        removedCount: data.length - deduplicated.length
+    };
+    return { data: deduplicated, stats };
+}

package/dist/test-data/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Test Data Module
+ * Provides utilities for loading, processing, and validating test data from Excel files
+ */
+export { loadTestData, validateTestData } from './loader';
+export { deduplicateTestData } from './deduplicator';
+export type { TestDataLoaderOptions, TestDataResult, DeduplicationStats } from './types';

package/dist/test-data/index.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Test Data Module
+ * Provides utilities for loading, processing, and validating test data from Excel files
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduplicateTestData = exports.validateTestData = exports.loadTestData = void 0;
+// Public API exports
+var loader_1 = require("./loader");
+Object.defineProperty(exports, "loadTestData", { enumerable: true, get: function () { return loader_1.loadTestData; } });
+Object.defineProperty(exports, "validateTestData", { enumerable: true, get: function () { return loader_1.validateTestData; } });
+var deduplicator_1 = require("./deduplicator");
+Object.defineProperty(exports, "deduplicateTestData", { enumerable: true, get: function () { return deduplicator_1.deduplicateTestData; } });

package/dist/test-data/loader.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Test Data Loader
+ * Provides utilities for loading and validating test data from Excel files
+ */
+import { TestDataLoaderOptions, TestDataResult } from './types';
+/**
+ * Loads test data from an Excel file with proper error handling and data processing
+ *
+ * @template T - The type of test data records
+ * @param options - Configuration options for loading test data
+ * @returns TestDataResult containing the loaded data and status information
+ *
+ * @example
+ * ```typescript
+ * const result = loadTestData<TripData>({
+ *   filePath: process.env.BOOK_TRIP_DATA_PATH!,
+ *   sheetName: 'TripData',
+ *   deduplicate: true
+ * });
+ *
+ * if (result.success) {
+ *   result.data.forEach((testCase) => {
+ *     // Use test case data
+ *   });
+ * }
+ * ```
+ */
+export declare function loadTestData<T = any>(options: TestDataLoaderOptions): TestDataResult<T>;
+/**
+ * Validates test data structure and returns validation errors
+ *
+ * @param data - Test data to validate
+ * @param requiredFields - Array of required field names
+ * @returns Array of validation error messages (empty if valid)
+ *
+ * @example
+ * ```typescript
+ * const errors = validateTestData(testData, ['testcaseid', 'description']);
+ * if (errors.length > 0) {
+ *   console.error('Validation errors:', errors);
+ * }
+ * ```
+ */
+export declare function validateTestData<T = any>(data: T[], requiredFields: string[]): string[];

package/dist/test-data/loader.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Test Data Loader
+ * Provides utilities for loading and validating test data from Excel files
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTestData = loadTestData;
+exports.validateTestData = validateTestData;
+const excel_utils_1 = require("../utils/excel/excel-utils");
+const deduplicator_1 = require("./deduplicator");
+/**
+ * Loads test data from an Excel file with proper error handling and data processing
+ *
+ * @template T - The type of test data records
+ * @param options - Configuration options for loading test data
+ * @returns TestDataResult containing the loaded data and status information
+ *
+ * @example
+ * ```typescript
+ * const result = loadTestData<TripData>({
+ *   filePath: process.env.BOOK_TRIP_DATA_PATH!,
+ *   sheetName: 'TripData',
+ *   deduplicate: true
+ * });
+ *
+ * if (result.success) {
+ *   result.data.forEach((testCase) => {
+ *     // Use test case data
+ *   });
+ * }
+ * ```
+ */
+function loadTestData(options) {
+    const { filePath, sheetName, testCaseId, deduplicate = false, testCaseIdFields = ['testcaseid', 'testCaseId', 'TestCaseId'] } = options;
+    try {
+        // Validate inputs
+        if (!filePath) {
+            return {
+                data: [],
+                success: false,
+                error: 'File path is required',
+                message: '✗ No file path provided'
+            };
+        }
+        if (!sheetName) {
+            return {
+                data: [],
+                success: false,
+                error: 'Sheet name is required',
+                message: '✗ No sheet name provided'
+            };
+        }
+        // Load data from Excel
+        const rawData = (0, excel_utils_1.getTestDataFromExcel)(filePath, sheetName, testCaseId);
+        // Process the data based on its structure
+        let processedData = [];
+        if (typeof rawData === 'object' && !Array.isArray(rawData)) {
+            // GroupedTestData: { "C12345": [...], "C12346": [...] }
+            processedData = Object.values(rawData).flat();
+        }
+        else if (Array.isArray(rawData)) {
+            // Already an array
+            processedData = rawData;
+        }
+        else {
+            return {
+                data: [],
+                success: false,
+                error: 'Unexpected data structure returned from Excel',
+                message: '✗ Invalid data structure in Excel file',
+                rawData
+            };
+        }
+        // Deduplicate if requested
+        if (deduplicate && processedData.length > 0) {
+            const { data, stats } = (0, deduplicator_1.deduplicateTestData)(processedData, testCaseIdFields);
+            processedData = data;
+            if (stats.removedCount > 0) {
+                console.log(`  ℹ Removed ${stats.removedCount} duplicate test case(s)`);
+            }
+        }
+        // Return result
+        if (processedData.length === 0) {
+            return {
+                data: [],
+                success: false,
+                error: 'No data found in Excel file',
+                message: `⚠ No test data found in sheet "${sheetName}"`,
+                rawData
+            };
+        }
+        return {
+            data: processedData,
+            success: true,
+            message: `✓ Loaded ${processedData.length} test case(s) from Excel file`
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            data: [],
+            success: false,
+            error: errorMessage,
+            message: `✗ Error loading test data: ${errorMessage}`
+        };
+    }
+}
+/**
+ * Validates test data structure and returns validation errors
+ *
+ * @param data - Test data to validate
+ * @param requiredFields - Array of required field names
+ * @returns Array of validation error messages (empty if valid)
+ *
+ * @example
+ * ```typescript
+ * const errors = validateTestData(testData, ['testcaseid', 'description']);
+ * if (errors.length > 0) {
+ *   console.error('Validation errors:', errors);
+ * }
+ * ```
+ */
+function validateTestData(data, requiredFields) {
+    const errors = [];
+    if (!Array.isArray(data)) {
+        errors.push('Test data must be an array');
+        return errors;
+    }
+    if (data.length === 0) {
+        errors.push('Test data array is empty');
+        return errors;
+    }
+    // Check each record for required fields
+    data.forEach((record, index) => {
+        if (typeof record !== 'object' || record === null) {
+            errors.push(`Record at index ${index} is not an object`);
+            return;
+        }
+        requiredFields.forEach((field) => {
+            if (!(field in record)) {
+                errors.push(`Record at index ${index} is missing required field: ${field}`);
+            }
+        });
+    });
+    return errors;
+}

package/dist/test-data/types.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Test Data Loading Types
+ * Provides type-safe interfaces for loading and managing test data from Excel files
+ */
+/**
+ * Options for loading test data from Excel files
+ */
+export interface TestDataLoaderOptions {
+    /** Path to the Excel file */
+    filePath: string;
+    /** Sheet name to read from */
+    sheetName: string;
+    /** Optional test case ID to filter by */
+    testCaseId?: string;
+    /** Whether to deduplicate data based on test case ID (default: false) */
+    deduplicate?: boolean;
+    /** Optional custom test case ID field names (default: ['testcaseid', 'testCaseId', 'TestCaseId']) */
+    testCaseIdFields?: string[];
+}
+/**
+ * Result of loading test data
+ */
+export interface TestDataResult<T> {
+    /** Array of test data records */
+    data: T[];
+    /** Whether data was loaded successfully */
+    success: boolean;
+    /** Error message if loading failed */
+    error?: string;
+    /** Information message about the load operation */
+    message: string;
+    /** Original raw data structure (for debugging) */
+    rawData?: any;
+}
+/**
+ * Deduplication statistics
+ */
+export interface DeduplicationStats {
+    /** Number of records before deduplication */
+    originalCount: number;
+    /** Number of records after deduplication */
+    deduplicatedCount: number;
+    /** Number of duplicates removed */
+    removedCount: number;
+}

package/dist/test-data/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Test Data Loading Types
+ * Provides type-safe interfaces for loading and managing test data from Excel files
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/Utils.d.ts

@@ -95,14 +95,16 @@ export declare function generateRandomFutureDate(): {
  *  └────────┴────────────────────────────┘
  *
  * @examples
- *  getDate("YYYY-MM-DD hh:mm:ss") → "2025-11-03 04:05:09"
- *  getDate("YYYY-M-D h:m:s")     → "2025-11-3 4:5:9"
- *  getDate("D/M/YYYY")           → "3/11/2025"
+ *  getDate("YYYY-MM-DD")                  → "2025-11-03"
+ *  getDate("YYYY-MM-DD", "3d")            → "2025-11-06" (3 days in the future)
+ *  getDate("YYYY-MM-DD", "-1m")           → "2025-10-03" (1 month in the past)
+ *  getDate("D/M/YYYY", "1y")              → "3/11/2026" (1 year in the future)
  *
  * @param format - (Optional) The desired date format string. Defaults to "YYYY-MM-DD".
+ * @param adjustment - (Optional) A string to adjust the date (e.g., "3d", "-2m", "1y").
  * @returns A formatted date/time string.
  */
-export declare function getDate(format?: string): string;
+export declare function getDate(format?: string, adjustment?: string): string;
 /**
  * Normalizes a date input to a timestamp (ms since epoch).
  * - If input is a string, it will be parsed with Date.parse().

package/dist/utils/Utils.js

@@ -178,15 +178,34 @@ function generateRandomFutureDate() {
  *  └────────┴────────────────────────────┘
  *
  * @examples
- *  getDate("YYYY-MM-DD hh:mm:ss") → "2025-11-03 04:05:09"
- *  getDate("YYYY-M-D h:m:s")     → "2025-11-3 4:5:9"
- *  getDate("D/M/YYYY")           → "3/11/2025"
+ *  getDate("YYYY-MM-DD")                  → "2025-11-03"
+ *  getDate("YYYY-MM-DD", "3d")            → "2025-11-06" (3 days in the future)
+ *  getDate("YYYY-MM-DD", "-1m")           → "2025-10-03" (1 month in the past)
+ *  getDate("D/M/YYYY", "1y")              → "3/11/2026" (1 year in the future)
  *
  * @param format - (Optional) The desired date format string. Defaults to "YYYY-MM-DD".
+ * @param adjustment - (Optional) A string to adjust the date (e.g., "3d", "-2m", "1y").
  * @returns A formatted date/time string.
  */
-function getDate(format = "YYYY-MM-DD") {
+function getDate(format = "YYYY-MM-DD", adjustment) {
     const date = new Date();
+    if (adjustment) {
+        const match = adjustment.match(/([+-]?)(\d+)([dmy])/);
+        if (match) {
+            const sign = match[1] === "-" ? -1 : 1;
+            const amount = parseInt(match[2], 10);
+            const unit = match[3];
+            if (unit === "d") {
+                date.setDate(date.getDate() + amount * sign);
+            }
+            else if (unit === "m") {
+                date.setMonth(date.getMonth() + amount * sign);
+            }
+            else if (unit === "y") {
+                date.setFullYear(date.getFullYear() + amount * sign);
+            }
+        }
+    }
     const parts = {
         YYYY: date.getFullYear().toString(),
         M: (date.getMonth() + 1).toString(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "transit-core-taf",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "Transit Core Automation Framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,6 +9,7 @@
   ],
   "exports": {
     ".": "./dist/index.js",
+    "./test-data": "./dist/test-data/index.js",
     "./dist/reporters/testrail-reporter": "./dist/reporters/testrail-reporter.js"
   },
   "devDependencies": {