@forwardimpact/libharness 0.1.22 → 1.0.0

package/src/mock/data.js

@@ -1,46 +0,0 @@
-/**
- * Shared test data for common testing scenarios
- */
-
-// Sample request data
-export const testRequestData = {
-  query: "test query",
-  userId: "test-user-123",
-  sessionId: "test-session-456",
-};
-
-// Sample vector data
-export const testVectorData = [
-  { id: "vector-1", embedding: [0.1, 0.2, 0.3], score: 0.9 },
-  { id: "vector-2", embedding: [0.4, 0.5, 0.6], score: 0.8 },
-  { id: "vector-3", embedding: [0.7, 0.8, 0.9], score: 0.7 },
-];
-
-// Sample message data
-export const testMessageData = [
-  { role: "system", content: "You are a helpful assistant." },
-  { role: "user", content: "Hello, how are you?" },
-  { role: "assistant", content: "I'm doing well, thank you for asking!" },
-];
-
-// Sample chunk data
-export const testChunkData = [
-  {
-    id: "chunk-1",
-    text: "This is a sample text chunk for testing purposes.",
-    tokens: 10,
-  },
-  {
-    id: "chunk-2",
-    text: "Another sample chunk with different content.",
-    tokens: 8,
-  },
-];
-
-// Sample configuration data
-export const testConfigData = {
-  host: "localhost",
-  port: 3000,
-  threshold: 0.5,
-  limit: 100,
-};

package/src/mock/fs.js

@@ -1,111 +0,0 @@
-import { spy } from "./spy.js";
-/**
- * Creates a mock filesystem backed by an in-memory Map
- * @param {Object<string, string>} files - Initial file contents keyed by path
- * @returns {object} Mock fs with readFile, writeFile, readdir, stat, mkdir, access, copyFile
- */
-export function createMockFs(files = {}) {
-  const data = new Map(Object.entries(files));
-  const dirs = new Set();
-
-  // Auto-create parent directories for initial files
-  for (const path of data.keys()) {
-    const parts = path.split("/");
-    for (let i = 1; i < parts.length; i++) {
-      dirs.add(parts.slice(0, i).join("/"));
-    }
-  }
-
-  return {
-    data,
-    dirs,
-    readFile: spy(async (path, encoding) => {
-      const content = data.get(path);
-      if (content === undefined) {
-        const err = new Error(
-          `ENOENT: no such file or directory, open '${path}'`,
-        );
-        err.code = "ENOENT";
-        throw err;
-      }
-      return encoding ? content : Buffer.from(content);
-    }),
-    writeFile: spy(async (path, content) => {
-      data.set(
-        path,
-        typeof content === "string" ? content : content.toString(),
-      );
-    }),
-    readdir: spy(async (path) => {
-      const entries = [];
-      const prefix = path.endsWith("/") ? path : `${path}/`;
-      for (const key of data.keys()) {
-        if (key.startsWith(prefix)) {
-          const rest = key.slice(prefix.length);
-          const name = rest.split("/")[0];
-          if (name && !entries.includes(name)) {
-            entries.push(name);
-          }
-        }
-      }
-      return entries;
-    }),
-    stat: spy(async (path) => {
-      if (data.has(path)) {
-        return { isFile: () => true, isDirectory: () => false };
-      }
-      if (dirs.has(path)) {
-        return { isFile: () => false, isDirectory: () => true };
-      }
-      const err = new Error(
-        `ENOENT: no such file or directory, stat '${path}'`,
-      );
-      err.code = "ENOENT";
-      throw err;
-    }),
-    mkdir: spy(async (path) => {
-      dirs.add(path);
-    }),
-    access: spy(async (path) => {
-      if (!data.has(path) && !dirs.has(path)) {
-        const err = new Error(
-          `ENOENT: no such file or directory, access '${path}'`,
-        );
-        err.code = "ENOENT";
-        throw err;
-      }
-    }),
-    copyFile: spy(async (src, dest) => {
-      const content = data.get(src);
-      if (content === undefined) {
-        const err = new Error(
-          `ENOENT: no such file or directory, copyFile '${src}'`,
-        );
-        err.code = "ENOENT";
-        throw err;
-      }
-      data.set(dest, content);
-    }),
-    existsSync: spy((path) => data.has(path) || dirs.has(path)),
-    readFileSync: spy((path, encoding) => {
-      const content = data.get(path);
-      if (content === undefined) {
-        const err = new Error(
-          `ENOENT: no such file or directory, open '${path}'`,
-        );
-        err.code = "ENOENT";
-        throw err;
-      }
-      return encoding ? content : Buffer.from(content);
-    }),
-    writeFileSync: spy((path, content) => {
-      data.set(
-        path,
-        typeof content === "string" ? content : content.toString(),
-      );
-    }),
-    mkdirSync: spy((path) => {
-      dirs.add(path);
-    }),
-  };
-}

package/src/mock/grpc.js

@@ -1,94 +0,0 @@
-import { spy } from "./spy.js";
-/**
- * Creates a mock gRPC factory function
- * @param {object} overrides - Method overrides
- * @returns {Function} Mock gRPC factory
- */
-export function createMockGrpcFn(overrides = {}) {
-  const mockGrpc = {
-    Server: function () {
-      return {
-        addService: spy(),
-        bindAsync: spy((uri, creds, callback) => callback(null, 5000)),
-        tryShutdown: spy((callback) => callback()),
-        ...overrides.server,
-      };
-    },
-    loadPackageDefinition: spy(() => ({
-      test: { Test: { service: {} } },
-    })),
-    makeGenericClientConstructor: spy(() => function () {}),
-    ServerCredentials: {
-      createInsecure: spy(),
-    },
-    credentials: {
-      createInsecure: spy(),
-    },
-    status: {
-      OK: 0,
-      CANCELLED: 1,
-      UNKNOWN: 2,
-      INVALID_ARGUMENT: 3,
-      DEADLINE_EXCEEDED: 4,
-      NOT_FOUND: 5,
-      ALREADY_EXISTS: 6,
-      PERMISSION_DENIED: 7,
-      RESOURCE_EXHAUSTED: 8,
-      FAILED_PRECONDITION: 9,
-      ABORTED: 10,
-      OUT_OF_RANGE: 11,
-      UNIMPLEMENTED: 12,
-      INTERNAL: 13,
-      UNAVAILABLE: 14,
-      DATA_LOSS: 15,
-      UNAUTHENTICATED: 16,
-    },
-    ...overrides.grpc,
-  };
-
-  const mockProtoLoader = {
-    loadSync: spy(() => ({})),
-    ...overrides.protoLoader,
-  };
-
-  return () => ({ grpc: mockGrpc, protoLoader: mockProtoLoader });
-}
-
-/**
- * Creates a mock gRPC Metadata class
- */
-export class MockMetadata {
-  /**
-   * Creates a new MockMetadata instance
-   */
-  constructor() {
-    this.data = new Map();
-  }
-
-  /**
-   * Sets a metadata key-value pair
-   * @param {string} key - The metadata key
-   * @param {string} value - The metadata value
-   */
-  set(key, value) {
-    this.data.set(key, value);
-  }
-
-  /**
-   * Gets metadata value by key
-   * @param {string} key - The metadata key
-   * @returns {string[]} Array containing the value, or empty array if not found
-   */
-  get(key) {
-    const value = this.data.get(key);
-    return value !== undefined ? [value] : [];
-  }
-
-  /**
-   * Returns all metadata as a plain object
-   * @returns {object} Object with all metadata key-value pairs
-   */
-  getMap() {
-    return Object.fromEntries(this.data);
-  }
-}

package/src/mock/http.js

@@ -1,60 +0,0 @@
-/**
- * Creates a mock HTTP request with event emitter behavior
- * @param {object} options - Request options
- * @returns {object} Mock request
- */
-export function createMockRequest(options = {}) {
-  const { method = "GET", url = "/", body = {}, headers = {} } = options;
-
-  const bodyStr = JSON.stringify(body);
-  let dataCallback;
-  let endCallback;
-  let errorCallback;
-
-  return {
-    method,
-    url,
-    headers,
-    on(event, callback) {
-      if (event === "data") dataCallback = callback;
-      if (event === "end") endCallback = callback;
-      if (event === "error") errorCallback = callback;
-    },
-    simulateBody() {
-      if (dataCallback) dataCallback(bodyStr);
-      if (endCallback) endCallback();
-    },
-    simulateError(err) {
-      if (errorCallback) errorCallback(err);
-    },
-  };
-}
-
-/**
- * Creates a mock HTTP response with tracking
- * @returns {object} Mock response
- */
-export function createMockResponse() {
-  const response = {
-    headersSent: false,
-    statusCode: null,
-    headers: {},
-    body: "",
-    chunks: [],
-    writeHead(status, headers) {
-      response.statusCode = status;
-      response.headers = headers || {};
-      response.headersSent = true;
-    },
-    write(data) {
-      response.chunks.push(data);
-    },
-    end(data) {
-      response.body = data || "";
-    },
-    getBody() {
-      return response.chunks.join("") + response.body;
-    },
-  };
-  return response;
-}

package/src/mock/index.js

@@ -1,36 +0,0 @@
-export {
-  createMockConfig,
-  createMockServiceConfig,
-  createMockExtensionConfig,
-} from "./config.js";
-export { createMockStorage, MockStorage } from "./storage.js";
-export { createMockLogger, createSilentLogger } from "./logger.js";
-export { createMockGrpcFn, MockMetadata } from "./grpc.js";
-export { createMockRequest, createMockResponse } from "./http.js";
-export {
-  createMockObserverFn,
-  createMockTracer,
-  createMockAuthFn,
-} from "./observer.js";
-
-export { createMockResourceIndex } from "./resource-index.js";
-export {
-  createMockMemoryClient,
-  createMockLlmClient,
-  createMockAgentClient,
-  createMockTraceClient,
-  createMockVectorClient,
-  createMockGraphClient,
-  createMockToolClient,
-} from "./clients.js";
-export { createMockServiceCallbacks } from "./service-callbacks.js";
-export { createMockFs } from "./fs.js";
-export { spy } from "./spy.js";
-export {
-  createMockSupabaseClient,
-  createTurtleHelpers,
-  createMockProcess,
-  withSilentConsole,
-  createMockS3Client,
-  createMockQueries,
-} from "./infra.js";

package/src/mock/infra.js

@@ -1,219 +0,0 @@
-/**
- * Additional infrastructure mocks for services/products tests.
- *
- * Historically each consumer inlined its own variant. See spec 620 for the
- * call-site inventory.
- */
-
-/**
- * Creates a mock Supabase-style client with configurable table and storage
- * behaviour. Covers the patterns found across products/map/test/activity/*.
- *
- * @param {object} [options]
- * @param {Record<string, object>} [options.tables] - Map of table name to
- *   override. Each override may expose `select`, `insert`, `upsert`, `delete`
- *   as async functions. Unspecified methods return `{ data: [], error: null }`.
- * @param {Record<string, string>} [options.files] - Files exposed via
- *   `storage.from(...).list(prefix)` / `.download(path)`.
- * @returns {object} Mock client and call-tracking arrays.
- */
-export function createMockSupabaseClient({ tables = {}, files = {} } = {}) {
-  const calls = {
-    select: [],
-    insert: [],
-    upsert: [],
-    delete: [],
-    download: [],
-    list: [],
-  };
-
-  function record(kind, entry) {
-    calls[kind].push(entry);
-  }
-
-  return {
-    calls,
-    from(table) {
-      const override = tables[table] ?? {};
-      return {
-        async select(...args) {
-          record("select", { table, args });
-          if (override.select) return override.select(...args);
-          return { data: [], error: null };
-        },
-        async insert(rows, opts) {
-          record("insert", { table, rows, options: opts });
-          if (override.insert) return override.insert(rows, opts);
-          return { data: rows, error: null };
-        },
-        async upsert(rows, opts) {
-          record("upsert", {
-            table,
-            rows,
-            onConflict: opts?.onConflict,
-            options: opts,
-          });
-          if (override.upsert) return override.upsert(rows, opts);
-          return { data: rows, error: null };
-        },
-        async delete(...args) {
-          record("delete", { table, args });
-          if (override.delete) return override.delete(...args);
-          return { error: null };
-        },
-      };
-    },
-    storage: {
-      from() {
-        return {
-          async list(prefix) {
-            record("list", { prefix });
-            const names = Object.keys(files)
-              .filter((k) => k.startsWith(prefix))
-              .map((k) => ({
-                name: k.slice(prefix.length),
-                created_at: "z",
-              }));
-            return { data: names, error: null };
-          },
-          async download(path) {
-            record("download", { path });
-            const content = files[path];
-            if (content === undefined) {
-              return { data: null, error: { message: "not found" } };
-            }
-            return {
-              data: { text: async () => content },
-              error: null,
-            };
-          },
-        };
-      },
-    },
-  };
-}
-
-/**
- * Creates Turtle parsing helpers bound to an injected n3 Parser. Keeps
- * libharness free of an n3 dependency while allowing services to share the
- * parseQuads / findAll / findOne idiom.
- *
- * @param {import("n3").Parser | Function} ParserOrInstance - n3 Parser class
- *   or a pre-built parser instance.
- * @param {object} [options]
- * @param {string} [options.format="Turtle"] - Parser format.
- * @returns {object} { parseQuads, findAll, findOne }
- */
-export function createTurtleHelpers(
-  ParserOrInstance,
-  { format = "Turtle" } = {},
-) {
-  const isClass =
-    typeof ParserOrInstance === "function" &&
-    ParserOrInstance.prototype &&
-    typeof ParserOrInstance.prototype.parse === "function";
-  const parser = isClass ? new ParserOrInstance({ format }) : ParserOrInstance;
-
-  function parseQuads(turtle) {
-    return parser.parse(turtle);
-  }
-
-  function findAll(quads, { subject, predicate, object } = {}) {
-    return quads.filter(
-      (q) =>
-        (!subject || q.subject.value === subject) &&
-        (!predicate || q.predicate.value === predicate) &&
-        (!object || q.object.value === object),
-    );
-  }
-
-  function findOne(quads, pattern) {
-    return findAll(quads, pattern)[0];
-  }
-
-  return { parseQuads, findAll, findOne };
-}
-
-/**
- * Creates a minimal mock `process`-like object with env, stdout, stderr,
- * exitCode, and simple write capture.
- *
- * @param {object} [options]
- * @param {Record<string, string>} [options.env]
- * @returns {object}
- */
-export function createMockProcess({ env = {} } = {}) {
-  const stdout = { chunks: [], write: (s) => stdout.chunks.push(String(s)) };
-  const stderr = { chunks: [], write: (s) => stderr.chunks.push(String(s)) };
-  return {
-    env: { ...env },
-    stdout,
-    stderr,
-    exitCode: 0,
-    exit(code = 0) {
-      this.exitCode = code;
-    },
-  };
-}
-
-/**
- * Runs `fn` with `console.log`, `console.info`, and `console.warn` suppressed,
- * returning whatever `fn` returns. Errors still propagate.
- *
- * @template T
- * @param {() => T | Promise<T>} fn
- * @returns {Promise<T>}
- */
-export async function withSilentConsole(fn) {
-  const originals = {
-    log: console.log,
-    info: console.info,
-    warn: console.warn,
-  };
-  console.log = () => {};
-  console.info = () => {};
-  console.warn = () => {};
-  try {
-    return await fn();
-  } finally {
-    console.log = originals.log;
-    console.info = originals.info;
-    console.warn = originals.warn;
-  }
-}
-
-/**
- * Creates a bag of async query stubs from a plain values object. A function
- * value is passed through untouched; anything else becomes an async function
- * returning that value. Collapses landmark-style `stubQueries` boilerplate.
- *
- * @param {Record<string, unknown>} values
- * @returns {Record<string, Function>}
- */
-export function createMockQueries(values = {}) {
-  const out = {};
-  for (const [key, val] of Object.entries(values)) {
-    out[key] = typeof val === "function" ? val : async () => val;
-  }
-  return out;
-}
-
-/**
- * Creates a minimal mock S3 client that records command sends and returns a
- * configurable response.
- *
- * @param {object} [options]
- * @param {(command: object) => unknown} [options.sendFn] - Custom send handler.
- * @returns {object} { client, sends }
- */
-export function createMockS3Client({ sendFn } = {}) {
-  const sends = [];
-  return {
-    sends,
-    async send(command) {
-      sends.push(command);
-      if (sendFn) return sendFn(command);
-      return {};
-    },
-  };
-}

package/src/mock/logger.js

@@ -1,42 +0,0 @@
-import { spy } from "./spy.js";
-/**
- * Creates a mock logger with call tracking
- * @param {object} options - Logger options
- * @param {boolean} options.captureOutput - Whether to capture log output
- * @returns {object} Mock logger
- */
-export function createMockLogger(options = {}) {
-  const logs = [];
-  const capture = options.captureOutput ?? false;
-
-  const createMethod = (level) =>
-    spy((appId, msg, attributes) => {
-      if (capture) {
-        logs.push({ level, appId, msg, attributes });
-      }
-    });
-
-  return {
-    logs,
-    debug: createMethod("debug"),
-    info: createMethod("info"),
-    warn: createMethod("warn"),
-    error: createMethod("error"),
-    exception: createMethod("exception"),
-  };
-}
-
-/**
- * Creates a silent logger that does nothing
- * @returns {object} Silent logger
- */
-export function createSilentLogger() {
-  const noop = () => {};
-  return {
-    debug: noop,
-    info: noop,
-    warn: noop,
-    error: noop,
-    exception: noop,
-  };
-}

package/src/mock/observer.js

@@ -1,74 +0,0 @@
-import { spy } from "./spy.js";
-/**
- * Creates a mock observer factory
- * @param {object} logger - Logger to use (optional)
- * @returns {Function} Mock observer factory
- */
-export function createMockObserverFn(logger = null) {
-  const mockLogger = logger || {
-    debug: spy(),
-    info: spy(),
-    error: spy(),
-  };
-
-  return () => ({
-    observeServerUnaryCall: async (_method, handler, call, callback) => {
-      return await handler(call, callback);
-    },
-    observeClientUnaryCall: async (_method, _request, fn) => {
-      return await fn();
-    },
-    observeClientStreamingCall: (_method, _request, fn) => {
-      return fn();
-    },
-    logger: () => mockLogger,
-  });
-}
-
-/**
- * Creates a mock tracer
- * @param {object} overrides - Method overrides
- * @returns {object} Mock tracer
- */
-export function createMockTracer(overrides = {}) {
-  return {
-    startSpan: spy((name, options = {}) => ({
-      span_id: `span-${Date.now()}`,
-      trace_id: `trace-${Date.now()}`,
-      name,
-      ...options,
-    })),
-    startClientSpan: spy((_service, _method) => ({
-      span: {
-        span_id: `client-span-${Date.now()}`,
-        trace_id: `trace-${Date.now()}`,
-      },
-      metadata: { get: () => [], set: () => {} },
-    })),
-    startServerSpan: spy((_service, _method, _request, metadata) => ({
-      span_id: `server-span-${Date.now()}`,
-      trace_id: metadata?.get?.("x-trace-id")?.[0] || `trace-${Date.now()}`,
-    })),
-    getSpanContext: () => ({
-      run: (span, fn) => fn(),
-      getStore: () => null,
-    }),
-    endSpan: spy(),
-    recordError: spy(),
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock auth factory
- * @param {object} options - Auth options
- * @returns {Function} Mock auth factory
- */
-export function createMockAuthFn(options = {}) {
-  const { isValid = true, serviceId = "test" } = options;
-
-  return () => ({
-    createClientInterceptor: () => () => {},
-    validateCall: () => ({ isValid, serviceId }),
-  });
-}