mirror of
https://github.com/Frooodle/Stirling-PDF.git
synced 2025-11-16 01:21:16 +01:00
ab6edd3196
## default
<img width="1012" height="627"
alt="{BF57458D-50A6-4057-94F1-D6AB4628EFD8}"
src="https://github.com/user-attachments/assets/85e550ab-0aed-4341-be95-d5d3bc7146db"
/>
## disabled
<img width="1141" height="620"
alt="{140DB87B-05CF-4E0E-A14A-ED15075BD2EE}"
src="https://github.com/user-attachments/assets/e0f56e84-fb9d-4787-b5cb-ba7c5a54b1e1"
/>
## unzip options
<img width="530" height="255"
alt="{482CE185-73D5-4D90-91BB-B9305C711391}"
src="https://github.com/user-attachments/assets/609b18ee-4eae-4cee-afc1-5db01f9d1088"
/>
<img width="579" height="473"
alt="{4DFCA96D-792D-4370-8C62-4BA42C9F1A5F}"
src="https://github.com/user-attachments/assets/c67fa4af-04ef-41df-9420-65ce4247e25b"
/>
## pop up and maintains version metadata
<img width="1071" height="1220"
alt="{7F2A785C-5717-4A79-9D45-74BDA46DF273}"
src="https://github.com/user-attachments/assets/9374cd2a-b7e5-46c4-a722-e141ab42f0de"
/>
---------
Co-authored-by: Connor Yoh <connor@stirlingpdf.com>
560 lines
19 KiB
TypeScript
560 lines
19 KiB
TypeScript
/**
|
|
* Integration tests for Convert Tool Smart Detection with real file scenarios
|
|
* Tests the complete flow from file upload through auto-detection to API calls
|
|
*/
|
|
|
|
import React from 'react';
|
|
import { describe, test, expect, vi, beforeEach, afterEach, Mock } from 'vitest';
|
|
import { renderHook, act, waitFor } from '@testing-library/react';
|
|
import { useConvertOperation } from '../../hooks/tools/convert/useConvertOperation';
|
|
import { useConvertParameters } from '../../hooks/tools/convert/useConvertParameters';
|
|
import { FileContextProvider } from '../../contexts/FileContext';
|
|
import { PreferencesProvider } from '../../contexts/PreferencesContext';
|
|
import { I18nextProvider } from 'react-i18next';
|
|
import i18n from '../../i18n/config';
|
|
import { detectFileExtension } from '../../utils/fileUtils';
|
|
import { FIT_OPTIONS } from '../../constants/convertConstants';
|
|
import { createTestStirlingFile, createTestFilesWithId } from '../utils/testFileHelpers';
|
|
|
|
// Mock axios (for static methods like CancelToken, isCancel)
|
|
vi.mock('axios', () => ({
|
|
default: {
|
|
CancelToken: {
|
|
source: vi.fn(() => ({
|
|
token: 'mock-cancel-token',
|
|
cancel: vi.fn()
|
|
}))
|
|
},
|
|
isCancel: vi.fn(() => false),
|
|
}
|
|
}));
|
|
|
|
// Mock our apiClient service
|
|
vi.mock('../../services/apiClient', () => ({
|
|
default: {
|
|
post: vi.fn(),
|
|
get: vi.fn(),
|
|
put: vi.fn(),
|
|
delete: vi.fn(),
|
|
interceptors: {
|
|
response: {
|
|
use: vi.fn()
|
|
}
|
|
}
|
|
}
|
|
}));
|
|
|
|
// Import the mocked apiClient
|
|
import apiClient from '../../services/apiClient';
|
|
const mockedApiClient = vi.mocked(apiClient);
|
|
|
|
// Mock only essential services that are actually called by the tests
|
|
vi.mock('../../services/fileStorage', () => ({
|
|
fileStorage: {
|
|
init: vi.fn().mockResolvedValue(undefined),
|
|
storeFile: vi.fn().mockImplementation((file, thumbnail) => {
|
|
return Promise.resolve({
|
|
id: `mock-id-${file.name}`,
|
|
name: file.name,
|
|
size: file.size,
|
|
type: file.type,
|
|
lastModified: file.lastModified,
|
|
thumbnail: thumbnail
|
|
});
|
|
}),
|
|
getAllFileMetadata: vi.fn().mockResolvedValue([]),
|
|
cleanup: vi.fn().mockResolvedValue(undefined)
|
|
}
|
|
}));
|
|
|
|
vi.mock('../../services/thumbnailGenerationService', () => ({
|
|
thumbnailGenerationService: {
|
|
generateThumbnail: vi.fn().mockResolvedValue('data:image/png;base64,fake-thumbnail'),
|
|
cleanup: vi.fn(),
|
|
destroy: vi.fn()
|
|
}
|
|
}));
|
|
|
|
const TestWrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => (
|
|
<I18nextProvider i18n={i18n}>
|
|
<PreferencesProvider>
|
|
<FileContextProvider>
|
|
{children}
|
|
</FileContextProvider>
|
|
</PreferencesProvider>
|
|
</I18nextProvider>
|
|
);
|
|
|
|
describe('Convert Tool - Smart Detection Integration Tests', () => {
|
|
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
|
|
// Mock successful API response
|
|
(mockedApiClient.post as Mock).mockResolvedValue({
|
|
data: new Blob(['fake converted content'], { type: 'application/pdf' })
|
|
});
|
|
});
|
|
|
|
afterEach(() => {
|
|
// Clean up any blob URLs created during tests
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
describe('Single File Auto-Detection Flow', () => {
|
|
test('should auto-detect PDF from DOCX and convert to PDF', async () => {
|
|
const { result: paramsResult } = renderHook(() => useConvertParameters(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const { result: operationResult } = renderHook(() => useConvertOperation(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
// Create mock DOCX file
|
|
const docxFile = createTestStirlingFile('document.docx', 'docx content', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
|
|
|
|
// Test auto-detection
|
|
act(() => {
|
|
paramsResult.current.analyzeFileTypes([docxFile]);
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(paramsResult.current.parameters.fromExtension).toBe('docx');
|
|
expect(paramsResult.current.parameters.toExtension).toBe('pdf');
|
|
expect(paramsResult.current.parameters.isSmartDetection).toBe(false);
|
|
});
|
|
|
|
// Test conversion operation
|
|
await act(async () => {
|
|
await operationResult.current.executeOperation(
|
|
paramsResult.current.parameters,
|
|
[docxFile]
|
|
);
|
|
});
|
|
|
|
expect(mockedApiClient.post).toHaveBeenCalledWith('/api/v1/convert/file/pdf', expect.any(FormData), {
|
|
responseType: 'blob'
|
|
});
|
|
});
|
|
|
|
test('should handle unknown file type with file-to-pdf fallback', async () => {
|
|
const { result: paramsResult } = renderHook(() => useConvertParameters(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const { result: operationResult } = renderHook(() => useConvertOperation(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
// Create mock unknown file
|
|
const unknownFile = createTestStirlingFile('document.xyz', 'unknown content', 'application/octet-stream');
|
|
|
|
// Test auto-detection
|
|
act(() => {
|
|
paramsResult.current.analyzeFileTypes([unknownFile]);
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(paramsResult.current.parameters.fromExtension).toBe('file-xyz');
|
|
expect(paramsResult.current.parameters.toExtension).toBe('pdf'); // Fallback
|
|
expect(paramsResult.current.parameters.isSmartDetection).toBe(false);
|
|
});
|
|
|
|
// Test conversion operation
|
|
await act(async () => {
|
|
await operationResult.current.executeOperation(
|
|
paramsResult.current.parameters,
|
|
[unknownFile]
|
|
);
|
|
});
|
|
|
|
expect(mockedApiClient.post).toHaveBeenCalledWith('/api/v1/convert/file/pdf', expect.any(FormData), {
|
|
responseType: 'blob'
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Multi-File Smart Detection Flow', () => {
|
|
|
|
test('should detect all images and use img-to-pdf endpoint', async () => {
|
|
const { result: paramsResult } = renderHook(() => useConvertParameters(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const { result: operationResult } = renderHook(() => useConvertOperation(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
// Create mock image files
|
|
const imageFiles = createTestFilesWithId([
|
|
{ name: 'photo1.jpg', content: 'jpg content', type: 'image/jpeg' },
|
|
{ name: 'photo2.png', content: 'png content', type: 'image/png' },
|
|
{ name: 'photo3.gif', content: 'gif content', type: 'image/gif' }
|
|
]);
|
|
|
|
// Test smart detection for all images
|
|
act(() => {
|
|
paramsResult.current.analyzeFileTypes(imageFiles);
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(paramsResult.current.parameters.fromExtension).toBe('image');
|
|
expect(paramsResult.current.parameters.toExtension).toBe('pdf');
|
|
expect(paramsResult.current.parameters.isSmartDetection).toBe(true);
|
|
expect(paramsResult.current.parameters.smartDetectionType).toBe('images');
|
|
});
|
|
|
|
// Test conversion operation
|
|
await act(async () => {
|
|
await operationResult.current.executeOperation(
|
|
paramsResult.current.parameters,
|
|
imageFiles
|
|
);
|
|
});
|
|
|
|
expect(mockedApiClient.post).toHaveBeenCalledWith('/api/v1/convert/img/pdf', expect.any(FormData), {
|
|
responseType: 'blob'
|
|
});
|
|
|
|
// Should send all files in single request
|
|
const formData = (mockedApiClient.post as Mock).mock.calls[0][1] as FormData;
|
|
const files = formData.getAll('fileInput');
|
|
expect(files).toHaveLength(3);
|
|
});
|
|
|
|
test('should detect mixed file types and use file-to-pdf endpoint', async () => {
|
|
const { result: paramsResult } = renderHook(() => useConvertParameters(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const { result: operationResult } = renderHook(() => useConvertOperation(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
// Create mixed file types
|
|
const mixedFiles = createTestFilesWithId([
|
|
{ name: 'document.pdf', content: 'pdf content', type: 'application/pdf' },
|
|
{ name: 'spreadsheet.xlsx', content: 'docx content', type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' },
|
|
{ name: 'presentation.pptx', content: 'pptx content', type: 'application/vnd.openxmlformats-officedocument.presentationml.presentation' }
|
|
]);
|
|
|
|
// Test smart detection for mixed types
|
|
act(() => {
|
|
paramsResult.current.analyzeFileTypes(mixedFiles);
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(paramsResult.current.parameters.fromExtension).toBe('any');
|
|
expect(paramsResult.current.parameters.toExtension).toBe('pdf');
|
|
expect(paramsResult.current.parameters.isSmartDetection).toBe(true);
|
|
expect(paramsResult.current.parameters.smartDetectionType).toBe('mixed');
|
|
});
|
|
|
|
// Test conversion operation
|
|
await act(async () => {
|
|
await operationResult.current.executeOperation(
|
|
paramsResult.current.parameters,
|
|
mixedFiles
|
|
);
|
|
});
|
|
|
|
expect(mockedApiClient.post).toHaveBeenCalledWith('/api/v1/convert/file/pdf', expect.any(FormData), {
|
|
responseType: 'blob'
|
|
});
|
|
});
|
|
|
|
test('should detect all web files and use html-to-pdf endpoint', async () => {
|
|
const { result: paramsResult } = renderHook(() => useConvertParameters(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const { result: operationResult } = renderHook(() => useConvertOperation(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
// Create mock web files
|
|
const webFiles = createTestFilesWithId([
|
|
{ name: 'page1.html', content: '<html>content</html>', type: 'text/html' },
|
|
{ name: 'site.zip', content: 'zip content', type: 'application/zip' }
|
|
]);
|
|
|
|
// Test smart detection for web files
|
|
act(() => {
|
|
paramsResult.current.analyzeFileTypes(webFiles);
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(paramsResult.current.parameters.fromExtension).toBe('html');
|
|
expect(paramsResult.current.parameters.toExtension).toBe('pdf');
|
|
expect(paramsResult.current.parameters.isSmartDetection).toBe(true);
|
|
expect(paramsResult.current.parameters.smartDetectionType).toBe('web');
|
|
});
|
|
|
|
// Test conversion operation
|
|
await act(async () => {
|
|
await operationResult.current.executeOperation(
|
|
paramsResult.current.parameters,
|
|
webFiles
|
|
);
|
|
});
|
|
|
|
expect(mockedApiClient.post).toHaveBeenCalledWith('/api/v1/convert/html/pdf', expect.any(FormData), {
|
|
responseType: 'blob'
|
|
});
|
|
|
|
// Should process files separately for web files
|
|
expect(mockedApiClient.post).toHaveBeenCalledTimes(2);
|
|
});
|
|
});
|
|
|
|
describe('Web and Email Conversion Options Integration', () => {
|
|
|
|
test('should send correct HTML parameters for web-to-pdf conversion', async () => {
|
|
const { result: paramsResult } = renderHook(() => useConvertParameters(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const { result: operationResult } = renderHook(() => useConvertOperation(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const htmlFile = createTestStirlingFile('page.html', '<html>content</html>', 'text/html');
|
|
|
|
// Set up HTML conversion parameters
|
|
act(() => {
|
|
paramsResult.current.analyzeFileTypes([htmlFile]);
|
|
paramsResult.current.updateParameter('htmlOptions', {
|
|
zoomLevel: 1.5
|
|
});
|
|
});
|
|
|
|
await act(async () => {
|
|
await operationResult.current.executeOperation(
|
|
paramsResult.current.parameters,
|
|
[htmlFile]
|
|
);
|
|
});
|
|
|
|
const formData = (mockedApiClient.post as Mock).mock.calls[0][1] as FormData;
|
|
expect(formData.get('zoom')).toBe('1.5');
|
|
});
|
|
|
|
test('should send correct email parameters for eml-to-pdf conversion', async () => {
|
|
const { result: paramsResult } = renderHook(() => useConvertParameters(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const { result: operationResult } = renderHook(() => useConvertOperation(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const emlFile = createTestStirlingFile('email.eml', 'email content', 'message/rfc822');
|
|
|
|
// Set up email conversion parameters
|
|
act(() => {
|
|
paramsResult.current.updateParameter('fromExtension', 'eml');
|
|
paramsResult.current.updateParameter('toExtension', 'pdf');
|
|
paramsResult.current.updateParameter('emailOptions', {
|
|
includeAttachments: false,
|
|
maxAttachmentSizeMB: 20,
|
|
downloadHtml: true,
|
|
includeAllRecipients: true
|
|
});
|
|
});
|
|
|
|
await act(async () => {
|
|
await operationResult.current.executeOperation(
|
|
paramsResult.current.parameters,
|
|
[emlFile]
|
|
);
|
|
});
|
|
|
|
const formData = (mockedApiClient.post as Mock).mock.calls[0][1] as FormData;
|
|
expect(formData.get('includeAttachments')).toBe('false');
|
|
expect(formData.get('maxAttachmentSizeMB')).toBe('20');
|
|
expect(formData.get('downloadHtml')).toBe('true');
|
|
expect(formData.get('includeAllRecipients')).toBe('true');
|
|
});
|
|
|
|
test('should send correct PDF/A parameters for pdf-to-pdfa conversion', async () => {
|
|
const { result: paramsResult } = renderHook(() => useConvertParameters(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const { result: operationResult } = renderHook(() => useConvertOperation(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const pdfFile = createTestStirlingFile('document.pdf', 'pdf content', 'application/pdf');
|
|
|
|
// Set up PDF/A conversion parameters
|
|
act(() => {
|
|
paramsResult.current.updateParameter('fromExtension', 'pdf');
|
|
paramsResult.current.updateParameter('toExtension', 'pdfa');
|
|
paramsResult.current.updateParameter('pdfaOptions', {
|
|
outputFormat: 'pdfa'
|
|
});
|
|
});
|
|
|
|
await act(async () => {
|
|
await operationResult.current.executeOperation(
|
|
paramsResult.current.parameters,
|
|
[pdfFile]
|
|
);
|
|
});
|
|
|
|
const formData = (mockedApiClient.post as Mock).mock.calls[0][1] as FormData;
|
|
expect(formData.get('outputFormat')).toBe('pdfa');
|
|
expect(mockedApiClient.post).toHaveBeenCalledWith('/api/v1/convert/pdf/pdfa', expect.any(FormData), {
|
|
responseType: 'blob'
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Image Conversion Options Integration', () => {
|
|
|
|
test('should send correct parameters for image-to-pdf conversion', async () => {
|
|
const { result: paramsResult } = renderHook(() => useConvertParameters(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const { result: operationResult } = renderHook(() => useConvertOperation(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const imageFiles = createTestFilesWithId([
|
|
{ name: 'photo1.jpg', content: 'jpg1', type: 'image/jpeg' },
|
|
{ name: 'photo2.jpg', content: 'jpg2', type: 'image/jpeg' }
|
|
]);
|
|
|
|
// Set up image conversion parameters
|
|
act(() => {
|
|
paramsResult.current.analyzeFileTypes(imageFiles);
|
|
paramsResult.current.updateParameter('imageOptions', {
|
|
colorType: 'grayscale',
|
|
dpi: 150,
|
|
singleOrMultiple: 'single',
|
|
fitOption: FIT_OPTIONS.FIT_PAGE,
|
|
autoRotate: false,
|
|
combineImages: true
|
|
});
|
|
});
|
|
|
|
await act(async () => {
|
|
await operationResult.current.executeOperation(
|
|
paramsResult.current.parameters,
|
|
imageFiles
|
|
);
|
|
});
|
|
|
|
const formData = (mockedApiClient.post as Mock).mock.calls[0][1] as FormData;
|
|
expect(formData.get('fitOption')).toBe(FIT_OPTIONS.FIT_PAGE);
|
|
expect(formData.get('colorType')).toBe('grayscale');
|
|
expect(formData.get('autoRotate')).toBe('false');
|
|
});
|
|
|
|
test('should process images separately when combineImages is false', async () => {
|
|
const { result: paramsResult } = renderHook(() => useConvertParameters(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const { result: operationResult } = renderHook(() => useConvertOperation(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const imageFiles = createTestFilesWithId([
|
|
{ name: 'photo1.jpg', content: 'jpg1', type: 'image/jpeg' },
|
|
{ name: 'photo2.jpg', content: 'jpg2', type: 'image/jpeg' }
|
|
]);
|
|
|
|
// Set up for separate processing
|
|
act(() => {
|
|
paramsResult.current.analyzeFileTypes(imageFiles);
|
|
paramsResult.current.updateParameter('imageOptions', {
|
|
...paramsResult.current.parameters.imageOptions,
|
|
combineImages: false
|
|
});
|
|
});
|
|
|
|
await act(async () => {
|
|
await operationResult.current.executeOperation(
|
|
paramsResult.current.parameters,
|
|
imageFiles
|
|
);
|
|
});
|
|
|
|
// Should make separate API calls for each file
|
|
expect(mockedApiClient.post).toHaveBeenCalledTimes(2);
|
|
});
|
|
});
|
|
|
|
describe('Error Scenarios in Smart Detection', () => {
|
|
|
|
|
|
test('should handle partial failures in multi-file processing', async () => {
|
|
const { result: paramsResult } = renderHook(() => useConvertParameters(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const { result: operationResult } = renderHook(() => useConvertOperation(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
// Mock one success, one failure
|
|
(mockedApiClient.post as Mock)
|
|
.mockResolvedValueOnce({
|
|
data: new Blob(['converted1'], { type: 'application/pdf' })
|
|
})
|
|
.mockRejectedValueOnce(new Error('File 2 failed'));
|
|
|
|
const mixedFiles = createTestFilesWithId([
|
|
{ name: 'doc1.txt', content: 'file1', type: 'text/plain' },
|
|
{ name: 'doc2.xyz', content: 'file2', type: 'application/octet-stream' }
|
|
]);
|
|
|
|
// Set up for separate processing (mixed smart detection)
|
|
act(() => {
|
|
paramsResult.current.analyzeFileTypes(mixedFiles);
|
|
});
|
|
|
|
await act(async () => {
|
|
await operationResult.current.executeOperation(
|
|
paramsResult.current.parameters,
|
|
mixedFiles
|
|
);
|
|
});
|
|
|
|
await waitFor(() => {
|
|
// Should have processed at least one file successfully
|
|
expect(operationResult.current.files.length).toBeGreaterThan(0);
|
|
expect(mockedApiClient.post).toHaveBeenCalledTimes(2);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Real File Extension Detection', () => {
|
|
|
|
test('should correctly detect various file extensions', async () => {
|
|
renderHook(() => useConvertParameters(), {
|
|
wrapper: TestWrapper
|
|
});
|
|
|
|
const testCases = [
|
|
{ filename: 'document.PDF', expected: 'pdf' },
|
|
{ filename: 'image.JPEG', expected: 'jpg' }, // JPEG should normalize to jpg
|
|
{ filename: 'photo.jpeg', expected: 'jpg' }, // jpeg should normalize to jpg
|
|
{ filename: 'archive.tar.gz', expected: 'gz' },
|
|
{ filename: 'file.', expected: '' },
|
|
{ filename: '.hidden', expected: 'hidden' },
|
|
{ filename: 'noextension', expected: '' }
|
|
];
|
|
|
|
testCases.forEach(({ filename, expected }) => {
|
|
const detected = detectFileExtension(filename);
|
|
expect(detected).toBe(expected);
|
|
});
|
|
});
|
|
});
|
|
});
|