norn-cli 2.3.0 → 2.4.0

package/out/testProvider.js

@@ -0,0 +1,767 @@
+"use strict";
+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 });
+exports.NornTestController = void 0;
+const vscode = __importStar(require("vscode"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+const sequenceRunner_1 = require("./sequenceRunner");
+const parser_1 = require("./parser");
+const environmentProvider_1 = require("./environmentProvider");
+const httpClient_1 = require("./httpClient");
+const coverageCalculator_1 = require("./coverageCalculator");
+const extension_1 = require("./extension");
+const theoryCaseLoader_1 = require("./theoryCaseLoader");
+const importErrors_1 = require("./importErrors");
+const environmentParser_1 = require("./environmentParser");
+const sequenceDeclaration_1 = require("./sequenceDeclaration");
+const breakpoints_1 = require("./debug/breakpoints");
+const contractAssertionSummary_1 = require("./contractAssertionSummary");
+// ANSI color codes for Test Explorer output
+const ansi = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    // Colors
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    magenta: '\x1b[35m',
+    gray: '\x1b[90m',
+    // Bright versions
+    brightGreen: '\x1b[92m',
+    brightRed: '\x1b[91m',
+    brightYellow: '\x1b[93m',
+    brightCyan: '\x1b[96m',
+};
+/**
+ * Formats tags for display in test description.
+ * e.g., "@smoke @team(CustomerExp)"
+ */
+function formatTagsDisplay(tags) {
+    if (tags.length === 0) {
+        return '';
+    }
+    return tags.map(t => t.value ? `@${t.name}(${t.value})` : `@${t.name}`).join(' ');
+}
+/**
+ * Gets the primary tag for grouping (first simple tag, or "Untagged").
+ */
+function getPrimaryTagGroup(tags) {
+    // Look for simple tags (no value) first - these are typically categories like @smoke, @regression
+    const simpleTag = tags.find(t => !t.value);
+    if (simpleTag) {
+        return `@${simpleTag.name}`;
+    }
+    // Fall back to first tag with value
+    if (tags.length > 0) {
+        const t = tags[0];
+        return t.value ? `@${t.name}(${t.value})` : `@${t.name}`;
+    }
+    return 'Untagged';
+}
+/**
+ * Creates TestTag objects from sequence tags.
+ */
+function createTestTags(controller, tags) {
+    return tags.map(tag => {
+        const tagId = tag.value ? `${tag.name}:${tag.value}` : tag.name;
+        return new vscode.TestTag(tagId);
+    });
+}
+/**
+ * Norn Test Controller - provides Test Explorer integration for .norn files.
+ *
+ * Features:
+ * - Discovers test sequences from .norn files
+ * - Supports parameterized tests via @data and @theory annotations
+ * - Streams test progress during execution
+ * - Maps sequence tags to Test Explorer tags for filtering
+ */
+class NornTestController {
+    controller;
+    disposables = [];
+    // Map from test item ID to sequence info
+    testData = new WeakMap();
+    constructor() {
+        this.controller = vscode.tests.createTestController('nornTests', 'Norn Tests');
+        // Set up resolve handler for lazy loading
+        this.controller.resolveHandler = async (item) => {
+            if (!item) {
+                // Initial request: discover all test files
+                await this.discoverAllTests();
+            }
+            else {
+                // Resolve a specific item (file or sequence with theory data)
+                await this.resolveTestItem(item);
+            }
+        };
+        // Create run profile
+        this.controller.createRunProfile('Run Tests', vscode.TestRunProfileKind.Run, (request, token) => this.runTests(request, token), true // isDefault
+        );
+        this.controller.createRunProfile('Debug Tests', vscode.TestRunProfileKind.Debug, (request, token) => this.debugTests(request, token), true);
+        // Watch for file changes
+        const fileWatcher = vscode.workspace.createFileSystemWatcher('**/*.norn');
+        fileWatcher.onDidCreate(uri => this.onFileCreated(uri));
+        fileWatcher.onDidChange(uri => this.onFileChanged(uri));
+        fileWatcher.onDidDelete(uri => this.onFileDeleted(uri));
+        this.disposables.push(fileWatcher);
+        // Watch for document changes (unsaved edits)
+        this.disposables.push(vscode.workspace.onDidChangeTextDocument(e => {
+            if (e.document.languageId === 'norn') {
+                this.updateTestsInDocument(e.document);
+            }
+        }));
+        // Initial discovery for open documents
+        vscode.workspace.textDocuments.forEach(doc => {
+            if (doc.languageId === 'norn') {
+                this.updateTestsInDocument(doc);
+            }
+        });
+    }
+    /**
+     * Discovers all .norn test files in the workspace.
+     */
+    async discoverAllTests() {
+        const files = await vscode.workspace.findFiles('**/*.norn', '**/node_modules/**');
+        for (const uri of files) {
+            await this.parseTestFile(uri);
+        }
+    }
+    /**
+     * Parses a .norn file and creates test items for test sequences.
+     */
+    async parseTestFile(uri) {
+        try {
+            const content = await fs.readFile(uri.fsPath, 'utf-8');
+            const lines = content.split('\n');
+            const sequences = (0, sequenceRunner_1.extractSequences)(content);
+            // Filter to only test sequences (isTest: true)
+            const testSequences = sequences.filter(seq => seq.isTest);
+            if (testSequences.length === 0) {
+                // Remove file from test explorer if it had tests before
+                this.controller.items.delete(uri.toString());
+                return;
+            }
+            // Create or update file item
+            const fileName = path.basename(uri.fsPath);
+            let fileItem = this.controller.items.get(uri.toString());
+            if (!fileItem) {
+                fileItem = this.controller.createTestItem(uri.toString(), fileName, uri);
+                this.controller.items.add(fileItem);
+            }
+            this.rebuildFileItemTests(fileItem, uri, lines, testSequences);
+        }
+        catch (error) {
+            console.error(`Failed to parse test file ${uri.fsPath}:`, error);
+        }
+    }
+    rebuildFileItemTests(fileItem, uri, lines, testSequences) {
+        fileItem.children.replace([]);
+        const tagGroups = new Map();
+        for (const seq of testSequences) {
+            const groupName = getPrimaryTagGroup(seq.tags);
+            if (!tagGroups.has(groupName)) {
+                tagGroups.set(groupName, []);
+            }
+            tagGroups.get(groupName).push(seq);
+        }
+        const sortedGroups = Array.from(tagGroups.keys()).sort((a, b) => {
+            if (a === 'Untagged') {
+                return 1;
+            }
+            if (b === 'Untagged') {
+                return -1;
+            }
+            return a.localeCompare(b);
+        });
+        for (const groupName of sortedGroups) {
+            const seqs = tagGroups.get(groupName);
+            if (sortedGroups.length === 1) {
+                for (const seq of seqs) {
+                    const declarationLine = (0, sequenceDeclaration_1.findSequenceDeclarationLine)(lines, seq.startLine, seq.endLine, { testOnly: true });
+                    const testItem = this.createTestItemForSequence(uri, seq, fileItem, declarationLine);
+                    fileItem.children.add(testItem);
+                }
+                continue;
+            }
+            const groupId = `${uri.toString()}::group::${groupName}`;
+            const groupItem = this.controller.createTestItem(groupId, groupName, uri);
+            groupItem.description = `${seqs.length} test${seqs.length > 1 ? 's' : ''}`;
+            for (const seq of seqs) {
+                const declarationLine = (0, sequenceDeclaration_1.findSequenceDeclarationLine)(lines, seq.startLine, seq.endLine, { testOnly: true });
+                const testItem = this.createTestItemForSequence(uri, seq, groupItem, declarationLine);
+                groupItem.children.add(testItem);
+            }
+            fileItem.children.add(groupItem);
+        }
+    }
+    /**
+     * Creates a test item for a sequence, including child items for theory cases.
+     */
+    createTestItemForSequence(uri, seq, parent, declarationLine) {
+        const testId = `${uri.toString()}::${seq.name}`;
+        const testItem = this.controller.createTestItem(testId, seq.name, uri);
+        // Set range for navigation
+        testItem.range = new vscode.Range(declarationLine, 0, seq.endLine, 0);
+        // Add tags
+        testItem.tags = createTestTags(this.controller, seq.tags);
+        // Build description showing tags and param info
+        const descParts = [];
+        const tagsDisplay = formatTagsDisplay(seq.tags);
+        if (tagsDisplay) {
+            descParts.push(tagsDisplay);
+        }
+        if (seq.theoryData && seq.theoryData.cases.length > 0) {
+            descParts.push(`${seq.theoryData.cases.length} cases`);
+        }
+        else if (seq.parameters.length > 0) {
+            const paramNames = seq.parameters.map(p => p.name).join(', ');
+            descParts.push(`(${paramNames})`);
+        }
+        if (descParts.length > 0) {
+            testItem.description = descParts.join(' · ');
+        }
+        // Store sequence data
+        this.testData.set(testItem, { sequence: seq, uri });
+        // If this sequence has theory data (parameterized), create child items
+        if (seq.theoryData && seq.theoryData.cases.length > 0) {
+            testItem.canResolveChildren = true;
+            // Eagerly create children for known cases
+            this.createTheoryCaseItems(testItem, seq, uri);
+        }
+        return testItem;
+    }
+    /**
+     * Creates child test items for each theory case.
+     */
+    createTheoryCaseItems(parentItem, seq, uri) {
+        if (!seq.theoryData) {
+            return;
+        }
+        for (let i = 0; i < seq.theoryData.cases.length; i++) {
+            const caseParams = seq.theoryData.cases[i];
+            const caseLabel = (0, theoryCaseLoader_1.formatTheoryCaseLabel)(caseParams);
+            const caseId = `${parentItem.id}::case${i}`;
+            const caseItem = this.controller.createTestItem(caseId, caseLabel, uri);
+            caseItem.range = parentItem.range; // Same range as parent
+            caseItem.tags = parentItem.tags; // Inherit tags
+            this.testData.set(caseItem, {
+                sequence: seq,
+                uri,
+                caseIndex: i,
+                caseParams
+            });
+            parentItem.children.add(caseItem);
+        }
+    }
+    /**
+     * Resolves children of a test item (for lazy loading theory cases from @theory files).
+     */
+    async resolveTestItem(item) {
+        const data = this.testData.get(item);
+        if (!data) {
+            return;
+        }
+        // If this has a @theory source file, load it now
+        if (data.sequence.theoryData?.source && data.sequence.theoryData.cases.length === 0) {
+            await this.loadTheoryFile(item, data.sequence, data.uri);
+        }
+    }
+    /**
+     * Loads theory data from an external JSON file.
+     */
+    async loadTheoryFile(parentItem, seq, uri) {
+        if (!seq.theoryData?.source) {
+            return;
+        }
+        try {
+            const cases = await (0, theoryCaseLoader_1.loadTheoryCasesFromSource)(seq.theoryData.source, path.dirname(uri.fsPath), seq.parameters.map(param => param.name));
+            // Update the theory data
+            seq.theoryData.cases = cases;
+            // Create child items
+            this.createTheoryCaseItems(parentItem, seq, uri);
+        }
+        catch (error) {
+            parentItem.error = `Failed to load theory file: ${seq.theoryData.source}`;
+            console.error(`Failed to load theory file for ${seq.name}:`, error);
+        }
+    }
+    /**
+     * Runs the requested tests.
+     */
+    async runTests(request, token) {
+        const run = this.controller.createTestRun(request);
+        const queue = [];
+        // Collect tests to run
+        if (request.include) {
+            request.include.forEach(test => queue.push(test));
+        }
+        else {
+            this.controller.items.forEach(test => queue.push(test));
+        }
+        // Process queue
+        while (queue.length > 0 && !token.isCancellationRequested) {
+            const test = queue.shift();
+            // Skip excluded tests
+            if (request.exclude?.includes(test)) {
+                continue;
+            }
+            const data = this.testData.get(test);
+            if (!data) {
+                // This is a file item - queue its children
+                test.children.forEach(child => queue.push(child));
+                continue;
+            }
+            // Check if this is a parameterized test with children
+            if (test.children.size > 0 && data.caseIndex === undefined) {
+                // Queue children instead of running parent
+                test.children.forEach(child => queue.push(child));
+                continue;
+            }
+            // Run the test
+            await this.runSingleTest(run, test, data, token);
+        }
+        run.end();
+        // Recalculate coverage after test run completes (uses cached swagger specs)
+        (0, coverageCalculator_1.recalculateCoverageAfterExecution)().catch(() => {
+            // Silently ignore coverage calculation errors
+        });
+    }
+    collectDebugTargets(item, exclude, targets, seenIds) {
+        if (exclude?.includes(item)) {
+            return;
+        }
+        const data = this.testData.get(item);
+        if (data) {
+            const hasChildCases = item.children.size > 0 && data.caseIndex === undefined;
+            if (hasChildCases) {
+                item.children.forEach(child => this.collectDebugTargets(child, exclude, targets, seenIds));
+                return;
+            }
+            if (!seenIds.has(item.id)) {
+                targets.push({ item, data });
+                seenIds.add(item.id);
+            }
+            return;
+        }
+        item.children.forEach(child => this.collectDebugTargets(child, exclude, targets, seenIds));
+    }
+    getDebugTargets(request) {
+        const roots = request.include
+            ? Array.from(request.include)
+            : [];
+        if (!request.include) {
+            this.controller.items.forEach(item => roots.push(item));
+        }
+        const targets = [];
+        const seenIds = new Set();
+        for (const root of roots) {
+            this.collectDebugTargets(root, request.exclude, targets, seenIds);
+        }
+        return targets;
+    }
+    async pickSingleDebugTarget(targets) {
+        if (targets.length === 0) {
+            return undefined;
+        }
+        if (targets.length === 1) {
+            return targets[0];
+        }
+        const items = targets.map(target => ({
+            label: target.item.label,
+            description: `${path.basename(target.data.uri.fsPath)} · sequence ${target.data.sequence.name}`,
+            target
+        }));
+        const picked = await vscode.window.showQuickPick(items, {
+            title: 'Select one test to debug',
+            placeHolder: 'Debug profile supports a single test/case per session in v1',
+            ignoreFocusOut: true
+        });
+        return picked?.target;
+    }
+    async debugTests(request, token) {
+        const run = this.controller.createTestRun(request);
+        try {
+            const targets = this.getDebugTargets(request);
+            if (targets.length === 0) {
+                run.appendOutput('\r\nNo debuggable test target selected.\r\n');
+                run.end();
+                return;
+            }
+            const selected = await this.pickSingleDebugTarget(targets);
+            if (!selected) {
+                run.appendOutput('\r\nDebug canceled: no single target selected.\r\n');
+                run.end();
+                return;
+            }
+            if (token.isCancellationRequested) {
+                run.skipped(selected.item);
+                run.end();
+                return;
+            }
+            run.started(selected.item);
+            const args = selected.data.caseParams
+                ? Object.fromEntries(Object.entries(selected.data.caseParams).map(([key, value]) => [key, String(value)]))
+                : undefined;
+            const config = {
+                type: 'norn',
+                request: 'launch',
+                name: `Debug ${selected.data.sequence.name}`,
+                file: selected.data.uri.fsPath,
+                sequence: selected.data.sequence.name,
+                stopOnEntry: !(0, breakpoints_1.hasEnabledNornBreakpoints)(),
+                args
+            };
+            const folder = vscode.workspace.getWorkspaceFolder(selected.data.uri);
+            const started = await vscode.debug.startDebugging(folder, config, { testRun: run });
+            if (!started) {
+                run.errored(selected.item, new vscode.TestMessage('Failed to start debug session.'));
+                run.end();
+                return;
+            }
+            run.end();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            run.appendOutput(`\r\nDebug launch error: ${message}\r\n`);
+            run.end();
+        }
+    }
+    /**
+     * Runs a single test (or single theory case).
+     */
+    async runSingleTest(run, test, data, token) {
+        run.started(test);
+        if (token.isCancellationRequested) {
+            run.skipped(test);
+            return;
+        }
+        try {
+            const startTime = Date.now();
+            // Load file content and variables
+            const content = await fs.readFile(data.uri.fsPath, 'utf-8');
+            const fileVariables = (0, parser_1.extractVariables)(content);
+            const envErrors = (0, environmentProvider_1.getEnvironmentImportErrorDetails)(data.uri.fsPath);
+            if (envErrors.length > 0) {
+                const firstError = envErrors[0];
+                const location = (0, environmentParser_1.formatNornenvErrorLocationForSource)(data.uri.fsPath, firstError.filePath, firstError.line);
+                const moreErrors = envErrors.length > 1
+                    ? `\n(+${envErrors.length - 1} more .nornenv error${envErrors.length > 2 ? 's' : ''})`
+                    : '';
+                run.failed(test, new vscode.TestMessage(`Cannot run while .nornenv has errors (${location}): ${firstError.message}${moreErrors}`), Date.now() - startTime);
+                return;
+            }
+            const unlocked = await (0, environmentProvider_1.promptForMissingEnvironmentSecretKeys)(data.uri.fsPath);
+            if (!unlocked) {
+                run.failed(test, new vscode.TestMessage('Cannot run while .nornenv secrets are locked. Provide the shared key to continue.'), Date.now() - startTime);
+                return;
+            }
+            const secretErrors = (0, environmentProvider_1.getEnvironmentSecretErrorDetails)(data.uri.fsPath);
+            if (secretErrors.length > 0) {
+                const firstError = secretErrors[0];
+                const location = (0, environmentParser_1.formatNornenvErrorLocationForSource)(data.uri.fsPath, firstError.filePath, firstError.line);
+                const moreErrors = secretErrors.length > 1
+                    ? `\n(+${secretErrors.length - 1} more secret error${secretErrors.length > 2 ? 's' : ''})`
+                    : '';
+                run.failed(test, new vscode.TestMessage(`Cannot run while .nornenv secrets are invalid (${location}): ${firstError.message}${moreErrors}`), Date.now() - startTime);
+                return;
+            }
+            // Get environment variables
+            const envVars = (0, environmentProvider_1.getEnvironmentVariables)(data.uri.fsPath);
+            // Merge variables (env vars take precedence)
+            const mergedVariables = (0, parser_1.attachEnvironmentScope)({ ...fileVariables, ...envVars }, envVars);
+            // If this is a theory case, add case params
+            if (data.caseParams) {
+                for (const [key, value] of Object.entries(data.caseParams)) {
+                    mergedVariables[key] = String(value);
+                }
+            }
+            // Helper to output with colors
+            const output = (text) => {
+                run.appendOutput(text, undefined, test);
+            };
+            // Output test header
+            const testName = data.caseParams
+                ? `${data.sequence.name}${(0, theoryCaseLoader_1.formatTheoryCaseLabel)(data.caseParams)}`
+                : data.sequence.name;
+            output(`\r\n${ansi.bold}${ansi.brightCyan}▸ ${testName}${ansi.reset}\r\n`);
+            // Create progress callback for streaming output with colors
+            const progressCallback = (info) => {
+                const prefix = '  '.repeat(info.nestingDepth || 0);
+                const stepNum = `${ansi.gray}[${info.currentStep}/${info.totalSteps}]${ansi.reset}`;
+                let icon = '';
+                let desc = info.stepDescription;
+                // Color based on step type and result
+                switch (info.stepType) {
+                    case 'request':
+                    case 'namedRequest':
+                        // HTTP method coloring
+                        desc = desc.replace(/^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+/, `${ansi.cyan}$1${ansi.reset} `);
+                        // Add status code coloring if present
+                        desc = desc.replace(/\s+(\d{3})\s*$/, (_, code) => {
+                            const status = parseInt(code);
+                            if (status >= 200 && status < 300) {
+                                return ` ${ansi.green}${code}${ansi.reset}`;
+                            }
+                            if (status >= 400) {
+                                return ` ${ansi.red}${code}${ansi.reset}`;
+                            }
+                            return ` ${ansi.yellow}${code}${ansi.reset}`;
+                        });
+                        icon = `${ansi.blue}→${ansi.reset}`;
+                        break;
+                    case 'assertion':
+                        if (desc.includes('✓')) {
+                            icon = `${ansi.green}✓${ansi.reset}`;
+                            desc = desc.replace('✓ ', '');
+                        }
+                        else if (desc.includes('✗')) {
+                            icon = `${ansi.red}✗${ansi.reset}`;
+                            desc = desc.replace('✗ ', '');
+                        }
+                        break;
+                    case 'print':
+                        icon = `${ansi.magenta}◆${ansi.reset}`;
+                        desc = desc.replace(/^print:\s*/, '');
+                        desc = `${ansi.dim}${desc}${ansi.reset}`;
+                        break;
+                    case 'script':
+                        icon = `${ansi.yellow}⚡${ansi.reset}`;
+                        break;
+                    case 'sql':
+                        icon = `${ansi.blue}▣${ansi.reset}`;
+                        break;
+                    case 'wait':
+                        icon = `${ansi.gray}⏱${ansi.reset}`;
+                        break;
+                    case 'runSequence':
+                    case 'sequenceStart':
+                        icon = `${ansi.brightCyan}▶${ansi.reset}`;
+                        break;
+                    case 'sequenceEnd':
+                        icon = `${ansi.brightCyan}■${ansi.reset}`;
+                        break;
+                    default:
+                        icon = ' ';
+                }
+                const contractDisplay = info.stepResult?.assertion
+                    ? (0, contractAssertionSummary_1.buildContractAssertionDisplay)(info.stepResult.assertion)
+                    : undefined;
+                if (contractDisplay) {
+                    desc = contractDisplay.titleText;
+                }
+                output(`${prefix}${stepNum} ${icon} ${desc}\r\n`);
+                if (contractDisplay && info.stepResult?.assertion) {
+                    if (!info.stepResult.assertion.passed) {
+                        for (const issue of contractDisplay.issueTexts) {
+                            output(`${prefix}        ${ansi.red}✗ ${issue}${ansi.reset}\r\n`);
+                        }
+                        if (contractDisplay.remainingIssueCount > 0) {
+                            output(`${prefix}        ${ansi.dim}+${contractDisplay.remainingIssueCount} more${ansi.reset}\r\n`);
+                        }
+                    }
+                }
+            };
+            // Resolve imports
+            const workingDir = path.dirname(data.uri.fsPath);
+            const importResult = await (0, parser_1.resolveImports)(content, workingDir, async (p) => fs.readFile(p, 'utf-8'), undefined, undefined, data.uri.fsPath);
+            const duplicateErrors = (0, importErrors_1.getBlockingImportErrors)(importResult.errors);
+            if (duplicateErrors.length > 0) {
+                const errorMessage = duplicateErrors.map(err => `${err.path}: ${err.error}`).join('\n');
+                run.failed(test, new vscode.TestMessage(`Import error: duplicate definitions found\n${errorMessage}`), Date.now() - startTime);
+                return;
+            }
+            // Combine content with imports
+            const fullContent = importResult.importedContent
+                ? importResult.importedContent + '\n\n' + content
+                : content;
+            // Create a fresh cookie jar for this test run
+            const cookieJar = (0, httpClient_1.createCookieJar)();
+            // Run the sequence
+            const result = await (0, sequenceRunner_1.runSequenceWithJar)(data.sequence.content, mergedVariables, cookieJar, workingDir, fullContent, progressCallback, undefined, // callStack
+            data.caseParams ? Object.fromEntries(Object.entries(data.caseParams).map(([k, v]) => [k, String(v)])) : undefined, { headerGroups: importResult.headerGroups, endpoints: importResult.endpoints }, undefined, // tagFilterOptions
+            importResult.sequenceSources, // For resolving script paths relative to imported files
+            importResult.sqlOperationsBySource, {
+                filePath: data.uri.fsPath,
+                sequenceName: data.sequence.name,
+                sequenceStartLine: data.sequence.startLine
+            });
+            const duration = Date.now() - startTime;
+            // Save schema validation results to cache for gutter icons
+            (0, extension_1.saveSchemaValidationResults)(result, data.uri.fsPath, data.sequence.startLine + 1);
+            // Output summary line - just show pass/fail with duration
+            if (result.success) {
+                output(`${ansi.green}${ansi.bold}✓ PASSED${ansi.reset} ${ansi.gray}${duration}ms${ansi.reset}\r\n`);
+                run.passed(test, duration);
+            }
+            else {
+                // Output detailed failure info
+                output(`${ansi.gray}${'─'.repeat(40)}${ansi.reset}\r\n`);
+                // Create failure messages from assertion results
+                const messages = [];
+                for (const assertion of result.assertionResults) {
+                    if (!assertion.passed) {
+                        // Build display expression with friendly name when available
+                        let displayExpr = assertion.expression;
+                        if (assertion.friendlyName && assertion.responseIndex) {
+                            displayExpr = displayExpr.replace('$' + assertion.responseIndex, assertion.friendlyName);
+                        }
+                        const contractDisplay = (0, contractAssertionSummary_1.buildContractAssertionDisplay)(assertion);
+                        if (contractDisplay) {
+                            output(`${ansi.red}✗ ${contractDisplay.titleText}${ansi.reset}\r\n`);
+                            if (contractDisplay.issueTexts.length > 0) {
+                                output(`  ${ansi.dim}Issues:${ansi.reset}\r\n`);
+                                for (const issue of contractDisplay.issueTexts) {
+                                    output(`    ${ansi.red}✗ ${issue}${ansi.reset}\r\n`);
+                                }
+                                if (contractDisplay.remainingIssueCount > 0) {
+                                    output(`    ${ansi.dim}+${contractDisplay.remainingIssueCount} more${ansi.reset}\r\n`);
+                                }
+                            }
+                            else if (assertion.error) {
+                                output(`  ${ansi.red}${assertion.error}${ansi.reset}\r\n`);
+                            }
+                            if (assertion.message) {
+                                output(`  ${ansi.yellow}${assertion.message}${ansi.reset}\r\n`);
+                            }
+                            output(`\r\n`);
+                            messages.push(new vscode.TestMessage(assertion.message || `Contract assertion failed: ${contractDisplay.summaryText}`));
+                            continue;
+                        }
+                        // Output to test results
+                        output(`${ansi.red}✗ ${displayExpr}${ansi.reset}\r\n`);
+                        if (assertion.leftValue !== undefined && assertion.rightValue !== undefined) {
+                            output(`  ${ansi.dim}Expected:${ansi.reset} ${ansi.green}${JSON.stringify(assertion.rightValue)}${ansi.reset}\r\n`);
+                            output(`  ${ansi.dim}Actual:${ansi.reset}   ${ansi.red}${JSON.stringify(assertion.leftValue)}${ansi.reset}\r\n`);
+                        }
+                        if (assertion.message) {
+                            output(`  ${ansi.yellow}${assertion.message}${ansi.reset}\r\n`);
+                        }
+                        output(`\r\n`);
+                        // Create VS Code diff message
+                        const msg = vscode.TestMessage.diff(assertion.message || `Assertion failed: ${displayExpr}`, String(assertion.rightValue ?? ''), // expected
+                        String(assertion.leftValue ?? '') // actual
+                        );
+                        messages.push(msg);
+                    }
+                }
+                // Add any errors with details
+                for (const error of result.errors) {
+                    // Split error into lines and output each properly
+                    const errorLines = error.split('\n');
+                    for (const line of errorLines) {
+                        if (line.trim()) {
+                            output(`${ansi.red}${line}${ansi.reset}\r\n`);
+                        }
+                    }
+                    messages.push(new vscode.TestMessage(error));
+                }
+                // Add request/response info for failed requests (use steps for URL info)
+                for (const step of result.steps) {
+                    if (step.type === 'request' && step.response && step.response.status >= 400) {
+                        output(`\r\n${ansi.yellow}Request Details:${ansi.reset}\r\n`);
+                        if (step.requestUrl) {
+                            output(`  ${ansi.dim}URL:${ansi.reset} ${step.requestMethod || 'GET'} ${step.requestUrl}\r\n`);
+                        }
+                        output(`  ${ansi.dim}Status:${ansi.reset} ${ansi.red}${step.response.status} ${step.response.statusText}${ansi.reset}\r\n`);
+                        if (step.response.body) {
+                            const bodyPreview = typeof step.response.body === 'string'
+                                ? step.response.body.slice(0, 500)
+                                : JSON.stringify(step.response.body, null, 2).slice(0, 500);
+                            output(`  ${ansi.dim}Response:${ansi.reset}\r\n`);
+                            // Indent each line of the body for proper formatting
+                            const indentedBody = bodyPreview.split('\n').map(line => `  ${line}`).join('\r\n');
+                            output(`${ansi.gray}${indentedBody}${bodyPreview.length >= 500 ? '...' : ''}${ansi.reset}\r\n`);
+                        }
+                    }
+                }
+                output(`${ansi.gray}${'─'.repeat(50)}${ansi.reset}\r\n`);
+                output(`${ansi.red}${ansi.bold}✗ FAILED${ansi.reset} ${ansi.gray}${duration}ms${ansi.reset}\r\n`);
+                if (messages.length === 0) {
+                    messages.push(new vscode.TestMessage('Test failed'));
+                }
+                run.failed(test, messages, duration);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            run.appendOutput(`\r\n${ansi.red}${ansi.bold}ERROR${ansi.reset}\r\n${ansi.red}${message}${ansi.reset}\r\n`, undefined, test);
+            run.errored(test, new vscode.TestMessage(message));
+        }
+    }
+    /**
+     * Updates tests when a document changes.
+     */
+    async updateTestsInDocument(document) {
+        if (document.uri.scheme !== 'file') {
+            return;
+        }
+        const content = document.getText();
+        const lines = content.split('\n');
+        const sequences = (0, sequenceRunner_1.extractSequences)(content);
+        const testSequences = sequences.filter(seq => seq.isTest);
+        if (testSequences.length === 0) {
+            this.controller.items.delete(document.uri.toString());
+            return;
+        }
+        // Create or update file item
+        const fileName = path.basename(document.uri.fsPath);
+        const uri = document.uri;
+        let fileItem = this.controller.items.get(uri.toString());
+        if (!fileItem) {
+            fileItem = this.controller.createTestItem(uri.toString(), fileName, uri);
+            this.controller.items.add(fileItem);
+        }
+        this.rebuildFileItemTests(fileItem, uri, lines, testSequences);
+    }
+    async onFileCreated(uri) {
+        await this.parseTestFile(uri);
+    }
+    async onFileChanged(uri) {
+        await this.parseTestFile(uri);
+    }
+    onFileDeleted(uri) {
+        this.controller.items.delete(uri.toString());
+    }
+    dispose() {
+        this.controller.dispose();
+        this.disposables.forEach(d => d.dispose());
+    }
+}
+exports.NornTestController = NornTestController;
+//# sourceMappingURL=testProvider.js.map