@o-lang/resolver-tests 1.0.0

package/lib/badge.js

@@ -0,0 +1,27 @@
+const fs = require("fs");
+const path = require("path");
+
+function generateBadge({ passed, outputDir }) {
+  const badgePath = path.join(outputDir, "certified.svg");
+
+  const svg = passed
+    ? `
+<svg xmlns="http://www.w3.org/2000/svg" width="160" height="28">
+  <rect rx="4" width="160" height="28" fill="#2d2d2d"/>
+  <rect rx="4" x="80" width="80" height="28" fill="#4cbb17"/>
+  <text x="40" y="18" fill="#fff" font-size="13" font-family="Arial" text-anchor="middle">O-lang</text>
+  <text x="120" y="18" fill="#fff" font-size="13" font-family="Arial" text-anchor="middle">CERTIFIED</text>
+</svg>`
+    : `
+<svg xmlns="http://www.w3.org/2000/svg" width="160" height="28">
+  <rect rx="4" width="160" height="28" fill="#2d2d2d"/>
+  <rect rx="4" x="80" width="80" height="28" fill="#bb2124"/>
+  <text x="40" y="18" fill="#fff" font-size="13" font-family="Arial" text-anchor="middle">O-lang</text>
+  <text x="120" y="18" fill="#fff" font-size="13" font-family="Arial" text-anchor="middle">FAILED</text>
+</svg>`;
+
+  fs.writeFileSync(badgePath, svg.trim());
+  return badgePath;
+}
+
+module.exports = { generateBadge };

package/lib/runner.js

@@ -0,0 +1,337 @@
+// lib/runner.js
+const path = require("path");
+const fs = require("fs");
+
+// ----------------------
+// Helper: Deep get by path (e.g., "steps[0].saveAs")
+// ----------------------
+function getNestedValue(obj, path) {
+  if (!path) return obj;
+  return path
+    .split(/\.(?![^\[]*\])|[\[\]]/)
+    .filter(Boolean)
+    .reduce((cur, prop) => cur?.[prop], obj);
+}
+
+// ----------------------
+// Validator functions for WORKFLOW AST
+// ----------------------
+function checkAllowlist(ast, expected) {
+  const allowed = ast.allowedResolvers || [];
+  return (
+    Array.isArray(allowed) &&
+    allowed.length === expected.length &&
+    expected.every(r => allowed.includes(r))
+  );
+}
+
+function checkResolverNameNormalization(ast) {
+  const allowed = ast.allowedResolvers || [];
+  const pattern = /^[a-zA-Z][a-zA-Z0-9]*$/;
+  return Array.isArray(allowed) && allowed.every(name => pattern.test(name));
+}
+
+function checkWorkflowName(ast, expected) {
+  return ast.name === expected;
+}
+
+function checkReturnValues(ast, expected) {
+  const returns = ast.returnValues || [];
+  return (
+    Array.isArray(returns) &&
+    returns.length === expected.length &&
+    expected.every(v => returns.includes(v))
+  );
+}
+
+function checkNoWarnings(status, expectedCount = 0) {
+  const warnings = status?.__warnings || [];
+  return warnings.length === expectedCount;
+}
+
+function checkStepType(ast, assertion) {
+  const steps = ast.steps || [];
+  const step = steps[assertion.stepIndex];
+  return step && step.type === assertion.expected;
+}
+
+function checkStepSaveAs(ast, assertion) {
+  const steps = ast.steps || [];
+  const step = steps[assertion.stepIndex];
+  return step && step.saveAs === assertion.expected;
+}
+
+function checkStepFailurePolicies(ast, assertion) {
+  const steps = ast.steps || [];
+  const step = steps[assertion.stepIndex];
+  if (!step || !step.failurePolicies) return false;
+
+  const expected = assertion.expected;
+  return Object.keys(expected).every(code => {
+    const policy = step.failurePolicies[code];
+    return (
+      policy &&
+      policy.action === expected[code].action &&
+      policy.count === expected[code].count
+    );
+  });
+}
+
+function checkContainsWarning(status, assertion) {
+  const warnings = status?.__warnings || [];
+  const needle = assertion.expected_substring.toLowerCase();
+  return warnings.some(w =>
+    (typeof w === "string" ? w : w.message || "")
+      .toLowerCase()
+      .includes(needle)
+  );
+}
+
+function checkStatusGreaterThan(status, assertion) {
+  const value = getNestedValue(status, assertion.path);
+  return typeof value === "number" && value > assertion.expected;
+}
+
+// ----------------------
+// Validator functions for RESOLVER METADATA (R-005)
+// ----------------------
+function checkResolverHasField(resolverMeta, assertion) {
+  return resolverMeta[assertion.field] === assertion.expected;
+}
+
+function checkResolverInputsValid(resolverMeta) {
+  const inputs = resolverMeta.inputs;
+  return (
+    Array.isArray(inputs) &&
+    inputs.every(
+      i =>
+        i &&
+        typeof i.name === "string" &&
+        typeof i.type === "string" &&
+        typeof i.required === "boolean"
+    )
+  );
+}
+
+function checkResolverOutputsValid(resolverMeta) {
+  const outputs = resolverMeta.outputs;
+  return (
+    Array.isArray(outputs) &&
+    outputs.every(
+      o =>
+        o &&
+        typeof o.name === "string" &&
+        typeof o.type === "string"
+    )
+  );
+}
+
+function checkFieldNamesNormalized(resolverMeta, assertion) {
+  const items = resolverMeta[assertion.field] || [];
+  const pattern = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+  return Array.isArray(items) && items.every(item => pattern.test(item.name));
+}
+
+function checkResolverFailuresValid(resolverMeta) {
+  const failures = resolverMeta.failures;
+  if (!failures) return false;
+
+  return (
+    Array.isArray(failures) &&
+    failures.every(
+      f =>
+        f &&
+        typeof f.code === "string" &&
+        typeof f.retries === "number"
+    )
+  );
+}
+
+// ----------------------
+// Assertion handler registry
+// ----------------------
+const assertionHandlers = {
+  // Workflow AST assertions
+  allowed_resolvers_listed: (ast, assertion) =>
+    checkAllowlist(ast, assertion.expected),
+
+  resolver_names_normalized: ast =>
+    checkResolverNameNormalization(ast),
+
+  workflow_name_present: (ast, assertion) =>
+    checkWorkflowName(ast, assertion.expected),
+
+  workflow_return_values: (ast, assertion) =>
+    checkReturnValues(ast, assertion.expected),
+
+  workflow_return_values_empty: (ast, assertion) =>
+    checkReturnValues(ast, assertion.expected),
+
+  no_parse_warnings: (ast, assertion, status) =>
+    checkNoWarnings(status, assertion.expected),
+
+  step_type: (ast, assertion) =>
+    checkStepType(ast, assertion),
+
+  step_saveas: (ast, assertion) =>
+    checkStepSaveAs(ast, assertion),
+
+  step_failure_policies: (ast, assertion) =>
+    checkStepFailurePolicies(ast, assertion),
+
+  // Negative test assertions (R-004)
+  contains_warning: (ast, assertion, status) =>
+    checkContainsWarning(status, assertion),
+
+  status_greater_than: (ast, assertion, status) =>
+    checkStatusGreaterThan(status, assertion),
+
+  // Resolver metadata assertions (R-005)
+  resolver_has_field: (resolverMeta, assertion) =>
+    checkResolverHasField(resolverMeta, assertion),
+
+  resolver_inputs_valid: resolverMeta =>
+    checkResolverInputsValid(resolverMeta),
+
+  resolver_outputs_valid: resolverMeta =>
+    checkResolverOutputsValid(resolverMeta),
+
+  field_names_normalized: (resolverMeta, assertion) =>
+    checkFieldNamesNormalized(resolverMeta, assertion),
+
+  resolver_failures_valid: resolverMeta =>
+    checkResolverFailuresValid(resolverMeta),
+};
+
+// ----------------------
+// Main assertion runner
+// ----------------------
+function runAssertions(testSpec, target, status = {}) {
+  if (!testSpec.assertions?.length) {
+    return { ok: true, message: "No assertions defined" };
+  }
+
+  const failures = [];
+
+  for (const assertion of testSpec.assertions) {
+    const { id, type, severity = "fatal", description } = assertion;
+    let passed = false;
+
+    if (type in assertionHandlers) {
+      passed = assertionHandlers[type](target, assertion, status);
+    } else {
+      failures.push({
+        id,
+        severity,
+        message: `Unknown assertion type: ${type}`,
+      });
+      continue;
+    }
+
+    if (!passed) {
+      failures.push({
+        id,
+        severity,
+        message: description || `Assertion failed: ${id}`,
+      });
+    }
+  }
+
+  return {
+    ok: failures.length === 0,
+    message:
+      failures.length === 0
+        ? "All assertions passed"
+        : failures
+            .map(f => `[${f.severity}] ${f.id}: ${f.message}`)
+            .join("; "),
+    failures,
+  };
+}
+
+// ----------------------
+// Test suite executor
+// ----------------------
+async function runAllTests({ suites, resolver }) {
+  let failed = 0;
+
+  for (const suite of suites) {
+    const suiteDir = path.join(process.cwd(), suite);
+    const testSpecPath = path.join(suiteDir, "test.json");
+
+    if (!fs.existsSync(testSpecPath)) {
+      console.error(`❌ Test spec not found: ${testSpecPath}`);
+      failed++;
+      continue;
+    }
+
+    const testSpec = JSON.parse(fs.readFileSync(testSpecPath, "utf8"));
+    let target;
+    let status = {};
+
+    const fixture = testSpec.fixtures.inputs[0];
+
+    if (fixture.workflow) {
+      // Workflow parsing test (R-001 → R-004)
+      const workflowPath = path.join(suiteDir, fixture.workflow);
+      if (!fs.existsSync(workflowPath)) {
+        console.error(`❌ Workflow file missing: ${workflowPath}`);
+        failed++;
+        continue;
+      }
+
+      const workflowSource = fs.readFileSync(workflowPath, "utf8");
+      try {
+        const parseResult = resolver.parse
+          ? resolver.parse(workflowSource)
+          : { ast: resolver };
+
+        target = parseResult.ast;
+        status = { __warnings: parseResult.__warnings || [] };
+      } catch (err) {
+        console.error(`❌ Parse failed for ${suite}:`, err.message);
+        failed++;
+        continue;
+      }
+    } else if (fixture.resolver_contract) {
+      // Resolver metadata test (R-005)
+      const contractPath = path.join(suiteDir, fixture.resolver_contract);
+      if (!fs.existsSync(contractPath)) {
+        console.error(`❌ Resolver contract missing: ${contractPath}`);
+        failed++;
+        continue;
+      }
+
+      try {
+        target = require(contractPath);
+      } catch (err) {
+        console.error(
+          `❌ Failed to load resolver contract ${suite}:`,
+          err.message
+        );
+        failed++;
+        continue;
+      }
+    } else {
+      console.error(`❌ Unrecognized fixture in ${suite}`);
+      failed++;
+      continue;
+    }
+
+    const result = runAssertions(testSpec, target, status);
+
+    if (!result.ok) {
+      console.error(`❌ ${suite} failed: ${result.message}`);
+      failed++;
+    } else {
+      console.log(`✅ ${suite} passed`);
+    }
+  }
+
+  return { failed };
+}
+
+module.exports = {
+  runAssertions,
+  runAllTests,
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@o-lang/resolver-tests",
+  "version": "1.0.0",
+  "description": "Official O-Lang Resolver Test Harness — locked single entrypoint",
+  "main": "run.js",
+  "type": "commonjs",
+  "scripts": {
+    "test": "node run.js",
+    "test:kernel": "node run-kernel.js",
+    "test:kernel:json": "node run-kernel.js --json",
+    "test:kernel:badge": "node run-kernel.js --badge",
+    "test:kernel:all": "node run-kernel.js --json --badge"
+  },
+  "bin": {
+    "olang-resolver-test": "run.js"
+  },
+  "keywords": [
+    "olang",
+    "resolver",
+    "test",
+    "harness",
+    "locked-entrypoint"
+  ],
+  "author": "O-Lang Team",
+  "license": "MIT",
+  "devDependencies": {
+    "fs-extra": "^11.1.1"
+  }
+}

package/reference-resolver/index.js

@@ -0,0 +1,10 @@
+module.exports = {
+  name: "olang-reference-resolver",
+
+  resolve(input) {
+    return {
+      ok: true,
+      output: input
+    };
+  }
+};

package/run-kernel.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+const path = require("path");
+const fs = require("fs");
+const { writeFileSync } = require("fs");
+
+// ----------------------
+// Load kernel from npm
+// ----------------------
+let kernel;
+try {
+  kernel = require("@o-lang/olang"); // Published kernel
+} catch (err) {
+  console.error("❌ Failed to load @o-lang/olang kernel from node_modules");
+  console.error(err);
+  process.exit(1);
+}
+
+// ----------------------
+// CLI arg parsing
+// ----------------------
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const opts = {
+    suites: [],
+    json: false,
+    badge: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--suite" && args[i + 1]) {
+      opts.suites.push(args[++i]);
+    }
+    if (args[i] === "--json") {
+      opts.json = true;
+    }
+    if (args[i] === "--badge") {
+      opts.badge = true;
+    }
+  }
+
+  return opts;
+}
+
+// ----------------------
+// Import resolver-test runner
+// ----------------------
+const { runAllTests } = require("./lib/runner");
+
+// ----------------------
+// Badge generator
+// ----------------------
+function generateBadge(passed) {
+  const color = passed ? "green" : "red";
+  const text = passed ? "certified" : "failed";
+  const badgeSvg = `
+<svg xmlns="http://www.w3.org/2000/svg" width="120" height="20">
+  <rect width="120" height="20" fill="${color}" rx="3" ry="3"/>
+  <text x="60" y="14" fill="#fff" font-family="Verdana" font-size="12" text-anchor="middle">${text}</text>
+</svg>
+`.trim();
+
+  return badgeSvg;
+}
+
+// ----------------------
+// Main
+// ----------------------
+(async () => {
+  try {
+    const opts = parseArgs();
+
+    const suites =
+      opts.suites.length > 0
+        ? opts.suites
+        : [
+            "R-001-allowlist",
+            "R-002-io-contract",
+            "R-003-failure-modes",
+            "R-004-invalid-syntax",
+            "R-005-resolver-metadata-contract"
+          ];
+
+    const result = await runAllTests({
+      suites,
+      resolver: kernel
+    });
+
+    // JSON output
+    if (opts.json) {
+      const report = {
+        passed: result.failed === 0,
+        failedTests: result.failed,
+        suites
+      };
+      console.log(JSON.stringify(report, null, 2));
+      writeFileSync("conformance-report.json", JSON.stringify(report, null, 2));
+    }
+
+    // Badge output
+    if (opts.badge) {
+      const svg = generateBadge(result.failed === 0);
+      const badgePath = path.join("badges", "certified.svg");
+      if (!fs.existsSync("badges")) fs.mkdirSync("badges");
+      writeFileSync(badgePath, svg, "utf8");
+      console.log(`🏷  Badge written to ${badgePath}`);
+    }
+
+    if (result.failed > 0) {
+      console.error(`❌ ${result.failed} resolver test(s) failed`);
+      process.exit(1);
+    }
+
+    console.log("✅ All resolver tests passed");
+    process.exit(0);
+
+  } catch (err) {
+    console.error("🔥 Kernel test runner crashed");
+    console.error(err);
+    process.exit(1);
+  }
+})();

package/run.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+
+const path = require("path");
+const fs = require("fs");
+
+// ----------------------
+// Load resolver from env
+// ----------------------
+let resolverPath = process.env.OLANG_RESOLVER;
+
+if (!resolverPath) {
+  console.error("❌ OLANG_RESOLVER environment variable is not set");
+  process.exit(1);
+}
+
+// Normalize relative paths
+if (resolverPath.startsWith(".")) {
+  resolverPath = path.resolve(process.cwd(), resolverPath);
+}
+
+// Verify resolver exists
+if (!fs.existsSync(resolverPath)) {
+  console.error(`❌ Resolver path does not exist: ${resolverPath}`);
+  process.exit(1);
+}
+
+let resolver;
+try {
+  resolver = require(resolverPath);
+} catch (err) {
+  console.error(`❌ Failed to load resolver from ${resolverPath}`);
+  console.error(err);
+  process.exit(1);
+}
+
+// ----------------------
+// CLI arg parsing
+// ----------------------
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const opts = {
+    suites: [],
+    json: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--suite" && args[i + 1]) {
+      opts.suites.push(args[++i]);
+    }
+    if (args[i] === "--json") {
+      opts.json = true;
+    }
+  }
+
+  return opts;
+}
+
+// ----------------------
+// Imports
+// ----------------------
+const { runAllTests } = require("./lib/runner");
+const { generateBadge } = require("./lib/badge");
+
+// ----------------------
+// Main
+// ----------------------
+(async () => {
+  try {
+    const opts = parseArgs();
+
+    const suites =
+      opts.suites.length > 0
+        ? opts.suites
+        : [
+            "R-001-allowlist",
+            "R-002-io-contract",
+            "R-003-failure-modes",
+            "R-004-invalid-syntax",
+            "R-005-resolver-metadata-contract"
+          ];
+
+    const result = await runAllTests({
+      suites,
+      resolver
+    });
+
+    // ----------------------
+    // Generate conformance report
+    // ----------------------
+    const conformanceReport = {
+      resolver: resolver?.resolverName || "unknown",
+      timestamp: new Date().toISOString(),
+      results: suites.map(suite => ({
+        suite,
+        status: result.failed > 0 ? "fail" : "pass"
+      }))
+    };
+
+    fs.writeFileSync(
+      path.join(process.cwd(), "conformance.json"),
+      JSON.stringify(conformanceReport, null, 2)
+    );
+
+    // ----------------------
+    // Generate certification badge
+    // ----------------------
+    generateBadge({
+      passed: result.failed === 0,
+      outputDir: process.cwd()
+    });
+
+    // ----------------------
+    // Output handling
+    // ----------------------
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    }
+
+    if (result.failed > 0) {
+      console.error(`❌ ${result.failed} resolver test(s) failed`);
+      console.error("❌ Resolver is NOT certified");
+      process.exit(1);
+    }
+
+    console.log("✅ All resolver tests passed");
+    console.log("🏅 Resolver is O-lang CERTIFIED");
+    process.exit(0);
+
+  } catch (err) {
+    console.error("🔥 Resolver test runner crashed");
+    console.error(err);
+    process.exit(1);
+  }
+})();

package/schema/conformance.schema.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "O-lang Resolver Conformance Report",
+  "type": "object",
+  "required": ["resolver", "timestamp", "results"],
+  "properties": {
+    "resolver": {
+      "type": "string",
+      "description": "Resolver name or package identifier"
+    },
+    "timestamp": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "results": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["suite", "status"],
+        "properties": {
+          "suite": { "type": "string" },
+          "status": { "type": "string", "enum": ["pass", "fail"] },
+          "failures": {
+            "type": "array",
+            "items": { "type": "string" }
+          }
+        }
+      }
+    }
+  }
+}