@slates/test 1.0.0-rc.2 → 1.0.0-rc.4

package/src/index.test.ts

@@ -1,4 +1,5 @@
 import {
+  createTextAttachment,
   Slate,
   SlateAuth,
   SlateConfig,
@@ -20,6 +21,7 @@ import {
   handleSlateTriggerWebhook,
   loadSlatesRuntimeContext,
   mapSlateTriggerEvent,
+  pollSlateTriggerEvents,
   registerSlateTriggerWebhook,
   unregisterSlateTriggerWebhook
 } from './index';
@@ -121,6 +123,53 @@ let createDemoSlate = () => {
     })
     .build();
 
+  let attachmentEcho = SlateTool.create(spec, {
+    key: 'attachment_echo',
+    name: 'Attachment Echo',
+    tags: {
+      readOnly: true
+    }
+  })
+    .input(
+      z.object({
+        mimeType: z.string().optional()
+      })
+    )
+    .output(
+      z.object({
+        size: z.number()
+      })
+    )
+    .handleInvocation(async ctx => ({
+      output: {
+        size: 5
+      },
+      message: 'attached',
+      attachments: [createTextAttachment('hello', ctx.input.mimeType)]
+    }))
+    .build();
+
+  let downloadLink = SlateTool.create(spec, {
+    key: 'download_link',
+    name: 'Download Link',
+    tags: {
+      readOnly: true
+    }
+  })
+    .input(z.object({}))
+    .output(
+      z.object({
+        downloadUrl: z.string()
+      })
+    )
+    .handleInvocation(async () => ({
+      output: {
+        downloadUrl: 'https://example.com/files/demo.txt'
+      },
+      message: 'linked'
+    }))
+    .build();
+
   let webhookEcho = SlateTrigger.create(spec, {
     key: 'webhook_echo',
     name: 'Webhook Echo'
@@ -176,10 +225,41 @@ let createDemoSlate = () => {
     })
     .build();
 
+  let pollEcho = SlateTrigger.create(spec, {
+    key: 'poll_echo',
+    name: 'Poll Echo'
+  })
+    .input(
+      z.object({
+        value: z.string()
+      })
+    )
+    .output(
+      z.object({
+        echoed: z.string()
+      })
+    )
+    .polling({
+      pollEvents: async ctx => ({
+        inputs: ctx.input.state?.seen ? [] : [{ value: 'poll-value' }],
+        updatedState: {
+          seen: true
+        }
+      }),
+      handleEvent: async ctx => ({
+        type: 'demo.poll',
+        id: `poll-${ctx.input.value}`,
+        output: {
+          echoed: ctx.input.value
+        }
+      })
+    })
+    .build();
+
   return Slate.create({
     spec,
-    tools: [echo, fail],
-    triggers: [webhookEcho]
+    tools: [echo, fail, attachmentEcho, downloadLink],
+    triggers: [webhookEcho, pollEcho]
   });
 };
 
@@ -247,14 +327,19 @@ describe('@slates/test', () => {
         name: 'Demo Slate',
         description: 'A tiny test slate'
       },
-      toolIds: ['echo', 'fail'],
-      triggerIds: ['webhook_echo'],
+      toolIds: ['echo', 'fail', 'attachment_echo', 'download_link'],
+      triggerIds: ['webhook_echo', 'poll_echo'],
       authMethodIds: ['token_auth'],
       tools: [
         { id: 'echo', readOnly: false, destructive: false },
-        { id: 'fail', readOnly: false, destructive: false }
+        { id: 'fail', readOnly: false, destructive: false },
+        { id: 'attachment_echo', readOnly: true, destructive: false },
+        { id: 'download_link', readOnly: true, destructive: false }
       ],
-      triggers: [{ id: 'webhook_echo', invocationType: 'webhook' }]
+      triggers: [
+        { id: 'webhook_echo', invocationType: 'webhook' },
+        { id: 'poll_echo', invocationType: 'polling' }
+      ]
     });
 
     expect(contract.configSchema.properties.prefix.type).toBe('string');
@@ -270,6 +355,30 @@ describe('@slates/test', () => {
         token: 'secret-token'
       }
     });
+
+    let attachmentResult = await client.invokeTool('attachment_echo', {
+      mimeType: 'text/plain'
+    });
+    expect(attachmentResult.attachments).toEqual([
+      {
+        mimeType: 'text/plain',
+        content: {
+          type: 'content',
+          encoding: 'utf-8',
+          content: 'hello'
+        }
+      }
+    ]);
+
+    let downloadResult = await client.invokeTool('download_link', {});
+    expect(downloadResult.attachments).toEqual([
+      {
+        content: {
+          type: 'url',
+          url: 'https://example.com/files/demo.txt'
+        }
+      }
+    ]);
   });
 
   it('wraps trigger webhook flows and error assertions', async () => {
@@ -357,4 +466,53 @@ describe('@slates/test', () => {
       { code: 'internal.unexpected', kind: 'internal', status: 500 }
     );
   });
+
+  it('wraps trigger polling flows', async () => {
+    let client = createLocalSlateTestClient({
+      slate: createDemoSlate(),
+      state: {
+        config: {
+          prefix: 'Hi'
+        },
+        auth: {
+          authenticationMethodId: 'token_auth',
+          output: {
+            token: 'secret-token'
+          }
+        }
+      }
+    });
+
+    let initialPoll = await pollSlateTriggerEvents({
+      client,
+      triggerId: 'poll_echo'
+    });
+    expect(initialPoll).toMatchObject({
+      inputs: [{ value: 'poll-value' }],
+      updatedState: {
+        seen: true
+      }
+    });
+
+    let mapped = await mapSlateTriggerEvent({
+      client,
+      triggerId: 'poll_echo',
+      input: initialPoll.inputs[0]!,
+      type: 'demo.poll',
+      output: {
+        echoed: 'poll-value'
+      }
+    });
+    expect(mapped.id).toBe('poll-poll-value');
+
+    let repeatedPoll = await pollSlateTriggerEvents({
+      client,
+      triggerId: 'poll_echo',
+      state: initialPoll.updatedState
+    });
+    expect(repeatedPoll.inputs).toEqual([]);
+    expect(repeatedPoll.updatedState).toEqual({
+      seen: true
+    });
+  });
 });

package/src/index.ts

@@ -1,332 +1 @@
-import { createVitestConfig } from '@lowerdeck/testing-tools';
-import {
-  createLocalSlateTransport,
-  createSlatesClient,
-  SlateProtocolError
-} from '@slates/client';
-import type { SlatesProtocolClientOptions } from '@slates/client';
-import {
-  createSlatesClientFromProfile,
-  openSlatesCliStore,
-  SlatesProfileRecord
-} from '@slates/profiles';
-import { readFile } from 'fs/promises';
-
-export interface SlatesRuntimeContext {
-  integration: string | null;
-  profileId: string | null;
-  profile: SlatesProfileRecord | null;
-  storePath: string;
-  cliDir: string;
-}
-
-export type SlatesTestClient = ReturnType<typeof createSlatesClient>;
-
-type LocalSlate = Parameters<typeof createLocalSlateTransport>[0]['slate'];
-
-export interface ExpectedSlateAction {
-  id: string;
-  name?: string;
-  description?: string;
-  readOnly?: boolean;
-  destructive?: boolean;
-  invocationType?: 'polling' | 'webhook';
-}
-
-let getExpect = () => {
-  let maybeExpect = (globalThis as typeof globalThis & { expect?: typeof import('vitest').expect })
-    .expect;
-
-  if (!maybeExpect) {
-    throw new Error('Vitest expect is not available in the current runtime.');
-  }
-
-  return maybeExpect;
-};
-
-export let loadSlatesRuntimeContext = async (
-  opts: {
-    cwd?: string;
-    profile?: string | null;
-  } = {}
-): Promise<SlatesRuntimeContext> => {
-  let runtimeContextPath = process.env.SLATES_TEST_CONTEXT_PATH;
-  if (runtimeContextPath) {
-    let raw = await readFile(runtimeContextPath, 'utf-8');
-    let parsed = JSON.parse(raw) as {
-      integration?: string | null;
-      profileId: string | null;
-      storePath: string;
-      cliDir: string;
-    };
-    let store = await openSlatesCliStore({ storePath: parsed.storePath });
-    let profile = store.getProfile(opts.profile ?? parsed.profileId ?? null);
-
-    return {
-      integration: parsed.integration ?? store.scope?.key ?? null,
-      profileId: profile?.id ?? parsed.profileId ?? null,
-      profile,
-      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
-  };
-};
-
-export let loadSlatesProfile = async (
-  opts: { cwd?: string; profile?: string | null } = {}
-) => {
-  let context = await loadSlatesRuntimeContext(opts);
-  if (!context.profile) {
-    throw new Error('No Slates profile is available for the current test context.');
-  }
-
-  return context.profile;
-};
-
-export let createSlatesTestClient = async (
-  opts: { cwd?: string; profile?: string | null } = {}
-) => {
-  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 });
-};
-
-export let withSlateProfile = async <T>(
-  profileName: string | null | undefined,
-  cb: (ctx: { profile: SlatesProfileRecord }) => Promise<T>
-) => {
-  let profile = await loadSlatesProfile({ profile: profileName });
-  return cb({ profile });
-};
-
-export let expectToolCall = async (d: {
-  client?: Awaited<ReturnType<typeof createSlatesTestClient>>;
-  profile?: string | null;
-  toolId: string;
-  input: Record<string, any>;
-  output?: Record<string, any>;
-}) => {
-  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;
-};
-
-export let createLocalSlateTestClient = (opts: {
-  slate: LocalSlate;
-  state?: SlatesProtocolClientOptions['state'];
-  participants?: SlatesProtocolClientOptions['participants'];
-}) =>
-  createSlatesClient({
-    transport: createLocalSlateTransport({ slate: opts.slate }),
-    state: opts.state,
-    participants: opts.participants
-  });
-
-export let getSlateContract = async (client: SlatesTestClient) => {
-  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
-  };
-};
-
-let expectActionMatches = (actual: Record<string, any> | undefined, expected: ExpectedSlateAction) => {
-  let expect = getExpect();
-  expect(actual).toBeTruthy();
-  expect(actual?.id).toBe(expected.id);
-
-  if (expected.name !== undefined) {
-    expect(actual?.name).toBe(expected.name);
-  }
-
-  if (expected.description !== undefined) {
-    expect(actual?.description).toBe(expected.description);
-  }
-
-  if (expected.readOnly !== undefined) {
-    expect(actual?.tags?.readOnly ?? false).toBe(expected.readOnly);
-  }
-
-  if (expected.destructive !== undefined) {
-    expect(actual?.tags?.destructive ?? false).toBe(expected.destructive);
-  }
-
-  if (expected.invocationType !== undefined) {
-    expect((actual as { invocation?: { type?: string } } | undefined)?.invocation?.type).toBe(
-      expected.invocationType
-    );
-  }
-};
-
-export let expectSlateContract = async (d: {
-  client: SlatesTestClient;
-  provider?: {
-    id: string;
-    name?: string;
-    description?: string;
-  };
-  toolIds?: string[];
-  triggerIds?: string[];
-  authMethodIds?: string[];
-  tools?: ExpectedSlateAction[];
-  triggers?: ExpectedSlateAction[];
-}) => {
-  let expect = getExpect();
-  let contract = await getSlateContract(d.client);
-
-  if (d.provider) {
-    expect(contract.provider.id).toBe(d.provider.id);
-    if (d.provider.name !== undefined) {
-      expect(contract.provider.name).toBe(d.provider.name);
-    }
-    if (d.provider.description !== undefined) {
-      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;
-};
-
-export let registerSlateTriggerWebhook = async (d: {
-  client: SlatesTestClient;
-  triggerId: string;
-  webhookBaseUrl: string;
-}) => d.client.registerTriggerWebhook(d.triggerId, d.webhookBaseUrl);
-
-export let handleSlateTriggerWebhook = async (d: {
-  client: SlatesTestClient;
-  triggerId: string;
-  url: string;
-  method?: string;
-  headers?: Record<string, string>;
-  body?: string | Uint8Array | null;
-  state?: any;
-}) =>
-  d.client.handleTriggerWebhook({
-    actionId: d.triggerId,
-    url: d.url,
-    method: d.method ?? 'POST',
-    headers: d.headers,
-    body: d.body,
-    state: d.state
-  });
-
-export let unregisterSlateTriggerWebhook = async (d: {
-  client: SlatesTestClient;
-  triggerId: string;
-  webhookBaseUrl: string;
-  registrationDetails: any;
-  state?: any;
-}) =>
-  d.client.unregisterTriggerWebhook({
-    actionId: d.triggerId,
-    webhookBaseUrl: d.webhookBaseUrl,
-    registrationDetails: d.registrationDetails,
-    state: d.state
-  });
-
-export let mapSlateTriggerEvent = async (d: {
-  client: SlatesTestClient;
-  triggerId: string;
-  input: Record<string, any>;
-  output?: Record<string, any>;
-  type?: string;
-}) => {
-  let expect = getExpect();
-  let result = await d.client.mapTriggerEvent(d.triggerId, d.input);
-
-  if (d.type !== undefined) {
-    expect(result.type).toBe(d.type);
-  }
-
-  if (d.output) {
-    expect(result.output).toMatchObject(d.output);
-  }
-
-  return result;
-};
-
-export let expectSlateError = async (
-  run: Promise<unknown> | (() => Promise<unknown>),
-  expected: Record<string, any> | string | RegExp
-) => {
-  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.');
-};
-
-export let createSlatesVitestConfig = (
-  config: Parameters<typeof createVitestConfig>[0] = {}
-) => createVitestConfig(config);
+export * from './runtime';