wrolpi/app/src/test-fixtures.test.js
Roland 9dbc64c112
test: one place for fixtures, real providers instead of mocked context modules
Specs had no shared vocabulary for the app's data or its contexts, so each one
rebuilt both.  A settings object was written out by hand wherever one was needed,
twenty-odd keys at a time, and nothing held those copies to each other or to the
API.  Contexts were worse: to render a consumer a spec mocked the whole context
module, which replaces every export including the providers, so each spec
reinvented the pieces it still needed.  One supplies a `Media` that always
reports desktop -- quietly leaving that component's mobile branch untested -- and
one hand-writes a context as a bare `_currentValue` with no provider, working only
because useContext reads that React internal.

test-fixtures.js is now the single definition of both, shared by jest, the
Cypress component specs, and e2e intercept bodies, so the three cannot disagree
about what the API returns.  Every fixture is a function taking overrides; a
shared mutable object lets one test change what the next one sees.

The drift this prevents was already real.  The theme fixture supplied `i`, `s`
and `t` holding hardcoded Semantic greys for months after ThemeProvider stopped
supplying them, and ThemeContext still declared all four.  So the fixture agreed
with the tests, and with nothing else: FileBrowser was reading `inverted` off the
context and pasting the resulting `undefined` into a className, which is why the
file browser's footer -- near-white #f9fafb, with a `.inverted` dark variant that
nothing could select any more -- stayed light in dark, night and amber.  A white
bar pinned to the bottom of the screen in night mode costs the user exactly the
dark adaptation the theme exists to protect.  It takes tokens now.

test-fixtures.test.js holds each fixture to its context's declared shape in both
directions, so a property added to one and forgotten in the other fails a test.

Two failed attempts are recorded in test-utils.js because both were instructive.
Importing Tags.js and FileWorkerStatusContext.js so the harness could supply
those providers broke eight suites: it put both into the module graph of every
spec ahead of that spec's own mocks, and components bound to a second instance of
a mocked module -- a different jest.fn() than the test had configured, so a hook
mocked to return a value returned undefined, in a file no test mentions.
Requiring them lazily fixed that and not its mirror image: useContext read a
different TagsContext than the harness had required, so the provider was ignored
and the context default won.  A harness must not change what a spec imports, so
it owns only contexts/contexts.js and a spec passes any other context itself.

DomainTagging is converted off the `_currentValue` fake as proof, and now asserts
the tag name a user sees rather than a test id its own mock invented.  The five
remaining specs are listed in a ratchet so the count can only fall.

974 jest, 15 browser component, 46 e2e, clean cache-busted build, tsc clean.
Fixtures are confirmed absent from the shipped bundle.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-05 18:36:48 -06:00

161 lines
7 KiB
JavaScript

import React from 'react';
import fs from 'fs';
import path from 'path';
import {render} from '@testing-library/react';
import {QueryContext, SettingsContext, StatusContext, ThemeContext} from './contexts/contexts';
import {
queryContextFixture,
settingsContextFixture,
statusContextFixture,
themeContextFixture,
} from './test-fixtures';
/*
* The fixtures are only worth having if they match what the app really carries. A fixture
* that has drifted is worse than none: the test passes, the component breaks in a browser,
* and the fixture is the last place anyone looks.
*
* That is not hypothetical here. The theme fixture supplied `i`, `s` and `t` holding
* hardcoded Semantic greys for months after ThemeProvider stopped supplying them, and
* FileBrowser was still reading `inverted` off the context and pasting it into a className --
* so the tests agreed with the fixture, the fixture agreed with nothing, and the file
* browser's footer stayed light in all three dark themes.
*
* Each context's `createContext` default is the declared shape; these hold the fixtures to it
* key for key, in both directions. A property added to a context and forgotten in a fixture
* fails here, and so does one deleted from a context and left in a fixture.
*/
/** Read a context's default by consuming it with no provider above -- public API only. */
const defaultValueOf = (Context) => {
let captured;
const Probe = () => {
captured = React.useContext(Context);
return null;
};
render(<Probe/>);
return captured;
};
describe('context fixtures match the contexts they stand in for', () => {
const cases = [
['ThemeContext', ThemeContext, themeContextFixture],
['StatusContext', StatusContext, statusContextFixture],
['SettingsContext', SettingsContext, settingsContextFixture],
['QueryContext', QueryContext, queryContextFixture],
];
cases.forEach(([name, Context, fixture]) => {
it(`${name} and its fixture declare the same properties`, () => {
expect(Object.keys(fixture()).sort()).toEqual(Object.keys(defaultValueOf(Context)).sort());
});
it(`${name}'s fixture supplies a function wherever the context does`, () => {
// A callback stubbed as a value rather than a function turns into a "not a
// function" crash the first time a component calls it, usually in an event
// handler where the failure surfaces far from the fixture.
const declared = defaultValueOf(Context);
const supplied = fixture();
Object.entries(declared)
.filter(([, value]) => typeof value === 'function')
.forEach(([key]) => expect(typeof supplied[key]).toBe('function'));
});
});
});
describe('fixtures cannot leak state between tests', () => {
it('hands out a new object every call', () => {
// Exported constants let one test mutate what the next one sees; every fixture is a
// function for that reason, and this fails if one is quietly turned back into a
// shared object.
const first = settingsContextFixture();
const second = settingsContextFixture();
expect(first).not.toBe(second);
expect(first.settings).not.toBe(second.settings);
first.settings.wrol_mode = true;
expect(second.settings.wrol_mode).toBe(false);
});
it('applies overrides without discarding the rest of the shape', () => {
const settings = settingsContextFixture({pending: true});
expect(settings.pending).toBe(true);
expect(settings.settings.media_directory).toBe('/media/wrolpi');
});
});
describe('specs still mocking a context module', () => {
/*
* A ratchet, not a prohibition. Mocking a context module replaces every export it has,
* providers included, so each spec that does it reinvents the pieces it still needs --
* one of them supplies a `Media` that always reports desktop, which quietly leaves the
* mobile branch of that component untested, and another hand-writes a context as a bare
* `_currentValue` with no provider at all.
*
* These six can pass their contexts to render() instead. The list is here so the count
* can only fall: converting one means deleting its line, and a new spec reaching for the
* old pattern fails this test rather than joining an unread pile.
*/
const ALLOWED = [
'components/collections/BatchReorganizeModal.test.js',
'components/collections/CollectionEditForm.test.js',
'components/collections/CollectionReorganizeModal.test.js',
'components/collections/CollectionTable.test.js',
'components/collections/CollectionTagModal.test.js',
'hooks/customHooks.test.js',
];
it('is only the specs already known to do it', () => {
const offenders = [];
const walk = (dir) => {
for (const entry of fs.readdirSync(dir, {withFileTypes: true})) {
const full = path.join(dir, entry.name);
if (entry.isDirectory()) walk(full);
else if (/\.test\.js$/.test(entry.name)) {
const source = fs.readFileSync(full, 'utf8');
if (/jest\.mock\('[^']*(contexts\/contexts|FileWorkerStatusContext|\/Tags)'/
.test(source)) {
offenders.push(path.relative(__dirname, full));
}
}
}
};
walk(__dirname);
expect(offenders.sort()).toEqual(ALLOWED);
});
});
describe('the Semantic theme compatibility props are gone for good', () => {
it('no context, fixture, or component carries i/s/t/inverted from the theme', () => {
/*
* These four props are why this whole file exists. They were removed from
* ThemeProvider, but survived in the context default, in the test harness, and in one
* component that read `inverted` and pasted the resulting `undefined` into a
* className. Nothing failed, because the fixture supplied what production did not.
*/
const offenders = [];
const walk = (dir) => {
for (const entry of fs.readdirSync(dir, {withFileTypes: true})) {
const full = path.join(dir, entry.name);
if (entry.isDirectory()) walk(full);
else if (/\.(js|jsx|ts|tsx)$/.test(entry.name)) {
const source = fs.readFileSync(full, 'utf8')
.replace(/\/\*[\s\S]*?\*\//g, '')
.replace(/^\s*\/\/.*$/gm, '');
// Destructuring any of them off ThemeContext, or a bare `inverted:` key
// in a context value.
if (/const\s*\{[^}]*\binverted\b[^}]*}\s*=\s*(React\.)?useContext\(\s*ThemeContext/
.test(source)) {
offenders.push(`${path.relative(__dirname, full)} reads theme.inverted`);
}
}
}
};
walk(__dirname);
expect(offenders).toEqual([]);
});
});