norn-cli 1.1.1 → 1.1.2

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to the "Norn" extension will be documented in this file.
 
+## [1.1.2] - 2026-02-01
+
+### Added
+- **VS Code Test Explorer Integration**: Run test sequences from the Testing sidebar
+  - Automatic test discovery for all `.norn` files
+  - Tests grouped by tag (`@smoke`, `@regression`, etc.)
+  - Colorful streaming output with ANSI colors
+  - Persistent output when selecting tests
+  - Detailed failure info with expected vs actual diffs
+  - Request/response details for failed HTTP calls
+
+- **Parameterized Tests**: Data-driven testing with `@data` and `@theory` annotations
+  - `@data(1, "Widget")` syntax for inline test data
+  - `@theory("./testdata.json")` for external data files
+  - Typed value parsing (numbers, booleans, strings)
+  - Each data row creates a separate test case in Test Explorer
+  - Example: `@data(1, 200)` with `test sequence ValidateStatus(id, expectedStatus)`
+
+- **Test Sequence Validation**: Diagnostics for test annotations
+  - Error if `@data`/`@theory` used on regular sequences (must use `test sequence`)
+  - Error if tags like `@smoke` used on regular sequences
+  - Error if test sequence has required params but no `@data`/`@theory`
+
+### Improved
+- **Test Explorer Output**: Rich colorized output with icons
+  - HTTP methods in cyan, status codes color-coded (green/red/yellow)
+  - Checkmarks for passed assertions, X for failures
+  - Clear test headers when running multiple tests
+  - Duration shown for each test
+
 ## [1.1.0] - 2026-02-01
 
 ### Added

package/README.md

@@ -13,6 +13,8 @@ A powerful REST client extension for VS Code with sequences, assertions, environ
 - **Environments**: Manage dev/staging/prod configurations with `.nornenv` files
 - **Sequences**: Chain multiple requests with response capture using `$N.path`
 - **Test Sequences**: Mark sequences as tests with `test sequence` for CLI execution
+- **Test Explorer**: Run tests from VS Code's Testing sidebar with colorful output
+- **Parameterized Tests**: Data-driven testing with `@data` and `@theory` annotations
 - **Sequence Tags**: Tag sequences with `@smoke`, `@team(CustomerExp)` for filtering in CI/CD
 - **Secret Variables**: Mark sensitive environment variables with `secret` for automatic redaction
 - **Assertions**: Validate responses with `assert` statements supporting comparison, type checking, and existence
@@ -753,6 +755,65 @@ npx norn --help
 | `--no-fail` | Don't exit with error code on failed tests |
 | `-h, --help` | Show help message |
 
+## Test Explorer
+
+Run tests directly from VS Code's Testing sidebar:
+
+- **Automatic Discovery**: Test sequences appear in the Testing view
+- **Tag Grouping**: Tests organized by tags (`@smoke`, `@regression`, etc.)
+- **Colorful Output**: ANSI-colored results with icons and status codes
+- **Persistent Output**: Select a test to see its full output anytime
+- **Failure Details**: Expected vs actual diffs, request/response info
+
+### Parameterized Tests
+
+Use `@data` for data-driven testing - each data row becomes a separate test:
+
+```bash
+# Single parameter - runs 3 times with id = 1, 2, 3
+@data(1, 2, 3)
+test sequence TodoTest(id)
+    GET {{baseUrl}}/todos/{{id}}
+    assert $1.status == 200
+    assert $1.body.id == {{id}}
+end sequence
+
+# Multiple parameters - runs 2 times
+@data(1, "delectus aut autem")
+@data(2, "quis ut nam facilis")
+test sequence TodoTitleTest(id, expectedTitle)
+    GET {{baseUrl}}/todos/{{id}}
+    assert $1.status == 200
+    assert $1.body.title == "{{expectedTitle}}"
+end sequence
+
+# Typed values (numbers, booleans, strings)
+@data(1, true, "active")
+@data(2, false, "inactive")
+test sequence UserStatusTest(userId, isActive, status)
+    GET {{baseUrl}}/users/{{userId}}
+    assert $1.status == 200
+end sequence
+```
+
+Use `@theory` for external data files:
+
+```bash
+@theory("./testdata.json")
+test sequence DataFileTest(id, name)
+    GET {{baseUrl}}/items/{{id}}
+    assert $1.body.name == "{{name}}"
+end sequence
+```
+
+Where `testdata.json` contains:
+```json
+[
+  {"id": 1, "name": "Widget"},
+  {"id": 2, "name": "Gadget"}
+]
+```
+
 ### CI/CD Example (GitHub Actions)
 
 ```yaml
@@ -793,8 +854,11 @@ jobs:
 | `run RequestName` | Execute a named request |
 | `sequence Name` | Start a helper sequence block |
 | `test sequence Name` | Start a test sequence (runs from CLI) |
-| `@tagname` | Simple tag on a sequence |
-| `@key(value)` | Key-value tag on a sequence |
+| `test sequence Name(params)` | Test sequence with parameters |
+| `@tagname` | Simple tag on a test sequence |
+| `@key(value)` | Key-value tag on a test sequence |
+| `@data(val1, val2)` | Inline test data for parameterized tests |
+| `@theory("file.json")` | External test data file |
 | `end sequence` | End a sequence block |
 | `var x = $1.path` | Capture value from response 1 |
 | `$N.status` | Access status code of response N |

package/dist/cli.js

@@ -20098,6 +20098,8 @@ function parseSequenceParameters(line2) {
 }
 function parseSequenceTags(lines, sequenceLineIndex) {
   const tags = [];
+  const dataCases = [];
+  let theorySource;
   let tagStartLine = sequenceLineIndex;
   for (let i = sequenceLineIndex - 1; i >= 0; i--) {
     const line2 = lines[i].trim();
@@ -20107,10 +20109,26 @@ function parseSequenceTags(lines, sequenceLineIndex) {
     if (!line2.startsWith("@")) {
       break;
     }
+    const dataMatch = line2.match(/^@data\s*\((.+)\)\s*$/);
+    if (dataMatch) {
+      const values = parseDataValues(dataMatch[1]);
+      dataCases.push(values);
+      tagStartLine = i;
+      continue;
+    }
+    const theoryMatch = line2.match(/^@theory\s*\(\s*["']([^"']+)["']\s*\)\s*$/);
+    if (theoryMatch) {
+      theorySource = theoryMatch[1];
+      tagStartLine = i;
+      continue;
+    }
     const tagPattern = /@([a-zA-Z_][a-zA-Z0-9_-]*)(?:\(([^)]+)\))?/g;
     let match;
     while ((match = tagPattern.exec(line2)) !== null) {
       const tagName = match[1];
+      if (tagName === "data" || tagName === "theory") {
+        continue;
+      }
       const tagValue = match[2]?.trim();
       tags.push({
         name: tagName,
@@ -20119,7 +20137,75 @@ function parseSequenceTags(lines, sequenceLineIndex) {
     }
     tagStartLine = i;
   }
-  return { tags, tagStartLine };
+  let theoryData;
+  if (dataCases.length > 0 || theorySource) {
+    theoryData = {
+      cases: [],
+      // Will be populated with param names after we know them
+      source: theorySource
+    };
+    theoryData._rawCases = dataCases.reverse();
+  }
+  return { tags, tagStartLine, theoryData };
+}
+function parseDataValues(valuesStr) {
+  const values = [];
+  let current = "";
+  let inQuote = null;
+  let i = 0;
+  while (i < valuesStr.length) {
+    const char = valuesStr[i];
+    if (inQuote) {
+      if (char === inQuote) {
+        values.push(current);
+        current = "";
+        inQuote = null;
+        i++;
+        while (i < valuesStr.length && valuesStr[i] !== ",") {
+          i++;
+        }
+        i++;
+        continue;
+      } else {
+        current += char;
+      }
+    } else {
+      if (char === '"' || char === "'") {
+        inQuote = char;
+        current = "";
+      } else if (char === ",") {
+        const trimmed = current.trim();
+        if (trimmed) {
+          values.push(parseTypedValue(trimmed));
+        }
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+    i++;
+  }
+  if (inQuote) {
+    values.push(current);
+  } else {
+    const trimmed = current.trim();
+    if (trimmed) {
+      values.push(parseTypedValue(trimmed));
+    }
+  }
+  return values;
+}
+function parseTypedValue(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (/^-?\d+(\.\d+)?$/.test(value)) {
+    return parseFloat(value);
+  }
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
 }
 function extractSequences(text) {
   const lines = text.split("\n");
@@ -20133,7 +20219,21 @@ function extractSequences(text) {
       const isTest = !!testSequenceMatch;
       const name = isTest ? testSequenceMatch[1] : sequenceMatch[1];
       const parameters = parseSequenceParameters(lines[i]);
-      const { tags, tagStartLine } = parseSequenceTags(lines, i);
+      const { tags, tagStartLine, theoryData } = parseSequenceTags(lines, i);
+      let finalTheoryData = theoryData;
+      if (theoryData && theoryData._rawCases) {
+        const rawCases = theoryData._rawCases;
+        finalTheoryData = {
+          cases: rawCases.map((values) => {
+            const caseObj = {};
+            parameters.forEach((param, idx) => {
+              caseObj[param.name] = values[idx];
+            });
+            return caseObj;
+          }),
+          source: theoryData.source
+        };
+      }
       currentSequence = {
         name,
         startLine: tagStartLine,
@@ -20141,7 +20241,8 @@ function extractSequences(text) {
         lines: [],
         parameters,
         tags,
-        isTest
+        isTest,
+        theoryData: finalTheoryData
       };
       continue;
     }
@@ -20153,7 +20254,8 @@ function extractSequences(text) {
         content: currentSequence.lines.join("\n"),
         parameters: currentSequence.parameters,
         tags: currentSequence.tags,
-        isTest: currentSequence.isTest
+        isTest: currentSequence.isTest,
+        theoryData: currentSequence.theoryData
       });
       currentSequence = null;
       continue;
@@ -23024,34 +23126,93 @@ function countTestSequences(fileContent, tagFilterOptions) {
   const filtered = tagFilterOptions && tagFilterOptions.filters.length > 0 ? testSequences.filter((seq) => sequenceMatchesTags(seq, tagFilterOptions)).length : testSequences.length;
   return { total: testSequences.length, filtered };
 }
+async function loadTheoryFile(theoryPath, workingDir) {
+  const absolutePath = path3.resolve(workingDir, theoryPath);
+  const content = await fsPromises.readFile(absolutePath, "utf-8");
+  return JSON.parse(content);
+}
+function formatCaseLabel(params) {
+  const parts = Object.entries(params).map(([key, value]) => {
+    if (typeof value === "string") {
+      return `${key}="${value}"`;
+    }
+    return `${key}=${value}`;
+  });
+  return `[${parts.join(", ")}]`;
+}
 async function runAllSequences(fileContent, variables, cookieJar, workingDir, apiDefinitions, tagFilterOptions) {
   const allSequences = extractSequences(fileContent);
   const results = [];
   const testSequences = allSequences.filter((seq) => seq.isTest);
   const sequences = tagFilterOptions && tagFilterOptions.filters.length > 0 ? testSequences.filter((seq) => sequenceMatchesTags(seq, tagFilterOptions)) : testSequences;
   for (const seq of sequences) {
-    const defaultArgs = {};
-    if (seq.parameters) {
-      for (const param of seq.parameters) {
-        if (param.defaultValue !== void 0) {
-          defaultArgs[param.name] = param.defaultValue;
+    let theoryData = seq.theoryData;
+    if (theoryData?.source && theoryData.cases.length === 0) {
+      try {
+        const cases = await loadTheoryFile(theoryData.source, workingDir);
+        theoryData = { ...theoryData, cases };
+      } catch (error) {
+        const errorResult = {
+          name: seq.name,
+          success: false,
+          responses: [],
+          scriptResults: [],
+          assertionResults: [],
+          steps: [],
+          errors: [`Failed to load theory file '${theoryData.source}': ${error instanceof Error ? error.message : String(error)}`],
+          duration: 0
+        };
+        results.push(errorResult);
+        continue;
+      }
+    }
+    if (theoryData && theoryData.cases.length > 0) {
+      for (let caseIdx = 0; caseIdx < theoryData.cases.length; caseIdx++) {
+        const caseParams = theoryData.cases[caseIdx];
+        const caseLabel = formatCaseLabel(caseParams);
+        const caseArgs = {};
+        for (const [key, value] of Object.entries(caseParams)) {
+          caseArgs[key] = String(value);
         }
+        const result = await runSequenceWithJar(
+          seq.content,
+          variables,
+          cookieJar,
+          workingDir,
+          fileContent,
+          void 0,
+          void 0,
+          caseArgs,
+          apiDefinitions,
+          tagFilterOptions
+        );
+        result.name = `${seq.name}${caseLabel}`;
+        results.push(result);
       }
+    } else {
+      const defaultArgs = {};
+      if (seq.parameters) {
+        for (const param of seq.parameters) {
+          if (param.defaultValue !== void 0) {
+            defaultArgs[param.name] = param.defaultValue;
+          }
+        }
+      }
+      const result = await runSequenceWithJar(
+        seq.content,
+        variables,
+        cookieJar,
+        workingDir,
+        fileContent,
+        void 0,
+        void 0,
+        defaultArgs,
+        apiDefinitions,
+        tagFilterOptions
+      );
+      result.name = seq.name;
+      results.push(result);
     }
-    const result = await runSequenceWithJar(
-      seq.content,
-      variables,
-      cookieJar,
-      workingDir,
-      fileContent,
-      void 0,
-      void 0,
-      defaultArgs,
-      apiDefinitions,
-      tagFilterOptions
-    );
-    result.name = seq.name;
-    results.push(result);
   }
   return results;
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "norn-cli",
   "displayName": "Norn - REST Client",
   "description": "A powerful REST client for making HTTP requests with sequences, variables, scripts, and cookie support",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "publisher": "Norn-PeterKrustanov",
   "author": {
     "name": "Peter Krastanov"