@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 540 lines 18.5 KB
Raw
1 import { describe, it, expect, vi, beforeEach } from 'vitest';
2 import { createConnectionRequest } from '../../src/models/ConnectionRequest';
3 import { ConnectionRequest } from '../../src/types/connectionRequest.types';
4 import ComposioClient, {
5 APIError,
6 Auth,
7 ComposioError,
8 createFetchTransport,
9 RateLimitError,
10 } from '@composio/client';
11 import {
12 ComposioConnectedAccountNotFoundError,
13 ConnectionRequestFailedError,
14 ConnectionRequestTimeoutError,
15 } from '../../src/errors';
16 import { ConnectedAccountStatuses } from '../../src/types/connectedAccounts.types';
17 import { AuthSchemeTypes } from '../../src/types/authConfigs.types';
18
19 // Mock ComposioClient
20 const mockClient = {
21 connectedAccounts: {
22 retrieve: vi.fn(),
23 },
24 };
25
26 describe('ConnectionRequest', () => {
27 let connectionRequest: ConnectionRequest;
28 const connectedAccountId = 'conn_123';
29 const redirectUrl = 'https://example.com/callback';
30
31 beforeEach(() => {
32 vi.resetAllMocks();
33 // Reset timers before each test
34 vi.useRealTimers();
35 });
36
37 describe('createConnectionRequest', () => {
38 it('should create an instance with an INITIATED status', () => {
39 connectionRequest = createConnectionRequest(
40 mockClient as unknown as ComposioClient,
41 connectedAccountId,
42 ConnectedAccountStatuses.INITIATED,
43 redirectUrl
44 );
45
46 expect(connectionRequest).toHaveProperty('id', connectedAccountId);
47 expect(connectionRequest).toHaveProperty('status', ConnectedAccountStatuses.INITIATED);
48 expect(connectionRequest).toHaveProperty('redirectUrl', redirectUrl);
49 });
50
51 it('should create an instance without a callbackUrl', () => {
52 connectionRequest = createConnectionRequest(
53 mockClient as unknown as ComposioClient,
54 connectedAccountId
55 );
56
57 expect(connectionRequest).toHaveProperty('redirectUrl', undefined);
58 });
59
60 it('should keep its fields assignable and reflected in toJSON()', () => {
61 connectionRequest = createConnectionRequest(
62 mockClient as unknown as ComposioClient,
63 connectedAccountId
64 );
65
66 connectionRequest.redirectUrl = redirectUrl;
67
68 expect(connectionRequest.toJSON()).toEqual({
69 id: connectedAccountId,
70 status: ConnectedAccountStatuses.INITIATED,
71 redirectUrl,
72 });
73 });
74 });
75
76 describe('waitForConnection', () => {
77 it('should immediately resolve if status is already ACTIVE', async () => {
78 // Create the connection request with ACTIVE status
79 connectionRequest = createConnectionRequest(
80 mockClient as unknown as ComposioClient,
81 connectedAccountId,
82 ConnectedAccountStatuses.ACTIVE,
83 redirectUrl
84 );
85
86 // Mock the retrieve response
87 const mockResponse = {
88 id: connectedAccountId,
89 status: ConnectedAccountStatuses.ACTIVE,
90 auth_config: {
91 id: 'auth_config_123',
92 is_composio_managed: true,
93 is_disabled: false,
94 },
95 state: {
96 authScheme: AuthSchemeTypes.OAUTH2,
97 val: {
98 status: 'ACTIVE',
99 access_token: 'access_token_123',
100 token_type: 'Bearer',
101 },
102 },
103 user_id: 'user_123',
104 data: {},
105 params: {},
106 is_disabled: false,
107 created_at: '2023-01-01T00:00:00Z',
108 updated_at: '2023-01-01T00:00:00Z',
109 status_reason: null,
110 toolkit: {
111 slug: 'test-toolkit',
112 },
113 };
114
115 mockClient.connectedAccounts.retrieve.mockResolvedValueOnce(mockResponse);
116
117 const result = await connectionRequest.waitForConnection();
118
119 expect(mockClient.connectedAccounts.retrieve).toHaveBeenCalledWith(connectedAccountId);
120 expect(mockClient.connectedAccounts.retrieve).toHaveBeenCalledTimes(1);
121 expect(result).toHaveProperty('id', connectedAccountId);
122 expect(result).toHaveProperty('status', ConnectedAccountStatuses.ACTIVE);
123 expect(result).toHaveProperty('state.authScheme', 'OAUTH2');
124 });
125
126 it('should report ACTIVE on the request once waitForConnection resolves', async () => {
127 connectionRequest = createConnectionRequest(
128 mockClient as unknown as ComposioClient,
129 connectedAccountId,
130 ConnectedAccountStatuses.INITIATED,
131 redirectUrl
132 );
133 mockClient.connectedAccounts.retrieve.mockResolvedValueOnce({
134 id: connectedAccountId,
135 status: ConnectedAccountStatuses.ACTIVE,
136 auth_config: {
137 id: 'auth_config_123',
138 auth_scheme: 'OAUTH2',
139 is_composio_managed: true,
140 is_disabled: false,
141 },
142 user_id: 'user_123',
143 data: {},
144 params: {},
145 is_disabled: false,
146 created_at: '2023-01-01T00:00:00Z',
147 updated_at: '2023-01-01T00:00:00Z',
148 status_reason: null,
149 toolkit: {
150 slug: 'test-toolkit',
151 },
152 });
153
154 await connectionRequest.waitForConnection();
155
156 expect(connectionRequest.status).toBe(ConnectedAccountStatuses.ACTIVE);
157 expect(connectionRequest.toJSON().status).toBe(ConnectedAccountStatuses.ACTIVE);
158 expect(JSON.parse(connectionRequest.toString()).status).toBe(ConnectedAccountStatuses.ACTIVE);
159 });
160
161 it('should poll until status becomes ACTIVE', async () => {
162 // Use fake timers to control timing
163 vi.useFakeTimers();
164
165 // Create the connection request with INITIATED status
166 connectionRequest = createConnectionRequest(
167 mockClient as unknown as ComposioClient,
168 connectedAccountId,
169 ConnectedAccountStatuses.INITIATED,
170 redirectUrl
171 );
172
173 // Mock initial "initiated" response
174 const pendingResponse = {
175 id: connectedAccountId,
176 status: ConnectedAccountStatuses.INITIATED,
177 auth_config: {
178 id: 'auth_config_123',
179 auth_scheme: 'OAUTH2',
180 is_composio_managed: true,
181 is_disabled: false,
182 },
183 user_id: 'user_123',
184 data: {},
185 params: {},
186 is_disabled: false,
187 created_at: '2023-01-01T00:00:00Z',
188 updated_at: '2023-01-01T00:00:00Z',
189 status_reason: null,
190 toolkit: {
191 slug: 'test-toolkit',
192 },
193 };
194
195 // Mock "active" response for the second call
196 const activeResponse = {
197 ...pendingResponse,
198 status: ConnectedAccountStatuses.ACTIVE,
199 };
200
201 mockClient.connectedAccounts.retrieve
202 .mockResolvedValueOnce(pendingResponse)
203 .mockResolvedValueOnce(activeResponse);
204
205 // Start the waitForConnection call but don't await it yet
206 const connectionPromise = connectionRequest.waitForConnection();
207
208 // Advance timer by 1 second (first poll)
209 await vi.advanceTimersByTimeAsync(1000);
210
211 // Advance timer by 1 more second (second poll)
212 await vi.advanceTimersByTimeAsync(1000);
213
214 // Resolve the promise
215 const result = await connectionPromise;
216
217 expect(mockClient.connectedAccounts.retrieve).toHaveBeenCalledWith(connectedAccountId);
218 expect(mockClient.connectedAccounts.retrieve).toHaveBeenCalledTimes(2);
219 expect(result).toHaveProperty('id', connectedAccountId);
220 expect(result).toHaveProperty('status', ConnectedAccountStatuses.ACTIVE);
221 expect(connectionRequest.status).toBe(ConnectedAccountStatuses.ACTIVE);
222 });
223
224 it('should throw ConnectionRequestTimeoutError if the request times out', async () => {
225 // Create connection request with INITIATED status
226 connectionRequest = createConnectionRequest(
227 mockClient as unknown as ComposioClient,
228 connectedAccountId,
229 ConnectedAccountStatuses.INITIATED,
230 redirectUrl
231 );
232
233 // Mock initiated response that never changes to active
234 const initiatedResponse = {
235 id: connectedAccountId,
236 status: ConnectedAccountStatuses.INITIATED,
237 auth_config: {
238 id: 'auth_config_123',
239 auth_scheme: 'OAUTH2',
240 is_composio_managed: true,
241 is_disabled: false,
242 },
243 user_id: 'user_123',
244 data: {},
245 params: {},
246 is_disabled: false,
247 created_at: '2023-01-01T00:00:00Z',
248 updated_at: '2023-01-01T00:00:00Z',
249 status_reason: null,
250 toolkit: {
251 slug: 'test-toolkit',
252 },
253 };
254
255 mockClient.connectedAccounts.retrieve.mockResolvedValue(initiatedResponse);
256
257 // Start the waitForConnection call with a short timeout
258 try {
259 await connectionRequest.waitForConnection(3000);
260 } catch (error) {
261 expect(error).toBeInstanceOf(ConnectionRequestTimeoutError);
262 }
263 });
264
265 it('should reject if the API call fails', async () => {
266 // Use fake timers to control timing
267 vi.useFakeTimers();
268
269 // Create connection request with INITIATED status
270 connectionRequest = createConnectionRequest(
271 mockClient as unknown as ComposioClient,
272 connectedAccountId,
273 ConnectedAccountStatuses.INITIATED,
274 redirectUrl
275 );
276
277 // Mock the API call to fail
278 const apiError = new ComposioError('API error');
279 mockClient.connectedAccounts.retrieve.mockRejectedValueOnce(apiError);
280
281 // Start the waitForConnection call but don't await it yet
282 const connectionPromise = connectionRequest.waitForConnection(50000);
283
284 // Now check for the rejection
285 await expect(connectionPromise).rejects.toBe(apiError);
286 });
287
288 it('should fail when the connection is revoked while polling', async () => {
289 connectionRequest = createConnectionRequest(
290 mockClient as unknown as ComposioClient,
291 connectedAccountId,
292 ConnectedAccountStatuses.INITIATED,
293 redirectUrl
294 );
295
296 const revokedResponse = {
297 id: connectedAccountId,
298 status: ConnectedAccountStatuses.REVOKED,
299 status_reason: 'revoked by user',
300 };
301 mockClient.connectedAccounts.retrieve.mockResolvedValueOnce(revokedResponse);
302
303 await expect(connectionRequest.waitForConnection(3000)).rejects.toThrow(
304 ConnectionRequestFailedError
305 );
306 expect(connectionRequest.status).toBe(ConnectedAccountStatuses.REVOKED);
307 expect(connectionRequest.toJSON().status).toBe(ConnectedAccountStatuses.REVOKED);
308 });
309 });
310
311 describe('waitForConnection polling', () => {
312 const pending = { id: connectedAccountId, status: ConnectedAccountStatuses.INITIATED };
313 const rateLimited = (headers: Record<string, string> = {}) =>
314 new RateLimitError(429, undefined, 'slow down', new Headers(headers));
315 const start = (timeout?: number) => {
316 vi.useFakeTimers();
317 const request = createConnectionRequest(
318 mockClient as unknown as ComposioClient,
319 connectedAccountId
320 );
321 const result = request.waitForConnection(timeout).catch(error => error);
322 return result;
323 };
324
325 /** Times of each poll, in ms since the wait started, up to `until`. */
326 const pollTimes = async (until: number) => {
327 const started = Date.now();
328 const times: number[] = [];
329 mockClient.connectedAccounts.retrieve.mockImplementation(async () => {
330 times.push(Date.now() - started);
331 return pending;
332 });
333 const result = start(until);
334 await vi.advanceTimersByTimeAsync(until);
335 return { times, result };
336 };
337
338 it('backs off from 1s to a 5s cap', async () => {
339 vi.useFakeTimers();
340 const { times, result } = await pollTimes(30000);
341
342 expect(await result).toBeInstanceOf(ConnectionRequestTimeoutError);
343 expect(times.slice(0, 7)).toEqual([0, 1000, 2500, 4750, 8125, 13125, 18125]);
344 });
345
346 it('sends about 16 requests in the default 60s wait', async () => {
347 vi.useFakeTimers();
348 const { times, result } = await pollTimes(60000);
349
350 expect(await result).toBeInstanceOf(ConnectionRequestTimeoutError);
351 expect(times).toHaveLength(16);
352 });
353
354 it('polls one last time at the deadline', async () => {
355 vi.useFakeTimers();
356 const { times, result } = await pollTimes(3000);
357
358 expect(await result).toBeInstanceOf(ConnectionRequestTimeoutError);
359 expect(times).toEqual([0, 1000, 2500, 3000]);
360 });
361
362 it('waits as long as a 429 asks, then keeps polling', async () => {
363 mockClient.connectedAccounts.retrieve
364 .mockRejectedValueOnce(rateLimited({ 'retry-after': '10' }))
365 .mockResolvedValueOnce({
366 ...pending,
367 status: ConnectedAccountStatuses.ACTIVE,
368 auth_config: { id: 'a', auth_scheme: 'OAUTH2', is_composio_managed: true },
369 data: {},
370 created_at: '2023-01-01T00:00:00Z',
371 updated_at: '2023-01-01T00:00:00Z',
372 status_reason: null,
373 toolkit: { slug: 'test-toolkit' },
374 });
375
376 const result = start();
377 await vi.advanceTimersByTimeAsync(9999);
378 expect(mockClient.connectedAccounts.retrieve).toHaveBeenCalledTimes(1);
379
380 await vi.advanceTimersByTimeAsync(1);
381 expect(mockClient.connectedAccounts.retrieve).toHaveBeenCalledTimes(2);
382 expect(await result).toHaveProperty('status', ConnectedAccountStatuses.ACTIVE);
383 });
384
385 it.each(['5', '60'])(
386 'does not repoll at the deadline after Retry-After: %s',
387 async retryAfter => {
388 mockClient.connectedAccounts.retrieve.mockRejectedValue(
389 rateLimited({ 'retry-after': retryAfter })
390 );
391
392 const result = start(5000);
393 await vi.advanceTimersByTimeAsync(5000);
394
395 expect(await result).toBeInstanceOf(ConnectionRequestTimeoutError);
396 expect(mockClient.connectedAccounts.retrieve).toHaveBeenCalledTimes(1);
397 }
398 );
399
400 it('times out after one poll on a NaN timeout', async () => {
401 mockClient.connectedAccounts.retrieve.mockResolvedValue(pending);
402
403 expect(await start(NaN)).toBeInstanceOf(ConnectionRequestTimeoutError);
404 expect(mockClient.connectedAccounts.retrieve).toHaveBeenCalledTimes(1);
405 });
406
407 it('keeps polling on an infinite timeout', async () => {
408 mockClient.connectedAccounts.retrieve.mockResolvedValue(pending);
409
410 void start(Infinity);
411 await vi.advanceTimersByTimeAsync(2500);
412
413 expect(mockClient.connectedAccounts.retrieve).toHaveBeenCalledTimes(3);
414 });
415
416 it('reads a date-format Retry-After', async () => {
417 vi.useFakeTimers({ now: Date.UTC(2026, 0, 1) });
418 mockClient.connectedAccounts.retrieve
419 .mockRejectedValueOnce(rateLimited({ 'retry-after': 'Thu, 01 Jan 2026 00:00:10 GMT' }))
420 .mockRejectedValue(new APIError(500, undefined, 'stop', new Headers()));
421
422 const result = createConnectionRequest(
423 mockClient as unknown as ComposioClient,
424 connectedAccountId
425 )
426 .waitForConnection()
427 .catch(error => error);
428 await vi.advanceTimersByTimeAsync(9999);
429 expect(mockClient.connectedAccounts.retrieve).toHaveBeenCalledTimes(1);
430
431 await vi.advanceTimersByTimeAsync(1);
432 expect(mockClient.connectedAccounts.retrieve).toHaveBeenCalledTimes(2);
433 await result;
434 });
435
436 it.each([
437 { timeout: 1000, retryAfter: '3', elapsed: 6000 },
438 { timeout: 25000, retryAfter: '10', elapsed: 25000 },
439 ])(
440 'does not restart client retries after a $timeout ms timeout',
441 async ({ timeout, retryAfter, elapsed }) => {
442 vi.useFakeTimers();
443 const fetch = vi.fn<typeof globalThis.fetch>(
444 async () =>
445 new Response(JSON.stringify({ error: { message: 'slow down' } }), {
446 status: 429,
447 headers: { 'content-type': 'application/json', 'retry-after': retryAfter },
448 })
449 );
450 const client = new ComposioClient({
451 auth: Auth.project('test-api-key'),
452 baseURL: 'https://backend.invalid',
453 transport: createFetchTransport({ fetch }),
454 });
455 let settled = false;
456 const result = createConnectionRequest(client, connectedAccountId)
457 .waitForConnection(timeout)
458 .catch(error => error)
459 .finally(() => {
460 settled = true;
461 });
462
463 await vi.advanceTimersByTimeAsync(elapsed - 1);
464 expect(settled).toBe(false);
465
466 await vi.advanceTimersByTimeAsync(1);
467 expect(await result).toBeInstanceOf(ConnectionRequestTimeoutError);
468 expect(fetch).toHaveBeenCalledTimes(3);
469 }
470 );
471
472 it('keeps its usual delay when a 429 has no usable Retry-After', async () => {
473 mockClient.connectedAccounts.retrieve.mockRejectedValue(
474 rateLimited({ 'retry-after': 'soon' })
475 );
476
477 const result = start(1000);
478 await vi.advanceTimersByTimeAsync(1000);
479
480 expect(await result).toBeInstanceOf(ConnectionRequestTimeoutError);
481 expect(mockClient.connectedAccounts.retrieve).toHaveBeenCalledTimes(1);
482 });
483
484 it('still fails on other API errors', async () => {
485 const serverError = new APIError(500, undefined, 'boom', new Headers());
486 mockClient.connectedAccounts.retrieve.mockRejectedValueOnce(serverError);
487
488 expect(await start()).toBe(serverError);
489 });
490
491 it('reports a connection deleted mid-wait as not found', async () => {
492 mockClient.connectedAccounts.retrieve
493 .mockResolvedValueOnce(pending)
494 .mockRejectedValueOnce(
495 new ComposioClient.NotFoundError(404, undefined, 'gone', new Headers())
496 );
497
498 const result = start();
499 await vi.advanceTimersByTimeAsync(1000);
500
501 expect(await result).toBeInstanceOf(ComposioConnectedAccountNotFoundError);
502 });
503 });
504
505 describe('serialization methods', () => {
506 it('should return a JSON-serializable object with toJSON()', () => {
507 // Create a connection request instance
508 connectionRequest = createConnectionRequest(
509 mockClient as unknown as ComposioClient,
510 connectedAccountId,
511 ConnectedAccountStatuses.INITIATED,
512 redirectUrl
513 );
514
515 const jsonObj = connectionRequest.toJSON();
516
517 expect(jsonObj).toHaveProperty('id', connectedAccountId);
518 expect(jsonObj).toHaveProperty('status', ConnectedAccountStatuses.INITIATED);
519 expect(jsonObj).toHaveProperty('redirectUrl', redirectUrl);
520 });
521
522 it('should return a formatted JSON string with toString()', () => {
523 // Create a connection request instance
524 connectionRequest = createConnectionRequest(
525 mockClient as unknown as ComposioClient,
526 connectedAccountId,
527 ConnectedAccountStatuses.INITIATED,
528 redirectUrl
529 );
530
531 const jsonString = connectionRequest.toString();
532 expect(typeof jsonString).toBe('string');
533
534 const parsedObj = JSON.parse(jsonString);
535 expect(parsedObj).toHaveProperty('id', connectedAccountId);
536 expect(parsedObj).toHaveProperty('status', ConnectedAccountStatuses.INITIATED);
537 expect(parsedObj).toHaveProperty('redirectUrl', redirectUrl);
538 });
539 });
540 });