@boolesai/tspec-cli 1.0.0 → 1.2.0

package/README.md

@@ -21,7 +21,7 @@ npx @boolesai/tspec-cli <command>
 
 ### `tspec validate`
 
-Validate `.tspec` files for schema correctness.
+Validate `.tcase` files for schema correctness.
 
 ```bash
 tspec validate <files...> [options]
@@ -34,13 +34,13 @@ tspec validate <files...> [options]
 **Examples:**
 ```bash
 # Validate a single file
-tspec validate tests/login.http.tspec
+tspec validate tests/login.http.tcase
 
 # Validate multiple files with glob pattern
-tspec validate "tests/**/*.tspec"
+tspec validate "tests/**/*.tcase"
 
 # JSON output for CI/CD
-tspec validate tests/*.tspec --output json
+tspec validate tests/*.tcase --output json
 ```
 
 ### `tspec run`
@@ -63,25 +63,25 @@ tspec run <files...> [options]
 **Examples:**
 ```bash
 # Run tests with default settings
-tspec run tests/*.http.tspec
+tspec run tests/*.http.tcase
 
 # Run with environment variables
-tspec run tests/*.tspec -e API_HOST=api.example.com -e API_KEY=secret
+tspec run tests/*.tcase -e API_HOST=api.example.com -e API_KEY=secret
 
 # Run with parameters
-tspec run tests/*.tspec -p username=testuser -p timeout=5000
+tspec run tests/*.tcase -p username=testuser -p timeout=5000
 
 # Run with higher concurrency
-tspec run tests/*.tspec -c 10
+tspec run tests/*.tcase -c 10
 
 # Verbose output for debugging
-tspec run tests/*.tspec -v
+tspec run tests/*.tcase -v
 
 # JSON output for CI/CD
-tspec run tests/*.tspec --output json
+tspec run tests/*.tcase --output json
 
 # Stop on first failure
-tspec run tests/*.tspec --fail-fast
+tspec run tests/*.tcase --fail-fast
 ```
 
 ### `tspec parse`
@@ -102,13 +102,13 @@ tspec parse <files...> [options]
 **Examples:**
 ```bash
 # Parse and display test cases
-tspec parse tests/login.http.tspec
+tspec parse tests/login.http.tcase
 
 # JSON output for inspection
-tspec parse tests/*.tspec --output json
+tspec parse tests/*.tcase --output json
 
 # With variable substitution
-tspec parse tests/*.tspec -e API_HOST=localhost
+tspec parse tests/*.tcase -e API_HOST=localhost
 ```
 
 ### `tspec list`
@@ -150,7 +150,7 @@ TSpec CLI can run as an MCP server, exposing all commands as tools for AI assist
 | Tool | Description |
 |------|-------------|
 | `tspec_run` | Execute test cases and report results |
-| `tspec_validate` | Validate .tspec files for schema correctness |
+| `tspec_validate` | Validate .tcase files for schema correctness |
 | `tspec_parse` | Parse and display test case information |
 | `tspec_list` | List supported protocols |
 
@@ -191,7 +191,7 @@ Or if installed globally:
 
 ```json
 {
-  "files": ["tests/*.tspec"],
+  "files": ["tests/*.tcase"],
   "concurrency": 5,
   "env": { "API_HOST": "localhost" },
   "params": { "timeout": "5000" },
@@ -204,7 +204,7 @@ Or if installed globally:
 
 ```json
 {
-  "files": ["tests/*.tspec"],
+  "files": ["tests/*.tcase"],
   "output": "text"
 }
 ```
@@ -213,7 +213,7 @@ Or if installed globally:
 
 ```json
 {
-  "files": ["tests/*.tspec"],
+  "files": ["tests/*.tcase"],
   "env": { "API_HOST": "localhost" },
   "params": { "timeout": "5000" },
   "verbose": true,
@@ -244,10 +244,10 @@ Or if installed globally:
 ```yaml
 - name: Run TSpec tests
   run: |
-    npx @boolesai/tspec-cli run tests/*.tspec --output json > results.json
+    npx @boolesai/tspec-cli run tests/*.tcase --output json > results.json
     
 - name: Validate TSpec files
-  run: npx @boolesai/tspec-cli validate tests/*.tspec
+  run: npx @boolesai/tspec-cli validate tests/*.tcase
 ```
 
 ### GitLab CI
@@ -255,7 +255,7 @@ Or if installed globally:
 ```yaml
 test:
   script:
-    - npx @boolesai/tspec-cli run tests/*.tspec --output json
+    - npx @boolesai/tspec-cli run tests/*.tcase --output json
   artifacts:
     reports:
       junit: results.json

package/dist/index.js

@@ -1,9 +1,10 @@
 import { Command } from "commander";
+import { existsSync, statSync, readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { isAbsolute, resolve as resolve$1, basename, relative, dirname, join } from "path";
 import ora from "ora";
-import { getTypeFromFilePath, validateTestCase, clearTemplateCache, parseTestCases, scheduler, registry as registry$1 } from "@boolesai/tspec";
+import { getTypeFromFilePath, isSuiteFile, getSuiteProtocolType, validateTestCase, clearTemplateCache, executeSuite, parseTestCases, scheduler, registry as registry$1 } from "@boolesai/tspec";
 import { glob } from "glob";
-import { isAbsolute, resolve as resolve$1, basename, relative } from "path";
-import { existsSync, statSync } from "fs";
 import chalk from "chalk";
 import process$2 from "node:process";
 async function discoverTSpecFiles(patterns, cwd) {
@@ -15,14 +16,14 @@ async function discoverTSpecFiles(patterns, cwd) {
     if (existsSync(absolutePath)) {
       const stat = statSync(absolutePath);
       if (stat.isFile()) {
-        if (absolutePath.endsWith(".tspec")) {
+        if (absolutePath.endsWith(".tcase")) {
           filePaths.push(absolutePath);
         }
         continue;
       } else if (stat.isDirectory()) {
-        const dirFiles = await glob("**/*.tspec", { cwd: absolutePath, absolute: true });
+        const dirFiles = await glob("**/*.tcase", { cwd: absolutePath, absolute: true });
         if (dirFiles.length === 0) {
-          errors2.push(`No .tspec files found in directory: ${pattern2}`);
+          errors2.push(`No .tcase files found in directory: ${pattern2}`);
         } else {
           filePaths.push(...dirFiles);
         }
@@ -30,9 +31,9 @@ async function discoverTSpecFiles(patterns, cwd) {
       }
     }
     const matches = await glob(pattern2, { cwd: workingDir, absolute: true });
-    const tspecMatches = matches.filter((f) => f.endsWith(".tspec"));
+    const tspecMatches = matches.filter((f) => f.endsWith(".tcase"));
     if (tspecMatches.length === 0) {
-      errors2.push(`No .tspec files matched pattern: ${pattern2}`);
+      errors2.push(`No .tcase files matched pattern: ${pattern2}`);
     } else {
       filePaths.push(...tspecMatches);
     }
@@ -46,6 +47,61 @@ async function discoverTSpecFiles(patterns, cwd) {
   }));
   return { files, errors: errors2 };
 }
+async function discoverAllTestFiles(patterns, cwd) {
+  const workingDir = process.cwd();
+  const tspecPaths = [];
+  const suitePaths = [];
+  const errors2 = [];
+  for (const pattern2 of patterns) {
+    const absolutePath = isAbsolute(pattern2) ? pattern2 : resolve$1(workingDir, pattern2);
+    if (existsSync(absolutePath)) {
+      const stat = statSync(absolutePath);
+      if (stat.isFile()) {
+        if (absolutePath.endsWith(".tcase")) {
+          tspecPaths.push(absolutePath);
+        } else if (isSuiteFile(absolutePath)) {
+          suitePaths.push(absolutePath);
+        }
+        continue;
+      } else if (stat.isDirectory()) {
+        const tspecFiles2 = await glob("**/*.tcase", { cwd: absolutePath, absolute: true });
+        const suiteFiles2 = await glob("**/*.tsuite", { cwd: absolutePath, absolute: true });
+        if (tspecFiles2.length === 0 && suiteFiles2.length === 0) {
+          errors2.push(`No .tcase or .tsuite files found in directory: ${pattern2}`);
+        } else {
+          tspecPaths.push(...tspecFiles2);
+          suitePaths.push(...suiteFiles2);
+        }
+        continue;
+      }
+    }
+    const matches = await glob(pattern2, { cwd: workingDir, absolute: true });
+    const tspecMatches = matches.filter((f) => f.endsWith(".tcase"));
+    const suiteMatches = matches.filter((f) => isSuiteFile(f));
+    if (tspecMatches.length === 0 && suiteMatches.length === 0) {
+      errors2.push(`No .tcase or .tsuite files matched pattern: ${pattern2}`);
+    } else {
+      tspecPaths.push(...tspecMatches);
+      suitePaths.push(...suiteMatches);
+    }
+  }
+  const uniqueTspecPaths = [...new Set(tspecPaths)];
+  const uniqueSuitePaths = [...new Set(suitePaths)];
+  const tspecFiles = uniqueTspecPaths.map((filePath) => ({
+    path: filePath,
+    relativePath: relative(workingDir, filePath),
+    fileName: basename(filePath),
+    protocol: getTypeFromFilePath(filePath)
+  }));
+  const suiteFiles = uniqueSuitePaths.map((filePath) => ({
+    path: filePath,
+    relativePath: relative(workingDir, filePath),
+    fileName: basename(filePath),
+    protocol: getSuiteProtocolType(filePath),
+    isTemplate: filePath.endsWith(".tsuite.yaml")
+  }));
+  return { tspecFiles, suiteFiles, errors: errors2 };
+}
 function formatJson(data) {
   return JSON.stringify(data, null, 2);
 }
@@ -86,6 +142,13 @@ function formatTestResult(result, verbose = false) {
       output += "\n" + assertionLines.join("\n");
     }
   }
+  if (verbose && result.extracted && Object.keys(result.extracted).length > 0) {
+    output += "\n" + chalk.gray("  Extracted:");
+    for (const [key, value] of Object.entries(result.extracted)) {
+      output += `
+    ${key}: ${JSON.stringify(value)}`;
+    }
+  }
   return output;
 }
 function formatTestSummary(summary) {
@@ -131,7 +194,16 @@ function formatParsedTestCase(testCase, options = {}) {
   const lines = [];
   lines.push(chalk.bold(`Test Case: ${tc.id || "unknown"}`));
   if (tc.description) lines.push(`  Description: ${tc.description}`);
-  if (tc.type) lines.push(`  Protocol: ${tc.type}`);
+  if (tc.protocol) lines.push(`  Protocol: ${tc.protocol}`);
+  if (tc.lifecycle) {
+    const lifecycle = tc.lifecycle;
+    if (lifecycle.setup?.length) {
+      lines.push(`  Lifecycle Setup: ${lifecycle.setup.length} action(s)`);
+    }
+    if (lifecycle.teardown?.length) {
+      lines.push(`  Lifecycle Teardown: ${lifecycle.teardown.length} action(s)`);
+    }
+  }
   return lines.join("\n");
 }
 let globalOptions = {};
@@ -183,7 +255,7 @@ async function executeValidate(params) {
   if (fileDescriptors.length === 0) {
     return {
       success: false,
-      output: "No .tspec files found",
+      output: "No .tcase files found",
       data: { results: [] }
     };
   }
@@ -206,7 +278,7 @@ async function executeValidate(params) {
     data: { results }
   };
 }
-const validateCommand = new Command("validate").description("Validate .tspec files for schema correctness").argument("<files...>", "Files or glob patterns to validate").option("-o, --output <format>", "Output format: json, text", "text").option("-q, --quiet", "Only output errors").action(async (files, options) => {
+const validateCommand = new Command("validate").description("Validate .tcase files for schema correctness").argument("<files...>", "Files or glob patterns to validate").option("-o, --output <format>", "Output format: json, text", "text").option("-q, --quiet", "Only output errors").action(async (files, options) => {
   setLoggerOptions({ quiet: options.quiet });
   const spinner = options.quiet ? null : ora("Validating...").start();
   try {
@@ -236,6 +308,7 @@ function formatResult(result) {
     testCaseId: result.testCaseId,
     passed: result.passed,
     duration: result.duration,
+    extracted: Object.keys(result.extracted).length > 0 ? result.extracted : void 0,
     assertions: result.assertions.map((a) => ({
       passed: a.passed,
       type: a.type,
@@ -287,11 +360,11 @@ async function executeRun(params) {
   const output = params.output ?? "text";
   const verbose = params.verbose ?? false;
   const quiet = params.quiet ?? false;
-  const { files: fileDescriptors, errors: resolveErrors } = await discoverTSpecFiles(params.files);
-  if (fileDescriptors.length === 0) {
+  const { tspecFiles, suiteFiles, errors: resolveErrors } = await discoverAllTestFiles(params.files);
+  if (tspecFiles.length === 0 && suiteFiles.length === 0) {
     return {
       success: false,
-      output: "No .tspec files found",
+      output: "No .tcase or .tsuite files found",
       data: {
         results: [],
         summary: { total: 0, passed: 0, failed: 0, passRate: 0, duration: 0 },
@@ -299,6 +372,29 @@ async function executeRun(params) {
       }
     };
   }
+  if (suiteFiles.length > 0) {
+    return executeSuiteRun(suiteFiles, tspecFiles, {
+      env,
+      params: paramValues,
+      concurrency,
+      failFast,
+      output,
+      verbose,
+      quiet
+    });
+  }
+  return executeTspecRun(tspecFiles, {
+    env,
+    params: paramValues,
+    concurrency,
+    failFast,
+    output,
+    verbose,
+    quiet
+  });
+}
+async function executeTspecRun(fileDescriptors, options) {
+  const { env, params: paramValues, concurrency, failFast, output, verbose, quiet } = options;
   const allResults = [];
   const parseErrors = [];
   let totalTestCases = 0;
@@ -367,6 +463,116 @@ ${parseErrors.length} file(s) failed to parse:`);
     data: { results: formattedResults, summary, parseErrors }
   };
 }
+async function executeSuiteRun(suiteFiles, additionalTspecFiles, options) {
+  const { env, params: paramValues, failFast, output, verbose, quiet } = options;
+  const allResults = [];
+  const parseErrors = [];
+  let totalTests = 0;
+  let totalPassed = 0;
+  let totalFailed = 0;
+  let stopped = false;
+  for (const suiteDescriptor of suiteFiles) {
+    if (stopped) break;
+    if (suiteDescriptor.isTemplate) continue;
+    try {
+      const suiteResult = await executeSuite(suiteDescriptor.path, {
+        env,
+        params: paramValues,
+        onSuiteStart: (name) => {
+          if (!quiet) logger.log(chalk.blue(`
+Suite: ${name}`));
+        },
+        onTestStart: (file) => {
+          if (verbose) logger.log(chalk.gray(`  Running: ${file}`));
+        },
+        onTestComplete: (file, result) => {
+          const statusIcon = result.status === "passed" ? chalk.green("✓") : chalk.red("✗");
+          if (!quiet) logger.log(`  ${statusIcon} ${result.name} (${result.duration}ms)`);
+        }
+      });
+      totalTests += suiteResult.stats.total;
+      totalPassed += suiteResult.stats.passed;
+      totalFailed += suiteResult.stats.failed + suiteResult.stats.error;
+      for (const testResult of suiteResult.tests) {
+        allResults.push({
+          testCaseId: testResult.name,
+          passed: testResult.status === "passed",
+          duration: testResult.duration,
+          assertions: (testResult.assertions || []).map((a) => ({
+            passed: a.passed,
+            type: a.type,
+            message: a.message || ""
+          }))
+        });
+      }
+      if (suiteResult.suites) {
+        for (const nestedSuite of suiteResult.suites) {
+          totalTests += nestedSuite.stats.total;
+          totalPassed += nestedSuite.stats.passed;
+          totalFailed += nestedSuite.stats.failed + nestedSuite.stats.error;
+          for (const testResult of nestedSuite.tests) {
+            allResults.push({
+              testCaseId: `${nestedSuite.name}/${testResult.name}`,
+              passed: testResult.status === "passed",
+              duration: testResult.duration,
+              assertions: (testResult.assertions || []).map((a) => ({
+                passed: a.passed,
+                type: a.type,
+                message: a.message || ""
+              }))
+            });
+          }
+        }
+      }
+      if (failFast && (suiteResult.status === "failed" || suiteResult.status === "error")) {
+        stopped = true;
+      }
+    } catch (err) {
+      parseErrors.push({
+        file: suiteDescriptor.path,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  if (additionalTspecFiles.length > 0 && !stopped) {
+    const tspecResult = await executeTspecRun(additionalTspecFiles, options);
+    allResults.push(...tspecResult.data.results);
+    parseErrors.push(...tspecResult.data.parseErrors);
+    totalTests += tspecResult.data.summary.total;
+    totalPassed += tspecResult.data.summary.passed;
+    totalFailed += tspecResult.data.summary.failed;
+  }
+  const summary = {
+    total: totalTests,
+    passed: totalPassed,
+    failed: totalFailed,
+    passRate: totalTests > 0 ? totalPassed / totalTests * 100 : 0,
+    duration: 0
+  };
+  let outputStr;
+  if (output === "json") {
+    outputStr = formatJson({ results: allResults, summary, parseErrors });
+  } else {
+    const parts = [];
+    if (!quiet) {
+      parts.push("\n" + chalk.bold("Results:"));
+      parts.push(formatTestResults(allResults, summary, { format: output, verbose }));
+    } else {
+      parts.push(`${summary.passed}/${summary.total} tests passed (${summary.passRate.toFixed(1)}%)`);
+    }
+    if (parseErrors.length > 0) {
+      parts.push(`
+${parseErrors.length} file(s) failed to parse:`);
+      parseErrors.forEach(({ file, error: error2 }) => parts.push(`  ${file}: ${error2}`));
+    }
+    outputStr = parts.join("\n");
+  }
+  return {
+    success: totalFailed === 0 && parseErrors.length === 0,
+    output: outputStr,
+    data: { results: allResults, summary, parseErrors }
+  };
+}
 const runCommand = new Command("run").description("Execute test cases and report results").argument("<files...>", "Files or glob patterns to run").option("-o, --output <format>", "Output format: json, text", "text").option("-c, --concurrency <number>", "Max concurrent tests", "5").option("-e, --env <key=value>", "Environment variables", parseKeyValue$1, {}).option("-p, --params <key=value>", "Parameters", parseKeyValue$1, {}).option("-v, --verbose", "Verbose output").option("-q, --quiet", "Only output summary").option("--fail-fast", "Stop on first failure").action(async (files, options) => {
   setLoggerOptions({ verbose: options.verbose, quiet: options.quiet });
   const spinner = options.quiet ? null : ora("Running tests...").start();
@@ -421,7 +627,7 @@ async function executeParse(params) {
   if (fileDescriptors.length === 0) {
     return {
       success: false,
-      output: "No .tspec files found",
+      output: "No .tcase files found",
       data: {
         testCases: [],
         parseErrors: [],
@@ -14739,7 +14945,7 @@ const TOOL_DEFINITIONS = [
         files: {
           type: "array",
           items: { type: "string" },
-          description: 'Files or glob patterns to run (e.g., ["tests/*.tspec"])'
+          description: 'Files or glob patterns to run (e.g., ["tests/*.tcase"])'
         },
         concurrency: {
           type: "number",
@@ -14770,7 +14976,7 @@ const TOOL_DEFINITIONS = [
   },
   {
     name: "tspec_validate",
-    description: "Validate .tspec files for schema correctness",
+    description: "Validate .tcase files for schema correctness",
     inputSchema: {
       type: "object",
       properties: {
@@ -14932,8 +15138,11 @@ const mcpCommand = new Command("mcp").description("Start MCP server for tool int
   setLoggerOptions({ quiet: true });
   await startMcpServer();
 });
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = dirname(__filename$1);
+const packageJson = JSON.parse(readFileSync(join(__dirname$1, "../package.json"), "utf-8"));
 const program = new Command();
-program.name("tspec").description("CLI for @boolesai/tspec testing framework").version("1.0.0");
+program.name("tspec").description("CLI for @boolesai/tspec testing framework").version(packageJson.version);
 program.addCommand(validateCommand);
 program.addCommand(runCommand);
 program.addCommand(parseCommand);