norn-cli 1.3.17 → 1.3.18

package/out/testProvider.js

@@ -0,0 +1,658 @@
+"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");
+// 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 a test case label from parameter names and values.
+ * e.g., [id=1, expectedName="Widget"]
+ */
+function formatCaseLabel(params) {
+    const parts = Object.entries(params).map(([key, value]) => {
+        if (typeof value === 'string') {
+            return `${key}="${value}"`;
+        }
+        return `${key}=${value}`;
+    });
+    return `[${parts.join(', ')}]`;
+}
+/**
+ * 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
+        );
+        // 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);
+            }
+            // Clear existing children and rebuild
+            fileItem.children.replace([]);
+            // Group tests by their primary tag
+            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);
+            }
+            // Sort groups: tagged groups first (alphabetically), then Untagged
+            const sortedGroups = Array.from(tagGroups.keys()).sort((a, b) => {
+                if (a === 'Untagged')
+                    return 1;
+                if (b === 'Untagged')
+                    return -1;
+                return a.localeCompare(b);
+            });
+            // Create group items and add tests
+            for (const groupName of sortedGroups) {
+                const seqs = tagGroups.get(groupName);
+                // If only one group (all tests have same tag or all untagged), skip group level
+                if (sortedGroups.length === 1) {
+                    for (const seq of seqs) {
+                        const declarationLine = this.findTestSequenceDeclarationLine(lines, seq);
+                        const testItem = this.createTestItemForSequence(uri, seq, fileItem, declarationLine);
+                        fileItem.children.add(testItem);
+                    }
+                }
+                else {
+                    // Create a group item
+                    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 = this.findTestSequenceDeclarationLine(lines, seq);
+                        const testItem = this.createTestItemForSequence(uri, seq, groupItem, declarationLine);
+                        groupItem.children.add(testItem);
+                    }
+                    fileItem.children.add(groupItem);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Failed to parse test file ${uri.fsPath}:`, error);
+        }
+    }
+    /**
+     * Finds the actual `test sequence` declaration line for better gutter icon placement.
+     * Sequence ranges may start at decorator lines (@tag/@data/@theory), but the test icon
+     * should anchor to the declaration line users interact with.
+     */
+    findTestSequenceDeclarationLine(lines, seq) {
+        for (let i = seq.startLine; i <= seq.endLine; i++) {
+            if (/^\s*test\s+sequence\s+/.test(lines[i])) {
+                return i;
+            }
+        }
+        return seq.startLine;
+    }
+    /**
+     * 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 = formatCaseLabel(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 theoryPath = path.resolve(path.dirname(uri.fsPath), seq.theoryData.source);
+            const content = await fs.readFile(theoryPath, 'utf-8');
+            const cases = JSON.parse(content);
+            // 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
+        });
+    }
+    /**
+     * 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);
+            // Get environment variables
+            const envVars = (0, environmentProvider_1.getEnvironmentVariables)();
+            // Merge variables (env vars take precedence)
+            const mergedVariables = { ...fileVariables, ...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}${formatCaseLabel(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 '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 = ' ';
+                }
+                output(`${prefix}${stepNum} ${icon} ${desc}\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'));
+            // Check for duplicate definition errors which should fail the test
+            const duplicateErrors = importResult.errors.filter(err => err.error.includes('Duplicate header group') ||
+                err.error.includes('Duplicate endpoint') ||
+                err.error.includes('Duplicate named request') ||
+                err.error.includes('Duplicate sequence'));
+            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
+            );
+            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);
+                        }
+                        // 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);
+        }
+        // Rebuild children
+        fileItem.children.replace([]);
+        // Group tests by their primary tag
+        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);
+        }
+        // Sort groups: tagged groups first (alphabetically), then Untagged
+        const sortedGroups = Array.from(tagGroups.keys()).sort((a, b) => {
+            if (a === 'Untagged')
+                return 1;
+            if (b === 'Untagged')
+                return -1;
+            return a.localeCompare(b);
+        });
+        // Create group items and add tests
+        for (const groupName of sortedGroups) {
+            const seqs = tagGroups.get(groupName);
+            // If only one group (all tests have same tag or all untagged), skip group level
+            if (sortedGroups.length === 1) {
+                for (const seq of seqs) {
+                    const declarationLine = this.findTestSequenceDeclarationLine(lines, seq);
+                    const testItem = this.createTestItemForSequence(uri, seq, fileItem, declarationLine);
+                    fileItem.children.add(testItem);
+                }
+            }
+            else {
+                // Create a group item
+                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 = this.findTestSequenceDeclarationLine(lines, seq);
+                    const testItem = this.createTestItemForSequence(uri, seq, groupItem, declarationLine);
+                    groupItem.children.add(testItem);
+                }
+                fileItem.children.add(groupItem);
+            }
+        }
+    }
+    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