@lark-apaas/action-plugin-testing 0.1.0

package/dist/index.js

@@ -0,0 +1,314 @@
+// src/context.ts
+var silentLogger = {
+  log: () => {
+  },
+  error: () => {
+  },
+  warn: () => {
+  },
+  debug: () => {
+  }
+};
+var consoleLogger = {
+  log: (...args) => console.log("[TEST]", ...args),
+  error: (...args) => console.error("[TEST]", ...args),
+  warn: (...args) => console.warn("[TEST]", ...args),
+  debug: (...args) => console.debug("[TEST]", ...args)
+};
+function createMockResponse(data = {}) {
+  return new Response(JSON.stringify(data), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+var mockHttpClient = {
+  get: async () => createMockResponse(),
+  post: async () => createMockResponse(),
+  put: async () => createMockResponse(),
+  delete: async () => createMockResponse(),
+  patch: async () => createMockResponse()
+};
+function resolveLogger(logger) {
+  if (!logger || logger === "silent") {
+    return silentLogger;
+  }
+  if (logger === "console") {
+    return consoleLogger;
+  }
+  return logger;
+}
+function createTestContext(options) {
+  const {
+    userId = "test-user",
+    tenantId = "test-tenant",
+    appId = "test-app",
+    logger,
+    platformHttpClient = mockHttpClient,
+    isDebug = false
+  } = options ?? {};
+  return {
+    userContext: {
+      userId,
+      tenantId,
+      appId
+    },
+    logger: resolveLogger(logger),
+    platformHttpClient,
+    isDebug
+  };
+}
+
+// src/runner.ts
+function createTestRunner(plugin, config, options) {
+  const instance = plugin.create(config);
+  const defaultContextOptions = options?.defaultContext ?? {};
+  return {
+    async run(actionName, input, contextOverrides) {
+      const mergedContextOptions = {
+        ...defaultContextOptions,
+        ...contextOverrides
+      };
+      const context = createTestContext(mergedContextOptions);
+      return instance.run(actionName, context, input);
+    },
+    getInstance() {
+      return instance;
+    },
+    getInputSchema(actionName) {
+      return instance.getInputSchema(actionName);
+    },
+    getOutputSchema(actionName, input) {
+      return instance.getOutputSchema(actionName, input);
+    }
+  };
+}
+
+// src/mocks/logger.ts
+function createMockLogger() {
+  const logs = [];
+  const createLogMethod = (level) => {
+    return (...args) => {
+      logs.push({
+        level,
+        args,
+        timestamp: Date.now()
+      });
+    };
+  };
+  return {
+    log: createLogMethod("log"),
+    error: createLogMethod("error"),
+    warn: createLogMethod("warn"),
+    debug: createLogMethod("debug"),
+    getLogs() {
+      return [...logs];
+    },
+    getLogsByLevel(level) {
+      return logs.filter((log) => log.level === level);
+    },
+    clear() {
+      logs.length = 0;
+    },
+    hasLog(level, messagePattern) {
+      return logs.some((log) => {
+        if (log.level !== level) return false;
+        return log.args.some((arg) => {
+          if (typeof arg !== "string") {
+            try {
+              arg = JSON.stringify(arg);
+            } catch {
+              return false;
+            }
+          }
+          if (typeof messagePattern === "string") {
+            return arg.includes(messagePattern);
+          }
+          return messagePattern.test(arg);
+        });
+      });
+    }
+  };
+}
+
+// src/stream.ts
+async function collectStream(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+  }
+  return chunks;
+}
+async function collectStreamData(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(chunk.data);
+  }
+  return chunks;
+}
+async function collectStreamText(stream) {
+  let result = "";
+  for await (const chunk of stream) {
+    result += chunk.data.content;
+  }
+  return result;
+}
+async function firstChunk(stream) {
+  for await (const chunk of stream) {
+    return chunk;
+  }
+  return void 0;
+}
+async function lastChunk(stream) {
+  let last;
+  for await (const chunk of stream) {
+    last = chunk;
+  }
+  return last;
+}
+async function countChunks(stream) {
+  let count = 0;
+  for await (const _item of stream) {
+    count++;
+  }
+  return count;
+}
+async function assertStreamChunks(stream, expected) {
+  const actual = await collectStream(stream);
+  if (actual.length !== expected.length) {
+    throw new Error(`Expected ${expected.length} chunks, but got ${actual.length}`);
+  }
+  for (let i = 0; i < expected.length; i++) {
+    const actualStr = JSON.stringify(actual[i]);
+    const expectedStr = JSON.stringify(expected[i]);
+    if (actualStr !== expectedStr) {
+      throw new Error(`Chunk ${i} mismatch:
+Expected: ${expectedStr}
+Actual: ${actualStr}`);
+    }
+  }
+}
+async function assertEveryChunk(stream, predicate) {
+  let index = 0;
+  for await (const chunk of stream) {
+    if (!predicate(chunk, index)) {
+      throw new Error(`Chunk ${index} failed assertion: ${JSON.stringify(chunk)}`);
+    }
+    index++;
+  }
+}
+
+// src/stream-events.ts
+async function collectStreamEvents(stream) {
+  const events = [];
+  const data = [];
+  let done;
+  let error;
+  for await (const event of stream) {
+    events.push(event);
+    switch (event.type) {
+      case "data":
+        data.push(event.data);
+        break;
+      case "done":
+        done = event;
+        break;
+      case "error":
+        error = event;
+        break;
+    }
+  }
+  return {
+    events,
+    data,
+    done,
+    error,
+    completed: done !== void 0 && error === void 0
+  };
+}
+async function collectEventData(stream) {
+  const data = [];
+  for await (const event of stream) {
+    if (event.type === "data") {
+      data.push(event.data);
+    }
+  }
+  return data;
+}
+async function waitForDone(stream) {
+  for await (const event of stream) {
+    if (event.type === "done") {
+      return event.metadata;
+    }
+    if (event.type === "error") {
+      throw new Error(`Stream ended with error: [${event.error.code}] ${event.error.message}`);
+    }
+  }
+  throw new Error("Stream ended without done or error event");
+}
+async function waitForError(stream) {
+  for await (const event of stream) {
+    if (event.type === "error") {
+      return event.error;
+    }
+    if (event.type === "done") {
+      throw new Error("Expected stream to error, but it completed successfully");
+    }
+  }
+  throw new Error("Stream ended without done or error event");
+}
+async function expectStreamCompletes(stream) {
+  const result = await collectStreamEvents(stream);
+  if (!result.completed) {
+    if (result.error) {
+      throw new Error(
+        `Expected stream to complete, but got error: [${result.error.error.code}] ${result.error.error.message}`
+      );
+    }
+    throw new Error("Expected stream to complete, but no done event received");
+  }
+}
+async function expectStreamErrors(stream, expectedCode) {
+  const result = await collectStreamEvents(stream);
+  if (!result.error) {
+    throw new Error("Expected stream to error, but it completed successfully");
+  }
+  if (expectedCode && result.error.error.code !== expectedCode) {
+    throw new Error(`Expected error code "${expectedCode}", but got "${result.error.error.code}"`);
+  }
+}
+async function expectAggregatedResult(stream, expected) {
+  const metadata = await waitForDone(stream);
+  const actual = JSON.stringify(metadata.aggregated);
+  const expectedStr = JSON.stringify(expected);
+  if (actual !== expectedStr) {
+    throw new Error(`Aggregated result mismatch:
+Expected: ${expectedStr}
+Actual: ${actual}`);
+  }
+}
+
+// src/schema.ts
+function parseInput(instance, actionName, input) {
+  const schema = instance.getInputSchema(actionName);
+  if (!schema) {
+    throw new Error(`Action "${actionName}" not found`);
+  }
+  return schema.parse(input);
+}
+function expectInputRejected(instance, actionName, input) {
+  const schema = instance.getInputSchema(actionName);
+  if (!schema) {
+    throw new Error(`Action "${actionName}" not found`);
+  }
+  let threw = false;
+  try {
+    schema.parse(input);
+  } catch {
+    threw = true;
+  }
+  if (!threw) {
+    throw new Error(`Expected input to be rejected: ${JSON.stringify(input)}`);
+  }
+}
+
+export { assertEveryChunk, assertStreamChunks, collectEventData, collectStream, collectStreamData, collectStreamEvents, collectStreamText, countChunks, createMockLogger, createTestContext, createTestRunner, expectAggregatedResult, expectInputRejected, expectStreamCompletes, expectStreamErrors, firstChunk, lastChunk, parseInput, waitForDone, waitForError };

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@lark-apaas/action-plugin-testing",
+  "version": "0.1.0",
+  "description": "Testing utilities for action plugins",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "action",
+    "plugin",
+    "testing",
+    "vitest"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@lark-apaas/action-plugin-core": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.0",
+    "zod": "^3.25.76"
+  },
+  "peerDependencies": {
+    "zod": "^3.25.76"
+  }
+}