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.

Add tests for wait for connection

haxziec407aa8dd7ef
diff --git a/packages/core/src/models/ConnectedAccounts.ts b/packages/core/src/models/ConnectedAccounts.ts
index bf0b44644..39dec20c9 100644
--- a/packages/core/src/models/ConnectedAccounts.ts
+++ b/packages/core/src/models/ConnectedAccounts.ts
@@ -13,6 +13,7 @@ import {
ConnectedAccountRefreshResponse,
ConnectedAccountUpdateStatusParams,
ConnectedAccountUpdateStatusResponse,
+ ConnectedAccountRetrieveResponse as ConnectedAccountRetrieveResponseRaw,
} from '@composio/client/resources/connected-accounts';
import {
CreateConnectedAccountOptions,
@@ -20,9 +21,7 @@ import {
ConnectedAccountRetrieveResponseSchema,
} from '../types/connectedAccounts.types';
import { ConnectionRequest } from './ConnectionRequest';
-import { ComposioConnectedAccountNotFoundError } from '../errors/ConnectedAccountsError';
import { ValidationError } from '../errors/ValidationError';
-import logger from '../utils/logger';
/**
* ConnectedAccounts class
@@ -47,6 +46,35 @@ export class ConnectedAccounts {
return this.client.connectedAccounts.list(query);
}
+ /**
+ * Transform the raw response from the API to the expected format
+ * @param {ConnectedAccountRetrieveResponseRaw} response - Raw response from the API
+ * @returns {ConnectedAccountRetrieveResponse} Transformed response
+ */
+ transformConnectedAccountResponse(
+ response: ConnectedAccountRetrieveResponseRaw
+ ): ConnectedAccountRetrieveResponse {
+ const result = ConnectedAccountRetrieveResponseSchema.safeParse({
+ ...response,
+ userId: response.user_id, // Add the missing userId property
+ authConfig: {
+ ...response.auth_config,
+ authScheme: response.auth_config.auth_scheme,
+ isComposioManaged: response.auth_config.is_composio_managed,
+ isDisabled: response.auth_config.is_disabled,
+ },
+ statusReason: response.status_reason,
+ isDisabled: response.is_disabled,
+ createdAt: response.created_at,
+ updatedAt: response.updated_at,
+ testRequestEndpoint: response.test_request_endpoint,
+ });
+ if (result.error) {
+ throw new ValidationError(result.error);
+ }
+ return result.data;
+ }
+
/**
* Compound function to create a new connected account.
* This function creates a new connected account and returns a connection request.
@@ -87,24 +115,7 @@ export class ConnectedAccounts {
connectedAccountId: string,
timeout: number = 60000
): Promise<ConnectedAccountRetrieveResponse> {
- let connectedAccount: ConnectedAccountRetrieveResponse;
- try {
- connectedAccount = await this.get(connectedAccountId);
- } catch (error) {
- logger.error(error);
- throw new ComposioConnectedAccountNotFoundError(
- `Unable to retrieve connected account with Id: ${connectedAccountId}`,
- {
- connectedAccountId,
- }
- );
- }
- const connectionRequest = new ConnectionRequest(
- this.client,
- connectedAccountId,
- connectedAccount.status
- );
-
+ const connectionRequest = new ConnectionRequest(this.client, connectedAccountId);
return connectionRequest.waitForConnection(timeout);
}
@@ -116,27 +127,7 @@ export class ConnectedAccounts {
*/
async get(nanoid: string): Promise<ConnectedAccountRetrieveResponse> {
const response = await this.client.connectedAccounts.retrieve(nanoid);
- const parsedResult = ConnectedAccountRetrieveResponseSchema.safeParse({
- ...response,
- userId: response.user_id, // Add the missing userId property
- authConfig: {
- ...response.auth_config,
- authScheme: response.auth_config.auth_scheme,
- isComposioManaged: response.auth_config.is_composio_managed,
- isDisabled: response.auth_config.is_disabled,
- },
- statusReason: response.status_reason,
- isDisabled: response.is_disabled,
- createdAt: response.created_at,
- updatedAt: response.updated_at,
- testRequestEndpoint: response.test_request_endpoint,
- });
-
- if (parsedResult.error) {
- throw new ValidationError(parsedResult.error);
- }
-
- return parsedResult.data;
+ return this.transformConnectedAccountResponse(response);
}
/**
diff --git a/packages/core/src/models/ConnectionRequest.ts b/packages/core/src/models/ConnectionRequest.ts
index 2a6abd48d..a0ec3772a 100644
--- a/packages/core/src/models/ConnectionRequest.ts
+++ b/packages/core/src/models/ConnectionRequest.ts
@@ -19,16 +19,18 @@ import {
ConnectionRequestFailedError,
ConnectionRequestTimeoutError,
} from '../errors/ConnectionRequestError';
+import { ComposioConnectedAccountNotFoundError } from '../errors/ConnectedAccountsError';
+import { log } from 'console';
export class ConnectionRequest {
private client: ComposioClient;
public id: string;
- public status: ConnectedAccountStatus;
+ public status?: ConnectedAccountStatus;
public redirectUrl?: string | null;
constructor(
client: ComposioClient,
connectedAccountId: string,
- connectedAccountStatus: ConnectedAccountStatus,
+ connectedAccountStatus?: ConnectedAccountStatus,
redirectUrl?: string | null
) {
this.client = client;
@@ -78,9 +80,22 @@ export class ConnectionRequest {
* @returns
*/
async waitForConnection(timeout: number = 60000): Promise<ConnectedAccountRetrieveResponse> {
- if (this.status === ConnectedAccountStatuses.ACTIVE) {
+ try {
const response = await this.client.connectedAccounts.retrieve(this.id);
- return this.transformResponse(response);
+ if (response.status === ConnectedAccountStatuses.ACTIVE) {
+ return this.transformResponse(response);
+ }
+ } catch (error) {
+ if (error instanceof ComposioClient.NotFoundError) {
+ throw new ComposioConnectedAccountNotFoundError(
+ `Connected account with id ${this.id} not found`,
+ {
+ connectedAccountId: this.id,
+ }
+ );
+ } else {
+ throw error;
+ }
}
const terminalErrorStates: ConnectedAccountStatus[] = [
diff --git a/packages/core/test/connectedAccounts/connectedAccounts.test.ts b/packages/core/test/connectedAccounts/connectedAccounts.test.ts
index 861ffe281..1d237426a 100644
--- a/packages/core/test/connectedAccounts/connectedAccounts.test.ts
+++ b/packages/core/test/connectedAccounts/connectedAccounts.test.ts
@@ -4,6 +4,7 @@ import { ConnectedAccounts } from '../../src/models/ConnectedAccounts';
import ComposioClient from '@composio/client';
import { ConnectionRequest } from '../../src/models/ConnectionRequest';
import { ConnectedAccountRetrieveResponse } from '@composio/client/resources/connected-accounts.mjs';
+import { ComposioConnectedAccountNotFoundError } from '../../src/errors/ConnectedAccountsError';
// Extend the mock client object for ConnectedAccounts testing
const extendedMockClient = {
@@ -287,4 +288,104 @@ describe('ConnectedAccounts', () => {
expect(result).toEqual(mockResponse);
});
});
+
+ describe('waitForConnection', () => {
+ it('should wait for a connected account to become active', async () => {
+ const nanoid = 'conn_123';
+ const authConfigId = 'auth_config_123';
+ const mockGetResponse = {
+ id: nanoid,
+ status: 'PENDING',
+ auth_scopes: ['read:user', 'write:user'],
+ auth_config: {
+ id: authConfigId,
+ auth_scheme: 'OAUTH2',
+ is_composio_managed: true,
+ is_disabled: false,
+ },
+ user_id: 'user_123',
+ data: {},
+ params: {},
+ is_disabled: false,
+ created_at: '2023-01-01T00:00:00Z',
+ updated_at: '2023-01-01T00:00:00Z',
+ status_reason: null,
+ toolkit: {
+ slug: 'test-toolkit',
+ },
+ } as unknown as ConnectedAccountRetrieveResponse;
+
+ const mockActiveResponse = {
+ ...mockGetResponse,
+ status: 'ACTIVE',
+ } as unknown as ConnectedAccountRetrieveResponse;
+
+ // Mock the get method first call
+ extendedMockClient.connectedAccounts.retrieve.mockResolvedValueOnce(mockGetResponse);
+ // Mock the subsequent call in waitForConnection
+ extendedMockClient.connectedAccounts.retrieve.mockResolvedValueOnce(mockActiveResponse);
+
+ const result = await connectedAccounts.waitForConnection(nanoid);
+
+ expect(extendedMockClient.connectedAccounts.retrieve).toHaveBeenCalledWith(nanoid);
+ expect(result).toEqual(
+ connectedAccounts.transformConnectedAccountResponse(mockActiveResponse)
+ );
+ });
+
+ it('should throw ComposioConnectedAccountNotFoundError if connected account does not exist', async () => {
+ const nanoid = 'non_existent_conn';
+
+ extendedMockClient.connectedAccounts.retrieve.mockRejectedValueOnce(
+ new ComposioClient.NotFoundError(404, undefined, undefined, {} as Headers)
+ );
+
+ try {
+ await connectedAccounts.waitForConnection(nanoid);
+ } catch (error) {
+ expect(error).toBeInstanceOf(ComposioConnectedAccountNotFoundError);
+ }
+ });
+
+ it('should use the provided timeout value', async () => {
+ const nanoid = 'conn_123';
+ const timeout = 30000;
+ const mockGetResponse = {
+ id: nanoid,
+ status: 'PENDING',
+ auth_config: {
+ id: 'auth_config_123',
+ auth_scheme: 'OAUTH2',
+ is_composio_managed: true,
+ is_disabled: false,
+ },
+ user_id: 'user_123',
+ data: {},
+ params: {},
+ is_disabled: false,
+ created_at: '2023-01-01T00:00:00Z',
+ updated_at: '2023-01-01T00:00:00Z',
+ status_reason: null,
+ auth_scopes: ['read:user'],
+ toolkit: {
+ slug: 'test-toolkit',
+ },
+ } as unknown as ConnectedAccountRetrieveResponse;
+
+ const mockActiveResponse = {
+ ...mockGetResponse,
+ status: 'ACTIVE',
+ } as unknown as ConnectedAccountRetrieveResponse;
+
+ extendedMockClient.connectedAccounts.retrieve.mockResolvedValueOnce(mockGetResponse);
+ extendedMockClient.connectedAccounts.retrieve.mockResolvedValueOnce(mockActiveResponse);
+
+ const result = await connectedAccounts.waitForConnection(nanoid, timeout);
+
+ expect(extendedMockClient.connectedAccounts.retrieve).toHaveBeenCalledWith(nanoid);
+ expect(result).toEqual(
+ connectedAccounts.transformConnectedAccountResponse(mockActiveResponse)
+ );
+ });
+ });
});