@rsweeten/dropbox-sync 0.1.2 → 0.1.3

package/src/adapters/__tests__/nuxt.spec.ts

@@ -0,0 +1,185 @@
+import {
+    useNuxtDropboxSync,
+    getCredentialsFromCookies,
+    createNuxtApiHandlers,
+} from '../nuxt'
+import { createDropboxSyncClient } from '../../core/client'
+import type { H3Event } from 'h3'
+
+// 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 as any).client = false
+        }
+    })
+
+    describe('useNuxtDropboxSync', () => {
+        it('should create a Dropbox sync client with config values', () => {
+            ;(createDropboxSyncClient as jest.Mock).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 as any).client = true
+
+            ;(createDropboxSyncClient as jest.Mock).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 = {} as H3Event
+
+            // Set up mock implementation
+            mockGetCookie.mockImplementation((event: any, name: string) => {
+                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 = {} as H3Event
+
+        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 as jest.Mock).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/src/adapters/__tests__/svelte.spec.ts

@@ -0,0 +1,194 @@
+import {
+    useSvelteDropboxSync,
+    getCredentialsFromCookies,
+    createSvelteKitHandlers,
+} from '../svelte'
+import { createDropboxSyncClient } from '../../core/client'
+import type { Cookies } from '@sveltejs/kit'
+
+// 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 as jest.Mock).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
+                }),
+            } as unknown as Cookies
+
+            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 as unknown as Cookies,
+            })
+
+            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 as jest.Mock).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'),
+                },
+            } as unknown as URL
+
+            const mockCookies = {
+                set: jest.fn(),
+            } as unknown as Cookies
+
+            const mockClient = {
+                auth: {
+                    exchangeCodeForToken: jest.fn().mockResolvedValue({
+                        accessToken: 'new-access-token',
+                        refreshToken: 'new-refresh-token',
+                        expiresAt: Date.now() + 14400 * 1000,
+                    }),
+                },
+            }
+
+            ;(createDropboxSyncClient as jest.Mock).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),
+                },
+            } as unknown as URL
+
+            const mockCookies = {} as unknown as Cookies
+
+            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(),
+            } as unknown as Cookies
+
+            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/src/core/__tests__/auth.spec.ts

@@ -0,0 +1,142 @@
+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/src/core/__tests__/client.spec.ts

@@ -0,0 +1,128 @@
+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 }),
+}))
+
+// Mock Dropbox constructor and track constructor options
+interface DropboxOptions {
+    accessToken?: string
+    clientId?: string
+}
+
+const mockDropboxOptions: DropboxOptions[] = []
+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: DropboxOptions) => {
+            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 as jest.Mock).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 = {} as any
+        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')
+    })
+})