@solidxai/core 0.1.10-beta.0 → 0.1.10-beta.10

package/src/subscribers/view-metadata.subscriber.ts

@@ -43,7 +43,7 @@ export class ViewMetadataSubsciber implements EntitySubscriberInterface<ViewMeta
             const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(viewMetadata.model.module.name);
             try {
                 await fs.access(filePath);
-            } catch (error) {
+            } catch (error: any) {
                 this.logger.error(`File not found at path: ${filePath}`);
                 return;
             }

package/src/testing/core/testing-engine.ts

@@ -57,7 +57,7 @@ export class TestingEngine {
         } else {
           await execute();
         }
-      } catch (err) {
+      } catch (err: any) {
         scenarioError = err;
       } finally {
         const durationMs = Date.now() - scenarioStart;
@@ -108,7 +108,7 @@ export class TestingEngine {
           // console.log(`Step ${resolvedStep.name} attempting to saveAs ${resolvedStep.saveAs}`, JSON.stringify(result));
           ctx.resources.set(resolvedStep.saveAs, result);
         }
-      } catch (err) {
+      } catch (err: any) {
         stepError = err;
         throw err;
       } finally {

package/src/testing/reporter/console-reporter.ts

@@ -146,6 +146,10 @@ function formatStepLabel(step: OpStep): string {
 }
 
 export class ConsoleReporter implements Reporter {
+  private totalScenarios = 0;
+  private passedScenarios = 0;
+  private failedScenarios = 0;
+
   onScenarioStart(scenario: { id: string; name?: string }): void {
     const label = scenario.name ? `${scenario.id} (${scenario.name})` : scenario.id;
     console.log(`\n▶ Scenario: ${label}`);
@@ -157,6 +161,12 @@ export class ConsoleReporter implements Reporter {
   ): void {
     const label = scenario.name ? `${scenario.id} (${scenario.name})` : scenario.id;
     const status = result.ok ? "✔" : "✖";
+    this.totalScenarios += 1;
+    if (result.ok) {
+      this.passedScenarios += 1;
+    } else {
+      this.failedScenarios += 1;
+    }
     console.log(`${status} Scenario: ${label} (${result.durationMs}ms)`);
   }
 
@@ -226,4 +236,21 @@ export class ConsoleReporter implements Reporter {
     if (!dataText.length) return;
     console.log(indentLines(dataText, `${STEP_INDENT}${INDENT}${INDENT}`));
   }
+
+  onRunEnd(args: {
+    ok: boolean;
+    total: number;
+    passed: number;
+    failed: number;
+    durationMs: number;
+  }): void {
+    const durationSeconds = (args.durationMs / 1000).toFixed(2);
+    const finalStatus = args.ok ? "PASSED" : "FAILED";
+
+    console.log("\n════════ Test Run Summary ════════");
+    console.log(`Result: Test run ${finalStatus}`);
+    console.log(`Cases: total=${args.total}, passed=${args.passed}, failed=${args.failed}`);
+    console.log(`Duration: ${durationSeconds}s`);
+    console.log("══════════════════════════════════");
+  }
 }

package/src/testing/reporter/reporter.types.ts

@@ -33,4 +33,11 @@ export interface Reporter {
     contentType: string;
     data: Buffer | string;
   }): void;
+  onRunEnd?(args: {
+    ok: boolean;
+    total: number;
+    passed: number;
+    failed: number;
+    durationMs: number;
+  }): void;
 }

package/src/testing/reporter/webhook-reporter.ts

@@ -0,0 +1,116 @@
+import { ConsoleReporter } from "./console-reporter";
+import type { OpStep, ScenarioSpec } from "../contracts/testing-metadata.types";
+import type { StepPhase } from "../contracts/runtime-context.types";
+
+interface TestStepResult {
+  phase: string;
+  operation: string;
+  name?: string;
+  ok: boolean;
+  durationMs: number;
+  error?: string;
+}
+
+interface TestScenarioResult {
+  id: string;
+  name?: string;
+  ok: boolean;
+  durationMs: number;
+  error?: string;
+  steps: TestStepResult[];
+}
+
+export interface TestRunPayload {
+  runName: string;
+  startedAt: string;
+  completedAt: string;
+  durationMs: number;
+  exitCode: number;
+  total: number;
+  passed: number;
+  failed: number;
+  scenarios: TestScenarioResult[];
+}
+
+function formatError(err: unknown): string {
+  if (!err) return "";
+  if (err instanceof Error) return err.stack || err.message;
+  return String(err);
+}
+
+export class WebhookReporter extends ConsoleReporter {
+  private readonly startedAt = new Date();
+  private readonly accumulated: TestScenarioResult[] = [];
+  private currentSteps: TestStepResult[] = [];
+
+  constructor(
+    private readonly webhookUrl: string,
+    private readonly runName: string,
+  ) {
+    super();
+  }
+
+  override onStepEnd(args: {
+    scenarioId: string;
+    phase: StepPhase;
+    step: OpStep;
+    ok: boolean;
+    error?: unknown;
+    durationMs: number;
+  }): void {
+    super.onStepEnd(args);
+    this.currentSteps.push({
+      phase: String(args.phase),
+      operation: args.step.op,
+      name: args.step.name,
+      ok: args.ok,
+      durationMs: args.durationMs,
+      error: args.error ? formatError(args.error) : undefined,
+    });
+  }
+
+  override onScenarioEnd(
+    scenario: ScenarioSpec,
+    result: { ok: boolean; error?: unknown; durationMs: number },
+  ): void {
+    super.onScenarioEnd(scenario, result);
+    this.accumulated.push({
+      id: scenario.id,
+      name: scenario.name,
+      ok: result.ok,
+      durationMs: result.durationMs,
+      error: result.error ? formatError(result.error) : undefined,
+      steps: [...this.currentSteps],
+    });
+    this.currentSteps = [];
+  }
+
+  async flush(exitCode: number): Promise<void> {
+    const completedAt = new Date();
+    const payload: TestRunPayload = {
+      runName: this.runName,
+      startedAt: this.startedAt.toISOString(),
+      completedAt: completedAt.toISOString(),
+      durationMs: completedAt.getTime() - this.startedAt.getTime(),
+      exitCode,
+      total: this.accumulated.length,
+      passed: this.accumulated.filter((s) => s.ok).length,
+      failed: this.accumulated.filter((s) => !s.ok).length,
+      scenarios: this.accumulated,
+    };
+
+    try {
+      const response = await fetch(this.webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(10_000),
+      });
+      if (!response.ok) {
+        console.warn(`[WebhookReporter] Webhook returned ${response.status}`);
+      }
+    } catch (err: any) {
+      console.warn(`[WebhookReporter] Failed to deliver test results: ${err}`);
+    }
+  }
+}

package/src/testing/runner/run-from-metadata.ts

@@ -44,6 +44,7 @@ export type RunnerOptions = {
 };
 
 export async function runFromMetadata(opts: RunnerOptions): Promise<void> {
+  const startedAt = Date.now();
   const registry = new StepRegistry();
   registerApiSteps(registry);
   registerUiSteps(registry);
@@ -71,15 +72,32 @@ export async function runFromMetadata(opts: RunnerOptions): Promise<void> {
   const ui = new PlaywrightAdapter(opts.ui);
   const ctxBase = { resources, reporter, api, ui, specRegistry, testData, options: opts.options };
   const uiStarted = { value: false };
+  let passed = 0;
+  let failed = 0;
+  let runError: unknown;
 
   try {
     for (const scenario of scenarios) {
       if (scenarioNeedsUi(scenario)) {
         await ensureUiStarted(ctxBase, uiStarted);
       }
-      await engine.runScenario(scenario, ctxBase);
+      try {
+        await engine.runScenario(scenario, ctxBase);
+        passed += 1;
+      } catch (error) {
+        failed += 1;
+        runError = error;
+        throw error;
+      }
     }
   } finally {
+    reporter.onRunEnd?.({
+      ok: !runError,
+      total: scenarios.length,
+      passed,
+      failed,
+      durationMs: Date.now() - startedAt,
+    });
     if (uiStarted.value) {
       await ui.stop();
     }