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

Reusable Dropbox synchronization module with framework adapters

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