@rsweeten/dropbox-sync 0.1.2 → 0.1.3

package/dist/adapters/__tests__/next.spec.js

@@ -0,0 +1,179 @@
+import { useNextDropboxSync, getCredentialsFromCookies, handleOAuthCallback, createNextDropboxApiHandlers, } from '../next';
+import { createDropboxSyncClient } from '../../core/client';
+import { cookies } from 'next/headers';
+import { NextResponse } from 'next/server';
+// Mock dependencies
+jest.mock('../../core/client');
+jest.mock('next/headers');
+jest.mock('next/server');
+describe('Next.js adapter', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Mock process.env
+        process.env.DROPBOX_APP_KEY = 'test-app-key';
+        process.env.DROPBOX_APP_SECRET = 'test-app-secret';
+        process.env.NEXT_PUBLIC_APP_URL = 'https://example.com';
+    });
+    describe('useNextDropboxSync', () => {
+        it('should create a Dropbox sync client with provided credentials', () => {
+            const mockCredentials = {
+                clientId: 'custom-client-id',
+                clientSecret: 'custom-client-secret',
+            };
+            createDropboxSyncClient.mockReturnValue({
+                mock: 'client',
+            });
+            const result = useNextDropboxSync(mockCredentials);
+            expect(createDropboxSyncClient).toHaveBeenCalledWith(mockCredentials);
+            expect(result).toEqual({ mock: 'client' });
+        });
+    });
+    describe('getCredentialsFromCookies', () => {
+        it('should get credentials from cookies', async () => {
+            const mockCookieStore = {
+                get: jest.fn((name) => {
+                    if (name === 'dropbox_access_token')
+                        return { value: 'test-access-token' };
+                    if (name === 'dropbox_refresh_token')
+                        return { value: 'test-refresh-token' };
+                    return null;
+                }),
+            };
+            cookies.mockResolvedValue(mockCookieStore);
+            const credentials = await getCredentialsFromCookies();
+            expect(cookies).toHaveBeenCalled();
+            expect(credentials).toEqual({
+                clientId: 'test-app-key',
+                clientSecret: 'test-app-secret',
+                accessToken: 'test-access-token',
+                refreshToken: 'test-refresh-token',
+            });
+        });
+        it('should handle missing cookie values', async () => {
+            const mockCookieStore = {
+                get: jest.fn().mockReturnValue(null),
+            };
+            cookies.mockResolvedValue(mockCookieStore);
+            const credentials = await getCredentialsFromCookies();
+            expect(credentials).toEqual({
+                clientId: 'test-app-key',
+                clientSecret: 'test-app-secret',
+                accessToken: undefined,
+                refreshToken: undefined,
+            });
+        });
+    });
+    describe('handleOAuthCallback', () => {
+        it('should handle successful OAuth callback', async () => {
+            // Mock URL with auth code
+            const mockRequest = {
+                url: 'https://example.com/callback?code=test-auth-code',
+            };
+            global.URL = jest.fn().mockImplementation(() => {
+                return {
+                    searchParams: {
+                        get: jest.fn().mockReturnValue('test-auth-code'),
+                    },
+                };
+            });
+            // Mock Dropbox client
+            const mockClient = {
+                auth: {
+                    exchangeCodeForToken: jest.fn().mockResolvedValue({
+                        accessToken: 'new-access-token',
+                        refreshToken: 'new-refresh-token',
+                        expiresAt: Date.now() + 14400 * 1000,
+                    }),
+                },
+            };
+            createDropboxSyncClient.mockReturnValue(mockClient);
+            // Mock NextResponse
+            const mockResponseCookies = {
+                set: jest.fn(),
+            };
+            const mockResponse = {
+                cookies: mockResponseCookies,
+            };
+            NextResponse.redirect.mockReturnValue(mockResponse);
+            await handleOAuthCallback(mockRequest);
+            expect(createDropboxSyncClient).toHaveBeenCalled();
+            expect(mockClient.auth.exchangeCodeForToken).toHaveBeenCalledWith('test-auth-code', expect.any(String));
+            expect(NextResponse.redirect).toHaveBeenCalled();
+            expect(mockResponseCookies.set).toHaveBeenCalledTimes(3); // Access, refresh, and connected cookies
+        });
+        it('should redirect to error page if code is missing', async () => {
+            const mockRequest = {
+                url: 'https://example.com/callback',
+            };
+            global.URL = jest.fn().mockImplementation(() => {
+                return {
+                    searchParams: {
+                        get: jest.fn().mockReturnValue(null),
+                    },
+                };
+            });
+            // Create a proper URL string for the mock response
+            const errorUrl = 'https://example.com/auth/error';
+            NextResponse.redirect.mockReturnValue({
+                url: errorUrl,
+            });
+            const result = await handleOAuthCallback(mockRequest);
+            // Now we'll check that the redirect was called, and the result contains our URL
+            expect(NextResponse.redirect).toHaveBeenCalled();
+            expect(result.url).toBe(errorUrl);
+        });
+    });
+    describe('createNextDropboxApiHandlers', () => {
+        it('should create API handlers with necessary methods', () => {
+            const handlers = createNextDropboxApiHandlers();
+            expect(handlers).toHaveProperty('status');
+            expect(handlers).toHaveProperty('oauthStart');
+            expect(handlers).toHaveProperty('logout');
+        });
+        it('should check status from cookies', async () => {
+            const mockCookieStore = {
+                get: jest.fn().mockReturnValue({ value: 'test-token' }),
+            };
+            cookies.mockResolvedValue(mockCookieStore);
+            NextResponse.json.mockReturnValue({
+                json: 'response',
+            });
+            const handlers = createNextDropboxApiHandlers();
+            const response = await handlers.status();
+            expect(cookies).toHaveBeenCalled();
+            expect(mockCookieStore.get).toHaveBeenCalledWith('dropbox_access_token');
+            expect(NextResponse.json).toHaveBeenCalledWith({ connected: true });
+        });
+        it('should start OAuth flow', async () => {
+            const mockClient = {
+                auth: {
+                    getAuthUrl: jest
+                        .fn()
+                        .mockResolvedValue('https://dropbox.com/oauth'),
+                },
+            };
+            createDropboxSyncClient.mockReturnValue(mockClient);
+            NextResponse.redirect.mockReturnValue({
+                redirect: 'response',
+            });
+            const handlers = createNextDropboxApiHandlers();
+            const response = await handlers.oauthStart();
+            expect(createDropboxSyncClient).toHaveBeenCalled();
+            expect(mockClient.auth.getAuthUrl).toHaveBeenCalled();
+            expect(NextResponse.redirect).toHaveBeenCalledWith('https://dropbox.com/oauth');
+        });
+        it('should handle logout', async () => {
+            const mockResponseCookies = {
+                delete: jest.fn(),
+            };
+            const mockResponse = {
+                cookies: mockResponseCookies,
+            };
+            NextResponse.json.mockReturnValue(mockResponse);
+            const handlers = createNextDropboxApiHandlers();
+            const response = await handlers.logout();
+            expect(NextResponse.json).toHaveBeenCalledWith({ success: true });
+            expect(mockResponseCookies.delete).toHaveBeenCalledTimes(3); // Should delete three cookies
+        });
+    });
+});

package/dist/adapters/__tests__/nuxt.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/adapters/__tests__/nuxt.spec.js

@@ -0,0 +1,145 @@
+import { useNuxtDropboxSync, getCredentialsFromCookies, createNuxtApiHandlers, } from '../nuxt';
+import { createDropboxSyncClient } from '../../core/client';
+// Mock dependencies
+jest.mock('../../core/client');
+// Manual mocks for Nuxt modules
+jest.mock('nuxt/app', () => ({
+    useRuntimeConfig: jest.fn().mockReturnValue({
+        public: {
+            dropboxAppKey: 'test-app-key',
+            appUrl: 'https://example.com',
+        },
+        dropboxAppSecret: 'test-app-secret',
+        dropboxRedirectUri: 'https://example.com/api/dropbox/auth/callback',
+    }),
+    useCookie: jest.fn().mockImplementation((name) => {
+        if (name === 'dropbox_access_token') {
+            return { value: 'test-access-token' };
+        }
+        if (name === 'dropbox_refresh_token') {
+            return { value: 'test-refresh-token' };
+        }
+        return { value: null };
+    }),
+}));
+// Mock H3 utilities
+const mockGetCookie = jest.fn();
+const mockSetCookie = jest.fn();
+const mockDeleteCookie = jest.fn();
+const mockGetQuery = jest.fn();
+const mockSendRedirect = jest.fn();
+jest.mock('h3', () => ({
+    getCookie: mockGetCookie,
+    setCookie: mockSetCookie,
+    deleteCookie: mockDeleteCookie,
+    getQuery: mockGetQuery,
+    sendRedirect: mockSendRedirect,
+}));
+describe('Nuxt.js adapter', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Define process.client as a property for client/server detection
+        if (!('client' in process)) {
+            Object.defineProperty(process, 'client', {
+                value: false,
+                writable: true,
+                configurable: true,
+            });
+        }
+        else {
+            ;
+            process.client = false;
+        }
+    });
+    describe('useNuxtDropboxSync', () => {
+        it('should create a Dropbox sync client with config values', () => {
+            ;
+            createDropboxSyncClient.mockReturnValue({
+                mock: 'client',
+            });
+            const result = useNuxtDropboxSync();
+            expect(createDropboxSyncClient).toHaveBeenCalledWith({
+                clientId: 'test-app-key',
+                clientSecret: 'test-app-secret',
+            });
+            expect(result).toEqual({ mock: 'client' });
+        });
+        it('should add cookie values on client-side', () => {
+            // Set as client-side
+            ;
+            process.client = true;
+            createDropboxSyncClient.mockReturnValue({
+                mock: 'client',
+            });
+            const result = useNuxtDropboxSync();
+            expect(createDropboxSyncClient).toHaveBeenCalledWith(expect.objectContaining({
+                clientId: 'test-app-key',
+                clientSecret: 'test-app-secret',
+                accessToken: 'test-access-token',
+                refreshToken: 'test-refresh-token',
+            }));
+        });
+    });
+    describe('getCredentialsFromCookies', () => {
+        it('should get credentials from H3 event', () => {
+            const mockEvent = {};
+            // Set up mock implementation
+            mockGetCookie.mockImplementation((event, name) => {
+                if (name === 'dropbox_access_token')
+                    return 'h3-access-token';
+                if (name === 'dropbox_refresh_token')
+                    return 'h3-refresh-token';
+                return null;
+            });
+            const credentials = getCredentialsFromCookies(mockEvent);
+            expect(mockGetCookie).toHaveBeenCalledWith(mockEvent, 'dropbox_access_token');
+            expect(mockGetCookie).toHaveBeenCalledWith(mockEvent, 'dropbox_refresh_token');
+            expect(credentials).toEqual({
+                clientId: 'test-app-key',
+                clientSecret: 'test-app-secret',
+                accessToken: 'h3-access-token',
+                refreshToken: 'h3-refresh-token',
+            });
+        });
+    });
+    describe('createNuxtApiHandlers', () => {
+        const mockEvent = {};
+        beforeEach(() => {
+            // Reset H3 mocks for each test
+            mockGetCookie.mockReset();
+            mockSetCookie.mockReset();
+            mockDeleteCookie.mockReset();
+            mockGetQuery.mockReset();
+            mockSendRedirect.mockReset();
+        });
+        it('should create Nuxt API handlers with necessary methods', () => {
+            const handlers = createNuxtApiHandlers();
+            expect(handlers).toHaveProperty('status');
+            expect(handlers).toHaveProperty('oauthStart');
+            expect(handlers).toHaveProperty('oauthCallback');
+            expect(handlers).toHaveProperty('logout');
+        });
+        it('should check connection status', async () => {
+            mockGetCookie.mockReturnValue('h3-access-token');
+            const handlers = createNuxtApiHandlers();
+            const result = await handlers.status(mockEvent);
+            expect(mockGetCookie).toHaveBeenCalledWith(mockEvent, 'dropbox_access_token');
+            expect(result).toEqual({ connected: true });
+        });
+        it('should handle OAuth start', async () => {
+            ;
+            createDropboxSyncClient.mockReturnValue({
+                auth: {
+                    getAuthUrl: jest
+                        .fn()
+                        .mockResolvedValue('https://dropbox.com/oauth'),
+                },
+            });
+            mockSendRedirect.mockImplementation(() => ({ redirected: true }));
+            const handlers = createNuxtApiHandlers();
+            await handlers.oauthStart(mockEvent);
+            expect(createDropboxSyncClient).toHaveBeenCalled();
+            expect(mockSendRedirect).toHaveBeenCalledWith(mockEvent, 'https://dropbox.com/oauth');
+        });
+    });
+});

package/dist/adapters/__tests__/svelte.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/adapters/__tests__/svelte.spec.js

@@ -0,0 +1,149 @@
+import { useSvelteDropboxSync, getCredentialsFromCookies, createSvelteKitHandlers, } from '../svelte';
+import { createDropboxSyncClient } from '../../core/client';
+// Mock dependencies
+jest.mock('../../core/client');
+describe('SvelteKit adapter', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Mock process.env
+        process.env.DROPBOX_APP_KEY = 'test-app-key';
+        process.env.DROPBOX_APP_SECRET = 'test-app-secret';
+        process.env.PUBLIC_APP_URL = 'https://example.com';
+    });
+    describe('useSvelteDropboxSync', () => {
+        it('should create a Dropbox sync client with provided credentials', () => {
+            const mockCredentials = {
+                clientId: 'custom-client-id',
+                clientSecret: 'custom-client-secret',
+            };
+            createDropboxSyncClient.mockReturnValue({
+                mock: 'client',
+            });
+            const result = useSvelteDropboxSync(mockCredentials);
+            expect(createDropboxSyncClient).toHaveBeenCalledWith(mockCredentials);
+            expect(result).toEqual({ mock: 'client' });
+        });
+    });
+    describe('getCredentialsFromCookies', () => {
+        it('should get credentials from cookies', () => {
+            const mockCookies = {
+                get: jest.fn((name) => {
+                    if (name === 'dropbox_access_token')
+                        return 'test-access-token';
+                    if (name === 'dropbox_refresh_token')
+                        return 'test-refresh-token';
+                    return null;
+                }),
+            };
+            const credentials = getCredentialsFromCookies(mockCookies);
+            expect(mockCookies.get).toHaveBeenCalledWith('dropbox_access_token');
+            expect(mockCookies.get).toHaveBeenCalledWith('dropbox_refresh_token');
+            expect(credentials).toEqual({
+                clientId: 'test-app-key',
+                clientSecret: 'test-app-secret',
+                accessToken: 'test-access-token',
+                refreshToken: 'test-refresh-token',
+            });
+        });
+    });
+    describe('createSvelteKitHandlers', () => {
+        it('should create SvelteKit handlers with necessary methods', () => {
+            const handlers = createSvelteKitHandlers();
+            expect(handlers).toHaveProperty('status');
+            expect(handlers).toHaveProperty('oauthStart');
+            expect(handlers).toHaveProperty('oauthCallback');
+            expect(handlers).toHaveProperty('logout');
+        });
+        it('should check connection status', async () => {
+            const mockCookies = {
+                get: jest.fn().mockReturnValue('test-token'),
+            };
+            const handlers = createSvelteKitHandlers();
+            const response = await handlers.status({
+                cookies: mockCookies,
+            });
+            expect(mockCookies.get).toHaveBeenCalledWith('dropbox_access_token');
+            expect(response.status).toBe(200);
+            // Parse the response body
+            const responseText = await response.text();
+            const responseData = JSON.parse(responseText);
+            expect(responseData).toEqual({ connected: true });
+        });
+        it('should start OAuth flow', async () => {
+            const mockClient = {
+                auth: {
+                    getAuthUrl: jest
+                        .fn()
+                        .mockResolvedValue('https://dropbox.com/oauth'),
+                },
+            };
+            createDropboxSyncClient.mockReturnValue(mockClient);
+            const handlers = createSvelteKitHandlers();
+            const response = await handlers.oauthStart();
+            expect(createDropboxSyncClient).toHaveBeenCalled();
+            expect(mockClient.auth.getAuthUrl).toHaveBeenCalled();
+            expect(response.status).toBe(302);
+            expect(response.headers.get('Location')).toBe('https://dropbox.com/oauth');
+        });
+        it('should handle OAuth callback success', async () => {
+            const mockUrl = {
+                searchParams: {
+                    get: jest.fn().mockReturnValue('test-auth-code'),
+                },
+            };
+            const mockCookies = {
+                set: jest.fn(),
+            };
+            const mockClient = {
+                auth: {
+                    exchangeCodeForToken: jest.fn().mockResolvedValue({
+                        accessToken: 'new-access-token',
+                        refreshToken: 'new-refresh-token',
+                        expiresAt: Date.now() + 14400 * 1000,
+                    }),
+                },
+            };
+            createDropboxSyncClient.mockReturnValue(mockClient);
+            const handlers = createSvelteKitHandlers();
+            const response = await handlers.oauthCallback({
+                url: mockUrl,
+                cookies: mockCookies,
+            });
+            expect(mockUrl.searchParams.get).toHaveBeenCalledWith('code');
+            expect(createDropboxSyncClient).toHaveBeenCalled();
+            expect(mockClient.auth.exchangeCodeForToken).toHaveBeenCalled();
+            expect(mockCookies.set).toHaveBeenCalledTimes(3); // Access, refresh, and connected cookies
+            expect(response.status).toBe(302);
+            expect(response.headers.get('Location')).toBe('/');
+        });
+        it('should handle OAuth callback with missing code', async () => {
+            const mockUrl = {
+                searchParams: {
+                    get: jest.fn().mockReturnValue(null),
+                },
+            };
+            const mockCookies = {};
+            const handlers = createSvelteKitHandlers();
+            const response = await handlers.oauthCallback({
+                url: mockUrl,
+                cookies: mockCookies,
+            });
+            expect(mockUrl.searchParams.get).toHaveBeenCalledWith('code');
+            expect(response.status).toBe(302);
+            expect(response.headers.get('Location')).toBe('/auth/error');
+        });
+        it('should handle logout', async () => {
+            const mockCookies = {
+                delete: jest.fn(),
+            };
+            const handlers = createSvelteKitHandlers();
+            const response = await handlers.logout({ cookies: mockCookies });
+            expect(mockCookies.delete).toHaveBeenCalledTimes(3); // Should delete three cookies
+            expect(response.status).toBe(200);
+            // Parse the response body
+            const responseText = await response.text();
+            const responseData = JSON.parse(responseText);
+            expect(responseData).toEqual({ success: true });
+        });
+    });
+});

package/dist/core/__tests__/auth.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/auth.spec.js

@@ -0,0 +1,83 @@
+import { createAuthMethods } from '../auth';
+describe('createAuthMethods', () => {
+    const mockClient = {
+        auth: {
+            getAuthenticationUrl: jest
+                .fn()
+                .mockReturnValue('https://dropbox.com/auth'),
+            getAccessTokenFromCode: jest.fn().mockResolvedValue({
+                result: {
+                    access_token: 'new-access-token',
+                    refresh_token: 'new-refresh-token',
+                    expires_in: 14400,
+                },
+            }),
+        },
+    };
+    const mockGetClient = jest.fn().mockReturnValue(mockClient);
+    const mockSetAccessToken = jest.fn();
+    const mockCredentials = {
+        clientId: 'test-client-id',
+        clientSecret: 'test-client-secret',
+        accessToken: 'test-access-token',
+        refreshToken: 'test-refresh-token',
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Mock fetch for refreshAccessToken method
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: jest.fn().mockResolvedValue({
+                access_token: 'refreshed-token',
+                refresh_token: 'new-refresh-token',
+                expires_in: 14400,
+            }),
+        });
+    });
+    it('should create auth methods object', () => {
+        const auth = createAuthMethods(mockGetClient, mockCredentials, mockSetAccessToken);
+        expect(auth).toHaveProperty('getAuthUrl');
+        expect(auth).toHaveProperty('exchangeCodeForToken');
+        expect(auth).toHaveProperty('refreshAccessToken');
+    });
+    it('should generate auth URL', async () => {
+        const auth = createAuthMethods(mockGetClient, mockCredentials, mockSetAccessToken);
+        const url = await auth.getAuthUrl('http://localhost/callback', 'test-state');
+        expect(mockGetClient).toHaveBeenCalled();
+        expect(mockClient.auth.getAuthenticationUrl).toHaveBeenCalledWith('http://localhost/callback', 'test-state', 'code', 'offline', undefined, undefined, true);
+        expect(url).toEqual('https://dropbox.com/auth');
+    });
+    it('should exchange code for token', async () => {
+        const auth = createAuthMethods(mockGetClient, mockCredentials, mockSetAccessToken);
+        const tokens = await auth.exchangeCodeForToken('auth-code', 'http://localhost/callback');
+        expect(mockGetClient).toHaveBeenCalled();
+        expect(mockClient.auth.getAccessTokenFromCode).toHaveBeenCalledWith('http://localhost/callback', 'auth-code');
+        expect(mockSetAccessToken).toHaveBeenCalledWith('new-access-token');
+        expect(tokens).toEqual({
+            accessToken: 'new-access-token',
+            refreshToken: 'new-refresh-token',
+            expiresAt: expect.any(Number),
+        });
+    });
+    it('should refresh access token', async () => {
+        const auth = createAuthMethods(mockGetClient, mockCredentials, mockSetAccessToken);
+        const tokens = await auth.refreshAccessToken();
+        expect(fetch).toHaveBeenCalledWith('https://api.dropboxapi.com/oauth2/token', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            body: expect.stringContaining('grant_type=refresh_token'),
+        });
+        expect(mockSetAccessToken).toHaveBeenCalledWith('refreshed-token');
+        expect(tokens).toEqual({
+            accessToken: 'refreshed-token',
+            refreshToken: 'new-refresh-token',
+            expiresAt: expect.any(Number),
+        });
+    });
+    it('should throw error if refresh token is missing', async () => {
+        const auth = createAuthMethods(mockGetClient, { clientId: 'test-id', clientSecret: 'test-secret' }, mockSetAccessToken);
+        await expect(auth.refreshAccessToken()).rejects.toThrow('Refresh token, client ID, and client secret are required to refresh access token');
+    });
+});

package/dist/core/__tests__/client.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/client.spec.js

@@ -0,0 +1,102 @@
+import { createDropboxSyncClient } from '../client';
+import { createAuthMethods } from '../auth';
+import { createSyncMethods } from '../sync';
+import { createSocketMethods } from '../socket';
+// First setup all the mocks before importing the actual code
+let dropboxInstanceCreated = false;
+// Mock the auth module to return a mock auth object that requires client initialization
+jest.mock('../auth', () => ({
+    createAuthMethods: jest.fn().mockImplementation((getClient) => ({
+        mockAuth: true,
+        getAuthUrl: jest.fn().mockImplementation((redirectUri) => {
+            // This will force the getClient() function to be called
+            getClient();
+            return Promise.resolve('https://dropbox.com/oauth');
+        }),
+    })),
+}));
+jest.mock('../sync', () => ({
+    createSyncMethods: jest.fn().mockReturnValue({ mockSync: true }),
+}));
+jest.mock('../socket', () => ({
+    createSocketMethods: jest.fn().mockReturnValue({ mockSocket: true }),
+}));
+const mockDropboxOptions = [];
+const mockDropboxClient = {
+    auth: {
+        getAuthenticationUrl: jest.fn(),
+        getAccessTokenFromCode: jest.fn(),
+    },
+    filesListFolder: jest.fn(),
+    filesUpload: jest.fn(),
+    filesDownload: jest.fn(),
+};
+// Mock the Dropbox class
+jest.mock('dropbox', () => {
+    return {
+        Dropbox: jest.fn().mockImplementation((options) => {
+            mockDropboxOptions.push(options);
+            dropboxInstanceCreated = true;
+            return mockDropboxClient;
+        }),
+    };
+});
+describe('createDropboxSyncClient', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockDropboxOptions.length = 0;
+        dropboxInstanceCreated = false;
+    });
+    it('should create a client with accessToken', async () => {
+        const credentials = { clientId: 'test-id', accessToken: 'test-token' };
+        const client = createDropboxSyncClient(credentials);
+        expect(client).toHaveProperty('auth');
+        expect(client).toHaveProperty('sync');
+        expect(client).toHaveProperty('socket');
+        // Force client instantiation by calling getAuthUrl which calls getClient internally
+        await client.auth.getAuthUrl('https://example.com/callback');
+        // Check that Dropbox was constructed with the correct options
+        expect(dropboxInstanceCreated).toBe(true);
+        expect(mockDropboxOptions.length).toBe(1);
+        expect(mockDropboxOptions[0]).toEqual({ accessToken: 'test-token' });
+        expect(createAuthMethods).toHaveBeenCalled();
+        expect(createSyncMethods).toHaveBeenCalled();
+        expect(createSocketMethods).toHaveBeenCalled();
+    });
+    it('should create a client with clientId when accessToken is not provided', async () => {
+        const credentials = { clientId: 'test-id' };
+        const client = createDropboxSyncClient(credentials);
+        expect(client).toHaveProperty('auth');
+        expect(client).toHaveProperty('sync');
+        expect(client).toHaveProperty('socket');
+        // Force client instantiation by calling getAuthUrl which calls getClient internally
+        await client.auth.getAuthUrl('https://example.com/callback');
+        // Check that Dropbox was constructed with the correct options
+        expect(dropboxInstanceCreated).toBe(true);
+        expect(mockDropboxOptions.length).toBe(1);
+        expect(mockDropboxOptions[0]).toEqual({ clientId: 'test-id' });
+        expect(createAuthMethods).toHaveBeenCalled();
+        expect(createSyncMethods).toHaveBeenCalled();
+        expect(createSocketMethods).toHaveBeenCalled();
+    });
+    it('should throw error if neither clientId nor accessToken is provided', async () => {
+        // Mock the auth implementation for this test specifically
+        ;
+        createAuthMethods.mockImplementationOnce((getClient) => ({
+            getAuthUrl: jest.fn().mockImplementation(() => {
+                // This will throw when called with empty credentials
+                try {
+                    getClient();
+                }
+                catch (error) {
+                    return Promise.reject(error);
+                }
+                return Promise.resolve('https://dropbox.com/oauth');
+            }),
+        }));
+        const credentials = {};
+        const client = createDropboxSyncClient(credentials);
+        // This should throw when getClient() is called inside getAuthUrl
+        await expect(client.auth.getAuthUrl('https://example.com/callback')).rejects.toThrow('Either clientId or accessToken must be provided');
+    });
+});

package/dist/core/__tests__/socket.spec.d.ts

@@ -0,0 +1 @@
+export {};