@elench/testkit 0.1.85 → 0.1.87

package/lib/cli/tui/inspect-state.mjs

@@ -0,0 +1,321 @@
+import {
+  applyArtifactToModel,
+  buildSnapshot,
+  createEmptyInspectModel,
+  cyclePane,
+  findEntryIdForFile,
+  findEntryIdForService,
+  finishModel,
+  initModelFromPlans,
+  markFileFinished,
+  markFileRunning,
+  markPlannedSkip,
+  markRuntimeError,
+  markServiceSkipped,
+  resetInspectModel,
+  revealEntry,
+  setPane,
+  setPhase,
+  setRegressionCatalog,
+  setTotalFileCount,
+  toggleCollapsed,
+  updateFilter,
+} from "./inspect-model.mjs";
+
+export function createInspectState({ dataSource = "live" } = {}) {
+  const model = createEmptyInspectModel(dataSource);
+  let mode = dataSource === "artifact" ? "complete" : "running";
+  let notice = null;
+  let agentSession = null;
+  const listeners = new Set();
+
+  function notify() {
+    for (const callback of listeners) callback();
+  }
+
+  function appendTranscriptEntry(kind, text) {
+    if (!agentSession || !text) return;
+    const normalizedText = String(text);
+    const entries = agentSession.transcriptEntries || [];
+    const lastEntry = entries.at(-1);
+    if (kind === "assistant" && lastEntry?.kind === "assistant") {
+      lastEntry.text += normalizedText;
+      agentSession.updatedAt = Date.now();
+      return;
+    }
+    entries.push({ kind, text: normalizedText });
+    agentSession.transcriptEntries = entries;
+    agentSession.updatedAt = Date.now();
+  }
+
+  function finishAgentSession(status, extra = {}) {
+    if (!agentSession) return;
+    agentSession = {
+      ...agentSession,
+      ...extra,
+      status,
+      endedAt: Date.now(),
+    };
+  }
+
+  function moveCursor(delta) {
+    const snapshot = getSnapshot();
+    if (snapshot.visibleEntries.length === 0) return;
+    const currentIndex = snapshot.visibleEntries.findIndex((entry) => entry.id === snapshot.selectedEntryId);
+    const nextIndex = clampIndex((currentIndex < 0 ? 0 : currentIndex) + delta, snapshot.visibleEntries.length);
+    model.selectedEntryId = snapshot.visibleEntries[nextIndex].id;
+    notify();
+  }
+
+  function getSnapshot() {
+    return {
+      ...buildSnapshot(model),
+      mode,
+      notice,
+      agentSession,
+    };
+  }
+
+  return {
+    initFromPlans(servicePlans) {
+      initModelFromPlans(model, servicePlans);
+      notify();
+    },
+
+    hydrateFromArtifact(artifact) {
+      applyArtifactToModel(model, artifact);
+      mode = model.finished ? "complete" : "running";
+      notify();
+    },
+
+    resetForLive() {
+      resetInspectModel(model, "live");
+      mode = "running";
+      notice = null;
+      agentSession = null;
+      notify();
+    },
+
+    setRegressionCatalog(document) {
+      setRegressionCatalog(model, document);
+      notify();
+    },
+
+    markFileRunning(serviceName, suiteKey, filePath) {
+      markFileRunning(model, serviceName, suiteKey, filePath);
+      notify();
+    },
+
+    markFileFinished(task, outcome) {
+      markFileFinished(model, task, outcome);
+      notify();
+    },
+
+    markServiceSkipped(serviceName, reason) {
+      markServiceSkipped(model, serviceName, reason);
+      notify();
+    },
+
+    markPlannedSkip(entry) {
+      markPlannedSkip(model, entry);
+      notify();
+    },
+
+    markRuntimeError(task, message) {
+      markRuntimeError(model, task, message);
+      notify();
+    },
+
+    setTotalFileCount(count) {
+      setTotalFileCount(model, count);
+      notify();
+    },
+
+    setPhase(label) {
+      setPhase(model, label);
+      notify();
+    },
+
+    finish(results, durationMs, regressionReport) {
+      finishModel(model, results, durationMs, regressionReport);
+      mode = "complete";
+      notify();
+    },
+
+    setNotice(message) {
+      notice = message ? String(message) : null;
+      notify();
+    },
+
+    clearNotice() {
+      if (!notice) return;
+      notice = null;
+      notify();
+    },
+
+    moveCursorUp() {
+      moveCursor(-1);
+    },
+
+    moveCursorDown() {
+      moveCursor(1);
+    },
+
+    moveCursorToEntry(entryId) {
+      model.selectedEntryId = entryId || null;
+      notify();
+    },
+
+    toggleExpand() {
+      const snapshot = getSnapshot();
+      if (!snapshot.selectedEntry) return;
+      toggleCollapsed(model, snapshot.selectedEntry.id);
+      notify();
+    },
+
+    activateFilter() {
+      model.filterActive = true;
+      notify();
+    },
+
+    updateFilterQuery(query) {
+      updateFilter(model, query);
+      const snapshot = buildSnapshot(model);
+      if (snapshot.filter.results.length > 0) {
+        model.selectedEntryId = snapshot.filter.results[0].id;
+      }
+      notify();
+    },
+
+    deactivateFilter() {
+      model.filterActive = false;
+      model.filterQuery = "";
+      model.filterMatches = new Map();
+      notify();
+    },
+
+    revealFile(serviceName, filePath) {
+      const entryId = findEntryIdForFile(model, serviceName, filePath);
+      if (!entryId) return false;
+      revealEntry(model, entryId);
+      notify();
+      return true;
+    },
+
+    revealService(serviceName) {
+      const entryId = findEntryIdForService(model, serviceName);
+      if (!entryId) return false;
+      revealEntry(model, entryId);
+      notify();
+      return true;
+    },
+
+    cyclePaneMode() {
+      cyclePane(model);
+      notify();
+    },
+
+    setPaneMode(paneMode) {
+      setPane(model, paneMode);
+      notify();
+    },
+
+    beginInvestigation({ provider, userMessage } = {}) {
+      mode = "investigating";
+      notice = null;
+      agentSession = {
+        provider: provider || "auto",
+        userMessage: userMessage || "",
+        status: "starting",
+        startedAt: Date.now(),
+        updatedAt: Date.now(),
+        rawEvents: [],
+        transcriptEntries: [],
+        timeline: [],
+        summary: null,
+        activePhase: "planning",
+        activeStep: null,
+        viewMode: "summary",
+      };
+      notify();
+    },
+
+    recordInvestigationProgress(event, presentation = null) {
+      if (!agentSession || !event) return;
+      agentSession.rawEvents.push({ ...event });
+      if (event.type === "start") {
+        agentSession.status = "running";
+      } else if (event.type === "delta") {
+        appendTranscriptEntry("assistant", event.text || "");
+      } else if (event.type === "final") {
+        if (event.text && !(agentSession.transcriptEntries || []).some((entry) => entry.kind === "assistant")) {
+          appendTranscriptEntry("assistant", event.text);
+        }
+        agentSession.finalText = event.text || agentSession.finalText || "";
+      } else if (event.type === "tool") {
+        appendTranscriptEntry("tool", event.detail ? `${event.name}: ${event.detail}` : event.name);
+      } else if (event.type === "status") {
+        appendTranscriptEntry("status", event.message || "");
+      } else if (event.type === "error") {
+        appendTranscriptEntry("error", event.message || "Agent error");
+      } else if (event.type === "exit") {
+        agentSession.exitCode = event.code;
+      }
+
+      if (presentation) {
+        agentSession.activePhase = presentation.phase || agentSession.activePhase || null;
+        agentSession.activeStep = presentation.activeStep || null;
+        agentSession.timeline = presentation.timeline || [];
+        agentSession.summary = presentation.summary || null;
+      }
+      notify();
+    },
+
+    toggleInvestigationViewMode() {
+      if (!agentSession) return;
+      agentSession.viewMode = agentSession.viewMode === "summary" ? "transcript" : "summary";
+      notify();
+    },
+
+    completeAgentSession(result = {}) {
+      finishAgentSession("complete", {
+        finalText: result.finalText || agentSession?.finalText || "",
+        exitCode: result.exitCode ?? agentSession?.exitCode ?? 0,
+      });
+      notify();
+    },
+
+    failAgentSession(error) {
+      finishAgentSession("error", {
+        error: error instanceof Error ? error.message : String(error || "Agent error"),
+      });
+      notify();
+    },
+
+    cancelAgentSession(message = "Cancelled investigation.") {
+      finishAgentSession("cancelled");
+      mode = "complete";
+      notice = message;
+      notify();
+    },
+
+    returnToSummary() {
+      mode = "complete";
+      notify();
+    },
+
+    subscribe(callback) {
+      listeners.add(callback);
+      return () => listeners.delete(callback);
+    },
+
+    getSnapshot,
+  };
+}
+
+function clampIndex(index, length) {
+  if (length <= 0) return 0;
+  if (index < 0) return 0;
+  if (index >= length) return length - 1;
+  return index;
+}

package/lib/index.d.ts

@@ -1,11 +1,13 @@
 import type {
   ActorRequestClient,
+  DalFixtureDefinition,
   HttpClient,
   HttpClientConfig,
   RawRequestClient,
   RuntimeDb,
   RuntimeDalContext,
   RuntimeEnv,
+  RuntimeFixtureScope,
   RuntimeHeaders,
   RuntimeOptions,
   RuntimeResponse,
@@ -120,16 +122,24 @@ export interface HttpSuiteConfig<TSession = unknown> {
   options?: RuntimeOptions;
 }
 
-export interface DalSuiteContext<TSetup = unknown> {
+export interface DalSuiteContext<TSetup = unknown, TFixtures = Record<string, unknown>> {
   db: RuntimeDb;
   dal: RuntimeDalContext;
+  fixtureScope: RuntimeFixtureScope;
+  fixtures: TFixtures;
   setupData: TSetup | null;
 }
 
-export interface DalSuiteConfig<TSetup = unknown> {
+export interface DalSuiteConfig<TSetup = unknown, TFixtures = Record<string, unknown>> {
   db?: RuntimeDb;
+  fixtures?: DalFixtureDefinition<TFixtures> | null;
   options?: RuntimeOptions;
-  setup?: (context: { db: RuntimeDb; dal: RuntimeDalContext }) => TSetup;
+  setup?: (context: {
+    db: RuntimeDb;
+    dal: RuntimeDalContext;
+    fixtureScope: RuntimeFixtureScope;
+    fixtures: TFixtures;
+  }) => TSetup;
 }
 
 export declare function defineHttpSuite<TSetup = unknown>(
@@ -150,13 +160,23 @@ export declare function defineScenarioSuite<TSetup = unknown>(
   run: (context: ScenarioSuiteContext<TSetup>) => unknown
 ): TestkitSuite<TSetup>;
 
-export declare function defineDalSuite<TSetup = unknown>(
-  run: (context: DalSuiteContext<TSetup>) => unknown
+export declare function defineDalFixtures<TFixtures = Record<string, unknown>>(
+  factory: (context: {
+    db: RuntimeDb;
+    dal: RuntimeDalContext;
+    fixtureScope: RuntimeFixtureScope;
+    seed: RuntimeFixtureScope["seed"];
+    values: RuntimeFixtureScope["values"];
+  }) => TFixtures
+): DalFixtureDefinition<TFixtures>;
+
+export declare function defineDalSuite<TSetup = unknown, TFixtures = Record<string, unknown>>(
+  run: (context: DalSuiteContext<TSetup, TFixtures>) => unknown
 ): TestkitSuite<TSetup>;
 
-export declare function defineDalSuite<TSetup = unknown>(
-  config: DalSuiteConfig<TSetup>,
-  run: (context: DalSuiteContext<TSetup>) => unknown
+export declare function defineDalSuite<TSetup = unknown, TFixtures = Record<string, unknown>>(
+  config: DalSuiteConfig<TSetup, TFixtures>,
+  run: (context: DalSuiteContext<TSetup, TFixtures>) => unknown
 ): TestkitSuite<TSetup>;
 
 export declare function createAuthAdapter<TSetup = unknown>(
@@ -164,11 +184,13 @@ export declare function createAuthAdapter<TSetup = unknown>(
 ): AuthAdapter<TSetup>;
 
 export type {
+  DalFixtureDefinition,
   HttpClient,
   HttpClientConfig,
   RuntimeDb,
   RuntimeDalContext,
   RuntimeEnv,
+  RuntimeFixtureScope,
   RuntimeHeaders,
   RuntimeOptions,
   RuntimeResponse,

package/lib/index.mjs

@@ -1,6 +1,9 @@
 export {
   defineDalSuite,
 } from "./runtime-src/k6/dal-suite.js";
+export {
+  defineDalFixtures,
+} from "./runtime-src/k6/dal-fixtures.js";
 export {
   defineHttpSuite,
 } from "./runtime-src/k6/suite.js";

package/lib/runtime/index.d.ts

@@ -82,6 +82,83 @@ export interface RuntimeDalContext {
   truncate(...tables: string[]): void;
 }
 
+export interface RuntimeFixtureLocation {
+  column: number;
+  line: number;
+  path: string;
+}
+
+export interface RuntimeFixtureReference {
+  key: string;
+  kind: string;
+}
+
+export interface RuntimeFixtureRecord {
+  dependencies: RuntimeFixtureReference[];
+  key: string;
+  kind: string;
+  location?: RuntimeFixtureLocation;
+  order: number;
+  reuseCount: number;
+  signature: unknown;
+}
+
+export interface RuntimeFixtureStringOptions {
+  fallback?: string;
+  maxLength?: number;
+  prefix?: string;
+  suffixLength?: number;
+}
+
+export interface RuntimeFixtureEmailOptions {
+  domain?: string;
+  fallback?: string;
+  suffixLength?: number;
+}
+
+export interface RuntimeFixtureSlugOptions {
+  fallback?: string;
+  maxLength?: number;
+}
+
+export interface RuntimeFixtureValueHelpers {
+  email(label: string, options?: RuntimeFixtureEmailOptions): string;
+  slug(label: string, options?: RuntimeFixtureSlugOptions): string;
+  string(label: string, options?: RuntimeFixtureStringOptions): string;
+  token(label: string, options?: RuntimeFixtureStringOptions): string;
+  uuid(label: string): string;
+}
+
+export interface RuntimeFixtureScope {
+  email(label: string, options?: RuntimeFixtureEmailOptions): string;
+  id(label: string): string;
+  namespace: string;
+  records(): RuntimeFixtureRecord[];
+  seed<TResult>(
+    kind: string,
+    key: string,
+    signature: unknown,
+    create: () => TResult
+  ): TResult;
+  slug(label: string, options?: RuntimeFixtureSlugOptions): string;
+  string(label: string, options?: RuntimeFixtureStringOptions): string;
+  token(label: string, options?: RuntimeFixtureStringOptions): string;
+  uuid(label: string): string;
+  values: RuntimeFixtureValueHelpers;
+}
+
+export interface DalFixtureDefinitionContext {
+  dal: RuntimeDalContext;
+  db: RuntimeDb;
+  fixtureScope: RuntimeFixtureScope;
+  seed: RuntimeFixtureScope["seed"];
+  values: RuntimeFixtureValueHelpers;
+}
+
+export interface DalFixtureDefinition<TFixtures = Record<string, unknown>> {
+  create(context: DalFixtureDefinitionContext): TFixtures;
+}
+
 export interface HttpRequestParams {
   headers?: RuntimeHeaders;
   redirects?: number;

package/lib/runtime-src/k6/dal-fixtures.js

@@ -0,0 +1,66 @@
+import { emitArtifact } from "./artifacts.js";
+import { createFixtureScope } from "../shared/fixture-engine.mjs";
+import { readTestkitContext } from "../../shared/test-context.mjs";
+
+export function defineDalFixtures(factory) {
+  if (typeof factory !== "function") {
+    throw new Error("defineDalFixtures(factory) requires a fixture factory function.");
+  }
+
+  return {
+    create: factory,
+  };
+}
+
+export function createDalFixtureRuntime({ db, dal, definition = null, env = __ENV } = {}) {
+  const runtimeContext = readTestkitContext(env);
+  const fixtureScope = createFixtureScope({
+    namespace: `dal-${runtimeContext.namespace}`,
+  });
+
+  const fixtureDefinition = normalizeFixtureDefinition(definition);
+  const fixtures = fixtureDefinition
+    ? fixtureDefinition.create({
+        db,
+        dal,
+        fixtureScope,
+        seed: fixtureScope.seed,
+        values: fixtureScope.values,
+      }) || {}
+    : {};
+
+  let artifactEmitted = false;
+
+  function emitArtifactOnce() {
+    if (artifactEmitted) return;
+    const records = fixtureScope.records();
+    if (records.length === 0) return;
+
+    emitArtifact(
+      "dal-fixtures",
+      {
+        namespace: fixtureScope.namespace,
+        fixtures: records,
+      },
+      {
+        kind: "testkit.dal-fixtures",
+        summary: `${records.length} DAL fixture(s)`,
+      }
+    );
+    artifactEmitted = true;
+  }
+
+  return {
+    fixtures,
+    fixtureScope,
+    emitArtifactOnce,
+  };
+}
+
+function normalizeFixtureDefinition(definition) {
+  if (!definition) return null;
+  if (typeof definition.create !== "function") {
+    throw new Error("DAL fixture definitions must be created with defineDalFixtures(...).");
+  }
+  return definition;
+}

package/lib/runtime-src/k6/dal-suite.js

@@ -6,23 +6,40 @@ import {
   startFailureCollection,
 } from "./checks.js";
 import { createDalContext, openDb } from "./dal.js";
+import { createDalFixtureRuntime } from "./dal-fixtures.js";
 
 export function defineDalSuite(configOrRun, maybeRun) {
   const { config, run } = normalizeSuiteArgs(configOrRun, maybeRun);
   const db = config.db || openDb();
   const dal = createDalContext(db);
+  const fixtureRuntime = createDalFixtureRuntime({
+    db,
+    dal,
+    definition: config.fixtures || null,
+  });
 
   return {
     options: config.options || defaultOptions,
     setup() {
       if (typeof config.setup !== "function") return null;
       startFailureCollection("setup");
+      let setupCompleted = false;
       try {
-        return config.setup({ db, dal });
+        const result = config.setup({
+          db,
+          dal,
+          fixtures: fixtureRuntime.fixtures,
+          fixtureScope: fixtureRuntime.fixtureScope,
+        });
+        setupCompleted = true;
+        return result;
       } catch (error) {
         recordRuntimeFailure();
         fail(formatFatalSuiteError("setup", error));
       } finally {
+        if (!setupCompleted) {
+          fixtureRuntime.emitArtifactOnce();
+        }
         emitFailureCollectionArtifact();
       }
     },
@@ -32,12 +49,15 @@ export function defineDalSuite(configOrRun, maybeRun) {
         return run({
           db,
           dal,
+          fixtures: fixtureRuntime.fixtures,
+          fixtureScope: fixtureRuntime.fixtureScope,
           setupData,
         });
       } catch (error) {
         recordRuntimeFailure();
         fail(formatFatalSuiteError("exec", error));
       } finally {
+        fixtureRuntime.emitArtifactOnce();
         emitFailureCollectionArtifact();
       }
     },