@chainlink/cre-sdk 0.0.2-alpha → 0.0.3-alpha

package/dist/sdk/wasm/runner.test.js

@@ -1,270 +0,0 @@
-import { afterEach, describe, expect, mock, test } from 'bun:test';
-import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
-import { anyPack, anyUnpack, EmptySchema } from '@bufbuild/protobuf/wkt';
-import { ConfigSchema, OutputsSchema, } from '../../generated/capabilities/internal/basictrigger/v1/basic_trigger_pb';
-import { AwaitSecretsRequestSchema, AwaitSecretsResponseSchema, ExecuteRequestSchema, ExecutionResultSchema, GetSecretsRequestSchema, SecretResponseSchema, SecretResponsesSchema, SecretSchema, TriggerSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
-import { BasicCapability as BasicTriggerCapability } from '../../generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen';
-import { cre } from '../cre';
-import { Value } from '../utils';
-import { Runner } from './runner';
-const anyConfig = Buffer.from('config');
-const anyMaxResponseSize = 2048n;
-const basicTrigger = new BasicTriggerCapability();
-const capID = BasicTriggerCapability.CAPABILITY_ID;
-const subscribeRequest = create(ExecuteRequestSchema, {
-    request: { case: 'subscribe', value: create(EmptySchema) },
-    maxResponseSize: anyMaxResponseSize,
-    config: anyConfig,
-});
-const anyExecuteRequest = create(ExecuteRequestSchema, {
-    request: {
-        case: 'trigger',
-        value: create(TriggerSchema, {
-            id: 0n,
-            payload: anyPack(OutputsSchema, create(OutputsSchema, { coolOutput: 'hi' })),
-        }),
-    },
-    maxResponseSize: anyMaxResponseSize,
-    config: anyConfig,
-});
-const mockHostBindings = {
-    sendResponse: mock(() => {
-        return 0;
-    }),
-    versionV2: mock(() => { }),
-    getWasiArgs: mock(() => {
-        throw new Error('override for tests');
-    }),
-    getSecrets: mock((data, maxResponseSize) => {
-        throw new Error('override for tests');
-    }),
-    awaitSecrets: mock((data, maxResponseSize) => {
-        throw new Error('override for tests');
-    }),
-};
-const proxyHostBindings = {
-    sendResponse: (data) => {
-        return mockHostBindings.sendResponse(data);
-    },
-    versionV2: () => {
-        return mockHostBindings.versionV2();
-    },
-    getWasiArgs: () => {
-        return mockHostBindings.getWasiArgs();
-    },
-    switchModes: mock(() => { }),
-    log: (message) => {
-        throw new Error('log called unexpectedly in test');
-    },
-    callCapability: (data) => {
-        throw new Error('callCapability called unexpectedly in test');
-    },
-    awaitCapabilities: (data, id) => {
-        throw new Error('awaitCapabilities called unexpectedly in test');
-    },
-    getSecrets: (data, id) => {
-        return mockHostBindings.getSecrets(data, id);
-    },
-    awaitSecrets: (data, id) => {
-        return mockHostBindings.awaitSecrets(data, id);
-    },
-    now: () => {
-        throw new Error('now called unexpectedly in test');
-    },
-};
-Object.assign(globalThis, proxyHostBindings);
-afterEach(() => {
-    mock.restore();
-});
-describe('runner', () => {
-    describe('run', () => {
-        test('gathers subscriptions', async () => {
-            var sentResponse = null;
-            mockHostBindings.sendResponse = mock((input) => {
-                sentResponse = fromBinary(ExecutionResultSchema, input);
-                return 0;
-            });
-            const runner = await getTestRunner(subscribeRequest);
-            await runner.run(async (_, secretsProvider) => {
-                return [
-                    cre.handler(basicTrigger.trigger({ name: 'foo', number: 10 }), () => {
-                        throw new Error('Must not be called during registration to tiggers');
-                    }),
-                ];
-            });
-            expect(sentResponse).toBeDefined();
-            expect(sentResponse.result.case).toBe('triggerSubscriptions');
-            const responseValue = sentResponse.result.value;
-            expect(responseValue.subscriptions.length).toBe(1);
-            expect(responseValue.subscriptions[0].id).toBe(capID);
-            expect(responseValue.subscriptions[0].method).toBe('Trigger');
-            expect(responseValue.subscriptions[0].payload).toBeDefined();
-            const actualConfig = anyUnpack(responseValue.subscriptions[0].payload, ConfigSchema);
-            expect(actualConfig.name).toBe('foo');
-            expect(actualConfig.number).toBe(10);
-        });
-        test('executes workflow', async () => {
-            var sentResponse = null;
-            mockHostBindings.sendResponse = mock((input) => {
-                sentResponse = fromBinary(ExecutionResultSchema, input);
-                return 0;
-            });
-            const runner = await getTestRunner(anyExecuteRequest);
-            await runner.run(async (_, secretsProvider) => {
-                return [
-                    cre.handler(basicTrigger.trigger({ name: 'foo', number: 10 }), (runtime, trigger) => {
-                        expect(runtime.config).toBe(anyConfig.toString());
-                        expect(trigger.coolOutput).toBe('hi');
-                        return 10;
-                    }),
-                ];
-            });
-            expect(sentResponse).toBeDefined();
-            expect(sentResponse.result.case).toBe('value');
-            expect(Value.wrap(sentResponse.result.value).unwrapToType({ instance: 10 })).toBe(10);
-        });
-    });
-    test('executes subscribe error', async () => {
-        var sentResponse = null;
-        const anyError = 'error';
-        mockHostBindings.sendResponse = mock((input) => {
-            sentResponse = fromBinary(ExecutionResultSchema, input);
-            expect(sentResponse.result.case).toBe('error');
-            expect(sentResponse.result.value).toBe(anyError);
-            return 0;
-        });
-        const runner = await getTestRunner(subscribeRequest);
-        await runner.run((_, secretsProvider) => {
-            throw new Error(anyError);
-        });
-    });
-    test('executes subscribe resolve error', async () => {
-        var sentResponse = null;
-        const anyError = 'error';
-        mockHostBindings.sendResponse = mock((input) => {
-            sentResponse = fromBinary(ExecutionResultSchema, input);
-            expect(sentResponse.result.case).toBe('error');
-            expect(sentResponse.result.value).toBe(anyError);
-            return 0;
-        });
-        const runner = await getTestRunner(subscribeRequest);
-        await runner.run(async (_, secretsProvider) => {
-            return Promise.reject(new Error(anyError));
-        });
-    });
-    test('executes trigger error', async () => {
-        var sentResponse = null;
-        const anyError = 'error';
-        mockHostBindings.sendResponse = mock((input) => {
-            sentResponse = fromBinary(ExecutionResultSchema, input);
-            expect(sentResponse.result.case).toBe('error');
-            expect(sentResponse.result.value).toBe(anyError);
-            return 0;
-        });
-        const runner = await getTestRunner(anyExecuteRequest);
-        await runner.run(async (_, secretsProvider) => {
-            throw new Error(anyError);
-        });
-    });
-    test('executes workflow with multiple triggers', async () => {
-        var sentResponse = null;
-        mockHostBindings.sendResponse = mock((input) => {
-            sentResponse = fromBinary(ExecutionResultSchema, input);
-            return 0;
-        });
-        const testRequest = structuredClone(anyExecuteRequest);
-        const trigger = testRequest.request.value;
-        trigger.id = 1n;
-        const runner = await getTestRunner(testRequest);
-        await runner.run(async (_, secretsProvider) => {
-            return [
-                cre.handler(basicTrigger.trigger({ name: 'foo', number: 10 }), (runtime, trigger) => {
-                    expect(runtime.config).toBe(anyConfig.toString());
-                    expect(trigger.coolOutput).toBe('hi');
-                    return 10;
-                }),
-                cre.handler(basicTrigger.trigger({ name: 'bar', number: 20 }), (runtime, trigger) => {
-                    expect(runtime.config).toBe(anyConfig.toString());
-                    expect(trigger.coolOutput).toBe('hi');
-                    return 20;
-                }),
-                cre.handler(basicTrigger.trigger({ name: 'baz', number: 30 }), (runtime, trigger) => {
-                    expect(runtime.config).toBe(anyConfig.toString());
-                    expect(trigger.coolOutput).toBe('hi');
-                    return 30;
-                }),
-            ];
-        });
-        expect(sentResponse).toBeDefined();
-        expect(sentResponse.result.case).toBe('value');
-        expect(Value.wrap(sentResponse.result.value).unwrapToType({ instance: 10 })).toBe(20);
-    });
-    test('get secrets passes max response size', async () => {
-        const anySecretResponse = create(SecretResponseSchema, {
-            response: {
-                case: 'secret',
-                value: create(SecretSchema, { id: 'Bar', namespace: 'Foo', owner: 'Baz', value: 'Qux' }),
-            },
-        });
-        const anySecretsResponse = create(SecretResponsesSchema, {
-            responses: [anySecretResponse],
-        });
-        mockHostBindings.getSecrets = (data, maxResponseSize) => {
-            const dataBytes = Array.isArray(data) ? new Uint8Array(data) : data;
-            const secretsRequest = fromBinary(GetSecretsRequestSchema, dataBytes);
-            expect(secretsRequest.requests.length).toBe(1);
-            expect(secretsRequest.requests[0].namespace).toBe('Foo');
-            expect(secretsRequest.requests[0].id).toBe('Bar');
-            expect(secretsRequest.callbackId).toBe(0);
-            expect(maxResponseSize).toBe(Number(anyMaxResponseSize));
-            return 0;
-        };
-        mockHostBindings.awaitSecrets = (data, maxResponseSize) => {
-            const dataBytes = Array.isArray(data) ? new Uint8Array(data) : data;
-            const awaitSecretsRequest = fromBinary(AwaitSecretsRequestSchema, dataBytes);
-            expect(awaitSecretsRequest.ids.length).toBe(1);
-            expect(awaitSecretsRequest.ids[0]).toBe(0);
-            expect(maxResponseSize).toBe(Number(anyMaxResponseSize));
-            // Create the proper AwaitSecretsResponse with a map
-            const awaitSecretsResponse = create(AwaitSecretsResponseSchema, {
-                responses: {
-                    0: anySecretsResponse,
-                },
-            });
-            return toBinary(AwaitSecretsResponseSchema, awaitSecretsResponse);
-        };
-        const dr = getTestRunner(subscribeRequest);
-        await (await dr).run(async (_, secretsProvider) => {
-            const secret = await secretsProvider.getSecret({ namespace: 'Foo', id: 'Bar' }).result();
-            expect(secret.namespace).toBe('Foo');
-            expect(secret.id).toBe('Bar');
-            expect(secret.owner).toBe('Baz');
-            expect(secret.value).toBe('Qux');
-            return [cre.handler(basicTrigger.trigger({}), () => 10)];
-        });
-        expect(true).toBe(true);
-    });
-});
-function assertEnv(r) {
-    let ran = false;
-    const verifyEnv = (config, _) => {
-        ran = true;
-        expect(config).toBe(anyConfig.toString());
-        return [];
-    };
-    r.run(verifyEnv);
-    expect(ran).toBe(true);
-}
-function getTestRunner(request) {
-    const serialized = toBinary(ExecuteRequestSchema, request);
-    const encoded = Buffer.from(serialized).toString('base64');
-    // Update the mock to return the specific request
-    mockHostBindings.getWasiArgs = mock(() => JSON.stringify(['program', encoded]));
-    return Runner.newRunner({
-        configParser: (b) => {
-            const stringConfig = Buffer.from(b).toString();
-            expect(stringConfig).toBe(anyConfig.toString());
-            return stringConfig;
-        },
-    });
-}