@rsweeten/dropbox-sync/dist/adapters/__tests__/svelte.spec.js

Reusable Dropbox synchronization module with framework adapters

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