@partylayer/conformance-runner 0.2.8 → 0.2.10

package/dist/index.js

@@ -1,97 +1,585 @@
 #!/usr/bin/env node
-/**
- * PartyLayer Conformance Runner CLI
- *
- * Runs adapter conformance tests and generates reports.
- */
+import { CapabilityNotSupportedError, CIP0103_MANDATORY_METHODS, CIP0103_EVENTS } from '@partylayer/core';
 import { program } from 'commander';
-import { readFileSync, writeFileSync, existsSync } from 'fs';
-import { loadAdapter } from './loader';
-import { runConformanceTests, createMockContext } from './tests';
-import { generateReport, formatReportText } from './report';
-program
-    .name('partylayer-conformance')
-    .description('Run conformance tests for PartyLayer wallet adapters')
-    .version('0.1.0');
-program
-    .command('run')
-    .description('Run conformance tests for an adapter')
-    .requiredOption('--adapter <packageOrPath>', 'Adapter package name or path')
-    .option('--network <network>', 'Network to use', 'devnet')
-    .option('--registryUrl <url>', 'Registry URL (optional)')
-    .option('--output <path>', 'Output JSON report path', 'conformance-report.json')
-    .action(async (options) => {
+import { writeFileSync, existsSync, readFileSync } from 'fs';
+import { createRequire } from 'module';
+import { resolve } from 'path';
+import { pathToFileURL } from 'url';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/cip0103-tests.ts
+var cip0103_tests_exports = {};
+__export(cip0103_tests_exports, {
+  formatCIP0103Report: () => formatCIP0103Report,
+  runCIP0103ConformanceTests: () => runCIP0103ConformanceTests
+});
+async function runCIP0103ConformanceTests(provider) {
+  const results = [];
+  results.push({
+    name: "Provider has request() method",
+    category: "interface",
+    passed: typeof provider.request === "function"
+  });
+  results.push({
+    name: "Provider has on() method",
+    category: "interface",
+    passed: typeof provider.on === "function"
+  });
+  results.push({
+    name: "Provider has emit() method",
+    category: "interface",
+    passed: typeof provider.emit === "function"
+  });
+  results.push({
+    name: "Provider has removeListener() method",
+    category: "interface",
+    passed: typeof provider.removeListener === "function"
+  });
+  for (const method of CIP0103_MANDATORY_METHODS) {
     try {
-        console.log(`Loading adapter: ${options.adapter}`);
-        const adapter = await loadAdapter(options.adapter);
-        console.log(`Running conformance tests for: ${adapter.name} (${adapter.walletId})`);
-        const context = createMockContext();
-        context.network = options.network;
-        const startTime = Date.now();
-        const testResults = await runConformanceTests(adapter, context);
-        const report = generateReport({
-            walletId: adapter.walletId,
-            name: adapter.name,
-        }, testResults, startTime);
-        // Write JSON report
-        writeFileSync(options.output, JSON.stringify(report, null, 2));
-        console.log(`\nReport written to: ${options.output}`);
-        // Print human-readable summary
-        console.log('\n' + formatReportText(report));
-        // Exit with error code if tests failed
-        if (report.results.failed > 0) {
-            process.exit(1);
-        }
-    }
-    catch (err) {
-        console.error('Error running conformance tests:', err);
-        process.exit(1);
+      await provider.request({ method, params: {} });
+      results.push({
+        name: `Method "${method}" is handled`,
+        category: "method",
+        passed: true
+      });
+    } catch (err) {
+      const isValidError = isNumericCodeError(err);
+      results.push({
+        name: `Method "${method}" is handled`,
+        category: "method",
+        passed: isValidError,
+        error: isValidError ? void 0 : `Expected ProviderRpcError with numeric code, got: ${String(err)}`,
+        details: isValidError ? { code: err.code } : void 0
+      });
     }
-});
-program
-    .command('report')
-    .description('Format and display a conformance report')
-    .requiredOption('--input <path>', 'Input JSON report path')
-    .action((options) => {
+  }
+  const noopHandler = () => {
+  };
+  const onResult = provider.on("statusChanged", noopHandler);
+  results.push({
+    name: "on() returns Provider for chaining",
+    category: "event",
+    passed: onResult === provider,
+    error: onResult === provider ? void 0 : "on() did not return the Provider instance"
+  });
+  const removeResult = provider.removeListener("statusChanged", noopHandler);
+  results.push({
+    name: "removeListener() returns Provider for chaining",
+    category: "event",
+    passed: removeResult === provider,
+    error: removeResult === provider ? void 0 : "removeListener() did not return the Provider instance"
+  });
+  try {
+    await provider.request({ method: "__cip0103_conformance_nonexistent__" });
+    results.push({
+      name: "Unsupported method returns ProviderRpcError",
+      category: "error",
+      passed: false,
+      error: "Expected error for unsupported method, got success"
+    });
+  } catch (err) {
+    const hasNumericCode = isNumericCodeError(err);
+    results.push({
+      name: "Unsupported method returns error with numeric code",
+      category: "error",
+      passed: hasNumericCode,
+      error: hasNumericCode ? void 0 : `Expected numeric code, got: ${String(err)}`,
+      details: hasNumericCode ? { code: err.code } : void 0
+    });
+    if (hasNumericCode) {
+      const code = err.code;
+      const isCorrectCode = code === 4200 || code === -32601;
+      results.push({
+        name: "Unsupported method uses code 4200 or -32601",
+        category: "error",
+        passed: isCorrectCode,
+        error: isCorrectCode ? void 0 : `Expected code 4200 or -32601, got ${code}`,
+        details: { code }
+      });
+    }
+  }
+  const emitResult = provider.emit("__cip0103_conformance_test__");
+  results.push({
+    name: "emit() returns boolean",
+    category: "interface",
+    passed: typeof emitResult === "boolean",
+    error: typeof emitResult === "boolean" ? void 0 : `emit() returned ${typeof emitResult}`
+  });
+  {
+    const txEvents = [];
+    const txHandler = (...args) => txEvents.push(...args);
+    provider.on(CIP0103_EVENTS.TX_CHANGED, txHandler);
     try {
-        if (!existsSync(options.input)) {
-            console.error(`Report file not found: ${options.input}`);
-            process.exit(1);
-        }
-        const reportJson = readFileSync(options.input, 'utf-8');
-        const report = JSON.parse(reportJson);
-        console.log(formatReportText(report));
-        if (report.results.failed > 0) {
-            process.exit(1);
-        }
-    }
-    catch (err) {
-        console.error('Error reading report:', err);
-        process.exit(1);
+      await provider.request({
+        method: "prepareExecute",
+        params: { tx: { _conformance: true } }
+      });
+      results.push({
+        name: 'prepareExecute emits txChanged with "pending"',
+        category: "lifecycle",
+        passed: txEvents.some(
+          (e) => typeof e === "object" && e !== null && e.status === "pending"
+        ),
+        error: txEvents.length === 0 ? "No txChanged events emitted" : void 0
+      });
+      const signedEvent = txEvents.find(
+        (e) => typeof e === "object" && e !== null && e.status === "signed"
+      );
+      results.push({
+        name: 'prepareExecute emits txChanged with "signed"',
+        category: "lifecycle",
+        passed: !!signedEvent
+      });
+      if (signedEvent) {
+        const payload = signedEvent.payload;
+        results.push({
+          name: "signed event has payload.signature (string)",
+          category: "lifecycle",
+          passed: typeof payload?.signature === "string"
+        });
+        results.push({
+          name: "signed event has payload.signedBy (string)",
+          category: "lifecycle",
+          passed: typeof payload?.signedBy === "string"
+        });
+        results.push({
+          name: "signed event has payload.party (string)",
+          category: "lifecycle",
+          passed: typeof payload?.party === "string"
+        });
+      }
+      const hasTerminal = txEvents.some(
+        (e) => typeof e === "object" && e !== null && (e.status === "executed" || e.status === "failed")
+      );
+      results.push({
+        name: "prepareExecute reaches terminal tx state (executed or failed)",
+        category: "lifecycle",
+        passed: hasTerminal
+      });
+      const executedEvent = txEvents.find(
+        (e) => typeof e === "object" && e !== null && e.status === "executed"
+      );
+      if (executedEvent) {
+        const payload = executedEvent.payload;
+        results.push({
+          name: "executed event has payload.updateId (string)",
+          category: "lifecycle",
+          passed: typeof payload?.updateId === "string"
+        });
+        results.push({
+          name: "executed event has payload.completionOffset (number)",
+          category: "lifecycle",
+          passed: typeof payload?.completionOffset === "number"
+        });
+      }
+    } catch {
+      results.push({
+        name: "prepareExecute emits txChanged events (despite error)",
+        category: "lifecycle",
+        passed: txEvents.length > 0,
+        error: txEvents.length === 0 ? "No txChanged events emitted before error" : void 0
+      });
+    } finally {
+      provider.removeListener(CIP0103_EVENTS.TX_CHANGED, txHandler);
     }
+  }
+  try {
+    await provider.request({
+      method: "ledgerApi",
+      params: { requestMethod: "GET", resource: "/v1/state/acs" }
+    });
+    results.push({
+      name: "ledgerApi returns result (supported)",
+      category: "method",
+      passed: true
+    });
+  } catch (err) {
+    const isHandled = isNumericCodeError(err);
+    results.push({
+      name: "ledgerApi is handled (returns result or ProviderRpcError)",
+      category: "method",
+      passed: isHandled,
+      error: isHandled ? void 0 : `Unexpected error type: ${String(err)}`
+    });
+  }
+  const passed = results.filter((r) => r.passed).length;
+  return {
+    total: results.length,
+    passed,
+    failed: results.length - passed,
+    results
+  };
+}
+function isNumericCodeError(err) {
+  if (typeof err !== "object" || err === null) return false;
+  return typeof err.code === "number";
+}
+function formatCIP0103Report(report) {
+  const lines = [
+    "\u2550\u2550\u2550 CIP-0103 Conformance Report \u2550\u2550\u2550",
+    "",
+    `Total: ${report.total}  Passed: ${report.passed}  Failed: ${report.failed}`,
+    ""
+  ];
+  const categories = ["interface", "method", "event", "error", "lifecycle"];
+  for (const cat of categories) {
+    const catResults = report.results.filter((r) => r.category === cat);
+    if (catResults.length === 0) continue;
+    lines.push(`\u2500\u2500 ${cat.toUpperCase()} \u2500\u2500`);
+    for (const r of catResults) {
+      const icon = r.passed ? "\u2713" : "\u2717";
+      lines.push(`  ${icon} ${r.name}`);
+      if (r.error) {
+        lines.push(`    \u2192 ${r.error}`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var init_cip0103_tests = __esm({
+  "src/cip0103-tests.ts"() {
+  }
 });
-program
-    .command('run-cip0103')
-    .description('Run CIP-0103 conformance tests against a Provider')
-    .option('--output <path>', 'Output JSON report path', 'cip0103-report.json')
-    .action(async (options) => {
+var nodeRequire = createRequire(import.meta.url);
+async function loadAdapter(packageNameOrPath) {
+  let adapterPath;
+  if (packageNameOrPath.startsWith(".") || packageNameOrPath.startsWith("/")) {
+    adapterPath = resolve(packageNameOrPath);
+  } else {
     try {
-        const { runCIP0103ConformanceTests, formatCIP0103Report } = await import('./cip0103-tests');
-        const { PartyLayerProvider } = await import('@partylayer/provider');
-        console.log('Running CIP-0103 conformance tests...');
-        const provider = new PartyLayerProvider();
-        const report = await runCIP0103ConformanceTests(provider);
-        writeFileSync(options.output, JSON.stringify(report, null, 2));
-        console.log(`\nReport written to: ${options.output}`);
-        console.log('\n' + formatCIP0103Report(report));
-        if (report.failed > 0) {
-            process.exit(1);
-        }
-    }
-    catch (err) {
-        console.error('Error running CIP-0103 conformance tests:', err);
-        process.exit(1);
+      adapterPath = nodeRequire.resolve(packageNameOrPath);
+    } catch {
+      throw new Error(`Cannot resolve adapter: ${packageNameOrPath}`);
+    }
+  }
+  try {
+    const moduleUrl = pathToFileURL(adapterPath).href;
+    const module = await import(moduleUrl);
+    const adapter = module.default || module[Object.keys(module)[0]];
+    if (!adapter) {
+      throw new Error("No adapter export found");
+    }
+    if (typeof adapter === "function") {
+      return new adapter();
+    }
+    return adapter;
+  } catch (err) {
+    try {
+      const module = nodeRequire(adapterPath);
+      const adapter = module.default || module[Object.keys(module)[0]];
+      if (!adapter) {
+        throw new Error("No adapter export found");
+      }
+      if (typeof adapter === "function") {
+        return new adapter();
+      }
+      return adapter;
+    } catch (cjsErr) {
+      throw new Error(
+        `Failed to load adapter: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+}
+function createMockContext() {
+  return {
+    appName: "Conformance Test",
+    origin: "https://test.example.com",
+    network: "devnet",
+    logger: {
+      debug: () => {
+      },
+      info: () => {
+      },
+      warn: () => {
+      },
+      error: () => {
+      }
+    },
+    telemetry: void 0,
+    registry: {
+      getWallet: async () => ({})
+    },
+    crypto: {
+      encrypt: async (data) => data,
+      decrypt: async (data) => data,
+      generateKey: async () => "test-key"
+    },
+    storage: {
+      get: async () => null,
+      set: async () => {
+      },
+      remove: async () => {
+      },
+      clear: async () => {
+      }
+    },
+    timeout: async (ms) => {
+      await new Promise((resolve2) => setTimeout(resolve2, ms));
+      throw new Error("Timeout");
+    }
+  };
+}
+async function runConformanceTests(adapter, context) {
+  const results = [];
+  results.push({
+    name: "Adapter has walletId",
+    passed: typeof adapter.walletId === "string" && adapter.walletId.length > 0,
+    details: { walletId: adapter.walletId }
+  });
+  results.push({
+    name: "Adapter has name",
+    passed: typeof adapter.name === "string" && adapter.name.length > 0,
+    details: { name: adapter.name }
+  });
+  let capabilities;
+  try {
+    capabilities = adapter.getCapabilities();
+    results.push({
+      name: "getCapabilities returns array",
+      passed: Array.isArray(capabilities),
+      details: { capabilities }
+    });
+    const hasConnect = capabilities.includes("connect");
+    results.push({
+      name: 'Capabilities include "connect"',
+      passed: hasConnect,
+      details: { capabilities }
+    });
+  } catch (err) {
+    results.push({
+      name: "getCapabilities throws error",
+      passed: false,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return results;
+  }
+  try {
+    const detect = await adapter.detectInstalled();
+    results.push({
+      name: "detectInstalled returns valid result",
+      passed: typeof detect === "object" && typeof detect.installed === "boolean" && (detect.installed || typeof detect.reason === "string"),
+      details: { detect }
+    });
+  } catch (err) {
+    results.push({
+      name: "detectInstalled throws error",
+      passed: false,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  if (capabilities.includes("signMessage")) {
+    if (typeof adapter.signMessage !== "function") {
+      results.push({
+        name: "signMessage capability declared but method missing",
+        passed: false,
+        error: "signMessage capability declared but method not implemented"
+      });
+    }
+  } else {
+    if (typeof adapter.signMessage === "function") {
+      try {
+        await adapter.signMessage(context, {}, { message: "test" });
+        results.push({
+          name: "signMessage throws CapabilityNotSupportedError when not supported",
+          passed: false,
+          error: "signMessage did not throw error"
+        });
+      } catch (err) {
+        const passed = err instanceof CapabilityNotSupportedError;
+        results.push({
+          name: "signMessage throws CapabilityNotSupportedError when not supported",
+          passed,
+          error: passed ? void 0 : err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  }
+  if (capabilities.includes("signTransaction")) {
+    if (typeof adapter.signTransaction !== "function") {
+      results.push({
+        name: "signTransaction capability declared but method missing",
+        passed: false,
+        error: "signTransaction capability declared but method not implemented"
+      });
+    }
+  }
+  if (capabilities.includes("submitTransaction")) {
+    if (typeof adapter.submitTransaction !== "function") {
+      results.push({
+        name: "submitTransaction capability declared but method missing",
+        passed: false,
+        error: "submitTransaction capability declared but method not implemented"
+      });
+    }
+  }
+  {
+    const hasRestoreMethod = typeof adapter.restore === "function";
+    const declaresRestore = capabilities.includes("restore");
+    if (declaresRestore && !hasRestoreMethod) {
+      results.push({
+        name: "restore capability declared but method missing",
+        passed: false,
+        error: `${adapter.name}: declares 'restore' capability but does not implement restore()`
+      });
+    } else if (hasRestoreMethod && !declaresRestore) {
+      results.push({
+        name: "restore method implemented but capability not declared",
+        passed: false,
+        error: `${adapter.name}: implements restore() but getCapabilities() does not include 'restore'. Add 'restore' to the returned array so consumers can discover the feature.`
+      });
+    } else {
+      results.push({
+        name: "restore capability / method symmetry",
+        passed: true,
+        details: { hasRestoreMethod, declaresRestore }
+      });
+    }
+  }
+  return results;
+}
+
+// src/report.ts
+function generateReport(adapter, tests, startTime) {
+  const passed = tests.filter((t) => t.passed).length;
+  const failed = tests.filter((t) => !t.passed).length;
+  return {
+    adapter,
+    environment: {
+      nodeVersion: process.version,
+      platform: process.platform,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    results: {
+      total: tests.length,
+      passed,
+      failed,
+      duration: Date.now() - startTime
+    },
+    tests
+  };
+}
+function formatReportText(report) {
+  const lines = [];
+  lines.push("=".repeat(60));
+  lines.push("PartyLayer Adapter Conformance Report");
+  lines.push("=".repeat(60));
+  lines.push("");
+  lines.push(`Adapter: ${report.adapter.name} (${report.adapter.walletId})`);
+  if (report.adapter.version) {
+    lines.push(`Version: ${report.adapter.version}`);
+  }
+  lines.push(`Environment: Node ${report.environment.nodeVersion} on ${report.environment.platform}`);
+  lines.push(`Timestamp: ${report.environment.timestamp}`);
+  lines.push("");
+  lines.push("Summary:");
+  lines.push(`  Total Tests: ${report.results.total}`);
+  lines.push(`  Passed: ${report.results.passed}`);
+  lines.push(`  Failed: ${report.results.failed}`);
+  lines.push(`  Duration: ${report.results.duration}ms`);
+  lines.push("");
+  lines.push("Test Results:");
+  lines.push("-".repeat(60));
+  report.tests.forEach((test, index) => {
+    const status = test.passed ? "\u2713" : "\u2717";
+    lines.push(`${index + 1}. ${status} ${test.name}`);
+    if (test.details) {
+      Object.entries(test.details).forEach(([key, value]) => {
+        lines.push(`   ${key}: ${JSON.stringify(value)}`);
+      });
+    }
+    if (test.error) {
+      lines.push(`   Error: ${test.error}`);
+    }
+  });
+  lines.push("-".repeat(60));
+  lines.push("");
+  if (report.results.failed === 0) {
+    lines.push("\u2713 All tests passed!");
+  } else {
+    lines.push(`\u2717 ${report.results.failed} test(s) failed`);
+  }
+  return lines.join("\n");
+}
+
+// src/index.ts
+program.name("partylayer-conformance").description("Run conformance tests for PartyLayer wallet adapters").version("0.1.0");
+program.command("run").description("Run conformance tests for an adapter").requiredOption("--adapter <packageOrPath>", "Adapter package name or path").option("--network <network>", "Network to use", "devnet").option("--registryUrl <url>", "Registry URL (optional)").option("--output <path>", "Output JSON report path", "conformance-report.json").action(async (options) => {
+  try {
+    console.log(`Loading adapter: ${options.adapter}`);
+    const adapter = await loadAdapter(options.adapter);
+    console.log(`Running conformance tests for: ${adapter.name} (${adapter.walletId})`);
+    const context = createMockContext();
+    context.network = options.network;
+    const startTime = Date.now();
+    const testResults = await runConformanceTests(adapter, context);
+    const report = generateReport(
+      {
+        walletId: adapter.walletId,
+        name: adapter.name
+      },
+      testResults,
+      startTime
+    );
+    writeFileSync(options.output, JSON.stringify(report, null, 2));
+    console.log(`
+Report written to: ${options.output}`);
+    console.log("\n" + formatReportText(report));
+    if (report.results.failed > 0) {
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error("Error running conformance tests:", err);
+    process.exit(1);
+  }
+});
+program.command("report").description("Format and display a conformance report").requiredOption("--input <path>", "Input JSON report path").action((options) => {
+  try {
+    if (!existsSync(options.input)) {
+      console.error(`Report file not found: ${options.input}`);
+      process.exit(1);
+    }
+    const reportJson = readFileSync(options.input, "utf-8");
+    const report = JSON.parse(reportJson);
+    console.log(formatReportText(report));
+    if (report.results.failed > 0) {
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error("Error reading report:", err);
+    process.exit(1);
+  }
+});
+program.command("run-cip0103").description("Run CIP-0103 conformance tests against a Provider").option("--output <path>", "Output JSON report path", "cip0103-report.json").action(async (options) => {
+  try {
+    const { runCIP0103ConformanceTests: runCIP0103ConformanceTests2, formatCIP0103Report: formatCIP0103Report2 } = await Promise.resolve().then(() => (init_cip0103_tests(), cip0103_tests_exports));
+    const { PartyLayerProvider } = await import('@partylayer/provider');
+    console.log("Running CIP-0103 conformance tests...");
+    const provider = new PartyLayerProvider();
+    const report = await runCIP0103ConformanceTests2(provider);
+    writeFileSync(options.output, JSON.stringify(report, null, 2));
+    console.log(`
+Report written to: ${options.output}`);
+    console.log("\n" + formatCIP0103Report2(report));
+    if (report.failed > 0) {
+      process.exit(1);
     }
+  } catch (err) {
+    console.error("Error running CIP-0103 conformance tests:", err);
+    process.exit(1);
+  }
 });
 program.parse();
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map