add tests

Author: adamjmcgrath

__tests__/Auth0Client/connectAccountWithRedirect.test.ts

@@ -0,0 +1,108 @@
+import { Auth0Client, RedirectConnectAccountOptions } from '../../src';
+
+(<any>global).crypto = {
+  subtle: {
+    digest: () => ''
+  },
+  getRandomValues: () => ''
+};
+
+describe('Auth0Client', () => {
+  let client: Auth0Client;
+  let mockMyAccountApi: any;
+  let mockConnectAccountTransactionManager: any;
+  const oldLocation = window.location;
+
+  beforeEach(() => {
+    delete window.location;
+    window.location = {
+      ...oldLocation,
+      assign: jest.fn()
+    } as Location;
+    mockMyAccountApi = {
+      connectAccount: jest.fn().mockResolvedValue({
+        connect_uri: 'https://connect.example.com',
+        connect_params: { ticket: 'test-ticket' },
+        auth_session: 'test-session'
+      })
+    };
+    mockConnectAccountTransactionManager = {
+      create: jest.fn()
+    };
+    client = new Auth0Client({
+      domain: 'test',
+      clientId: 'abc',
+      authorizationParams: {}
+    } as any);
+    // @ts-ignore
+    client.myAccountApi = mockMyAccountApi;
+    // @ts-ignore
+    client.connectAccountTransactionManager =
+      mockConnectAccountTransactionManager;
+  });
+
+  afterEach(() => {
+    window.location = oldLocation;
+  });
+
+  describe('connectAccountWithRedirect', () => {
+    it('should call myAccountApi.connectAccount with correct params', async () => {
+      const options: RedirectConnectAccountOptions<any> = {
+        connection: 'google-oauth2',
+        authorization_params: { scope: 'profile email' }
+      };
+
+      await client.connectAccountWithRedirect(options);
+
+      expect(mockMyAccountApi.connectAccount).toHaveBeenCalledWith(
+        expect.objectContaining({
+          connection: 'google-oauth2',
+          authorization_params: { scope: 'profile email' }
+        })
+      );
+    });
+
+    it('should create a transaction with correct state and code_verifier', async () => {
+      const options: RedirectConnectAccountOptions<any> = {
+        connection: 'github'
+      };
+
+      await client.connectAccountWithRedirect(options);
+
+      expect(mockConnectAccountTransactionManager.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          state: expect.any(String),
+          code_verifier: expect.any(String),
+          auth_session: 'test-session',
+          redirect_uri: expect.any(String)
+        })
+      );
+    });
+
+    it('should use openUrl if provided', async () => {
+      const openUrl = jest.fn();
+      const options: RedirectConnectAccountOptions<any> = {
+        connection: 'github',
+        openUrl
+      };
+
+      await client.connectAccountWithRedirect(options);
+
+      expect(openUrl).toHaveBeenCalledWith(
+        'https://connect.example.com/?ticket=test-ticket'
+      );
+    });
+
+    it('should fallback to window.location.assign if openUrl is not provided', async () => {
+      const options: RedirectConnectAccountOptions<any> = {
+        connection: 'github'
+      };
+
+      await client.connectAccountWithRedirect(options);
+
+      expect(window.location.assign).toHaveBeenCalledWith(
+        expect.objectContaining({ href: 'https://connect.example.com/?ticket=test-ticket' })
+      );
+    });
+  });
+});

__tests__/Auth0Client/handleRedirectCallback.test.ts

@@ -30,7 +30,8 @@ import {
 } from '../constants';
 
 import { DEFAULT_AUTH0_CLIENT } from '../../src/constants';
-import { GenericError } from '../../src';
+import { Auth0Client, GenericError } from '../../src';
+import { CompleteResponse } from '../../src/MyAccountApiClient';
 
 jest.mock('es-cookie');
 jest.mock('../../src/jwt');
@@ -522,4 +523,94 @@ describe('Auth0Client', () => {
       );
     });
   });
+
+  describe('handleRedirectCallback with connect_code', () => {
+    let client: Auth0Client;
+    let myAccountApi: any;
+    let url: URL;
+    let completeResponse: CompleteResponse;
+    let transaction: any;
+
+    beforeEach(() => {
+      url = new URL('https://example.com/callback');
+      client = new Auth0Client({ domain: 'test', clientId: 'abc', authorizationParams: {} });
+      transaction = {
+        state: 'state123',
+        code_verifier: 'verifier',
+        auth_session: 'session',
+        redirect_uri: 'uri',
+        appState: { foo: 'bar' }
+      };
+      completeResponse = {
+        id: 'account_123',
+        connection: 'google-oauth2',
+        access_type: 'offline',
+        scopes: ['email', 'profile'],
+        created_at: '2024-06-01T12:00:00Z',
+        expires_at: '2025-06-01T12:00:00Z'
+      };
+      myAccountApi = {
+        completeAccount: jest.fn().mockResolvedValue(completeResponse)
+      };
+      (client as any).myAccountApi = myAccountApi;
+      (client as any).connectAccountTransactionManager = {
+        get: jest.fn(),
+        remove: jest.fn()
+      };
+    });
+
+    it('returns appState and data on success', async () => {
+      (client as any).connectAccountTransactionManager.get.mockReturnValue(transaction);
+
+      url.searchParams.set('state', 'state123');
+      url.searchParams.set('connect_code', 'code');
+
+      const result = await client.handleRedirectCallback(url.toString());
+
+      expect(myAccountApi.completeAccount).toHaveBeenCalledWith({
+        auth_session: 'session',
+        connect_code: 'code',
+        redirect_uri: 'uri',
+        code_verifier: 'verifier'
+      });
+      expect(result).toEqual({ appState: { foo: 'bar' }, ...completeResponse });
+      expect((client as any).connectAccountTransactionManager.remove).toHaveBeenCalled();
+    });
+
+    it('throws GenericError if transaction is missing', async () => {
+      (client as any).connectAccountTransactionManager.get.mockReturnValue(undefined);
+      url.searchParams.set('state', 'state123');
+      url.searchParams.set('connect_code', 'code');
+      await expect(client.handleRedirectCallback(url.toString())).rejects.toThrow(GenericError);
+    });
+
+    it('throws GenericError if error is present', async () => {
+      (client as any).connectAccountTransactionManager.get.mockReturnValue(transaction);
+
+      url.searchParams.set('error', 'err');
+      url.searchParams.set('error_description', 'desc');
+      url.searchParams.set('state', 'state123');
+      await expect(client.handleRedirectCallback(url.toString())).rejects.toThrow(GenericError);
+      expect((client as any).connectAccountTransactionManager.remove).toHaveBeenCalled();
+    });
+
+    it('throws GenericError on state mismatch', async () => {
+      (client as any).connectAccountTransactionManager.get.mockReturnValue(transaction);
+
+      url.searchParams.set('state', 'wrong-state');
+      url.searchParams.set('connect_code', 'code');
+      await expect(client.handleRedirectCallback(url.toString())).rejects.toThrow(GenericError);
+    });
+
+    it('throws MyAccountApiError if completeAccount fails', async () => {
+      (client as any).connectAccountTransactionManager.get.mockReturnValue(transaction);
+      const apiError = new Error('API error');
+      myAccountApi.completeAccount.mockRejectedValue(apiError);
+
+      url.searchParams.set('state', 'state123');
+      url.searchParams.set('connect_code', 'code');
+      await expect(client.handleRedirectCallback(url.toString())).rejects.toThrow('API error');
+      expect((client as any).connectAccountTransactionManager.remove).toHaveBeenCalled();
+    });
+  });
 });