@devries-cameron20 / composio Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/composio.git

Synced Nov 21, 04:45 UTC

next
ts 848 lines 27.3 KB
Raw
1 import * as crypto from 'node:crypto';
2 import { describe, it, expect, vi, beforeEach } from 'vitest';
3 import { Triggers } from '../../src/models/Triggers';
4 import ComposioClient from '@composio/client';
5 import {
6 WebhookPayloadV1,
7 WebhookPayloadV2,
8 WebhookPayloadV3,
9 WebhookVersions,
10 VerifyWebhookParams,
11 } from '../../src/types/triggers.types';
12 import { ValidationError } from '../../src/errors';
13 import {
14 ComposioWebhookSignatureVerificationError,
15 ComposioWebhookPayloadError,
16 } from '../../src/errors/TriggerErrors';
17 import type { BaseComposioProvider } from '../../src/provider/BaseProvider';
18
19 /** Shape of the `cause` payload attached to {@link ComposioWebhookPayloadError} when no version schema matches. */
20 type WebhookVersionMismatchCause = {
21 v1Error: string;
22 v2Error: string;
23 v3Error: string;
24 };
25
26 // Mock dependencies
27 vi.mock('../../src/utils/logger');
28 vi.mock('../../src/telemetry/Telemetry', () => ({
29 telemetry: {
30 instrument: vi.fn(),
31 },
32 }));
33 vi.mock('../../src/services/pusher/Pusher');
34
35 // Create mock client
36 const createMockClient = () => ({
37 baseURL: 'https://api.composio.dev',
38 apiKey: 'test-api-key',
39 triggerInstances: {
40 listActive: vi.fn(),
41 upsert: vi.fn(),
42 manage: {
43 delete: vi.fn(),
44 update: vi.fn(),
45 },
46 },
47 triggersTypes: {
48 list: vi.fn(),
49 retrieve: vi.fn(),
50 retrieveEnum: vi.fn(),
51 },
52 connectedAccounts: {
53 list: vi.fn(),
54 },
55 });
56
57 /**
58 * Helper to create a valid webhook signature in the format used by Composio.
59 * Format: v1,base64(HMAC-SHA256(msgId.timestamp.payload, secret))
60 */
61 const createSignature = (
62 webhookId: string,
63 webhookTimestamp: string,
64 payload: string,
65 secret: string
66 ): string => {
67 const toSign = `${webhookId}.${webhookTimestamp}.${payload}`;
68 const signature = crypto.createHmac('sha256', secret).update(toSign, 'utf8').digest('base64');
69 return `v1,${signature}`;
70 };
71
72 // Mock V1 webhook payload
73 const createMockV1Payload = (overrides: Partial<WebhookPayloadV1> = {}): WebhookPayloadV1 => ({
74 trigger_name: 'GITHUB_PUSH_EVENT',
75 connection_id: 'conn-123',
76 trigger_id: 'trigger-123',
77 payload: { action: 'push', repository: 'test-repo' },
78 log_id: 'log-123',
79 ...overrides,
80 });
81
82 // Mock V2 webhook payload
83 const createMockV2Payload = (overrides: Partial<WebhookPayloadV2> = {}): WebhookPayloadV2 => ({
84 type: 'github_push_event',
85 timestamp: new Date().toISOString(),
86 log_id: 'log-123',
87 data: {
88 connection_id: 'conn-123',
89 connection_nano_id: 'conn-nano-123',
90 trigger_nano_id: 'trigger-nano-123',
91 trigger_id: 'trigger-123',
92 user_id: 'user-456',
93 action: 'push',
94 repository: 'test-repo',
95 },
96 ...overrides,
97 });
98
99 // Mock V3 webhook payload
100 const createMockV3Payload = (overrides: Partial<WebhookPayloadV3> = {}): WebhookPayloadV3 => ({
101 id: 'msg_abc123',
102 timestamp: new Date().toISOString(),
103 type: 'composio.trigger.message',
104 metadata: {
105 log_id: 'log-123',
106 trigger_slug: 'GITHUB_PUSH_EVENT',
107 trigger_id: 'trigger-nano-123',
108 connected_account_id: 'conn-nano-123',
109 auth_config_id: 'auth-nano-123',
110 user_id: 'user-456',
111 },
112 data: { action: 'push', repository: 'test-repo' },
113 ...overrides,
114 });
115
116 describe('Triggers.verifyWebhook', () => {
117 let triggers: Triggers<BaseComposioProvider<unknown, unknown, unknown>>;
118 let mockClient: ReturnType<typeof createMockClient>;
119 const testSecret = 'test-webhook-secret-12345';
120 const testWebhookId = 'msg_test123';
121 const testTimestamp = Math.floor(Date.now() / 1000).toString();
122
123 beforeEach(() => {
124 vi.clearAllMocks();
125 mockClient = createMockClient();
126 triggers = new Triggers(mockClient as unknown as ComposioClient);
127 });
128
129 describe('successful verification with V3 payload', () => {
130 it('should verify a valid V3 webhook payload and signature', async () => {
131 const v3Payload = createMockV3Payload();
132 const payloadStr = JSON.stringify(v3Payload);
133 const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret);
134
135 const result = await triggers.verifyWebhook({
136 payload: payloadStr,
137 signature,
138 secret: testSecret,
139 id: testWebhookId,
140 timestamp: testTimestamp,
141 });
142
143 expect(result).toBeDefined();
144 expect(result.version).toBe(WebhookVersions.V3);
145 expect(result.payload.triggerSlug).toBe('GITHUB_PUSH_EVENT');
146 expect(result.payload.userId).toBe('user-456');
147 expect(result.rawPayload).toEqual(v3Payload);
148 });
149
150 it('should correctly normalize V3 payload to IncomingTriggerPayload format', async () => {
151 const v3Payload = createMockV3Payload();
152 const payloadStr = JSON.stringify(v3Payload);
153 const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret);
154
155 const result = await triggers.verifyWebhook({
156 payload: payloadStr,
157 signature,
158 secret: testSecret,
159 id: testWebhookId,
160 timestamp: testTimestamp,
161 });
162
163 expect(result.payload.metadata.connectedAccount).toEqual({
164 id: 'conn-nano-123',
165 uuid: 'conn-nano-123',
166 authConfigId: 'auth-nano-123',
167 authConfigUUID: 'auth-nano-123',
168 userId: 'user-456',
169 status: 'ACTIVE',
170 });
171 });
172
173 it('should detect V3 payload with non-trigger event type (e.g., connected_account.expired)', async () => {
174 // This test uses realistic connection metadata (project_id, org_id)
175 // instead of fabricated trigger metadata, verifying that V3 detection
176 // works for events with different metadata shapes.
177 const payload = {
178 id: 'msg_abc123',
179 timestamp: new Date().toISOString(),
180 type: 'composio.connected_account.expired',
181 metadata: {
182 project_id: 'pr_koucdrMIwRsf',
183 org_id: '4a4ded8f-d3ae-4dea-a229-c30234298b05',
184 },
185 data: {
186 toolkit: { slug: 'gmail' },
187 id: 'ca__IvSeEzEBjVt',
188 user_id: 'test-user',
189 status: 'EXPIRED',
190 },
191 };
192 const payloadStr = JSON.stringify(payload);
193 const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret);
194
195 const result = await triggers.verifyWebhook({
196 payload: payloadStr,
197 signature,
198 secret: testSecret,
199 id: testWebhookId,
200 timestamp: testTimestamp,
201 });
202
203 expect(result.version).toBe(WebhookVersions.V3);
204 expect(result.rawPayload).toEqual(payload);
205 });
206 });
207
208 describe('successful verification with V2 payload', () => {
209 it('should verify a valid V2 webhook payload and signature', async () => {
210 const v2Payload = createMockV2Payload();
211 const payloadStr = JSON.stringify(v2Payload);
212 const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret);
213
214 const result = await triggers.verifyWebhook({
215 payload: payloadStr,
216 signature,
217 secret: testSecret,
218 id: testWebhookId,
219 timestamp: testTimestamp,
220 });
221
222 expect(result).toBeDefined();
223 expect(result.version).toBe(WebhookVersions.V2);
224 expect(result.payload.triggerSlug).toBe('GITHUB_PUSH_EVENT');
225 expect(result.payload.userId).toBe('user-456');
226 });
227 });
228
229 describe('successful verification with V1 payload', () => {
230 it('should verify a valid V1 webhook payload and signature', async () => {
231 const v1Payload = createMockV1Payload();
232 const payloadStr = JSON.stringify(v1Payload);
233 const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret);
234
235 const result = await triggers.verifyWebhook({
236 payload: payloadStr,
237 signature,
238 secret: testSecret,
239 id: testWebhookId,
240 timestamp: testTimestamp,
241 });
242
243 expect(result).toBeDefined();
244 expect(result.version).toBe(WebhookVersions.V1);
245 expect(result.payload.triggerSlug).toBe('GITHUB_PUSH_EVENT');
246 expect(result.payload.id).toBe('trigger-123');
247 });
248 });
249
250 describe('tolerance settings', () => {
251 it('should verify webhook with tolerance set to 0 (skip timestamp validation)', async () => {
252 const v3Payload = createMockV3Payload();
253 const payloadStr = JSON.stringify(v3Payload);
254 // Use an old timestamp
255 const oldTimestamp = Math.floor((Date.now() - 60 * 60 * 1000) / 1000).toString();
256 const signature = createSignature(testWebhookId, oldTimestamp, payloadStr, testSecret);
257
258 const result = await triggers.verifyWebhook({
259 payload: payloadStr,
260 signature,
261 secret: testSecret,
262 id: testWebhookId,
263 timestamp: oldTimestamp,
264 tolerance: 0,
265 });
266
267 expect(result).toBeDefined();
268 expect(result.version).toBe(WebhookVersions.V3);
269 });
270
271 it('should verify webhook with custom tolerance', async () => {
272 const v3Payload = createMockV3Payload();
273 const payloadStr = JSON.stringify(v3Payload);
274 const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret);
275
276 const result = await triggers.verifyWebhook({
277 payload: payloadStr,
278 signature,
279 secret: testSecret,
280 id: testWebhookId,
281 timestamp: testTimestamp,
282 tolerance: 600, // 10 minutes
283 });
284
285 expect(result).toBeDefined();
286 });
287 });
288
289 describe('signature verification errors', () => {
290 it('should throw error when payload is empty', async () => {
291 await expect(() =>
292 triggers.verifyWebhook({
293 payload: '',
294 signature: 'v1,somesignature',
295 secret: testSecret,
296 id: testWebhookId,
297 timestamp: testTimestamp,
298 })
299 ).rejects.toThrow(ComposioWebhookSignatureVerificationError);
300
301 await expect(() =>
302 triggers.verifyWebhook({
303 payload: '',
304 signature: 'v1,somesignature',
305 secret: testSecret,
306 id: testWebhookId,
307 timestamp: testTimestamp,
308 })
309 ).rejects.toThrow('No webhook payload was provided.');
310 });
311
312 it('should throw error when signature is empty', async () => {
313 const payloadStr = JSON.stringify(createMockV3Payload());
314
315 await expect(() =>
316 triggers.verifyWebhook({
317 payload: payloadStr,
318 signature: '',
319 secret: testSecret,
320 id: testWebhookId,
321 timestamp: testTimestamp,
322 })
323 ).rejects.toThrow(ComposioWebhookSignatureVerificationError);
324
325 await expect(() =>
326 triggers.verifyWebhook({
327 payload: payloadStr,
328 signature: '',
329 secret: testSecret,
330 id: testWebhookId,
331 timestamp: testTimestamp,
332 })
333 ).rejects.toThrow('No signature header value was provided.');
334 });
335
336 it('should throw error when secret is empty', async () => {
337 const payloadStr = JSON.stringify(createMockV3Payload());
338
339 await expect(() =>
340 triggers.verifyWebhook({
341 payload: payloadStr,
342 signature: 'v1,somesignature',
343 secret: '',
344 id: testWebhookId,
345 timestamp: testTimestamp,
346 })
347 ).rejects.toThrow(ComposioWebhookSignatureVerificationError);
348
349 await expect(() =>
350 triggers.verifyWebhook({
351 payload: payloadStr,
352 signature: 'v1,somesignature',
353 secret: '',
354 id: testWebhookId,
355 timestamp: testTimestamp,
356 })
357 ).rejects.toThrow('No webhook secret was provided.');
358 });
359
360 it('should throw error when webhookId is empty', async () => {
361 const payloadStr = JSON.stringify(createMockV3Payload());
362
363 await expect(() =>
364 triggers.verifyWebhook({
365 payload: payloadStr,
366 signature: 'v1,somesignature',
367 secret: testSecret,
368 id: '',
369 timestamp: testTimestamp,
370 })
371 ).rejects.toThrow(ComposioWebhookSignatureVerificationError);
372
373 await expect(() =>
374 triggers.verifyWebhook({
375 payload: payloadStr,
376 signature: 'v1,somesignature',
377 secret: testSecret,
378 id: '',
379 timestamp: testTimestamp,
380 })
381 ).rejects.toThrow('No webhook ID was provided.');
382 });
383
384 it('should throw error when webhookTimestamp is empty', async () => {
385 const payloadStr = JSON.stringify(createMockV3Payload());
386
387 // Empty timestamp is treated as invalid timestamp format (parseInt('') = NaN)
388 await expect(() =>
389 triggers.verifyWebhook({
390 payload: payloadStr,
391 signature: 'v1,somesignature',
392 secret: testSecret,
393 id: testWebhookId,
394 timestamp: '',
395 })
396 ).rejects.toThrow(ComposioWebhookPayloadError);
397
398 await expect(() =>
399 triggers.verifyWebhook({
400 payload: payloadStr,
401 signature: 'v1,somesignature',
402 secret: testSecret,
403 id: testWebhookId,
404 timestamp: '',
405 })
406 ).rejects.toThrow('Invalid webhook timestamp');
407 });
408
409 it('should throw error when signature format is invalid (no v1 prefix)', async () => {
410 const payloadStr = JSON.stringify(createMockV3Payload());
411
412 await expect(() =>
413 triggers.verifyWebhook({
414 payload: payloadStr,
415 signature: 'invalid-signature-no-prefix',
416 secret: testSecret,
417 id: testWebhookId,
418 timestamp: testTimestamp,
419 })
420 ).rejects.toThrow(ComposioWebhookSignatureVerificationError);
421
422 await expect(() =>
423 triggers.verifyWebhook({
424 payload: payloadStr,
425 signature: 'invalid-signature-no-prefix',
426 secret: testSecret,
427 id: testWebhookId,
428 timestamp: testTimestamp,
429 })
430 ).rejects.toThrow('No valid v1 signature found');
431 });
432
433 it('should throw error when signature is invalid', async () => {
434 const payloadStr = JSON.stringify(createMockV3Payload());
435
436 await expect(() =>
437 triggers.verifyWebhook({
438 payload: payloadStr,
439 signature: 'v1,invalidbase64signature==',
440 secret: testSecret,
441 id: testWebhookId,
442 timestamp: testTimestamp,
443 })
444 ).rejects.toThrow(ComposioWebhookSignatureVerificationError);
445
446 await expect(() =>
447 triggers.verifyWebhook({
448 payload: payloadStr,
449 signature: 'v1,invalidbase64signature==',
450 secret: testSecret,
451 id: testWebhookId,
452 timestamp: testTimestamp,
453 })
454 ).rejects.toThrow('The signature provided is invalid.');
455 });
456
457 it('should throw error when signature was created with different secret', async () => {
458 const payloadStr = JSON.stringify(createMockV3Payload());
459 const signatureWithDifferentSecret = createSignature(
460 testWebhookId,
461 testTimestamp,
462 payloadStr,
463 'different-secret'
464 );
465
466 await expect(() =>
467 triggers.verifyWebhook({
468 payload: payloadStr,
469 signature: signatureWithDifferentSecret,
470 secret: testSecret,
471 id: testWebhookId,
472 timestamp: testTimestamp,
473 })
474 ).rejects.toThrow(ComposioWebhookSignatureVerificationError);
475 });
476
477 it('should throw error when payload was modified after signing', async () => {
478 const originalPayload = createMockV3Payload();
479 const payloadStr = JSON.stringify(originalPayload);
480 const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret);
481
482 const modifiedPayload = JSON.stringify({
483 ...originalPayload,
484 data: { modified: true },
485 });
486
487 await expect(() =>
488 triggers.verifyWebhook({
489 payload: modifiedPayload,
490 signature,
491 secret: testSecret,
492 id: testWebhookId,
493 timestamp: testTimestamp,
494 })
495 ).rejects.toThrow(ComposioWebhookSignatureVerificationError);
496 });
497 });
498
499 describe('payload parsing errors', () => {
500 it('should throw error when payload is not valid JSON', async () => {
501 const invalidJson = 'not-valid-json{';
502 const signature = createSignature(testWebhookId, testTimestamp, invalidJson, testSecret);
503
504 await expect(() =>
505 triggers.verifyWebhook({
506 payload: invalidJson,
507 signature,
508 secret: testSecret,
509 id: testWebhookId,
510 timestamp: testTimestamp,
511 })
512 ).rejects.toThrow(ComposioWebhookPayloadError);
513
514 await expect(() =>
515 triggers.verifyWebhook({
516 payload: invalidJson,
517 signature,
518 secret: testSecret,
519 id: testWebhookId,
520 timestamp: testTimestamp,
521 })
522 ).rejects.toThrow('Failed to parse webhook payload as JSON');
523 });
524
525 it('should throw error for unrecognized payload format', async () => {
526 const unknownPayload = JSON.stringify({ unknown: 'format' });
527 const signature = createSignature(testWebhookId, testTimestamp, unknownPayload, testSecret);
528
529 await expect(() =>
530 triggers.verifyWebhook({
531 payload: unknownPayload,
532 signature,
533 secret: testSecret,
534 id: testWebhookId,
535 timestamp: testTimestamp,
536 })
537 ).rejects.toThrow(ComposioWebhookPayloadError);
538
539 await expect(() =>
540 triggers.verifyWebhook({
541 payload: unknownPayload,
542 signature,
543 secret: testSecret,
544 id: testWebhookId,
545 timestamp: testTimestamp,
546 })
547 ).rejects.toThrow('does not match any known version');
548 });
549
550 it('should include detailed schema errors when payload does not match any version', async () => {
551 const invalidPayload = JSON.stringify({ invalid: 'data' });
552 const signature = createSignature(testWebhookId, testTimestamp, invalidPayload, testSecret);
553
554 try {
555 await triggers.verifyWebhook({
556 payload: invalidPayload,
557 signature,
558 secret: testSecret,
559 id: testWebhookId,
560 timestamp: testTimestamp,
561 });
562 expect.fail('Should have thrown');
563 } catch (error) {
564 expect(error).toBeInstanceOf(ComposioWebhookPayloadError);
565 const webhookError = error as ComposioWebhookPayloadError;
566 expect(webhookError.cause).toBeDefined();
567 // The cause should contain v1Error, v2Error, and v3Error with schema validation messages
568 const cause = webhookError.cause as unknown as WebhookVersionMismatchCause;
569 expect(cause.v1Error).toBeDefined();
570 expect(cause.v2Error).toBeDefined();
571 expect(cause.v3Error).toBeDefined();
572 }
573 });
574 });
575
576 describe('timestamp validation', () => {
577 it('should pass when webhook timestamp is within tolerance', async () => {
578 const v3Payload = createMockV3Payload();
579 const payloadStr = JSON.stringify(v3Payload);
580 const recentTimestamp = Math.floor(Date.now() / 1000).toString();
581 const signature = createSignature(testWebhookId, recentTimestamp, payloadStr, testSecret);
582
583 const result = await triggers.verifyWebhook({
584 payload: payloadStr,
585 signature,
586 secret: testSecret,
587 id: testWebhookId,
588 timestamp: recentTimestamp,
589 tolerance: 300,
590 });
591
592 expect(result).toBeDefined();
593 });
594
595 it('should throw error when webhook timestamp is outside tolerance', async () => {
596 const v3Payload = createMockV3Payload();
597 const payloadStr = JSON.stringify(v3Payload);
598 // 10 minutes ago
599 const oldTimestamp = Math.floor((Date.now() - 10 * 60 * 1000) / 1000).toString();
600 const signature = createSignature(testWebhookId, oldTimestamp, payloadStr, testSecret);
601
602 await expect(() =>
603 triggers.verifyWebhook({
604 payload: payloadStr,
605 signature,
606 secret: testSecret,
607 id: testWebhookId,
608 timestamp: oldTimestamp,
609 tolerance: 300, // 5 minutes
610 })
611 ).rejects.toThrow(ComposioWebhookSignatureVerificationError);
612
613 await expect(() =>
614 triggers.verifyWebhook({
615 payload: payloadStr,
616 signature,
617 secret: testSecret,
618 id: testWebhookId,
619 timestamp: oldTimestamp,
620 tolerance: 300,
621 })
622 ).rejects.toThrow('The webhook timestamp is outside the allowed tolerance');
623 });
624
625 it('should throw error for invalid timestamp format', async () => {
626 const v3Payload = createMockV3Payload();
627 const payloadStr = JSON.stringify(v3Payload);
628 const invalidTimestamp = 'not-a-timestamp';
629 const signature = createSignature(testWebhookId, invalidTimestamp, payloadStr, testSecret);
630
631 await expect(() =>
632 triggers.verifyWebhook({
633 payload: payloadStr,
634 signature,
635 secret: testSecret,
636 id: testWebhookId,
637 timestamp: invalidTimestamp,
638 tolerance: 300,
639 })
640 ).rejects.toThrow(ComposioWebhookPayloadError);
641
642 await expect(() =>
643 triggers.verifyWebhook({
644 payload: payloadStr,
645 signature,
646 secret: testSecret,
647 id: testWebhookId,
648 timestamp: invalidTimestamp,
649 tolerance: 300,
650 })
651 ).rejects.toThrow('Invalid webhook timestamp');
652 });
653 });
654
655 describe('input validation', () => {
656 it('should throw ValidationError for missing payload parameter', async () => {
657 await expect(() =>
658 triggers.verifyWebhook({
659 signature: 'v1,sig',
660 secret: testSecret,
661 webhookId: testWebhookId,
662 webhookTimestamp: testTimestamp,
663 } as unknown as VerifyWebhookParams)
664 ).rejects.toThrow(ValidationError);
665 });
666
667 it('should throw ValidationError for missing signature parameter', async () => {
668 await expect(() =>
669 triggers.verifyWebhook({
670 payload: '{}',
671 secret: testSecret,
672 webhookId: testWebhookId,
673 webhookTimestamp: testTimestamp,
674 } as unknown as VerifyWebhookParams)
675 ).rejects.toThrow(ValidationError);
676 });
677
678 it('should throw ValidationError for missing secret parameter', async () => {
679 await expect(() =>
680 triggers.verifyWebhook({
681 payload: '{}',
682 signature: 'v1,sig',
683 webhookId: testWebhookId,
684 webhookTimestamp: testTimestamp,
685 } as unknown as VerifyWebhookParams)
686 ).rejects.toThrow(ValidationError);
687 });
688
689 it('should throw ValidationError for missing webhookId parameter', async () => {
690 await expect(() =>
691 triggers.verifyWebhook({
692 payload: '{}',
693 signature: 'v1,sig',
694 secret: testSecret,
695 webhookTimestamp: testTimestamp,
696 } as unknown as VerifyWebhookParams)
697 ).rejects.toThrow(ValidationError);
698 });
699
700 it('should throw ValidationError for missing webhookTimestamp parameter', async () => {
701 await expect(() =>
702 triggers.verifyWebhook({
703 payload: '{}',
704 signature: 'v1,sig',
705 secret: testSecret,
706 webhookId: testWebhookId,
707 } as unknown as VerifyWebhookParams)
708 ).rejects.toThrow(ValidationError);
709 });
710
711 it('should throw ValidationError for invalid tolerance type', async () => {
712 await expect(() =>
713 triggers.verifyWebhook({
714 payload: '{}',
715 signature: 'v1,sig',
716 secret: testSecret,
717 id: testWebhookId,
718 timestamp: testTimestamp,
719 tolerance: 'invalid' as unknown as number,
720 })
721 ).rejects.toThrow(ValidationError);
722 });
723 });
724
725 describe('security considerations', () => {
726 it('should use timing-safe comparison for signatures', async () => {
727 const v3Payload = createMockV3Payload();
728 const payloadStr = JSON.stringify(v3Payload);
729 const validSignature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret);
730
731 // Valid signature should work
732 await expect(
733 triggers.verifyWebhook({
734 payload: payloadStr,
735 signature: validSignature,
736 secret: testSecret,
737 id: testWebhookId,
738 timestamp: testTimestamp,
739 })
740 ).resolves.toBeDefined();
741
742 // Invalid signature with same format should fail
743 const invalidSignature = 'v1,' + 'a'.repeat(44); // base64 SHA256 is 44 chars
744 await expect(() =>
745 triggers.verifyWebhook({
746 payload: payloadStr,
747 signature: invalidSignature,
748 secret: testSecret,
749 id: testWebhookId,
750 timestamp: testTimestamp,
751 })
752 ).rejects.toThrow(ComposioWebhookSignatureVerificationError);
753 });
754
755 it('should handle unicode in payload correctly', async () => {
756 const v3Payload = createMockV3Payload({ data: { message: '你好世界 🌍 مرحبا' } });
757 const payloadStr = JSON.stringify(v3Payload);
758 const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret);
759
760 const result = await triggers.verifyWebhook({
761 payload: payloadStr,
762 signature,
763 secret: testSecret,
764 id: testWebhookId,
765 timestamp: testTimestamp,
766 });
767
768 expect(result).toBeDefined();
769 expect(result.payload.payload).toEqual({ message: '你好世界 🌍 مرحبا' });
770 });
771
772 it('should handle special characters in secret', async () => {
773 const specialSecret = 'secret!@#$%^&*()_+-=[]{}|;:,.<>?';
774 const v3Payload = createMockV3Payload();
775 const payloadStr = JSON.stringify(v3Payload);
776 const signature = createSignature(testWebhookId, testTimestamp, payloadStr, specialSecret);
777
778 const result = await triggers.verifyWebhook({
779 payload: payloadStr,
780 signature,
781 secret: specialSecret,
782 id: testWebhookId,
783 timestamp: testTimestamp,
784 });
785
786 expect(result).toBeDefined();
787 });
788
789 it('should support multiple signatures in header', async () => {
790 const v3Payload = createMockV3Payload();
791 const payloadStr = JSON.stringify(v3Payload);
792 const validSignature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret);
793 // Multiple signatures space-separated
794 const multipleSignatures = `v1,invalidsig== ${validSignature}`;
795
796 const result = await triggers.verifyWebhook({
797 payload: payloadStr,
798 signature: multipleSignatures,
799 secret: testSecret,
800 id: testWebhookId,
801 timestamp: testTimestamp,
802 });
803
804 expect(result).toBeDefined();
805 });
806 });
807
808 describe('error properties', () => {
809 it('should include proper error class for signature verification error', async () => {
810 const payloadStr = JSON.stringify(createMockV3Payload());
811
812 try {
813 await triggers.verifyWebhook({
814 payload: payloadStr,
815 signature: 'v1,invalid',
816 secret: testSecret,
817 id: testWebhookId,
818 timestamp: testTimestamp,
819 });
820 expect.fail('Should have thrown');
821 } catch (error) {
822 expect(error).toBeInstanceOf(ComposioWebhookSignatureVerificationError);
823 expect((error as ComposioWebhookSignatureVerificationError).name).toBe(
824 'ComposioWebhookSignatureVerificationError'
825 );
826 }
827 });
828
829 it('should include proper error class for payload error', async () => {
830 const invalidPayload = 'not-json';
831 const signature = createSignature(testWebhookId, testTimestamp, invalidPayload, testSecret);
832
833 try {
834 await triggers.verifyWebhook({
835 payload: invalidPayload,
836 signature,
837 secret: testSecret,
838 id: testWebhookId,
839 timestamp: testTimestamp,
840 });
841 expect.fail('Should have thrown');
842 } catch (error) {
843 expect(error).toBeInstanceOf(ComposioWebhookPayloadError);
844 expect((error as ComposioWebhookPayloadError).name).toBe('ComposioWebhookPayloadError');
845 }
846 });
847 });
848 });