@slates/test 1.0.0-rc.2

package/dist/index.module.js

@@ -0,0 +1,209 @@
+// src/index.ts
+import { createVitestConfig } from "@lowerdeck/testing-tools";
+import {
+  createLocalSlateTransport,
+  createSlatesClient,
+  SlateProtocolError
+} from "@slates/client";
+import {
+  createSlatesClientFromProfile,
+  openSlatesCliStore
+} from "@slates/profiles";
+import { readFile } from "fs/promises";
+var getExpect = () => {
+  let maybeExpect = globalThis.expect;
+  if (!maybeExpect) {
+    throw new Error("Vitest expect is not available in the current runtime.");
+  }
+  return maybeExpect;
+};
+var loadSlatesRuntimeContext = async (opts = {}) => {
+  let runtimeContextPath = process.env.SLATES_TEST_CONTEXT_PATH;
+  if (runtimeContextPath) {
+    let raw = await readFile(runtimeContextPath, "utf-8");
+    let parsed = JSON.parse(raw);
+    let store2 = await openSlatesCliStore({ storePath: parsed.storePath });
+    let profile2 = store2.getProfile(opts.profile ?? parsed.profileId ?? null);
+    return {
+      integration: parsed.integration ?? store2.scope?.key ?? null,
+      profileId: profile2?.id ?? parsed.profileId ?? null,
+      profile: profile2,
+      storePath: parsed.storePath,
+      cliDir: parsed.cliDir
+    };
+  }
+  let store = process.env.SLATES_STORE_PATH ? await openSlatesCliStore({ storePath: process.env.SLATES_STORE_PATH }) : await openSlatesCliStore({ cwd: opts.cwd });
+  let profileId = opts.profile ?? process.env.SLATES_PROFILE_ID ?? null;
+  let profile = store.getProfile(profileId);
+  return {
+    integration: process.env.SLATES_INTEGRATION ?? store.scope?.key ?? null,
+    profileId: profile?.id ?? null,
+    profile,
+    storePath: store.storePath,
+    cliDir: store.dirPath
+  };
+};
+var loadSlatesProfile = async (opts = {}) => {
+  let context = await loadSlatesRuntimeContext(opts);
+  if (!context.profile) {
+    throw new Error("No Slates profile is available for the current test context.");
+  }
+  return context.profile;
+};
+var createSlatesTestClient = async (opts = {}) => {
+  let context = await loadSlatesRuntimeContext(opts);
+  if (!context.profile) {
+    throw new Error("No Slates profile is available for the current test context.");
+  }
+  let store = await openSlatesCliStore({ storePath: context.storePath });
+  return createSlatesClientFromProfile(context.profile, { cwd: opts.cwd, store });
+};
+var withSlateProfile = async (profileName, cb) => {
+  let profile = await loadSlatesProfile({ profile: profileName });
+  return cb({ profile });
+};
+var expectToolCall = async (d) => {
+  let expect = getExpect();
+  let client = d.client ?? await createSlatesTestClient({ profile: d.profile });
+  let result = await client.invokeTool(d.toolId, d.input);
+  if (d.output) {
+    expect(result.output).toMatchObject(d.output);
+  }
+  return result;
+};
+var createLocalSlateTestClient = (opts) => createSlatesClient({
+  transport: createLocalSlateTransport({ slate: opts.slate }),
+  state: opts.state,
+  participants: opts.participants
+});
+var getSlateContract = async (client) => {
+  let [provider, actions, authMethods, configSchema] = await Promise.all([
+    client.identify(),
+    client.listActions(),
+    client.listAuthMethods(),
+    client.getConfigSchema()
+  ]);
+  return {
+    provider: provider.provider,
+    actions: actions.actions,
+    tools: actions.actions.filter((action) => action.type === "action.tool"),
+    triggers: actions.actions.filter((action) => action.type === "action.trigger"),
+    authMethods: authMethods.authenticationMethods,
+    configSchema: configSchema.schema
+  };
+};
+var expectActionMatches = (actual, expected) => {
+  let expect = getExpect();
+  expect(actual).toBeTruthy();
+  expect(actual?.id).toBe(expected.id);
+  if (expected.name !== void 0) {
+    expect(actual?.name).toBe(expected.name);
+  }
+  if (expected.description !== void 0) {
+    expect(actual?.description).toBe(expected.description);
+  }
+  if (expected.readOnly !== void 0) {
+    expect(actual?.tags?.readOnly ?? false).toBe(expected.readOnly);
+  }
+  if (expected.destructive !== void 0) {
+    expect(actual?.tags?.destructive ?? false).toBe(expected.destructive);
+  }
+  if (expected.invocationType !== void 0) {
+    expect(actual?.invocation?.type).toBe(
+      expected.invocationType
+    );
+  }
+};
+var expectSlateContract = async (d) => {
+  let expect = getExpect();
+  let contract = await getSlateContract(d.client);
+  if (d.provider) {
+    expect(contract.provider.id).toBe(d.provider.id);
+    if (d.provider.name !== void 0) {
+      expect(contract.provider.name).toBe(d.provider.name);
+    }
+    if (d.provider.description !== void 0) {
+      expect(contract.provider.description).toBe(d.provider.description);
+    }
+  }
+  if (d.toolIds) {
+    expect(contract.tools.map((action) => action.id)).toEqual(d.toolIds);
+  }
+  if (d.triggerIds) {
+    expect(contract.triggers.map((action) => action.id)).toEqual(d.triggerIds);
+  }
+  if (d.authMethodIds) {
+    expect(contract.authMethods.map((method) => method.id)).toEqual(d.authMethodIds);
+  }
+  for (let tool of d.tools ?? []) {
+    expectActionMatches(contract.tools.find((action) => action.id === tool.id), tool);
+  }
+  for (let trigger of d.triggers ?? []) {
+    expectActionMatches(contract.triggers.find((action) => action.id === trigger.id), trigger);
+  }
+  return contract;
+};
+var registerSlateTriggerWebhook = async (d) => d.client.registerTriggerWebhook(d.triggerId, d.webhookBaseUrl);
+var handleSlateTriggerWebhook = async (d) => d.client.handleTriggerWebhook({
+  actionId: d.triggerId,
+  url: d.url,
+  method: d.method ?? "POST",
+  headers: d.headers,
+  body: d.body,
+  state: d.state
+});
+var unregisterSlateTriggerWebhook = async (d) => d.client.unregisterTriggerWebhook({
+  actionId: d.triggerId,
+  webhookBaseUrl: d.webhookBaseUrl,
+  registrationDetails: d.registrationDetails,
+  state: d.state
+});
+var mapSlateTriggerEvent = async (d) => {
+  let expect = getExpect();
+  let result = await d.client.mapTriggerEvent(d.triggerId, d.input);
+  if (d.type !== void 0) {
+    expect(result.type).toBe(d.type);
+  }
+  if (d.output) {
+    expect(result.output).toMatchObject(d.output);
+  }
+  return result;
+};
+var expectSlateError = async (run, expected) => {
+  let expect = getExpect();
+  try {
+    await (typeof run === "function" ? run() : run);
+  } catch (error) {
+    if (typeof expected === "string" || expected instanceof RegExp) {
+      let message = error instanceof Error ? error.message : String(error);
+      if (expected instanceof RegExp) {
+        expect(message).toMatch(expected);
+      } else {
+        expect(message).toContain(expected);
+      }
+    } else if (error instanceof SlateProtocolError) {
+      expect(error.data).toMatchObject(expected);
+    } else {
+      expect(error).toMatchObject(expected);
+    }
+    return error;
+  }
+  throw new Error("Expected the operation to fail, but it completed successfully.");
+};
+var createSlatesVitestConfig = (config = {}) => createVitestConfig(config);
+export {
+  createLocalSlateTestClient,
+  createSlatesTestClient,
+  createSlatesVitestConfig,
+  expectSlateContract,
+  expectSlateError,
+  expectToolCall,
+  getSlateContract,
+  handleSlateTriggerWebhook,
+  loadSlatesProfile,
+  loadSlatesRuntimeContext,
+  mapSlateTriggerEvent,
+  registerSlateTriggerWebhook,
+  unregisterSlateTriggerWebhook,
+  withSlateProfile
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@slates/test",
+  "version": "1.0.0-rc.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src/**",
+    "dist/**",
+    "README.md",
+    "package.json"
+  ],
+  "author": "Tobias Herber",
+  "license": "FSL 1.1",
+  "type": "module",
+  "source": "src/index.ts",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "require": "./dist/index.cjs",
+    "import": "./dist/index.module.js",
+    "default": "./dist/index.module.js"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.module.js",
+  "types": "dist/index.d.ts",
+  "unpkg": "./dist/index.module.js",
+  "scripts": {
+    "test": "vitest run --passWithNoTests",
+    "lint": "prettier src/**/*.ts --check",
+    "build": "tsup --config ../../tsup.packages.config.ts --external async_hooks",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@lowerdeck/testing-tools": "latest",
+    "@slates/client": "1.0.0-rc.2",
+    "@slates/profiles": "1.0.0-rc.2"
+  },
+  "devDependencies": {
+    "@slates/provider": "1.0.0-rc.8",
+    "@slates/tsconfig": "1.0.0-rc.1",
+    "typescript": "5.8.2",
+    "vitest": "^3.1.2",
+    "zod": "^4.2"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,360 @@
+import {
+  Slate,
+  SlateAuth,
+  SlateConfig,
+  SlateSpecification,
+  SlateTool,
+  SlateTrigger
+} from '@slates/provider';
+import { openSlatesCliStore } from '@slates/profiles';
+import { mkdtemp, rm, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import path from 'path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import {
+  createLocalSlateTestClient,
+  expectSlateContract,
+  expectSlateError,
+  expectToolCall,
+  handleSlateTriggerWebhook,
+  loadSlatesRuntimeContext,
+  mapSlateTriggerEvent,
+  registerSlateTriggerWebhook,
+  unregisterSlateTriggerWebhook
+} from './index';
+
+(globalThis as typeof globalThis & { expect?: typeof expect }).expect = expect;
+
+let tempDirs: string[] = [];
+
+let createTempDir = async () => {
+  let dir = await mkdtemp(path.join(tmpdir(), 'slates-test-'));
+  tempDirs.push(dir);
+  return dir;
+};
+
+afterEach(async () => {
+  delete process.env.SLATES_INTEGRATION;
+  delete process.env.SLATES_PROFILE_ID;
+  delete process.env.SLATES_STORE_PATH;
+  delete process.env.SLATES_TEST_CONTEXT_PATH;
+  await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
+});
+
+let createDemoSlate = () => {
+  let config = SlateConfig.create(
+    z.object({
+      prefix: z.string()
+    })
+  ).getDefaultConfig(() => ({
+    prefix: 'Hello'
+  }));
+
+  let auth = SlateAuth.create<{ token: string }>()
+    .output(
+      z.object({
+        token: z.string()
+      })
+    )
+    .addTokenAuth({
+      type: 'auth.token',
+      key: 'token_auth',
+      name: 'Token Auth',
+      inputSchema: z.object({
+        token: z.string()
+      }),
+      getOutput: async ctx => ({
+        output: {
+          token: ctx.input.token
+        }
+      })
+    });
+
+  let spec = SlateSpecification.create({
+    key: 'demo-slate',
+    name: 'Demo Slate',
+    description: 'A tiny test slate',
+    config,
+    auth
+  });
+
+  let echo = SlateTool.create(spec, {
+    key: 'echo',
+    name: 'Echo',
+    tags: {
+      readOnly: false
+    }
+  })
+    .input(
+      z.object({
+        name: z.string()
+      })
+    )
+    .output(
+      z.object({
+        greeting: z.string(),
+        token: z.string()
+      })
+    )
+    .handleInvocation(async ctx => ({
+      output: {
+        greeting: `${ctx.config.prefix} ${ctx.input.name}`,
+        token: ctx.auth.token
+      },
+      message: 'done'
+    }))
+    .build();
+
+  let fail = SlateTool.create(spec, {
+    key: 'fail',
+    name: 'Fail'
+  })
+    .input(
+      z.object({
+        reason: z.string()
+      })
+    )
+    .output(z.object({}))
+    .handleInvocation(async ctx => {
+      throw new Error(ctx.input.reason);
+    })
+    .build();
+
+  let webhookEcho = SlateTrigger.create(spec, {
+    key: 'webhook_echo',
+    name: 'Webhook Echo'
+  })
+    .input(
+      z.object({
+        value: z.string()
+      })
+    )
+    .output(
+      z.object({
+        echoed: z.string()
+      })
+    )
+    .webhook({
+      autoRegisterWebhook: async ctx => ({
+        registrationDetails: {
+          webhookBaseUrl: ctx.input.webhookBaseUrl,
+          channelId: 'channel-1'
+        },
+        state: {
+          registered: true
+        }
+      }),
+      autoUnregisterWebhook: async ctx => {
+        if (ctx.input.registrationDetails?.channelId !== 'channel-1') {
+          throw new Error('Unexpected channel');
+        }
+      },
+      handleRequest: async ctx => {
+        if (ctx.request.headers.get('x-demo-event') === 'ignore') {
+          return { inputs: [] };
+        }
+
+        return {
+          inputs: [
+            {
+              value: (await ctx.request.text()) || 'empty'
+            }
+          ],
+          updatedState: {
+            lastEvent: ctx.request.headers.get('x-demo-event') ?? 'unknown'
+          }
+        };
+      },
+      handleEvent: async ctx => ({
+        type: 'demo.webhook',
+        id: `webhook-${ctx.input.value}`,
+        output: {
+          echoed: ctx.input.value
+        }
+      })
+    })
+    .build();
+
+  return Slate.create({
+    spec,
+    tools: [echo, fail],
+    triggers: [webhookEcho]
+  });
+};
+
+describe('@slates/test', () => {
+  it('loads runtime context from the CLI handoff file', async () => {
+    let cwd = await createTempDir();
+    let store = await openSlatesCliStore({
+      cwd,
+      scope: {
+        key: 'integrations/demo',
+        name: 'demo'
+      }
+    });
+    let profile = store.upsertProfile({
+      name: 'Demo',
+      target: {
+        type: 'local',
+        entry: './demo-slate.mjs',
+        exportName: 'provider'
+      }
+    });
+    await store.save();
+
+    let runtimeContextPath = path.join(cwd, 'runtime.json');
+    await writeFile(
+      runtimeContextPath,
+      JSON.stringify({
+        integration: 'integrations/demo',
+        profileId: profile.id,
+        storePath: store.storePath,
+        cliDir: store.dirPath
+      }),
+      'utf-8'
+    );
+
+    process.env.SLATES_TEST_CONTEXT_PATH = runtimeContextPath;
+
+    let context = await loadSlatesRuntimeContext({ cwd });
+    expect(context.integration).toBe('integrations/demo');
+    expect(context.profileId).toBe(profile.id);
+    expect(context.profile?.target.type).toBe('local');
+    expect(context.storePath).toBe(store.storePath);
+  });
+
+  it('creates local slate clients and asserts provider contracts', async () => {
+    let client = createLocalSlateTestClient({
+      slate: createDemoSlate(),
+      state: {
+        config: {
+          prefix: 'Hi'
+        },
+        auth: {
+          authenticationMethodId: 'token_auth',
+          output: {
+            token: 'secret-token'
+          }
+        }
+      }
+    });
+
+    let contract = await expectSlateContract({
+      client,
+      provider: {
+        id: 'demo-slate',
+        name: 'Demo Slate',
+        description: 'A tiny test slate'
+      },
+      toolIds: ['echo', 'fail'],
+      triggerIds: ['webhook_echo'],
+      authMethodIds: ['token_auth'],
+      tools: [
+        { id: 'echo', readOnly: false, destructive: false },
+        { id: 'fail', readOnly: false, destructive: false }
+      ],
+      triggers: [{ id: 'webhook_echo', invocationType: 'webhook' }]
+    });
+
+    expect(contract.configSchema.properties.prefix.type).toBe('string');
+
+    await expectToolCall({
+      client,
+      toolId: 'echo',
+      input: {
+        name: 'Tobias'
+      },
+      output: {
+        greeting: 'Hi Tobias',
+        token: 'secret-token'
+      }
+    });
+  });
+
+  it('wraps trigger webhook flows and error assertions', async () => {
+    let client = createLocalSlateTestClient({
+      slate: createDemoSlate(),
+      state: {
+        config: {
+          prefix: 'Hi'
+        },
+        auth: {
+          authenticationMethodId: 'token_auth',
+          output: {
+            token: 'secret-token'
+          }
+        }
+      }
+    });
+
+    let registration = await registerSlateTriggerWebhook({
+      client,
+      triggerId: 'webhook_echo',
+      webhookBaseUrl: 'https://example.com/hooks/google-calendar'
+    });
+    expect(registration).toMatchObject({
+      registrationDetails: {
+        webhookBaseUrl: 'https://example.com/hooks/google-calendar',
+        channelId: 'channel-1'
+      },
+      state: {
+        registered: true
+      }
+    });
+
+    let ignored = await handleSlateTriggerWebhook({
+      client,
+      triggerId: 'webhook_echo',
+      url: 'https://example.com/hooks/google-calendar',
+      headers: {
+        'x-demo-event': 'ignore'
+      }
+    });
+    expect(ignored.inputs).toEqual([]);
+
+    let handled = await handleSlateTriggerWebhook({
+      client,
+      triggerId: 'webhook_echo',
+      url: 'https://example.com/hooks/google-calendar',
+      headers: {
+        'x-demo-event': 'created'
+      },
+      body: 'payload-value'
+    });
+    expect(handled).toMatchObject({
+      inputs: [{ value: 'payload-value' }],
+      updatedState: {
+        lastEvent: 'created'
+      }
+    });
+
+    let mapped = await mapSlateTriggerEvent({
+      client,
+      triggerId: 'webhook_echo',
+      input: {
+        value: 'payload-value'
+      },
+      type: 'demo.webhook',
+      output: {
+        echoed: 'payload-value'
+      }
+    });
+    expect(mapped.id).toBe('webhook-payload-value');
+
+    await unregisterSlateTriggerWebhook({
+      client,
+      triggerId: 'webhook_echo',
+      webhookBaseUrl: 'https://example.com/hooks/google-calendar',
+      registrationDetails: registration.registrationDetails
+    });
+
+    await expectSlateError(
+      () =>
+        client.invokeTool('fail', {
+          reason: 'intentional failure'
+        }),
+      { code: 'internal.unexpected', kind: 'internal', status: 500 }
+    );
+  });
+});