Skip to content

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

Fix trigger tests

haxziec4bd379b4bee
diff --git a/packages/core/src/models/Triggers.ts b/packages/core/src/models/Triggers.ts
index 279174f2e..a1c1111c2 100644
--- a/packages/core/src/models/Triggers.ts
+++ b/packages/core/src/models/Triggers.ts
@@ -374,7 +374,7 @@ export class Triggers {
};
logger.debug('🔄 Subscribing to triggers with filters: ', JSON.stringify(filters, null, 2));
- this.pusherService.subscribe((_data: Record<string, unknown>) => {
+ await this.pusherService.subscribe((_data: Record<string, unknown>) => {
logger.debug('Received trigger data', JSON.stringify(_data, null, 2));
// @TODO: This is a temporary fix to get the trigger data
// ideally we should have a type for the trigger data
@@ -389,26 +389,30 @@ export class Triggers {
metadata: {
...data.metadata,
id: data.metadata.id,
- connectedAccountId: data.metadata.connection.id,
+ connectedAccountId: data.metadata.connection?.id,
triggerSlug: data.metadata.triggerName,
triggerName: data.metadata.triggerName,
triggerData: data.metadata.triggerData,
triggerConfig: data.metadata.triggerConfig,
connection: {
- id: data.metadata.connection.id,
- integrationId: data.metadata.connection.integrationId,
- clientUniqueUserId: data.metadata.connection.clientUniqueUserId,
- status: data.metadata.connection.status,
+ id: data.metadata?.connection?.id,
+ integrationId: data.metadata?.connection?.integrationId,
+ clientUniqueUserId: data.metadata?.connection?.clientUniqueUserId,
+ status: data.metadata?.connection?.status,
},
},
} as IncomingTriggerPayload);
- if (!parsedData.success) {
+ if (parsedData.error) {
throw new ValidationError(`Invalid trigger payload`, {
cause: parsedData.error,
});
}
if (shouldSendTriggerAfterFilters(parsedData.data)) {
- fn(parsedData.data);
+ try {
+ fn(parsedData.data);
+ } catch (error) {
+ logger.error('❌ Error in trigger callback:', error);
+ }
} else {
logger.debug('Trigger does not match filters', JSON.stringify(parsedFilters.data, null, 2));
}
diff --git a/packages/core/src/types/triggers.types.ts b/packages/core/src/types/triggers.types.ts
index 0197ded44..fb0f51285 100644
--- a/packages/core/src/types/triggers.types.ts
+++ b/packages/core/src/types/triggers.types.ts
@@ -104,7 +104,7 @@ export const IncomingTriggerPayloadSchema = z.object({
connectedAccountId: z.string(),
triggerSlug: z.string(),
triggerName: z.string(),
- triggerData: z.string(),
+ triggerData: z.string().optional(),
triggerConfig: z.record(z.unknown()),
connection: z.object({
id: z.string(),
diff --git a/packages/core/test/models/triggers.test.ts b/packages/core/test/models/triggers.test.ts
index 1ee999f21..d26f0d5a3 100644
--- a/packages/core/test/models/triggers.test.ts
+++ b/packages/core/test/models/triggers.test.ts
@@ -1,17 +1,15 @@
import { describe, it, expect, vi, beforeEach, afterEach, Mock } from 'vitest';
import { Triggers } from '../../src/models/triggers';
import ComposioClient from '@composio/client';
-import { Session } from '../../src/models/Session';
-import { PusherUtils, TriggerData } from '../../src/utils/pusher';
+import { TriggerData } from '../../src/utils/pusher';
import logger from '../../src/utils/logger';
-import { TriggerStatusEnum, TriggerSubscribeParams } from '../../src/types/triggers.types';
+import { TriggerSubscribeParams } from '../../src/types/triggers.types';
import { telemetry } from '../../src/telemetry/Telemetry';
import { ValidationError } from '../../src/errors';
import { PusherService } from '../../src/services/pusher/Pusher';
+import { ComposioFailedToSubscribeToPusherChannelError } from '../../src/errors/TriggerErrors';
// Mock dependencies
-vi.mock('../../src/models/Session');
-vi.mock('../../src/utils/pusher');
vi.mock('../../src/utils/logger');
vi.mock('../../src/telemetry/Telemetry', () => ({
telemetry: {
@@ -37,11 +35,6 @@ const createMockClient = () => ({
retrieve: vi.fn(),
retrieveEnum: vi.fn(),
},
- auth: {
- session: {
- retrieve: vi.fn(),
- },
- },
});
// Mock response data
@@ -173,7 +166,6 @@ const mockIncomingTriggerPayload = {
describe('Triggers', () => {
let triggers: Triggers;
let mockClient: ReturnType<typeof createMockClient>;
- let mockSession: Session;
let mockPusherService: {
subscribe: Mock;
unsubscribe: Mock;
@@ -188,17 +180,6 @@ describe('Triggers', () => {
unsubscribe: vi.fn(),
} as unknown as { subscribe: Mock; unsubscribe: Mock };
- // Mock Session
- mockSession = {
- getInfo: vi.fn().mockResolvedValue(mockSessionInfo),
- } as unknown as Session;
- (Session as any).mockImplementation(() => mockSession);
-
- // Mock PusherUtils
- vi.mocked(PusherUtils.getPusherClient).mockResolvedValue({} as any);
- vi.mocked(PusherUtils.triggerSubscribe).mockImplementation(() => {});
- vi.mocked(PusherUtils.triggerUnsubscribe).mockImplementation(() => {});
-
// Mock PusherService constructor
(PusherService as unknown as Mock).mockImplementation(() => mockPusherService);
@@ -416,18 +397,6 @@ describe('Triggers', () => {
);
});
- it('should throw error if client ID is not found', async () => {
- mockSession.getInfo = vi.fn().mockResolvedValue({ project: null });
-
- await expect(triggers.subscribe(mockCallback)).rejects.toThrow('Client ID not found');
- });
-
- it('should throw error if API key is not found', async () => {
- mockClient.apiKey = undefined as any;
-
- await expect(triggers.subscribe(mockCallback)).rejects.toThrow('API key not found');
- });
-
it('should subscribe to triggers without filters', async () => {
await triggers.subscribe(mockCallback);
@@ -458,7 +427,6 @@ describe('Triggers', () => {
const filters: TriggerSubscribeParams = { toolkits: ['GITHUB'] };
await triggers.subscribe(mockCallback, filters);
- // Get the callback function passed to PusherService.subscribe
const subscribeCall = vi.mocked(mockPusherService.subscribe).mock.calls[0];
const filterCallback = subscribeCall[0];
@@ -604,20 +572,99 @@ describe('Triggers', () => {
);
});
- it('should throw validation error for invalid trigger data', async () => {
+ it('should handle invalid trigger data format', async () => {
const invalidTriggerData = {
- ...mockTriggerData,
+ appName: 'github',
+ clientId: 123,
+ payload: { action: 'push' },
+ originalPayload: { action: 'push' },
metadata: {
- ...mockTriggerData.metadata,
- id: undefined, // Make the data invalid
+ triggerName: 'github_webhook',
},
};
await triggers.subscribe(mockCallback);
+
const subscribeCall = vi.mocked(mockPusherService.subscribe).mock.calls[0];
const filterCallback = subscribeCall[0];
expect(() => filterCallback(invalidTriggerData)).toThrow(ValidationError);
+ expect(mockCallback).not.toHaveBeenCalled();
+ });
+
+ it('should handle partial trigger data with missing optional fields', async () => {
+ const partialTriggerData = {
+ appName: 'github',
+ clientId: 123,
+ payload: { action: 'push', repository: 'test-repo' },
+ originalPayload: { action: 'push', repository: 'test-repo' },
+ metadata: {
+ id: 'trigger-123',
+ connectionId: 'conn-123',
+ triggerName: 'github_webhook',
+ triggerConfig: { webhook_url: 'https://example.com/webhook' },
+ connection: {
+ id: 'conn-123',
+ integrationId: 'github',
+ clientUniqueUserId: 'user-456',
+ status: 'enable',
+ },
+ },
+ };
+
+ await triggers.subscribe(mockCallback);
+
+ const subscribeCall = vi.mocked(mockPusherService.subscribe).mock.calls[0];
+ const filterCallback = subscribeCall[0];
+
+ // Should not throw for missing optional fields
+ expect(() => filterCallback(partialTriggerData)).not.toThrow();
+ expect(mockCallback).toHaveBeenCalledTimes(1);
+ expect(mockCallback).toHaveBeenCalledWith(
+ expect.objectContaining({
+ id: 'trigger-123',
+ metadata: expect.objectContaining({
+ triggerData: undefined,
+ }),
+ })
+ );
+ });
+
+ it('should handle multiple callbacks with different filters', async () => {
+ const callback1 = vi.fn();
+ const callback2 = vi.fn();
+
+ // Subscribe with different filters
+ await triggers.subscribe(callback1, { toolkits: ['github'] });
+ await triggers.subscribe(callback2, { toolkits: ['slack'] });
+
+ const subscribeCall1 = vi.mocked(mockPusherService.subscribe).mock.calls[0];
+ const subscribeCall2 = vi.mocked(mockPusherService.subscribe).mock.calls[1];
+
+ // Trigger github event
+ subscribeCall1[0](mockTriggerData);
+ // Trigger should only call callback1
+ expect(callback1).toHaveBeenCalledTimes(1);
+ expect(callback2).not.toHaveBeenCalled();
+
+ // Reset mocks
+ callback1.mockClear();
+ callback2.mockClear();
+
+ // Trigger slack event
+ const slackTriggerData = {
+ ...mockTriggerData,
+ appName: 'slack',
+ metadata: {
+ ...mockTriggerData.metadata,
+ triggerName: 'slack_message',
+ },
+ };
+
+ subscribeCall2[0](slackTriggerData);
+ // Trigger should only call callback2
+ expect(callback1).not.toHaveBeenCalled();
+ expect(callback2).toHaveBeenCalledTimes(1);
});
});
@@ -626,12 +673,6 @@ describe('Triggers', () => {
await triggers.unsubscribe();
expect(mockPusherService.unsubscribe).toHaveBeenCalled();
});
-
- it('should throw error if client ID is not found', async () => {
- mockSession.getInfo = vi.fn().mockResolvedValue({ project: null });
-
- await expect(triggers.unsubscribe()).rejects.toThrow('Client ID not found');
- });
});
describe('error handling', () => {
@@ -642,18 +683,15 @@ describe('Triggers', () => {
await expect(triggers.listActive()).rejects.toThrow('API request failed');
});
- it('should handle session retrieval errors', async () => {
- const sessionError = new Error('Session retrieval failed');
- mockSession.getInfo = vi.fn().mockRejectedValue(sessionError);
-
- await expect(triggers.subscribe(vi.fn())).rejects.toThrow('Session retrieval failed');
- });
-
it('should handle pusher service errors gracefully', async () => {
- const pusherError = new Error('Pusher connection failed');
+ const pusherError = new ComposioFailedToSubscribeToPusherChannelError(
+ 'Failed to subscribe to Pusher channel'
+ );
mockPusherService.subscribe.mockRejectedValue(pusherError);
- await expect(triggers.subscribe(vi.fn())).rejects.toThrow('Pusher connection failed');
+ await expect(triggers.subscribe(vi.fn())).rejects.toThrow(
+ ComposioFailedToSubscribeToPusherChannelError
+ );
});
});
@@ -662,4 +700,167 @@ describe('Triggers', () => {
expect(telemetry.instrument).toHaveBeenCalledWith(triggers);
});
});
+
+ describe('subscribe callback handling', () => {
+ const mockCallback = vi.fn();
+
+ beforeEach(() => {
+ mockCallback.mockClear();
+ vi.mocked(logger.debug).mockClear();
+ });
+
+ it('should pass the parsed trigger data to callback when filters match', async () => {
+ await triggers.subscribe(mockCallback);
+
+ const subscribeCall = vi.mocked(mockPusherService.subscribe).mock.calls[0];
+ const filterCallback = subscribeCall[0];
+
+ filterCallback(mockTriggerData);
+
+ expect(mockCallback).toHaveBeenCalledTimes(1);
+ expect(mockCallback).toHaveBeenCalledWith(
+ expect.objectContaining({
+ id: 'trigger-123',
+ clientId: '123',
+ triggerSlug: 'github_webhook',
+ toolkitSlug: 'github',
+ payload: { action: 'push', repository: 'test-repo' },
+ metadata: expect.objectContaining({
+ connectedAccountId: 'conn-123',
+ triggerName: 'github_webhook',
+ }),
+ })
+ );
+ });
+
+ it('should not call callback when trigger data does not match filters', async () => {
+ const filters: TriggerSubscribeParams = {
+ toolkits: ['slack'], // Different toolkit than the mock data
+ };
+
+ await triggers.subscribe(mockCallback, filters);
+
+ const subscribeCall = vi.mocked(mockPusherService.subscribe).mock.calls[0];
+ const filterCallback = subscribeCall[0];
+
+ filterCallback(mockTriggerData);
+
+ expect(mockCallback).not.toHaveBeenCalled();
+ });
+
+ it('should handle errors in user callback without breaking the subscription', async () => {
+ const errorCallback = vi.fn().mockImplementation(() => {
+ throw new Error('Error in user callback');
+ });
+
+ await triggers.subscribe(errorCallback);
+
+ const subscribeCall = vi.mocked(mockPusherService.subscribe).mock.calls[0];
+ const filterCallback = subscribeCall[0];
+
+ // This should not throw even though the callback throws
+ expect(() => filterCallback(mockTriggerData)).not.toThrow();
+
+ expect(errorCallback).toHaveBeenCalledTimes(1);
+ expect(logger.error).toHaveBeenCalledWith(
+ '❌ Error in trigger callback:',
+ Error('Error in user callback')
+ );
+ });
+
+ it('should handle invalid trigger data format', async () => {
+ const invalidTriggerData = {
+ appName: 'github',
+ clientId: 123,
+ payload: { action: 'push' },
+ originalPayload: { action: 'push' },
+ metadata: {
+ triggerName: 'github_webhook',
+ },
+ };
+
+ await triggers.subscribe(mockCallback);
+
+ const subscribeCall = vi.mocked(mockPusherService.subscribe).mock.calls[0];
+ const filterCallback = subscribeCall[0];
+
+ expect(() => filterCallback(invalidTriggerData)).toThrow(ValidationError);
+ expect(mockCallback).not.toHaveBeenCalled();
+ });
+
+ it('should handle partial trigger data with missing optional fields', async () => {
+ const partialTriggerData = {
+ appName: 'github',
+ clientId: 123,
+ payload: { action: 'push', repository: 'test-repo' },
+ originalPayload: { action: 'push', repository: 'test-repo' },
+ metadata: {
+ id: 'trigger-123',
+ connectionId: 'conn-123',
+ triggerName: 'github_webhook',
+ triggerConfig: { webhook_url: 'https://example.com/webhook' },
+ connection: {
+ id: 'conn-123',
+ integrationId: 'github',
+ clientUniqueUserId: 'user-456',
+ status: 'enable',
+ },
+ },
+ };
+
+ await triggers.subscribe(mockCallback);
+
+ const subscribeCall = vi.mocked(mockPusherService.subscribe).mock.calls[0];
+ const filterCallback = subscribeCall[0];
+
+ // Should not throw for missing optional fields
+ expect(() => filterCallback(partialTriggerData)).not.toThrow();
+ expect(mockCallback).toHaveBeenCalledTimes(1);
+ expect(mockCallback).toHaveBeenCalledWith(
+ expect.objectContaining({
+ id: 'trigger-123',
+ metadata: expect.objectContaining({
+ triggerData: undefined,
+ }),
+ })
+ );
+ });
+
+ it('should handle multiple callbacks with different filters', async () => {
+ const callback1 = vi.fn();
+ const callback2 = vi.fn();
+
+ // Subscribe with different filters
+ await triggers.subscribe(callback1, { toolkits: ['github'] });
+ await triggers.subscribe(callback2, { toolkits: ['slack'] });
+
+ const subscribeCall1 = vi.mocked(mockPusherService.subscribe).mock.calls[0];
+ const subscribeCall2 = vi.mocked(mockPusherService.subscribe).mock.calls[1];
+
+ // Trigger github event
+ subscribeCall1[0](mockTriggerData);
+ // Trigger should only call callback1
+ expect(callback1).toHaveBeenCalledTimes(1);
+ expect(callback2).not.toHaveBeenCalled();
+
+ // Reset mocks
+ callback1.mockClear();
+ callback2.mockClear();
+
+ // Trigger slack event
+ const slackTriggerData = {
+ ...mockTriggerData,
+ appName: 'slack',
+ metadata: {
+ ...mockTriggerData.metadata,
+ triggerName: 'slack_message',
+ },
+ };
+
+ subscribeCall2[0](slackTriggerData);
+ // Trigger should only call callback2
+ expect(callback1).not.toHaveBeenCalled();
+ expect(callback2).toHaveBeenCalledTimes(1);
+ });
+ });
});