@rsweeten/dropbox-sync 0.1.1 → 0.1.3

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

@@ -0,0 +1,240 @@
+import {
+    useNextDropboxSync,
+    getCredentialsFromCookies,
+    handleOAuthCallback,
+    createNextDropboxApiHandlers,
+} from '../next'
+import { createDropboxSyncClient } from '../../core/client'
+import { cookies } from 'next/headers'
+import { NextRequest, 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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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',
+            } as unknown as NextRequest
+
+            // Mock URL constructor behavior
+            ;(global as any).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 as jest.Mock).mockReturnValue(mockClient)
+
+            // Mock NextResponse
+            const mockResponseCookies = {
+                set: jest.fn(),
+            }
+
+            const mockResponse = {
+                cookies: mockResponseCookies,
+            }
+
+            ;(NextResponse.redirect as jest.Mock).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',
+            } as unknown as NextRequest
+
+            ;(global as any).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'
+
+            // Mock the redirect implementation to return this URL
+            ;(NextResponse.redirect as jest.Mock).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 as jest.Mock).mockResolvedValue(mockCookieStore)
+            ;(NextResponse.json as jest.Mock).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 as jest.Mock).mockReturnValue(mockClient)
+            ;(NextResponse.redirect as jest.Mock).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 as jest.Mock).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/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 })
+        })
+    })
+})