testchimp-runner-core 0.0.87 → 0.0.89

package/dist/utils/test-file-parser.js

@@ -0,0 +1,702 @@
+"use strict";
+/**
+ * Utilities for parsing test files to extract hooks and tests
+ * Supports Playwright hooks: test.beforeAll, test.afterAll, test.beforeEach, test.afterEach
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestFileParser = void 0;
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const t = __importStar(require("@babel/types"));
+const generator_1 = __importDefault(require("@babel/generator"));
+class TestFileParser {
+    /**
+     * Generate full test name with suite prefix
+     * @param suitePath - Array of suite names from root to current suite
+     * @param testName - Original test name
+     * @returns Full test name with suite prefix (e.g., "LoginSuite__testLogin")
+     */
+    static generateTestFullName(suitePath, testName) {
+        if (suitePath.length === 0) {
+            return testName;
+        }
+        return `${suitePath.join('__')}__${testName}`;
+    }
+    /**
+     * Find all parent describe blocks for a given AST path
+     * @param path - Babel AST path
+     * @returns Array of suite names from root to current (empty if not in any describe block)
+     */
+    static findSuitePath(path) {
+        const suitePath = [];
+        let currentPath = path.parentPath;
+        while (currentPath) {
+            // Check if current path is a test.describe() call
+            if (currentPath.isCallExpression()) {
+                const callee = currentPath.node.callee;
+                if (t.isMemberExpression(callee)) {
+                    const object = callee.object;
+                    const property = callee.property;
+                    if (t.isIdentifier(object) && object.name === 'test' &&
+                        t.isIdentifier(property) && property.name === 'describe') {
+                        // Extract suite name from first argument
+                        if (currentPath.node.arguments.length >= 1) {
+                            const suiteNameArg = currentPath.node.arguments[0];
+                            let suiteName = null;
+                            if (t.isStringLiteral(suiteNameArg)) {
+                                suiteName = suiteNameArg.value;
+                            }
+                            else if (t.isTemplateLiteral(suiteNameArg)) {
+                                if (suiteNameArg.quasis.length > 0) {
+                                    suiteName = suiteNameArg.quasis[0].value.raw;
+                                }
+                            }
+                            if (suiteName) {
+                                suitePath.unshift(suiteName); // Add to beginning (root first)
+                            }
+                        }
+                    }
+                }
+            }
+            currentPath = currentPath.parentPath;
+        }
+        return suitePath;
+    }
+    /**
+     * Parse a test file to extract hooks and tests, supporting test.describe() blocks
+     * @param script - The test file content
+     * @param testNames - Optional array of test names to filter (supports both original names and full names with suite prefix)
+     * @returns Parsed structure with hooks and tests
+     */
+    static parseTestFile(script, testNames) {
+        const result = {
+            fileHooks: {
+                beforeAll: [],
+                afterAll: [],
+                beforeEach: [],
+                afterEach: []
+            },
+            tests: [],
+            suites: []
+        };
+        try {
+            // Parse the script with Babel
+            const ast = (0, parser_1.parse)(script, {
+                sourceType: 'module',
+                plugins: ['typescript', 'classProperties', 'decorators-legacy'],
+                allowImportExportEverywhere: true
+            });
+            // Track if we should filter tests
+            const shouldFilter = testNames && testNames.length > 0;
+            const testNameSet = shouldFilter ? new Set(testNames.map(name => name.trim())) : null;
+            // Map to store suites by their path (for nested suite tracking)
+            const suiteMap = new Map();
+            /**
+             * Recursively parse a suite (describe block) and its nested suites
+             */
+            const parseSuite = (describePath, parentSuitePath) => {
+                if (!describePath.isCallExpression()) {
+                    return null;
+                }
+                const callee = describePath.node.callee;
+                if (!t.isMemberExpression(callee)) {
+                    return null;
+                }
+                const object = callee.object;
+                const property = callee.property;
+                if (!t.isIdentifier(object) || object.name !== 'test' ||
+                    !t.isIdentifier(property) || property.name !== 'describe') {
+                    return null;
+                }
+                // Extract suite name
+                if (describePath.node.arguments.length < 2) {
+                    return null;
+                }
+                const suiteNameArg = describePath.node.arguments[0];
+                let suiteName = null;
+                if (t.isStringLiteral(suiteNameArg)) {
+                    suiteName = suiteNameArg.value;
+                }
+                else if (t.isTemplateLiteral(suiteNameArg)) {
+                    if (suiteNameArg.quasis.length > 0) {
+                        suiteName = suiteNameArg.quasis[0].value.raw;
+                    }
+                }
+                if (!suiteName) {
+                    return null;
+                }
+                // Build current suite path
+                const currentSuitePath = [...parentSuitePath, suiteName];
+                const suitePathKey = currentSuitePath.join('__');
+                // Check if suite already exists (shouldn't happen, but safety check)
+                if (suiteMap.has(suitePathKey)) {
+                    return suiteMap.get(suitePathKey);
+                }
+                // Create new suite
+                const suite = {
+                    name: suiteName,
+                    suitePath: currentSuitePath,
+                    beforeAll: [],
+                    afterAll: [],
+                    beforeEach: [],
+                    afterEach: [],
+                    tests: [],
+                    nestedSuites: []
+                };
+                suiteMap.set(suitePathKey, suite);
+                // Get callback function (second argument)
+                const callback = describePath.node.arguments[1];
+                if (!t.isFunctionExpression(callback) && !t.isArrowFunctionExpression(callback)) {
+                    return suite;
+                }
+                // Traverse the callback body to find hooks, tests, and nested describe blocks
+                const callbackBody = callback.body;
+                if (!t.isBlockStatement(callbackBody)) {
+                    return suite;
+                }
+                // Traverse the suite's callback body
+                // Traverse the block statement directly - Babel can handle this
+                (0, traverse_1.default)(callbackBody, {
+                    CallExpression(path) {
+                        const callee = path.node.callee;
+                        // Check for test.beforeAll, test.afterAll, test.beforeEach, test.afterEach
+                        if (t.isMemberExpression(callee)) {
+                            const object = callee.object;
+                            const property = callee.property;
+                            if (t.isIdentifier(object) && object.name === 'test' && t.isIdentifier(property)) {
+                                const hookName = property.name;
+                                // Check if this is a hook
+                                if (hookName === 'beforeAll' || hookName === 'afterAll' ||
+                                    hookName === 'beforeEach' || hookName === 'afterEach') {
+                                    // Get the callback function
+                                    if (path.node.arguments.length >= 1) {
+                                        const hookCallback = path.node.arguments[0];
+                                        if (t.isFunctionExpression(hookCallback) || t.isArrowFunctionExpression(hookCallback)) {
+                                            let hookBody;
+                                            if (t.isBlockStatement(hookCallback.body)) {
+                                                hookBody = (0, generator_1.default)(hookCallback.body, { comments: false }).code;
+                                            }
+                                            else {
+                                                const exprCode = (0, generator_1.default)(hookCallback.body, { comments: false }).code;
+                                                hookBody = `{ return ${exprCode}; }`;
+                                            }
+                                            const hook = {
+                                                code: hookBody,
+                                                name: hookName,
+                                                suitePath: currentSuitePath,
+                                                scope: 'suite'
+                                            };
+                                            // Add to suite's appropriate array
+                                            if (hookName === 'beforeAll') {
+                                                suite.beforeAll.push(hook);
+                                            }
+                                            else if (hookName === 'afterAll') {
+                                                suite.afterAll.push(hook);
+                                            }
+                                            else if (hookName === 'beforeEach') {
+                                                suite.beforeEach.push(hook);
+                                            }
+                                            else if (hookName === 'afterEach') {
+                                                suite.afterEach.push(hook);
+                                            }
+                                        }
+                                    }
+                                    return;
+                                }
+                            }
+                        }
+                        // Check for test() calls
+                        if (t.isIdentifier(callee) && callee.name === 'test') {
+                            if (path.node.arguments.length >= 2) {
+                                const testNameArg = path.node.arguments[0];
+                                const testCallback = path.node.arguments[1];
+                                // Extract test name
+                                let testName = null;
+                                if (t.isStringLiteral(testNameArg)) {
+                                    testName = testNameArg.value;
+                                }
+                                else if (t.isTemplateLiteral(testNameArg)) {
+                                    if (testNameArg.quasis.length > 0) {
+                                        testName = testNameArg.quasis[0].value.raw;
+                                    }
+                                }
+                                if (testName) {
+                                    const fullName = TestFileParser.generateTestFullName(currentSuitePath, testName);
+                                    // Filter tests if testNames provided (support both original and full names)
+                                    if (shouldFilter && testNameSet) {
+                                        if (!testNameSet.has(testName) && !testNameSet.has(fullName)) {
+                                            return; // Skip this test
+                                        }
+                                    }
+                                    // Extract test body
+                                    if (t.isFunctionExpression(testCallback) || t.isArrowFunctionExpression(testCallback)) {
+                                        let testBody;
+                                        let statements;
+                                        if (t.isBlockStatement(testCallback.body)) {
+                                            testBody = (0, generator_1.default)(testCallback.body, { comments: false }).code;
+                                            // Extract ALL statements from BlockStatement.body (includes variables)
+                                            const bodyStatements = testCallback.body.body;
+                                            statements = bodyStatements.map((stmt, index) => {
+                                                const code = (0, generator_1.default)(stmt, { comments: false }).code;
+                                                const isVar = t.isVariableDeclaration(stmt);
+                                                // Extract intent comment (leading comment, exclude @Screen/@State)
+                                                let intentComment;
+                                                if (stmt.leadingComments && stmt.leadingComments.length > 0) {
+                                                    for (const comment of stmt.leadingComments) {
+                                                        const commentText = comment.value.trim();
+                                                        if (!commentText.includes('@Screen') && !commentText.includes('@State')) {
+                                                            intentComment = commentText;
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                                // Extract screen-state annotation (trailing or next statement's leading)
+                                                let screenStateAnnotation;
+                                                if (stmt.trailingComments && stmt.trailingComments.length > 0) {
+                                                    for (const comment of stmt.trailingComments) {
+                                                        const commentText = comment.value.trim();
+                                                        if (commentText.includes('@Screen') || commentText.includes('@State')) {
+                                                            screenStateAnnotation = commentText;
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                                // Fallback: check next statement's leading @Screen/@State comment
+                                                if (!screenStateAnnotation && index + 1 < bodyStatements.length) {
+                                                    const nextStmt = bodyStatements[index + 1];
+                                                    if (nextStmt.leadingComments && nextStmt.leadingComments.length > 0) {
+                                                        for (const comment of nextStmt.leadingComments) {
+                                                            const commentText = comment.value.trim();
+                                                            if (commentText.includes('@Screen') || commentText.includes('@State')) {
+                                                                screenStateAnnotation = commentText;
+                                                                break;
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                                return { code, isVariableDeclaration: isVar, intentComment, screenStateAnnotation };
+                                            });
+                                        }
+                                        else {
+                                            // Expression body - single statement
+                                            const exprCode = (0, generator_1.default)(testCallback.body, { comments: false }).code;
+                                            testBody = `{ return ${exprCode}; }`;
+                                            statements = [{
+                                                    code: exprCode,
+                                                    isVariableDeclaration: false
+                                                }];
+                                        }
+                                        suite.tests.push({
+                                            name: testName,
+                                            code: testBody,
+                                            suitePath: currentSuitePath,
+                                            fullName: fullName,
+                                            statements: statements
+                                        });
+                                    }
+                                }
+                            }
+                            return;
+                        }
+                        // Check for nested test.describe() calls
+                        if (t.isMemberExpression(callee)) {
+                            const object = callee.object;
+                            const property = callee.property;
+                            if (t.isIdentifier(object) && object.name === 'test' &&
+                                t.isIdentifier(property) && property.name === 'describe') {
+                                // This is a nested describe block - parse it recursively
+                                const nestedSuite = parseSuite(path, currentSuitePath);
+                                if (nestedSuite) {
+                                    suite.nestedSuites.push(nestedSuite);
+                                }
+                                return;
+                            }
+                        }
+                    }
+                });
+                return suite;
+            };
+            // Traverse the AST to find top-level hooks, tests, and describe blocks
+            (0, traverse_1.default)(ast, {
+                CallExpression(path) {
+                    const callee = path.node.callee;
+                    // Check for test.describe() at top level
+                    if (t.isMemberExpression(callee)) {
+                        const object = callee.object;
+                        const property = callee.property;
+                        if (t.isIdentifier(object) && object.name === 'test' &&
+                            t.isIdentifier(property) && property.name === 'describe') {
+                            // Check if this is at the top level (not nested in another describe)
+                            const suitePath = TestFileParser.findSuitePath(path);
+                            if (suitePath.length === 0) {
+                                // This is a top-level describe block
+                                const suite = parseSuite(path, []);
+                                if (suite) {
+                                    result.suites.push(suite);
+                                }
+                            }
+                            return;
+                        }
+                    }
+                    // Check for file-level hooks (test.beforeAll, etc.) - not inside any describe block
+                    if (t.isMemberExpression(callee)) {
+                        const object = callee.object;
+                        const property = callee.property;
+                        if (t.isIdentifier(object) && object.name === 'test' && t.isIdentifier(property)) {
+                            const hookName = property.name;
+                            if (hookName === 'beforeAll' || hookName === 'afterAll' ||
+                                hookName === 'beforeEach' || hookName === 'afterEach') {
+                                // Check if this hook is at file level (not inside any describe block)
+                                const suitePath = TestFileParser.findSuitePath(path);
+                                if (suitePath.length === 0) {
+                                    // This is a file-level hook
+                                    if (path.node.arguments.length >= 1) {
+                                        const callback = path.node.arguments[0];
+                                        if (t.isFunctionExpression(callback) || t.isArrowFunctionExpression(callback)) {
+                                            let hookBody;
+                                            if (t.isBlockStatement(callback.body)) {
+                                                hookBody = (0, generator_1.default)(callback.body, { comments: false }).code;
+                                            }
+                                            else {
+                                                const exprCode = (0, generator_1.default)(callback.body, { comments: false }).code;
+                                                hookBody = `{ return ${exprCode}; }`;
+                                            }
+                                            const hook = {
+                                                code: hookBody,
+                                                name: hookName,
+                                                suitePath: [],
+                                                scope: 'file'
+                                            };
+                                            // Add to appropriate array
+                                            if (hookName === 'beforeAll') {
+                                                result.fileHooks.beforeAll.push(hook);
+                                            }
+                                            else if (hookName === 'afterAll') {
+                                                result.fileHooks.afterAll.push(hook);
+                                            }
+                                            else if (hookName === 'beforeEach') {
+                                                result.fileHooks.beforeEach.push(hook);
+                                            }
+                                            else if (hookName === 'afterEach') {
+                                                result.fileHooks.afterEach.push(hook);
+                                            }
+                                        }
+                                    }
+                                }
+                                return;
+                            }
+                        }
+                    }
+                    // Check for file-level test() calls (not inside any describe block)
+                    if (t.isIdentifier(callee) && callee.name === 'test') {
+                        // Check if this test is at file level
+                        const suitePath = TestFileParser.findSuitePath(path);
+                        if (suitePath.length === 0) {
+                            // This is a file-level test
+                            if (path.node.arguments.length >= 2) {
+                                const testNameArg = path.node.arguments[0];
+                                const testCallback = path.node.arguments[1];
+                                // Extract test name
+                                let testName = null;
+                                if (t.isStringLiteral(testNameArg)) {
+                                    testName = testNameArg.value;
+                                }
+                                else if (t.isTemplateLiteral(testNameArg)) {
+                                    if (testNameArg.quasis.length > 0) {
+                                        testName = testNameArg.quasis[0].value.raw;
+                                    }
+                                }
+                                if (testName) {
+                                    const fullName = TestFileParser.generateTestFullName([], testName);
+                                    // Filter tests if testNames provided
+                                    if (shouldFilter && testNameSet) {
+                                        if (!testNameSet.has(testName) && !testNameSet.has(fullName)) {
+                                            return; // Skip this test
+                                        }
+                                    }
+                                    // Extract test body
+                                    if (t.isFunctionExpression(testCallback) || t.isArrowFunctionExpression(testCallback)) {
+                                        let testBody;
+                                        let statements;
+                                        if (t.isBlockStatement(testCallback.body)) {
+                                            testBody = (0, generator_1.default)(testCallback.body, { comments: false }).code;
+                                            // Extract ALL statements from BlockStatement.body (includes variables)
+                                            const bodyStatements = testCallback.body.body;
+                                            statements = bodyStatements.map((stmt, index) => {
+                                                const code = (0, generator_1.default)(stmt, { comments: false }).code;
+                                                const isVar = t.isVariableDeclaration(stmt);
+                                                // Extract intent comment (leading comment, exclude @Screen/@State)
+                                                let intentComment;
+                                                if (stmt.leadingComments && stmt.leadingComments.length > 0) {
+                                                    for (const comment of stmt.leadingComments) {
+                                                        const commentText = comment.value.trim();
+                                                        if (!commentText.includes('@Screen') && !commentText.includes('@State')) {
+                                                            intentComment = commentText;
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                                // Extract screen-state annotation (trailing or next statement's leading)
+                                                let screenStateAnnotation;
+                                                if (stmt.trailingComments && stmt.trailingComments.length > 0) {
+                                                    for (const comment of stmt.trailingComments) {
+                                                        const commentText = comment.value.trim();
+                                                        if (commentText.includes('@Screen') || commentText.includes('@State')) {
+                                                            screenStateAnnotation = commentText;
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                                // Fallback: check next statement's leading @Screen/@State comment
+                                                if (!screenStateAnnotation && index + 1 < bodyStatements.length) {
+                                                    const nextStmt = bodyStatements[index + 1];
+                                                    if (nextStmt.leadingComments && nextStmt.leadingComments.length > 0) {
+                                                        for (const comment of nextStmt.leadingComments) {
+                                                            const commentText = comment.value.trim();
+                                                            if (commentText.includes('@Screen') || commentText.includes('@State')) {
+                                                                screenStateAnnotation = commentText;
+                                                                break;
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                                return { code, isVariableDeclaration: isVar, intentComment, screenStateAnnotation };
+                                            });
+                                        }
+                                        else {
+                                            // Expression body - single statement
+                                            const exprCode = (0, generator_1.default)(testCallback.body, { comments: false }).code;
+                                            testBody = `{ return ${exprCode}; }`;
+                                            statements = [{
+                                                    code: exprCode,
+                                                    isVariableDeclaration: false
+                                                }];
+                                        }
+                                        result.tests.push({
+                                            name: testName,
+                                            code: testBody,
+                                            suitePath: [],
+                                            fullName: fullName,
+                                            statements: statements
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to parse test file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return result;
+    }
+    /**
+     * Flatten suite structure into execution-ready format
+     * Separates per-test hooks (beforeEach/afterEach) from per-suite hooks (beforeAll/afterAll)
+     * @param parsed - Parsed test file structure
+     * @returns Flattened structure ready for execution
+     */
+    static flattenForExecution(parsed) {
+        const result = {
+            fileLevelHooks: {
+                beforeAll: parsed.fileHooks.beforeAll,
+                afterAll: parsed.fileHooks.afterAll,
+                beforeEach: parsed.fileHooks.beforeEach,
+                afterEach: parsed.fileHooks.afterEach
+            },
+            tests: [],
+            suites: []
+        };
+        let testIndex = 0;
+        /**
+         * Recursively collect tests and hooks from a suite and its nested suites
+         * Returns the test indices collected (including from nested suites)
+         */
+        const collectFromSuite = (suite, parentBeforeEach, parentAfterEach) => {
+            // Collect beforeEach/afterEach hooks from this suite (parent hooks first)
+            const suiteBeforeEach = [...parentBeforeEach, ...suite.beforeEach];
+            const suiteAfterEach = [...suite.afterEach, ...parentAfterEach]; // Reverse order for afterEach
+            // Track test indices for this suite (includes tests from this suite and nested suites)
+            const suiteTestIndices = [];
+            // Add tests from this suite
+            for (const test of suite.tests) {
+                suiteTestIndices.push(testIndex);
+                result.tests.push({
+                    test: test,
+                    suitePath: test.suitePath || [],
+                    suiteBeforeEachHooks: suiteBeforeEach,
+                    suiteAfterEachHooks: suiteAfterEach
+                });
+                testIndex++;
+            }
+            // Process nested suites and collect their test indices
+            for (const nestedSuite of suite.nestedSuites) {
+                const nestedTestIndices = collectFromSuite(nestedSuite, suiteBeforeEach, suiteAfterEach);
+                // Include nested suite test indices in parent suite's test indices
+                // (needed for afterAll execution - parent suite's afterAll runs after all nested tests)
+                suiteTestIndices.push(...nestedTestIndices);
+            }
+            // Add suite info (for beforeAll/afterAll execution)
+            // Include suite if it has hooks OR if it has tests (direct or nested)
+            if (suite.beforeAll.length > 0 || suite.afterAll.length > 0 || suiteTestIndices.length > 0) {
+                result.suites.push({
+                    suitePath: suite.suitePath,
+                    beforeAll: suite.beforeAll,
+                    afterAll: suite.afterAll,
+                    testIndices: suiteTestIndices
+                });
+            }
+            return suiteTestIndices;
+        };
+        // Add file-level tests
+        for (const test of parsed.tests) {
+            result.tests.push({
+                test: test,
+                suitePath: [],
+                suiteBeforeEachHooks: [],
+                suiteAfterEachHooks: []
+            });
+            testIndex++;
+        }
+        // Process all top-level suites
+        for (const suite of parsed.suites) {
+            collectFromSuite(suite, [], []);
+        }
+        return result;
+    }
+    /**
+     * Construct a test script with imports and a single test using AST
+     * This is more robust than string interpolation
+     * @param originalScript - The full original script (to extract imports)
+     * @param testName - The test name
+     * @param testBodyCode - The test body code (already extracted)
+     * @returns A complete script with imports and the test
+     */
+    static constructTestScriptWithImports(originalScript, testName, testBodyCode) {
+        try {
+            // Parse original script to extract import statements as AST nodes
+            const originalAst = (0, parser_1.parse)(originalScript, {
+                sourceType: 'module',
+                plugins: ['typescript', 'classProperties', 'decorators-legacy'],
+                allowImportExportEverywhere: true
+            });
+            // Collect import declarations
+            const importDeclarations = [];
+            (0, traverse_1.default)(originalAst, {
+                ImportDeclaration(path) {
+                    importDeclarations.push(path.node);
+                }
+            });
+            // Parse the test body code to get it as an AST node
+            // The test body is a block statement, so we need to parse it
+            let testBody;
+            try {
+                // Try parsing as a block statement
+                const bodyAst = (0, parser_1.parse)(`{ ${testBodyCode} }`, {
+                    sourceType: 'module',
+                    plugins: ['typescript', 'classProperties', 'decorators-legacy'],
+                    allowReturnOutsideFunction: true
+                });
+                // Extract the block statement from the parsed code
+                if (bodyAst.program.body.length > 0 && t.isBlockStatement(bodyAst.program.body[0])) {
+                    testBody = bodyAst.program.body[0];
+                }
+                else {
+                    // Fallback: create a block with the statements
+                    const statements = bodyAst.program.body.filter(stmt => !t.isImportDeclaration(stmt));
+                    testBody = t.blockStatement(statements);
+                }
+            }
+            catch (parseError) {
+                // If parsing fails, try parsing as statements
+                const bodyAst = (0, parser_1.parse)(testBodyCode, {
+                    sourceType: 'module',
+                    plugins: ['typescript', 'classProperties', 'decorators-legacy'],
+                    allowReturnOutsideFunction: true,
+                    allowAwaitOutsideFunction: true
+                });
+                const statements = bodyAst.program.body.filter(stmt => !t.isImportDeclaration(stmt));
+                testBody = t.blockStatement(statements);
+            }
+            // Create the test call expression
+            // test('testName', async ({ page, browser, context }) => { ... })
+            const testIdentifier = t.identifier('test');
+            const testNameLiteral = t.stringLiteral(testName);
+            // Create async arrow function with parameters
+            const pageParam = t.objectPattern([
+                t.objectProperty(t.identifier('page'), t.identifier('page'), false, true),
+                t.objectProperty(t.identifier('browser'), t.identifier('browser'), false, true),
+                t.objectProperty(t.identifier('context'), t.identifier('context'), false, true)
+            ]);
+            const asyncArrowFunction = t.arrowFunctionExpression([pageParam], testBody, true // async
+            );
+            // Create the test() call
+            const testCall = t.callExpression(testIdentifier, [
+                testNameLiteral,
+                asyncArrowFunction
+            ]);
+            // Create a new program with imports + test call
+            const programBody = [
+                ...importDeclarations,
+                t.expressionStatement(testCall)
+            ];
+            const newProgram = t.program(programBody);
+            // Generate code from AST
+            const output = (0, generator_1.default)(newProgram, {
+                retainLines: false,
+                compact: false
+            });
+            return output.code;
+        }
+        catch (error) {
+            // Fallback to string interpolation if AST construction fails
+            const importStatements = originalScript.match(/import\s+.*?from\s+['"]([^'"]+)['"];?/g) || [];
+            const importsCode = importStatements.length > 0
+                ? importStatements.join('\n') + '\n\n'
+                : '';
+            // Escape test name properly for fallback
+            const escapedName = testName.replace(/'/g, "\\'").replace(/\n/g, '\\n');
+            return `${importsCode}test('${escapedName}', async ({ page, browser, context }) => {\n${testBodyCode}\n});`;
+        }
+    }
+}
+exports.TestFileParser = TestFileParser;
+//# sourceMappingURL=test-file-parser.js.map