diff --git a/gitgram/mobile/__tests__/app/backup/export.test.tsx b/gitgram/mobile/__tests__/app/backup/export.test.tsx new file mode 100644 index 00000000..82b88772 --- /dev/null +++ b/gitgram/mobile/__tests__/app/backup/export.test.tsx @@ -0,0 +1,99 @@ +import React from 'react'; +import { Alert } from 'react-native'; +import { render, fireEvent, waitFor, act } from '@testing-library/react-native'; +import ExportDataScreen from '../../../app/backup/export'; +import { + requestAndDownloadDataExport, + shareExportFile, + DataExportTimeoutError, +} from '../../../utils/dataExportFlow'; + +jest.mock('../../../utils/dataExportFlow'); + +describe('ExportDataScreen', () => { + beforeEach(() => { + jest.clearAllMocks(); + jest.spyOn(Alert, 'alert').mockImplementation(() => undefined); + }); + + it('wires the export button to the real data-export flow and shares the result', async () => { + (requestAndDownloadDataExport as jest.Mock).mockImplementation(async (onPhaseChange) => { + onPhaseChange?.('requesting'); + onPhaseChange?.('processing'); + onPhaseChange?.('downloading'); + onPhaseChange?.('done'); + return { exportId: 'export-123', fileUri: 'file:///mock-cache/export.json' }; + }); + (shareExportFile as jest.Mock).mockResolvedValue(undefined); + + const { getByText } = render(); + + await act(async () => { + fireEvent.press(getByText('JSON')); + }); + + await waitFor(() => { + expect(requestAndDownloadDataExport).toHaveBeenCalledTimes(1); + }); + expect(shareExportFile).toHaveBeenCalledWith('file:///mock-cache/export.json'); + expect(getByText('Your data export is ready.')).toBeTruthy(); + expect(Alert.alert).not.toHaveBeenCalled(); + }); + + it('shows a user-visible error instead of failing silently when the export request fails', async () => { + (requestAndDownloadDataExport as jest.Mock).mockRejectedValue( + new Error('Network request failed') + ); + + const { getByText } = render(); + + await act(async () => { + fireEvent.press(getByText('JSON')); + }); + + await waitFor(() => { + expect(Alert.alert).toHaveBeenCalledWith('Export Failed', 'Network request failed'); + }); + expect(shareExportFile).not.toHaveBeenCalled(); + }); + + it('shows a friendly timeout message when the export never becomes ready', async () => { + (requestAndDownloadDataExport as jest.Mock).mockRejectedValue( + new DataExportTimeoutError('export-slow') + ); + + const { getByText } = render(); + + await act(async () => { + fireEvent.press(getByText('JSON')); + }); + + await waitFor(() => { + expect(Alert.alert).toHaveBeenCalledWith( + 'Export Failed', + 'Still preparing your export. Please check back in a few minutes.' + ); + }); + }); + + it('tells the user the export downloaded even if sharing it fails', async () => { + (requestAndDownloadDataExport as jest.Mock).mockResolvedValue({ + exportId: 'export-123', + fileUri: 'file:///mock-cache/export.json', + }); + (shareExportFile as jest.Mock).mockRejectedValue(new Error('Share sheet unavailable')); + + const { getByText } = render(); + + await act(async () => { + fireEvent.press(getByText('JSON')); + }); + + await waitFor(() => { + expect(Alert.alert).toHaveBeenCalledWith( + 'Export Downloaded', + 'Your data export was downloaded but could not be opened for sharing. It is saved in app storage.' + ); + }); + }); +}); diff --git a/gitgram/mobile/__tests__/services/backupService.test.ts b/gitgram/mobile/__tests__/services/backupService.test.ts new file mode 100644 index 00000000..239fb7a3 --- /dev/null +++ b/gitgram/mobile/__tests__/services/backupService.test.ts @@ -0,0 +1,61 @@ +import { backupService } from '../../services/backupService'; +import api from '../../services/api'; + +jest.mock('../../services/api'); + +describe('backupService', () => { + beforeEach(() => { + jest.clearAllMocks(); + }); + + describe('requestDataExport', () => { + it('calls the real GDPR export request endpoint', async () => { + const mockResponse = { + data: { + success: true, + data: { + exportId: 'export-123', + estimatedTime: '2-5 minutes', + createdAt: '2026-10-21T00:00:00.000Z', + }, + }, + }; + + (api.post as jest.Mock).mockResolvedValue(mockResponse); + + const result = await backupService.requestDataExport(); + + expect(api.post).toHaveBeenCalledWith('/data-export/request'); + expect(result).toEqual(mockResponse.data); + }); + }); + + describe('getDataExportStatus', () => { + it('calls the status endpoint with the exportId path param', async () => { + const mockResponse = { + data: { + success: true, + data: { exportId: 'export-123', status: 'processing', progress: 40 }, + }, + }; + + (api.get as jest.Mock).mockResolvedValue(mockResponse); + + const result = await backupService.getDataExportStatus('export-123'); + + expect(api.get).toHaveBeenCalledWith('/data-export/export-123/status'); + expect(result).toEqual(mockResponse.data); + }); + }); + + describe('exportData (legacy, deprecated)', () => { + it('still calls the old non-existent compliance endpoint', async () => { + const mockResponse = { data: { message: 'queued' } }; + (api.post as jest.Mock).mockResolvedValue(mockResponse); + + await backupService.exportData('json'); + + expect(api.post).toHaveBeenCalledWith('/compliance/export-data', { format: 'json' }); + }); + }); +}); diff --git a/gitgram/mobile/__tests__/utils/dataExportFlow.test.ts b/gitgram/mobile/__tests__/utils/dataExportFlow.test.ts new file mode 100644 index 00000000..b5d7288c --- /dev/null +++ b/gitgram/mobile/__tests__/utils/dataExportFlow.test.ts @@ -0,0 +1,212 @@ +import * as FileSystem from 'expo-file-system/legacy'; +import * as Sharing from 'expo-sharing'; +import { + requestAndDownloadDataExport, + shareExportFile, + DataExportTimeoutError, +} from '../../utils/dataExportFlow'; +import { backupService } from '../../services/backupService'; +import { useAuthStore } from '../../store/authStore'; + +jest.mock('../../services/backupService'); +jest.mock('../../store/authStore'); + +describe('dataExportFlow', () => { + beforeEach(() => { + jest.clearAllMocks(); + jest.useRealTimers(); + + (useAuthStore.getState as jest.Mock) = jest.fn(() => ({ + accessToken: 'test-access-token', + refreshAccessToken: jest.fn(), + })); + }); + + describe('requestAndDownloadDataExport', () => { + it('requests the export, polls until ready, then downloads the file', async () => { + (backupService.requestDataExport as jest.Mock).mockResolvedValue({ + success: true, + data: { exportId: 'export-abc', estimatedTime: '2-5 minutes', createdAt: 'now' }, + }); + + (backupService.getDataExportStatus as jest.Mock) + .mockResolvedValueOnce({ + success: true, + data: { exportId: 'export-abc', status: 'processing', progress: 20 }, + }) + .mockResolvedValueOnce({ + success: true, + data: { exportId: 'export-abc', status: 'ready', progress: 100 }, + }); + + jest.useFakeTimers(); + const phases: string[] = []; + const resultPromise = requestAndDownloadDataExport((phase) => phases.push(phase)); + await jest.advanceTimersByTimeAsync(3000); + const result = await resultPromise; + jest.useRealTimers(); + + expect(backupService.requestDataExport).toHaveBeenCalledTimes(1); + expect(backupService.getDataExportStatus).toHaveBeenCalledTimes(2); + expect(FileSystem.downloadAsync).toHaveBeenCalledWith( + expect.stringContaining('/data-export/export-abc/download'), + expect.stringContaining('export-abc'), + { headers: { Authorization: 'Bearer test-access-token' } } + ); + expect(result).toEqual({ + exportId: 'export-abc', + fileUri: 'file:///mock-cache/mock-export.json', + }); + expect(phases).toEqual(['requesting', 'processing', 'downloading', 'done']); + }); + + it('falls back to a refreshed token when there is no access token yet', async () => { + const refreshAccessToken = jest.fn().mockResolvedValue('refreshed-token'); + (useAuthStore.getState as jest.Mock).mockReturnValue({ + accessToken: null, + refreshAccessToken, + }); + + (backupService.requestDataExport as jest.Mock).mockResolvedValue({ + success: true, + data: { exportId: 'export-xyz', estimatedTime: '2-5 minutes', createdAt: 'now' }, + }); + (backupService.getDataExportStatus as jest.Mock).mockResolvedValue({ + success: true, + data: { exportId: 'export-xyz', status: 'ready', progress: 100 }, + }); + + await requestAndDownloadDataExport(); + + expect(refreshAccessToken).toHaveBeenCalledTimes(1); + expect(FileSystem.downloadAsync).toHaveBeenCalledWith( + expect.any(String), + expect.any(String), + { headers: { Authorization: 'Bearer refreshed-token' } } + ); + }); + + it('throws when the user is not signed in and cannot refresh a token', async () => { + (useAuthStore.getState as jest.Mock).mockReturnValue({ + accessToken: null, + refreshAccessToken: jest.fn().mockResolvedValue(null), + }); + + (backupService.requestDataExport as jest.Mock).mockResolvedValue({ + success: true, + data: { exportId: 'export-xyz', estimatedTime: '2-5 minutes', createdAt: 'now' }, + }); + (backupService.getDataExportStatus as jest.Mock).mockResolvedValue({ + success: true, + data: { exportId: 'export-xyz', status: 'ready', progress: 100 }, + }); + + await expect(requestAndDownloadDataExport()).rejects.toThrow( + 'You must be signed in to export your data.' + ); + }); + + it('throws a user-visible error when the export fails server-side', async () => { + (backupService.requestDataExport as jest.Mock).mockResolvedValue({ + success: true, + data: { exportId: 'export-fail', estimatedTime: '2-5 minutes', createdAt: 'now' }, + }); + (backupService.getDataExportStatus as jest.Mock).mockResolvedValue({ + success: true, + data: { exportId: 'export-fail', status: 'failed', progress: 0 }, + }); + + await expect(requestAndDownloadDataExport()).rejects.toThrow( + 'Data export failed. Please try again.' + ); + }); + + it('throws a user-visible error when the export expires before download', async () => { + (backupService.requestDataExport as jest.Mock).mockResolvedValue({ + success: true, + data: { exportId: 'export-expired', estimatedTime: '2-5 minutes', createdAt: 'now' }, + }); + (backupService.getDataExportStatus as jest.Mock).mockResolvedValue({ + success: true, + data: { exportId: 'export-expired', status: 'expired', progress: 100 }, + }); + + await expect(requestAndDownloadDataExport()).rejects.toThrow( + 'Data export expired before it could be downloaded. Please request a new one.' + ); + }); + + it('propagates the request error without silently swallowing it', async () => { + (backupService.requestDataExport as jest.Mock).mockRejectedValue( + new Error('Network request failed') + ); + + await expect(requestAndDownloadDataExport()).rejects.toThrow('Network request failed'); + expect(backupService.getDataExportStatus).not.toHaveBeenCalled(); + }); + + it('throws DataExportTimeoutError when the export never becomes ready', async () => { + (backupService.requestDataExport as jest.Mock).mockResolvedValue({ + success: true, + data: { exportId: 'export-slow', estimatedTime: '2-5 minutes', createdAt: 'now' }, + }); + (backupService.getDataExportStatus as jest.Mock).mockResolvedValue({ + success: true, + data: { exportId: 'export-slow', status: 'processing', progress: 10 }, + }); + + jest.useFakeTimers(); + // Attach the rejection assertion synchronously, right when the promise + // is created, so Node never sees it as unhandled while the fake timers + // are advanced below. + const assertion = expect(requestAndDownloadDataExport()).rejects.toBeInstanceOf( + DataExportTimeoutError + ); + // Let every poll's sleep() resolve without waiting real wall-clock time. + await jest.advanceTimersByTimeAsync(3000 * 61); + + await assertion; + jest.useRealTimers(); + }, 15000); + + it('surfaces a non-2xx download status as a thrown error', async () => { + (backupService.requestDataExport as jest.Mock).mockResolvedValue({ + success: true, + data: { exportId: 'export-bad', estimatedTime: '2-5 minutes', createdAt: 'now' }, + }); + (backupService.getDataExportStatus as jest.Mock).mockResolvedValue({ + success: true, + data: { exportId: 'export-bad', status: 'ready', progress: 100 }, + }); + (FileSystem.downloadAsync as jest.Mock).mockResolvedValueOnce({ + uri: 'file:///mock-cache/export-bad.json', + status: 410, + }); + + await expect(requestAndDownloadDataExport()).rejects.toThrow( + 'Failed to download export (status 410).' + ); + }); + }); + + describe('shareExportFile', () => { + it('shares the downloaded file via the OS share sheet', async () => { + await shareExportFile('file:///mock-cache/mock-export.json'); + + expect(Sharing.isAvailableAsync).toHaveBeenCalledTimes(1); + expect(Sharing.shareAsync).toHaveBeenCalledWith('file:///mock-cache/mock-export.json', { + mimeType: 'application/json', + dialogTitle: 'Save or share your data export', + }); + }); + + it('throws a user-visible error when sharing is unavailable on this device', async () => { + (Sharing.isAvailableAsync as jest.Mock).mockResolvedValueOnce(false); + + await expect(shareExportFile('file:///mock-cache/mock-export.json')).rejects.toThrow( + 'Sharing is not available on this device. The file was saved to app storage.' + ); + expect(Sharing.shareAsync).not.toHaveBeenCalled(); + }); + }); +}); diff --git a/gitgram/mobile/app/backup/export.tsx b/gitgram/mobile/app/backup/export.tsx index 6f796530..f7652dcf 100644 --- a/gitgram/mobile/app/backup/export.tsx +++ b/gitgram/mobile/app/backup/export.tsx @@ -11,23 +11,58 @@ import { Colors } from '../../constants/Colors'; import Header from '../../components/navigation/Header'; import LoadingSpinner from '../../components/common/LoadingSpinner'; import { logger } from '../../utils/logger'; -import { backupService } from '../../services/backupService'; +import { + requestAndDownloadDataExport, + shareExportFile, + DataExportTimeoutError, + DataExportPhase, +} from '../../utils/dataExportFlow'; import Icon from 'react-native-vector-icons/MaterialIcons'; +const PHASE_MESSAGES: Record = { + requesting: 'Requesting your export…', + processing: 'Preparing your export… this can take a couple of minutes.', + downloading: 'Export ready — downloading…', + done: 'Export downloaded. Opening share sheet…', +}; + export default function ExportDataScreen() { const [loading, setLoading] = useState(false); + const [statusMessage, setStatusMessage] = useState(null); - const handleExport = async (format: 'json' | 'csv') => { + const handleExport = async () => { setLoading(true); + setStatusMessage(null); try { - await backupService.exportData(format); - Alert.alert( - 'Export Started', - `Your data export in ${format.toUpperCase()} format will be ready shortly. You'll receive a notification when it's complete.` - ); + const { fileUri } = await requestAndDownloadDataExport((phase) => { + setStatusMessage(PHASE_MESSAGES[phase]); + }); + + try { + await shareExportFile(fileUri); + } catch (shareError) { + // The export downloaded fine; sharing it is best-effort, so surface + // this but don't treat it as a failed export. + logger.error('Share export file error:', shareError); + Alert.alert( + 'Export Downloaded', + 'Your data export was downloaded but could not be opened for sharing. It is saved in app storage.' + ); + return; + } + + setStatusMessage('Your data export is ready.'); } catch (error) { logger.error('Export data error:', error); - Alert.alert('Error', 'Failed to export data. Please try again.'); + Alert.alert( + 'Export Failed', + error instanceof DataExportTimeoutError + ? 'Still preparing your export. Please check back in a few minutes.' + : error instanceof Error + ? error.message + : 'Failed to export data. Please try again.' + ); + setStatusMessage(null); } finally { setLoading(false); } @@ -38,14 +73,14 @@ export default function ExportDataScreen() {
- Export a copy of your data including posts, comments, messages, and account information. + Export a copy of your data including posts, snippets, collections, messages, and account information. Export Format handleExport('json')} + style={[styles.formatOption, loading && styles.formatOptionDisabled]} + onPress={handleExport} disabled={loading} > @@ -57,26 +92,17 @@ export default function ExportDataScreen() { - - handleExport('csv')} - disabled={loading} - > - - - CSV - - Spreadsheet format, easy to view - - - - + {statusMessage && ( + + {statusMessage} + + )} + - Note: Large exports may take several minutes to process. You'll receive a notification when your export is ready. + Note: Large exports may take a couple of minutes to process. Keep this screen open while your export is prepared, then use the share sheet to save or send the file. @@ -131,6 +157,19 @@ const styles = StyleSheet.create({ fontSize: 14, color: Colors.textSecondary, }, + formatOptionDisabled: { + opacity: 0.6, + }, + statusBanner: { + backgroundColor: Colors.surface, + borderRadius: 8, + padding: 12, + marginBottom: 20, + }, + statusText: { + fontSize: 14, + color: Colors.text, + }, note: { backgroundColor: Colors.surface, borderRadius: 8, diff --git a/gitgram/mobile/jest.setup.js b/gitgram/mobile/jest.setup.js index a01de8ef..0d92ad0e 100644 --- a/gitgram/mobile/jest.setup.js +++ b/gitgram/mobile/jest.setup.js @@ -38,6 +38,24 @@ jest.mock('expo-constants', () => ({ }, })); +// Mock expo-sharing (used to let the user save/share a downloaded file) +jest.mock('expo-sharing', () => ({ + isAvailableAsync: jest.fn(() => Promise.resolve(true)), + shareAsync: jest.fn(() => Promise.resolve()), +})); + +// Mock expo-file-system legacy API (used for downloading the GDPR export to +// local app storage before handing it to expo-sharing) +jest.mock('expo-file-system/legacy', () => ({ + cacheDirectory: 'file:///mock-cache/', + downloadAsync: jest.fn(() => + Promise.resolve({ uri: 'file:///mock-cache/mock-export.json', status: 200 }) + ), + getInfoAsync: jest.fn(() => Promise.resolve({ exists: false, isDirectory: false })), + readDirectoryAsync: jest.fn(() => Promise.resolve([])), + deleteAsync: jest.fn(() => Promise.resolve()), +})); + // Mock expo-notifications jest.mock('expo-notifications', () => ({ setNotificationHandler: jest.fn(), diff --git a/gitgram/mobile/package.json b/gitgram/mobile/package.json index 721d045c..9cdef9b6 100644 --- a/gitgram/mobile/package.json +++ b/gitgram/mobile/package.json @@ -44,6 +44,7 @@ "expo-media-library": "^18.2.0", "expo-notifications": "^0.32.13", "expo-router": "^6.0.15", + "expo-sharing": "~14.0.8", "expo-status-bar": "~3.0.8", "expo-video": "^3.0.14", "expo-web-browser": "^15.0.9", diff --git a/gitgram/mobile/services/backupService.ts b/gitgram/mobile/services/backupService.ts index 753e2f0e..5aeeb68b 100644 --- a/gitgram/mobile/services/backupService.ts +++ b/gitgram/mobile/services/backupService.ts @@ -1,11 +1,50 @@ import api from './api'; +export type DataExportStatus = 'processing' | 'ready' | 'expired' | 'failed'; + +export interface DataExportRequestResponse { + success: boolean; + data: { + exportId: string; + estimatedTime: string; + createdAt: string; + }; +} + +export interface DataExportStatusResponse { + success: boolean; + data: { + exportId: string; + status: DataExportStatus; + progress: number; + }; +} + export const backupService = { + /** + * @deprecated Hits `/compliance/export-data`, which does not exist on the + * backend (always 404s). Use `requestDataExport` + `getDataExportStatus` + + * `utils/dataExportFlow.ts`'s `requestAndDownloadDataExport`, which drive the + * real GDPR export pipeline at `/api/v1/data-export` (see + * backend/src/routes/dataExport.ts). Matches the web fix in commit 842be56e. + */ exportData: async (format: 'json' | 'csv') => { const response = await api.post('/compliance/export-data', { format }); return response.data; }, + // Data export (GDPR). Backend flow is async: request -> poll status -> download + // once ready. See backend/src/routes/dataExport.ts + services/dataExportService.ts. + requestDataExport: async (): Promise => { + const { data } = await api.post('/data-export/request'); + return data; + }, + + getDataExportStatus: async (exportId: string): Promise => { + const { data } = await api.get(`/data-export/${exportId}/status`); + return data; + }, + importData: async (fileUri: string) => { const formData = new FormData(); formData.append('file', { diff --git a/gitgram/mobile/utils/dataExportFlow.ts b/gitgram/mobile/utils/dataExportFlow.ts new file mode 100644 index 00000000..6fd1ac7c --- /dev/null +++ b/gitgram/mobile/utils/dataExportFlow.ts @@ -0,0 +1,119 @@ +import * as FileSystem from 'expo-file-system/legacy'; +import * as Sharing from 'expo-sharing'; +import { API_BASE_URL } from '../constants/Config'; +import { useAuthStore } from '../store/authStore'; +import { backupService } from '../services/backupService'; + +/** + * Drives the full GDPR data-export flow against the real backend + * (backend/src/routes/dataExport.ts): request -> poll status -> download -> + * share/save. Mirrors web/utils/dataExportFlow.ts (fixed in commit 842be56e). + * + * The backend generates the export asynchronously (2-5 min estimate), so this + * polls until the job is 'ready' (or fails/expires), downloads the resulting + * file into app storage via expo-file-system, then hands it to expo-sharing + * so the user can save or share it. Used by app/backup/export.tsx, which + * previously called `backupService.exportData` -> `/compliance/export-data`, + * an endpoint that never existed on the backend and always 404'd. + */ + +const POLL_INTERVAL_MS = 3000; +const MAX_POLL_ATTEMPTS = 60; // ~3 minutes + +export type DataExportPhase = 'requesting' | 'processing' | 'downloading' | 'done'; + +export interface DataExportFlowResult { + exportId: string; + fileUri: string; +} + +export class DataExportTimeoutError extends Error { + constructor(public exportId: string) { + super('Export is taking longer than expected. Check back in a few minutes.'); + this.name = 'DataExportTimeoutError'; + } +} + +function sleep(ms: number): Promise { + return new Promise((resolve) => setTimeout(resolve, ms)); +} + +async function getAuthHeader(): Promise> { + const { accessToken, refreshAccessToken } = useAuthStore.getState(); + const token = accessToken ?? (await refreshAccessToken()); + + if (!token) { + throw new Error('You must be signed in to export your data.'); + } + + return { Authorization: `Bearer ${token}` }; +} + +async function downloadExportFile(exportId: string): Promise { + const headers = await getAuthHeader(); + const url = `${API_BASE_URL}/data-export/${exportId}/download`; + const destUri = `${FileSystem.cacheDirectory}gitgram-data-export-${exportId}.json`; + + const result = await FileSystem.downloadAsync(url, destUri, { headers }); + + if (result.status < 200 || result.status >= 300) { + throw new Error(`Failed to download export (status ${result.status}).`); + } + + return result.uri; +} + +/** + * Requests a new export, polls until it is ready, and downloads the file to + * local app storage. Does not share/save the file — call `shareExportFile` + * with the returned `fileUri` to let the user save or share it. + */ +export async function requestAndDownloadDataExport( + onPhaseChange?: (phase: DataExportPhase) => void +): Promise { + onPhaseChange?.('requesting'); + const requested = await backupService.requestDataExport(); + const { exportId } = requested.data; + + onPhaseChange?.('processing'); + for (let attempt = 0; attempt < MAX_POLL_ATTEMPTS; attempt += 1) { + const statusResult = await backupService.getDataExportStatus(exportId); + const { status } = statusResult.data; + + if (status === 'ready') { + onPhaseChange?.('downloading'); + const fileUri = await downloadExportFile(exportId); + onPhaseChange?.('done'); + return { exportId, fileUri }; + } + + if (status === 'failed') { + throw new Error('Data export failed. Please try again.'); + } + + if (status === 'expired') { + throw new Error('Data export expired before it could be downloaded. Please request a new one.'); + } + + await sleep(POLL_INTERVAL_MS); + } + + throw new DataExportTimeoutError(exportId); +} + +/** + * Hands the downloaded export file to the OS share sheet so the user can + * save it (Files app, Drive, etc.) or share it elsewhere. + */ +export async function shareExportFile(fileUri: string): Promise { + const canShare = await Sharing.isAvailableAsync(); + + if (!canShare) { + throw new Error('Sharing is not available on this device. The file was saved to app storage.'); + } + + await Sharing.shareAsync(fileUri, { + mimeType: 'application/json', + dialogTitle: 'Save or share your data export', + }); +}