wrolpi/app/src/test-utils.js
Roland 528a5702d0
ui: migrate the extension pages and Configs; five components they needed
Phase 2, part 1.  Three files leave Semantic UI (baseline 75 -> 72), and the
components they needed join the library and the gallery:

  Header       Semantic's shape (as/icon/subheader/dividing).  47 files use
               <Header>, and the level now picks the size, so the type scale
               stays a scale instead of each call site choosing a font size.
  Message      gains an icon and a dismiss button.
  ActionInput  input and button sharing one outline, for <Input action={...}/>.
  Loading      centered loader with a caption, replacing the
               <Loader active inline='centered'> + wrapper div in 19 places.
  Modal        becomes compound - Modal.Header/.Content/.Actions, plus
               Semantic's open, closeIcon, and size names - because 34 files
               are written against that shape.

test-utils mounts MantineProvider with ThemeProvider's exact configuration:
migrated components render Mantine internals and every one of their test files
would otherwise need its own provider.

One Semantic bleed found and fixed: semantic.min.css sets
`h1,h2,h3,h4,h5 { font-family: Lato }` and loads after Mantine's element rule,
so headings ignored the theme's body face.  Only visible in amber, where the
body is mono and the headings were not.  A class-level restatement outranks it;
the rule comes out when Semantic does.

Verified: 925 jest tests, clean production build, and a night-mode audit of
every painted pixel in the gallery (red-only, one known false positive).  The
Configs backup and restore flow was exercised against the real API.
2026-08-05 18:34:46 -06:00

320 lines
9.5 KiB
JavaScript

/**
* Test utilities for React Testing Library
* Provides custom render functions with necessary context providers
*/
import React, {createContext, useContext} from 'react';
import {render} from '@testing-library/react';
import {BrowserRouter} from 'react-router';
import {MantineProvider} from '@mantine/core';
import {MediaContextProvider, ThemeContext} from './contexts/contexts';
import {cssVariablesResolver, mantineTheme} from './themes/mantine';
// Mock FileWorkerStatusContext for tests - avoids API calls during testing
const MockFileWorkerStatusContext = createContext(null);
function MockFileWorkerStatusProvider({children}) {
const mockValue = {
status: null,
error: null,
refresh: jest.fn(),
setFastPolling: jest.fn(),
};
return (
<MockFileWorkerStatusContext.Provider value={mockValue}>
{children}
</MockFileWorkerStatusContext.Provider>
);
}
// Re-export hooks that use the mock context
export function useFileWorkerStatus() {
const context = useContext(MockFileWorkerStatusContext);
if (!context) {
throw new Error('useFileWorkerStatus must be used within FileWorkerStatusProvider');
}
return context;
}
export function useReorganizationStatus() {
const {status: progress, refresh} = useFileWorkerStatus();
return {
isReorganizing: false,
taskType: null,
collectionId: null,
collectionKind: null,
batchStatus: null,
workerStatus: progress,
refresh,
};
}
/**
* Custom render function that wraps components with necessary providers
* @param {React.Component} ui - Component to render
* @param {Object} options - Render options
* @param {boolean} options.inverted - Whether to use dark theme
* @param {Object} options.themeContext - Custom theme context values
* @param {boolean} options.withMedia - Include MediaContextProvider (default: false)
* @param {Object} options.renderOptions - Additional React Testing Library options
*/
export function renderWithProviders(
ui,
{
inverted = false,
themeContext = {},
withMedia = false,
...renderOptions
} = {}
) {
const defaultThemeContext = {
inverted,
setInverted: jest.fn(),
// Theme components use different properties:
i: inverted ? {inverted: true} : {inverted: undefined}, // For Semantic UI elements (Segment, Form, etc.)
s: inverted ? {style: {backgroundColor: '#1B1C1D', color: '#dddddd'}} : {}, // For style inversion
t: inverted ? {style: {color: '#eeeeee'}} : {}, // For text color inversion (Header, etc.)
theme: inverted ? 'dark' : 'light',
isDark: inverted,
savedTheme: null,
setTheme: jest.fn(),
setDarkTheme: jest.fn(),
setLightTheme: jest.fn(),
cycleSavedTheme: jest.fn(),
...themeContext
};
function Wrapper({children}) {
// MantineProvider, configured exactly as ThemeProvider configures it: components
// from src/components/ui render Mantine internals and need it in the tree.
const content = (
<BrowserRouter>
<MantineProvider
theme={mantineTheme}
cssVariablesResolver={cssVariablesResolver}
forceColorScheme={inverted ? 'dark' : 'light'}
>
<MockFileWorkerStatusProvider>
<ThemeContext.Provider value={defaultThemeContext}>
{children}
</ThemeContext.Provider>
</MockFileWorkerStatusProvider>
</MantineProvider>
</BrowserRouter>
);
// Only wrap with MediaContextProvider if explicitly requested
// (since it requires window.matchMedia which can be tricky in tests)
if (withMedia) {
return <MediaContextProvider>{content}</MediaContextProvider>;
}
return content;
}
return render(ui, {wrapper: Wrapper, ...renderOptions});
}
/**
* Creates a mock domain collection object for testing
*/
export function createMockDomain(overrides = {}) {
return {
id: 1,
domain: 'example.com',
archive_count: 42,
size: 1024000,
tag_name: null,
directory: '',
can_be_tagged: false,
description: '',
...overrides
};
}
/**
* Creates multiple mock domains for list testing
*/
export function createMockDomains(count = 3) {
return Array.from({length: count}, (_, i) => createMockDomain({
id: i + 1,
domain: `example${i + 1}.com`,
archive_count: (i + 1) * 10,
size: (i + 1) * 1000000,
}));
}
/**
* Mock fetch implementation for API calls
*/
export function mockFetch(data, options = {}) {
const {
ok = true,
status = 200,
delay = 0,
} = options;
return jest.fn(() =>
new Promise((resolve) => {
setTimeout(() => {
resolve({
ok,
status,
json: async () => data,
text: async () => JSON.stringify(data),
});
}, delay);
})
);
}
/**
* Mock API error response
*/
export function mockFetchError(error = 'An error occurred', status = 400) {
return jest.fn(() =>
Promise.resolve({
ok: false,
status,
json: async () => ({error}),
text: async () => error,
})
);
}
/**
* Wait for async updates to complete
* Useful for testing loading states
*/
export async function waitForLoadingToFinish() {
const {waitFor} = await import('@testing-library/react');
await waitFor(() => {
}, {timeout: 100});
}
/**
* Test helper to render components in dark mode
*
* Usage:
* renderInDarkMode(<MyComponent />)
*
* Verify inverted styling is applied:
* const element = container.querySelector('.ui.segment.inverted');
* expect(element).toBeInTheDocument();
*/
export function renderInDarkMode(ui, options = {}) {
return renderWithProviders(ui, {
inverted: true,
...options
});
}
/**
* Test helper to render components in light mode
* (This is the default, but provided for explicitness in tests)
*/
export function renderInLightMode(ui, options = {}) {
return renderWithProviders(ui, {
inverted: false,
...options
});
}
/**
* Helper to check if an element has theme-aware (inverted) styling
* Returns true if the element has the 'inverted' class
*
* Usage:
* const segment = container.querySelector('.ui.segment');
* expect(hasInvertedStyling(segment)).toBe(true);
*/
export function hasInvertedStyling(element) {
return element && element.classList.contains('inverted');
}
/**
* Creates a test-friendly form object using real useForm hook
*
* This uses the actual useForm implementation, making tests more reliable.
* The form starts in a "ready" state with the provided data.
*
* Usage:
* const form = createTestForm({domain: 'test.com', directory: '/path'});
* render(<CollectionEditForm form={form} metadata={metadata} />);
*
* // With overrides:
* const form = createTestForm(data, {overrides: {loading: true, disabled: true}});
*/
export function createTestForm(initialData = {}, config = {}) {
// Return a plain object that mimics the useForm interface without actual React hooks
// This avoids async state updates that cause act() warnings in tests
const _ = require('lodash');
const formData = {...initialData};
const setValue = (path, newValue) => {
_.set(formData, path, newValue);
};
const form = {
formData,
ready: true,
loading: false,
disabled: false,
dirty: false,
error: null,
errors: {},
// Methods that update formData directly
patchFormData: jest.fn((updates) => {
Object.assign(formData, updates);
}),
reset: jest.fn(() => {
Object.keys(formData).forEach(key => delete formData[key]);
Object.assign(formData, initialData);
}),
onSubmit: config.submitter || jest.fn(async () => initialData),
// Input helpers
setError: jest.fn(),
setValidator: jest.fn(),
setValidValue: jest.fn(),
setRequired: jest.fn(),
// Property getter for field values
get: (path) => _.get(formData, path),
setValue: jest.fn((path, value) => setValue(path, value)),
// getCustomProps - mimics the real useForm method
getCustomProps: ({name, path, required = false, type = 'text'}) => {
path = path || name;
const value = _.get(formData, path);
const inputProps = {
type,
disabled: form.disabled,
value: value !== undefined ? value : (type === 'array' ? [] : null),
onChange: (newValue) => {
setValue(path, newValue);
},
'data-path': path,
};
const inputAttrs = {
valid: true,
path,
localSetValue: (newValue) => setValue(path, newValue),
};
return [inputProps, inputAttrs];
},
};
// Apply any overrides
if (config.overrides) {
Object.assign(form, config.overrides);
}
return form;
}
// Re-export everything from React Testing Library
export * from '@testing-library/react';
// Override the default render with our custom one
export {renderWithProviders as render};