@rsweeten/dropbox-sync 0.1.2 → 0.1.3

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

@@ -0,0 +1,338 @@
+// Mock Angular modules before importing the code under test
+jest.mock('@angular/core', () => ({
+    Injectable: () => jest.fn(),
+}))
+
+jest.mock('@angular/common/http', () => ({
+    HttpClient: jest.fn(),
+    HttpHeaders: jest.fn(),
+}))
+
+// Now import the code that uses Angular modules
+import { DropboxSyncService, getCredentialsFromEnvironment } from '../angular'
+import { createDropboxSyncClient } from '../../core/client'
+import { of } from 'rxjs'
+import { Observable } from 'rxjs'
+
+// Mock the core client
+jest.mock('../../core/client')
+
+describe('Angular adapter', () => {
+    let service: DropboxSyncService
+    const mockHttpClient = {
+        get: jest.fn(),
+        post: jest.fn(),
+    }
+
+    beforeEach(() => {
+        jest.clearAllMocks()
+        service = new DropboxSyncService(mockHttpClient as any)
+    })
+
+    describe('DropboxSyncService', () => {
+        it('should be created', () => {
+            expect(service).toBeTruthy()
+        })
+
+        it('should initialize with credentials', () => {
+            const mockCredentials = {
+                clientId: 'test-client-id',
+                clientSecret: 'test-client-secret',
+                accessToken: 'test-access-token',
+                refreshToken: 'test-refresh-token',
+            }
+
+            const mockClient = { mock: 'client' }
+            ;(createDropboxSyncClient as jest.Mock).mockReturnValue(mockClient)
+
+            const result = service.initialize(mockCredentials)
+
+            expect(createDropboxSyncClient).toHaveBeenCalledWith(
+                mockCredentials
+            )
+            expect(result).toEqual(mockClient)
+        })
+
+        it('should get client after initialization', () => {
+            const mockCredentials = { clientId: 'test-id' }
+            const mockClient = { mock: 'client' }
+            ;(createDropboxSyncClient as jest.Mock).mockReturnValue(mockClient)
+
+            service.initialize(mockCredentials)
+            const client = service.getClient()
+
+            expect(client).toEqual(mockClient)
+        })
+
+        it('should throw error if getClient called before initialization', () => {
+            expect(() => service.getClient()).toThrow(
+                'DropboxSyncService not initialized. Call initialize() first.'
+            )
+        })
+
+        it('should check connection status via HTTP', () => {
+            mockHttpClient.get.mockReturnValue(of({ connected: true }))
+
+            service.checkConnection().subscribe((result) => {
+                expect(result).toBe(true)
+            })
+
+            expect(mockHttpClient.get).toHaveBeenCalledWith(
+                '/api/dropbox/status'
+            )
+        })
+
+        it('should handle connection error', () => {
+            mockHttpClient.get.mockReturnValue(of(null)) // Simulate error
+
+            service.checkConnection().subscribe((result) => {
+                expect(result).toBe(false)
+            })
+        })
+
+        it('should disconnect via HTTP', () => {
+            mockHttpClient.post.mockReturnValue(of({ success: true }))
+
+            service.disconnectDropbox().subscribe((result) => {
+                expect(result).toBe(true)
+            })
+
+            expect(mockHttpClient.post).toHaveBeenCalledWith(
+                '/api/dropbox/logout',
+                {}
+            )
+        })
+
+        it('should start sync process', () => {
+            const mockOptions = { localDir: '/test-dir' }
+            const mockResult = { uploaded: [], downloaded: [] }
+
+            const mockClient = {
+                sync: {
+                    syncFiles: jest.fn().mockResolvedValue(mockResult),
+                },
+                socket: {
+                    connect: jest.fn(),
+                },
+            }
+
+            ;(createDropboxSyncClient as jest.Mock).mockReturnValue(mockClient)
+            service.initialize({ clientId: 'test-id' })
+
+            // Mock setupSocketListeners to return an observable
+            service.setupSocketListeners = jest.fn().mockReturnValue(of({}))
+
+            service.startSync(mockOptions).subscribe((result) => {
+                expect(result).toEqual(mockResult)
+            })
+
+            expect(mockClient.socket.connect).toHaveBeenCalled()
+            expect(mockClient.sync.syncFiles).toHaveBeenCalledWith(mockOptions)
+            expect(service.setupSocketListeners).toHaveBeenCalled()
+        })
+
+        it('should cancel sync', () => {
+            const mockClient = {
+                sync: {
+                    cancelSync: jest.fn(),
+                },
+            }
+
+            ;(createDropboxSyncClient as jest.Mock).mockReturnValue(mockClient)
+            service.initialize({ clientId: 'test-id' })
+
+            service.cancelSync()
+
+            expect(mockClient.sync.cancelSync).toHaveBeenCalled()
+        })
+
+        // Mock the implementation of setupSocketListeners for testing
+        it('should setup socket listeners', () => {
+            const mockSocket = {
+                on: jest.fn(),
+                off: jest.fn(),
+            }
+
+            const mockClient = {
+                socket: mockSocket,
+            }
+
+            ;(createDropboxSyncClient as jest.Mock).mockReturnValue(mockClient)
+            service.initialize({ clientId: 'test-id' })
+
+            const observable = service.setupSocketListeners()
+
+            // Should return an Observable
+            expect(observable).toBeInstanceOf(Observable)
+
+            // Get the subscriber function that was used to create the Observable
+            const observer = {
+                next: jest.fn(),
+                error: jest.fn(),
+                complete: jest.fn(),
+            }
+            const subscription = observable.subscribe(observer)
+
+            // Since we have direct access to the socket mock, we can verify its behavior
+            expect(mockSocket.on).toHaveBeenCalledWith(
+                'sync:progress',
+                expect.any(Function)
+            )
+            expect(mockSocket.on).toHaveBeenCalledWith(
+                'sync:queue',
+                expect.any(Function)
+            )
+            expect(mockSocket.on).toHaveBeenCalledWith(
+                'sync:complete',
+                expect.any(Function)
+            )
+            expect(mockSocket.on).toHaveBeenCalledWith(
+                'sync:error',
+                expect.any(Function)
+            )
+
+            // Clean up the subscription
+            subscription.unsubscribe()
+        })
+
+        it('should handle OAuth callback', () => {
+            const mockCode = 'test-auth-code'
+            const mockTokens = {
+                accessToken: 'new-access-token',
+                refreshToken: 'new-refresh-token',
+            }
+
+            const mockClient = {
+                auth: {
+                    exchangeCodeForToken: jest
+                        .fn()
+                        .mockResolvedValue(mockTokens),
+                },
+            }
+
+            ;(createDropboxSyncClient as jest.Mock).mockReturnValue(mockClient)
+            service.initialize({ clientId: 'test-id' })
+
+            // Create a proper localStorage mock
+            const mockLocalStorage = {
+                setItem: jest.fn(),
+                getItem: jest.fn(),
+                removeItem: jest.fn(),
+            }
+
+            Object.defineProperty(global, 'localStorage', {
+                value: mockLocalStorage,
+                writable: true,
+            })
+
+            // Mock window.location.origin
+            Object.defineProperty(window, 'location', {
+                value: {
+                    origin: 'http://localhost',
+                },
+                writable: true,
+            })
+
+            // Subscribe to the observable to trigger the code
+            let receivedResult: any
+            service.handleOAuthCallback(mockCode).subscribe((result) => {
+                receivedResult = result
+            })
+
+            // Verify the exchangeCodeForToken was called with the expected args
+            expect(mockClient.auth.exchangeCodeForToken).toHaveBeenCalledWith(
+                mockCode,
+                'http://localhost/api/dropbox/auth/callback'
+            )
+
+            // Create and resolve the promise to trigger the localStorage set calls
+            const resolvePromise = Promise.resolve(mockTokens)
+
+            // Return a promise that will resolve after our mocked promise
+            return resolvePromise.then(() => {
+                // Now we can check localStorage was called
+                expect(mockLocalStorage.setItem).toHaveBeenCalledWith(
+                    'dropbox_access_token',
+                    mockTokens.accessToken
+                )
+
+                expect(mockLocalStorage.setItem).toHaveBeenCalledWith(
+                    'dropbox_refresh_token',
+                    mockTokens.refreshToken
+                )
+
+                expect(mockLocalStorage.setItem).toHaveBeenCalledWith(
+                    'dropbox_connected',
+                    'true'
+                )
+
+                // Verify we received the tokens
+                expect(receivedResult).toEqual(mockTokens)
+            })
+        })
+    })
+
+    describe('getCredentialsFromEnvironment', () => {
+        it('should extract credentials from environment', () => {
+            const mockEnvironment = {
+                dropboxAppKey: 'env-app-key',
+                dropboxAppSecret: 'env-app-secret',
+            }
+
+            // Mock localStorage
+            const mockLocalStorage = {
+                getItem: jest.fn().mockImplementation((key) => {
+                    if (key === 'dropbox_access_token')
+                        return 'storage-access-token'
+                    if (key === 'dropbox_refresh_token')
+                        return 'storage-refresh-token'
+                    return null
+                }),
+            }
+
+            Object.defineProperty(global, 'localStorage', {
+                value: mockLocalStorage,
+                writable: true,
+            })
+
+            const credentials = getCredentialsFromEnvironment(mockEnvironment)
+
+            expect(credentials).toEqual({
+                clientId: 'env-app-key',
+                clientSecret: 'env-app-secret',
+                accessToken: 'storage-access-token',
+                refreshToken: 'storage-refresh-token',
+            })
+
+            expect(mockLocalStorage.getItem).toHaveBeenCalledWith(
+                'dropbox_access_token'
+            )
+            expect(mockLocalStorage.getItem).toHaveBeenCalledWith(
+                'dropbox_refresh_token'
+            )
+        })
+
+        it('should handle missing environment values', () => {
+            const mockEnvironment = {}
+
+            // Mock localStorage with no tokens
+            const mockLocalStorage = {
+                getItem: jest.fn().mockReturnValue(null),
+            }
+
+            Object.defineProperty(global, 'localStorage', {
+                value: mockLocalStorage,
+                writable: true,
+            })
+
+            const credentials = getCredentialsFromEnvironment(mockEnvironment)
+
+            expect(credentials).toEqual({
+                clientId: '',
+                clientSecret: undefined,
+                accessToken: undefined,
+                refreshToken: undefined,
+            })
+        })
+    })
+})

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
+        })
+    })
+})