yamltest 1.1.4 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yamltest",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "Declarative YAML-based HTTP, command, and Kubernetes test runner",
   "main": "./src/index.js",
   "bin": {

package/src/cli.js

@@ -36,7 +36,7 @@ const c = {
 // ── Argument parsing ──────────────────────────────────────────────────────────
 function parseArgs(argv) {
   const args = argv.slice(2); // strip node + script
-  const opts = { file: null };
+  const opts = { file: null, check: false };
 
   for (let i = 0; i < args.length; i++) {
     if (args[i] === '-f' || args[i] === '--file') {
@@ -46,6 +46,8 @@ function parseArgs(argv) {
       opts.file = args[i].slice(3);
     } else if (args[i] === '--help' || args[i] === '-h') {
       opts.help = true;
+    } else if (args[i] === '--check') {
+      opts.check = true;
     }
   }
 
@@ -75,6 +77,7 @@ function printUsage() {
       '',
       c.bold('OPTIONS'),
       '  -f, --file <path|->   YAML file to run, or - for stdin',
+      '  --check               Validate YAML structure only; do not run tests',
       '  -h, --help            Show this help',
       '',
       c.bold('ENVIRONMENT'),
@@ -185,6 +188,20 @@ async function main() {
     process.exit(1);
   }
 
+  if (opts.check) {
+    try {
+      const { parseTestDefinitions } = require('./runner');
+      const { validateTestDefinitions } = require('./validate');
+      const defs = parseTestDefinitions(yamlContent);
+      validateTestDefinitions(defs);
+      process.stdout.write(c.green('ok') + '\n');
+      process.exit(0);
+    } catch (err) {
+      process.stderr.write(c.red('invalid: ') + err.message + '\n');
+      process.exit(1);
+    }
+  }
+
   let result;
   try {
     result = await runTests(yamlContent);

package/src/core.js

@@ -1067,6 +1067,26 @@ async function executePodHttpRequestViaPodExec(test) {
       targetUrl += httpConfig.path;
     }
 
+    // If the URL is an IP address and a Host header is set, use --resolve so curl
+    // uses the hostname for TLS SNI — matching how axios behaves for local requests.
+    const parsedTargetUrl = new URL(targetUrl);
+    const hostHeader = httpConfig.headers && Object.entries(httpConfig.headers).find(
+      ([k]) => k.toLowerCase() === 'host'
+    );
+    const urlHostIsIp = net.isIP(parsedTargetUrl.hostname) !== 0;
+    if (urlHostIsIp && hostHeader) {
+      const sniHostname = hostHeader[1];
+      const originalIp = parsedTargetUrl.hostname;
+      const port = parsedTargetUrl.port || (parsedTargetUrl.protocol === 'https:' ? '443' : '80');
+      // Rewrite the URL to use the hostname so curl sends SNI correctly
+      parsedTargetUrl.hostname = sniHostname;
+      parsedTargetUrl.port = port;
+      targetUrl = parsedTargetUrl.toString();
+      // --resolve maps hostname:port to the original IP so the connection still goes to the right place
+      curlCmd += ` --resolve '${sniHostname}:${port}:${originalIp}'`;
+      debugLog(`Added --resolve for SNI: ${sniHostname}:${port}:${originalIp}`);
+    }
+
     curlCmd += ` '${targetUrl}'`;
 
     // Build kubectl exec command

package/src/validate.js

@@ -458,18 +458,41 @@ const testDefinitionSchema = {
     {
       if: { required: ['http'] },
       then: {
-        required: ['source'],
+        required: ['source', 'expect'],
         properties: {
           expect: httpExpectSchema,
           setVars: httpSetVarsSchema,
         },
       },
     },
+    // HTTP: url is required unless source is a local Service (auto-discovery)
+    {
+      if: { required: ['http'] },
+      then: {
+        anyOf: [
+          { type: 'object', properties: { http: { type: 'object', required: ['url'] } } },
+          {
+            type: 'object',
+            properties: {
+              source: {
+                type: 'object',
+                properties: {
+                  type: { const: 'local' },
+                  selector: { type: 'object', properties: { kind: { const: 'Service' } }, required: ['kind'] },
+                },
+                required: ['type', 'selector'],
+              },
+            },
+          },
+        ],
+        errorMessage: 'http.url is required (or use source.selector.kind: Service for auto-discovery)',
+      },
+    },
     // Command: validate expect and setVars shapes
     {
       if: { required: ['command'] },
       then: {
-        required: ['source'],
+        required: ['source', 'expect'],
         properties: {
           expect: commandExpectSchema,
           setVars: commandSetVarsSchema,
@@ -533,10 +556,25 @@ function formatValidationErrors(errors, definitions) {
   const seen = new Set();
   const meaningful = [];
 
+  // Collect instance paths that have a custom errorMessage so we can suppress
+  // the raw sub-errors from their anyOf branches (they are noise).
+  const errorMessagePaths = errors
+    .filter(e => e.keyword === 'errorMessage')
+    .map(e => e.instancePath);
+
+  // Returns true when a custom errorMessage covers this instancePath (exact or ancestor).
+  const coveredByErrorMessage = (instancePath) =>
+    errorMessagePaths.some(p => instancePath === p || instancePath.startsWith(p + '/'));
+
   for (const err of errors) {
     // Skip generic wrapper messages that aren't actionable
     if (err.keyword === 'if' || err.keyword === 'ifThen') continue;
 
+    // Skip raw sub-errors that originate inside an anyOf branch when a custom
+    // errorMessage already covers the same instance path — the errorMessage is
+    // the actionable line; the branch sub-errors are misleading noise.
+    if (err.schemaPath.includes('/anyOf/') && coveredByErrorMessage(err.instancePath)) continue;
+
     const key = `${err.instancePath}|${err.keyword}|${err.message}`;
     if (seen.has(key)) continue;
     seen.add(key);