fix: Immich outage handling, image tiers, admin save safety (#394)
* fix: migrate deprecated middleware convention to proxy Next.js 16 deprecated the `middleware` file convention in favour of `proxy`. The build warned on every run, and the convention is slated for removal in a future major — at which point Next.js would silently stop invoking this file. That is not a cosmetic failure: proxy.ts owns the Content-Security-Policy and the per-request nonce, so an uninvoked file means every document response ships with no CSP at all, with nothing in the build output to catch it. Renames middleware.ts to proxy.ts and the exported middleware() to proxy(), per the official migration. The config.matcher export is unchanged, so route coverage is identical. Adds lib/__tests__/proxy.test.ts, which pins the export name and verifies the behaviour a silent regression would take out: a CSP is set, the nonce in the policy matches the one forwarded to pages via x-nonce, nonces differ per request, x-pathname still reaches the root layout, and the matcher continues to cover /admin. Verified: tsc 0 errors, 105 unit tests passing (98 before), production build succeeds with 0 deprecation warnings. * fix: stop reporting Immich outages as missing albums lib/immich.ts request() returned null for every failure mode: a 5xx, a rejected API key, a network error, and a non-JSON body all looked exactly like "Immich answered and said this does not exist". Callers had no way to tell the two apart, and app/[...path]/page.tsx calls notFound() on a null album in five places. The result was that while Immich was down or returning 5xx, every album URL served a hard 404 — for albums that exist. Visitors saw "not found", and crawlers were free to de-index real content over a transient outage. request() now throws ImmichUnavailableError for anything that is not a definitive answer about the resource, and reserves null for 404 and 410. Pages let that propagate, so an outage surfaces as a 500 rather than a 404. Two callers must not propagate and are handled explicitly: - ping() catches and returns false — it answers "is Immich reachable", and both callers (/api/health, /api/admin/status) render that as a status field. - /api/exif and /api/map return 503 with Retry-After instead of 404 and an empty marker list respectively. An empty map is otherwise indistinguishable from a gallery with no GPS data. Adds 10 tests: each failure mode maps to the right outcome, getAlbum and getAlbums propagate rather than reporting empty, ping stays non-throwing, and a failed request leaves no stale entry in the in-flight coalescing map — which would otherwise replay the failure after Immich recovered. Verified: tsc 0 errors, 115 unit tests passing (105 before), production build exit 0, eslint 0 errors on all touched files. * fix: bound how long Immich requests may hang lib/immich.ts set no timeout on any of its three fetch call sites, so the only ceiling was undici's built-in default, measured in minutes. Every page is force-dynamic, which means an Immich that accepts connections but never answers held each visitor's render open for that whole window — and since nothing caches the failure, load kept arriving. Adds IMMICH_TIMEOUT_MS (default 15000, floored at 1000 so a stray 0 cannot mean "no timeout"), threaded through env.ts and AppConfig like CACHE_TTL. The two kinds of call need different treatment: - request() carries a whole-exchange AbortSignal.timeout(). JSON payloads are small, so one budget can cover headers and body. - streamAsset()/streamVideo() use an AbortController whose timer is cleared in a finally the moment response headers arrive. A large original photo or a long video is legitimately slow to transfer; a whole-request timeout would truncate playback and break seeking, since every range request would restart the clock. A timed-out request surfaces as ImmichUnavailableError naming the budget, so a misconfigured value is diagnosable from the log line alone. Adds 5 tests, including the two that pin the distinction: a stream whose headers have arrived is not aborted an hour later, while a stream that never sends headers still is. Verified: tsc 0 errors, 120 unit tests passing (115 before), production build exit 0, no new eslint errors (the one error in env.ts is pre-existing — confirmed against a clean tree). * fix: stop caching Immich outages as permanently missing media f3 split "gone" from "unavailable" in request(), but streamAsset() and streamVideo() have their own fetch calls and were left returning null for every failure. Both proxy routes turn null into a 404. That 404 carried no Cache-Control, and a 404 is heuristically cacheable per RFC 9111 — on URLs the success path serves as `immutable`. So a transient outage, or a timeout introduced in 370e668, could pin a broken image or an unplayable video in the visitor's browser cache well after Immich recovered. Both stream methods now throw ImmichUnavailableError for transport failures, timeouts, and any error status other than 404/410, and reserve null for genuinely absent media. A 200 with no body counts as unavailable, not as missing. The routes translate that into 503 with Retry-After, and both error responses — the 503 and the real 404 — now send Cache-Control: no-store. streamVideo keeps accepting 206, so range requests and seeking are unaffected. Adds 7 tests covering each failure mode for both methods plus the 206 path, and updates the F4 timeout test, which asserted the old null return. Verified: tsc 0 errors, 127 unit tests passing (120 before), production build exit 0, eslint 0 errors on touched files. * perf: cache "does not exist" answers from Immich getAlbum() and getAssetInfo() cached successes but discarded a definitive "not found", so a missing resource was re-queried upstream on every call. Measured before: 5 sequential lookups of a missing asset produced 5 upstream fetches. After: 1. This is not hypothetical. app/page.tsx resolves every gallery.yaml hero ID through getAssetInfo() on each render, and the homepage is force-dynamic — so a hero photo deleted from Immich but still listed in gallery.yaml cost one 404 round-trip per page view, indefinitely. Absence is stored as a frozen MISSING sentinel because the cache cannot distinguish a miss from a stored null; both read back as null. Only definitive 404/410 answers are cached. An outage throws ImmichUnavailableError and is deliberately never stored — caching one would keep the gallery broken after Immich recovered. A test pins that: a 503 followed by a healthy response must reach Immich the second time. Stored under the normal cacheTtl rather than a separate shorter negative TTL, because the reason for a shorter one no longer applies: outages are not cached at all now, and both invalidation paths (the Immich webhook and the admin save/reload) clear the entry immediately, so a corrected asset ID takes effect at once rather than waiting out a TTL. Also raises the test config's cacheTtl from 0, which expired entries in the same millisecond they were written and would have made any caching assertion flaky. Test isolation comes from cache.clear() in beforeEach. Verified: tsc 0 errors, 131 unit tests passing (127 before), production build exit 0, eslint 0 errors on touched files. * fix: add themed error and not-found pages The app had no app/error.tsx, app/not-found.tsx or global-error.tsx, so every failure fell through to Next.js's unstyled default page. That gap became visible with 253ade0, which made an Immich outage produce a 500 instead of a false 404 — correct, but what a visitor saw was a bare framework error screen with none of the site's theming. The two pages also carry the distinction the error split was for, and they carry it structurally rather than by inspecting the error: notFound() renders not-found.tsx, a throw renders error.tsx. That matters because Next.js strips error messages in production and replaces them with a digest — this component genuinely cannot tell an Immich outage from any other server error, so it does not claim to. It frames the failure as temporary and offers reset(); not-found.tsx deliberately does not, since a real 404 is not transient. The digest is shown so a user report can be traced to a log line. The raw error message is never rendered — it can carry an upstream URL, a header or a config value. Both pages reuse .empty-state, which existed in globals.css but was unreferenced anywhere in the app; extended with title, actions and button elements matching the PasswordGate button, the only other action button in the codebase. Tested by server-rendering both components (react-dom/server, no new dependencies) — 8 tests covering the styling hook, the retry and home affordances, digest handling, and that a message containing an API key or host address does not reach the markup. Note vitest.config.ts only includes lib/__tests__/**/*.test.ts, so the test uses createElement rather than JSX; a .tsx file there would never run. Not verified in a browser: this worktree has no .env.local and only .example content files, so the app boots into setup mode and neither Playwright nor a dev server can exercise these routes here. Verified: tsc 0 errors, 139 unit tests passing (131 before), production build exit 0 with /_not-found registered, eslint 0 errors. * perf: drop the unused originalUrl from every photo item PhotoItem declared originalUrl and toPhotoItems computed it for every asset, but a repo-wide grep found exactly two references: the field declaration and the assignment. Nothing ever read it — the grid uses thumbUrl, the lightbox uses previewUrl. The cost was not the encryption. PhotoItem is a server-to-client prop, so the dead field was serialized into the RSC payload and shipped to the browser for every photo. Measured: 137 bytes per asset once serialized, so 6.7 KB for a 50-photo album and 66.9 KB for a 500-photo one — transferred and parsed on every page view, never read. Removed rather than wired up to a "view original" affordance. Exposing full-size originals is a bandwidth and privacy decision for the project to make deliberately, not something to infer from a dangling field. No unit test: this is a deletion whose correctness is exactly "nothing referenced it", which tsc and a repo-wide grep already establish. A test asserting the absence of a field would restate the type checker. Verified: tsc 0 errors, 139 unit tests passing, production build exit 0, eslint unchanged at 4 pre-existing errors on the touched files (unused imports, confirmed identical against a stashed clean tree). * chore: remove four orphaned imports from the catch-all route Link, Image, PhotoGrid and BackLink were imported by app/[...path]/page.tsx and never used — 4 of the 6 no-unused-vars errors in the repo baseline. Verified they are leftovers, not a dropped render path: PhotoGrid and BackLink are both rendered by AlbumDetailView, which imports them itself, and BackLink is also used by the impressum and map pages. Rendering was extracted out of page.tsx into AlbumDetailView/SubpageGridView at some point and the imports stayed behind. `type PhotoItem` is still needed by toPhotoItems, so that import narrows to a type-only import rather than disappearing. No bundle win, measured: .next/static is 1084 KB across 20 JS chunks both before and after, byte-identical. Turbopack already tree-shook them. The backlog note that predicted unused client-component imports would hold them in the client graph was wrong, and has been corrected there. The value is readability and lint: repo errors drop from 54 to 50, and page.tsx no longer reads as though it renders the grid itself. chore: rather than fix:/perf: — nothing behaves differently and the measurement showed no performance change, so either of those labels would misdescribe it. CLAUDE.md lists chore: as a valid prefix. Verified: tsc 0 errors, 139 unit tests passing, production build exit 0, eslint 0 errors on the touched file. * fix: make ?w= able to narrow the image tier instead of being ignored The image proxy resolved its Immich rendition with `?size=` winning whenever present, falling back to `?w=` otherwise. lib/urls.ts always writes `?size=`, so for every URL this app generates the width branch was unreachable and widthToSize() was dead code — while CLAUDE.md documented the width mapping as the actual behaviour. `?size=` is now a ceiling rather than an override: when both are present the smaller tier wins, so a width can narrow the request but never widen it. That asymmetry is the point. Letting width win outright — the obvious reading of the docs — would have been a real regression: next/image emits widths up to 3840 and widthToSize(1920) is 'original', so every large display would have started downloading full-size originals in place of previews. A test pins that specific case. No measured change today. The only URLs carrying both parameters are ?size=preview with next/image widths, whose smallest vw-based deviceSize is 640 — already preview either way. This is a correctness fix that makes the documented contract true and testable, not a performance win. Moved the logic to lib/imageSize.ts so it can be tested at all: vitest.config.ts only collects lib/__tests__, so nothing inside a route file is reachable from the suite. 9 tests cover the tier boundaries, both single-parameter paths, malformed input, and the ceiling behaviour. CLAUDE.md updated to describe the ceiling rule rather than a plain width mapping. Verified: tsc 0 errors, 148 unit tests passing (139 before), production build exit 0, eslint 0 errors on touched files. * fix: validate the per-album heroImage UUID from gallery.yaml Every asset ID in gallery.yaml is routed through validateUuid before it can reach encodeAssetId, which encrypts whatever it is handed. One was not: for a per-album entry the album ID (the map key) was validated while the heroImage value was stored raw. A typo there produced a perfectly well-formed image URL that 404s forever, with nothing in the log naming the cause — the failure surfaced as a broken hero image on an album page, far from the line that caused it. This is narrower than the finding that prompted it, which proposed guarding encodeAssetId itself. Validation belongs at config load, where it runs once and can name the file and the album; a guard in encodeAssetId would run on every render and duplicate validateUuid at the wrong layer. The heroImage path was the only unvalidated route into it. validateUuid warns and substitutes the nil UUID rather than throwing, so a bad ID still degrades to a missing image instead of taking the page down — and since f511e62 that 404 is negative-cached, so it costs one upstream request rather than one per render. Adds 4 tests. The two that pin the wiring were mutation-checked: both fail against the unfixed code and pass with it. Verified: tsc 0 errors, 152 unit tests passing (148 before), production build exit 0, eslint 0 errors on touched files. * fix: keep /admin reachable when gallery.yaml cannot be derived getConfig() throws on three shapes the admin page builder is able to write: a gallery with neither albums nor subpages, a subpage with no name, and a subpage with neither albums nor sections. RootLayout called it unguarded, and a throw in a *layout* is not caught by app/error.tsx — that needs a global-error boundary, which this app does not have. /admin renders inside that same layout, so one bad save took down the site together with the only tool that could undo it. Recovery meant editing content/gallery.yaml on the host, or exec'ing into the container. This is issue #326's failure mode reached through an invalid config instead of a missing one. Adds getConfigOrNull(), which returns null rather than throwing and logs the underlying error plus the path to content/.backups/. The layout treats null exactly like needsSetup: setup screen for visitors, children rendered for admin paths so the panel still loads. generateMetadata() is guarded too — it also calls getConfig(), and it also runs before any error boundary. This is the half of the finding that makes every broken config recoverable, including ones this app never wrote: a hand-edited file, a restored backup, a config from an older version. The other half — validating in the admin PUT so the bad state is never written — is filed separately; it prevents new breakage but cannot repair existing breakage, so it was not the one to do first. Adds 10 tests. Three pin the premise by asserting getConfig() really does throw on each shape, so the fallback cannot quietly become dead weight. One asserts the needsSetup path still returns a config rather than null, since missing and invalid are different states that must not collapse. Not verified in a browser: this worktree has no .env.local and only .example content files, so the layout/error-boundary interaction is reasoned from Next.js semantics and covered at the getConfig level only. Verified: tsc 0 errors, 162 unit tests passing (152 before), production build exit 0, eslint 0 errors on touched files. * fix: reject an admin save the site would not be able to load The admin PUT validated only the shape of the hero field, then wrote. None of getConfig()'s three throw conditions was checked, so the page builder could persist a gallery.yaml that cannot be loaded — and the user got "Saved successfully" for it. Since 95877af that no longer locks anyone out, but the public site still drops to the setup screen until someone notices. Extracts the gallery half of getConfig() into deriveGallery(), which the route now runs against the proposed gallery before writing. Two alternatives were rejected on purpose: - Re-checking the three conditions in the route would put a second copy of the rules next to the first, and the two would drift. - Write-then-verify-then-roll-back leaves a window in which other requests read the broken config. The extraction is a pure move: no logic changed inside it, and all 162 pre-existing tests pass untouched, which is what makes that claim checkable rather than asserted. The 400 carries the derivation's own message, so the admin UI names the offending subpage instead of saying "invalid gallery" — a builder with a dozen subpages needs to know which one. A test pins that the message identifies it. Adds 8 tests: each rejected shape, the named-subpage message, and the valid structures (standalone albums, subpage membership, sections, per-album overrides and hero images) so the extraction cannot silently lose behaviour. Verified: tsc 0 errors, 170 unit tests passing (162 before), production build exit 0, eslint 0 errors on touched files. * fix: hash subpage passwords off the main thread verifyScrypt used crypto.scryptSync, measured at 22.8ms per call — 22.8ms during which the Node process serves nothing else, because the sync variant runs on the main thread rather than the libuv threadpool. The /api/auth rate limit does not contain this. It allows 10 attempts per minute, but the bucket key is the client IP, and with the default TRUSTED_PROXY_HOPS=0 that IP is read from x-real-ip / x-forwarded-for — both attacker-controlled. lib/rate-limit.ts already documents that those headers are spoofable at hops=0; what followed from it was not written down anywhere: one attacker rotating a header gets unlimited buckets, and each request buys 22.8ms of dead process. Roughly 44 requests per second saturates it. Switches verifyScrypt and generateScryptHash to the async crypto.scrypt, which runs on the threadpool. This does not stop the spoofing — that is inherent to hops=0 and already documented — it removes the amplification that made spoofing worth doing. authenticate() becomes async. It had exactly one caller (app/api/auth/route.ts). isAuthenticated() is deliberately left synchronous: it only computes an HMAC, and it is called from server components. Adds 4 tests, two of which pin the fix and were mutation-checked against the old implementation — both fail with scryptSync and pass with scrypt. One asserts scryptSync is never called; the other asserts a 2ms interval still fires during a hash, which is the property that actually matters. A slower machine lengthens the hash and yields more ticks, so that test fails on a blocked loop rather than on a busy one. Also adds a scrypt-hashed fixture subpage, so the suite exercises verifyScrypt rather than only the deprecated plaintext fallback. Verified: tsc 0 errors, 174 unit tests passing (170 before), production build exit 0, eslint 0 errors on touched files. * fix: warn when TRUSTED_PROXY_HOPS cannot identify a client getClientIp falls back to a shared 'unknown' bucket whenever the X-Forwarded-For chain is shorter than the configured hop count, or the header is absent with hops > 1. That fallback is correct — the alternative is trusting a spoofable entry — but it was silent, and silence is the problem. Every unidentified request shares one bucket per endpoint, and this is an image proxy: a single 50-photo grid issues ~50 /api/image requests, so the default RATE_LIMIT_RPM=1500 is collectively spent by roughly 30 page loads a minute. Someone who sets TRUSTED_PROXY_HOPS=2 for Cloudflare-plus-nginx and then reaches nginx directly gets a site that 429s everyone, with nothing in the log pointing at the cause. Warns once per process, naming the configured hop count and what was actually seen — the chain length, or which header was missing. Once, not per request: enough to diagnose without flooding the log. The fallback itself is unchanged. Trusting a shorter chain would hand every client its own bucket key and defeat the limiter entirely. No warning at hops=0, where the shared bucket is the documented consequence of not declaring a proxy rather than a misconfiguration. Adds 6 tests covering each fall-through path, the once-per-process behaviour, and both silence cases. The once-per-process flag needs a test seam to re-arm, hence the __resetProxyWarningForTests export. Verified: tsc 0 errors, 180 unit tests passing (174 before), production build exit 0, eslint 0 errors on touched files. * fix: send Retry-After on every rate-limited response /api/image, /api/video and /api/exif each computed the retry delay, interpolated it into a console.warn, and then returned a 429 without it — the number was calculated and thrown away. /api/og did not compute it at all. Only /api/auth and /api/map sent the header. This matters more for an image proxy than for a typical API: one gallery page issues around fifty /api/image requests, so a burst that trips the limit produces fifty rejections carrying no back-off signal. The browser and next/image then retry on their own schedule — a retry storm against a server that just reported it was overloaded. Adds Retry-After and Cache-Control: no-store to all four. no-store because the success path serves these same URLs as `immutable`. The delay now comes from a shared retryAfterSeconds() helper rather than an inline Math.ceil in each route, which also fixes an edge every copy shared: a window on the point of expiring yields 0, and Retry-After: 0 tells the client to retry immediately, which is the opposite of what a 429 means. A resetAt already in the past yields a negative number, which is not valid HTTP. The helper floors at 1. The three routes that already sent the header (/api/auth, /api/map, /api/admin/auth) and /api/health now use the helper too — leaving four copies of the buggy arithmetic behind while centralising the rest would have been worse than not centralising at all. Adds 2 tests, one of them specifically for the zero-and-negative edge. Verified: tsc 0 errors, 182 unit tests passing (180 before), production build exit 0, eslint 0 errors on all ten touched files. * fix: add an escape hatch for stale browser image caches Image and video responses are served `Cache-Control: public, max-age=31536000, immutable`, so a browser does not revalidate them for a year — the ETag is not even consulted. When Immich regenerates thumbnails after a job re-run, or a photo is rotated, the asset ID does not change, so neither does the deterministic token or the URL. Visitors keep the old rendition, and the webhook that clears the server-side caches cannot reach a browser. The only existing remedy was rotating AUTH_SECRET, which invalidates every token on the site. Corrects the framing this started from. The finding described it as an ETag problem, but `immutable` means the ETag is never reached in the case that matters. The URL is the only lever a browser cache responds to, so the buster belongs there. It is also mixed into the ETag, since a matching ETag across two different URLs would be wrong regardless. Adds IMAGE_CACHE_VERSION, empty by default. Unset, the generated URLs are byte-identical to before — a test asserts exactly that, because a cache-busting feature that changes URLs when nobody asked for it would silently discard every visitor's cache on deploy. The value is URL-encoded at parse time; an unescaped one could otherwise inject query parameters into every image URL on the site. Deliberately not done: shortening max-age or dropping `immutable`. Both trade a large, real bandwidth win for a rare correctness case, and the cost is not measurable from this worktree. The aggressive caching stays the default; this only adds a way out. Adds 6 tests: default-unchanged, whitespace treated as unset, both URL shapes, escaping, and that a bump changes the query while leaving the token intact. Verified: tsc 0 errors, 188 unit tests passing (182 before), production build exit 0, eslint unchanged (the one error in env.ts is pre-existing, confirmed against a stashed tree). * security: validate the backup filename before restoring from it restoreBackup() joined its argument straight into a path and copied the result over a content file. path.join resolves `..`, so restoreBackup('../../../../etc/passwd') would have written any readable file over content/settings.yaml — whose contents the admin GET endpoints hand straight back. The destination was chosen by backupFilename.includes('gallery.yaml'), which is substring matching on the same attacker-supplied string, so the caller picked that too. Not exploitable today: the function has zero callers. That is precisely why it was worth fixing rather than leaving — it is an exported function carrying a traversal bug, waiting for whoever wires up the restore button the admin panel does not yet have. Hardened rather than deleted. The status endpoint already reports backup counts, so restore is plainly intended; removing a half-built feature is the maintainer's call, not a side effect of a security fix. The name must now match the pattern this service itself produces, and the destination is derived from the matched group rather than a substring search. The redundant basename check is kept on purpose: it preserves the guarantee if that pattern is ever loosened. Adds 12 tests. Nine of them fail against the unguarded version — mutation-checked by removing the guard and confirming, rather than assuming they would. Verified: tsc 0 errors, 200 unit tests passing (188 before), production build exit 0, eslint 0 errors on touched files. * fix: give each admin save its own temp file writeYamlFile wrote to a constant `${filePath}.tmp` before renaming. The rename is what makes the write atomic; the temp filename was not. Two saves of the same file in flight at once shared that path, so the second writeFile could interleave with the first's rename — publishing one save's bytes under the other's, or a truncated mix of both. A double-clicked Save in the page builder is enough to reach it. The temp name now carries the pid and a per-process counter, so concurrent writers cannot collide either within a process or across workers. Also wraps the write and rename so a failure unlinks the temp file instead of leaving it in content/. The cleanup swallows its own errors: failing to tidy up must not replace the real error with a misleading one. Adds 7 tests, and both halves were mutation-checked independently — reverting to the fixed temp path fails two of them, removing the cleanup fails two others. Two of the tests exist to pin properties that are easy to regress silently: that the rename targets the temp file just written, and that the happy path issues no unlink. Verified: tsc 0 errors, 207 unit tests passing (200 before), production build exit 0, eslint 0 errors on touched files. * fix: await the stream-timeout rejection before advancing timers `npm run test:unit` exited 1 even though all 207 tests passed. The timeout test started `streamAsset`, advanced the fake timers past the 15s budget, and only then attached the rejection expectation. The abort fires *during* `advanceTimersByTimeAsync`, so for one microtask turn the promise was rejected with no handler attached — Node reports that as an unhandled rejection, and vitest fails the whole run on it regardless of test outcomes. CI would have blocked on a green suite. Attaching the assertion before advancing the timers fixes the ordering without weakening it: the same rejection and the same `captured.aborted` check still run, just awaited after the advance rather than created after it. Verified: vitest exit 0, 207/207 passing, tsc 0 errors, prettier clean. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> --------- Co-authored-by: ralksta <ralksta@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ralksta
@@ -1,4 +1,5 @@
|
||||
import { describe, it, expect, vi, afterEach } from 'vitest';
|
||||
import crypto from 'crypto';
|
||||
|
||||
// Mock config to provide a predictable API key and subpage config
|
||||
vi.mock('@/lib/config', () => ({
|
||||
@@ -18,6 +19,15 @@ vi.mock('@/lib/config', () => ({
|
||||
albumIds: ['00000000-0000-0000-0000-000000000002'],
|
||||
// no password
|
||||
},
|
||||
{
|
||||
name: 'Hashed',
|
||||
slug: 'hashed',
|
||||
albumIds: ['00000000-0000-0000-0000-000000000003'],
|
||||
// scrypt hash of 'scrypted-pass' with a fixed salt — exercises the
|
||||
// verifyScrypt path rather than the deprecated plaintext fallback.
|
||||
password:
|
||||
'scrypt:0123456789abcdef0123456789abcdef:4850eef18a09612ef11fdcd943bf64ce98d0eca2b0f677f9c0c51d1f648b8a101cf7ea36b6f94cfc05236b2fda6fffabd0929dc7e14c07626522fba68bf26de5',
|
||||
},
|
||||
],
|
||||
}),
|
||||
}));
|
||||
@@ -51,27 +61,64 @@ describe('isProtected', () => {
|
||||
});
|
||||
|
||||
describe('authenticate', () => {
|
||||
it('returns a Set-Cookie string for the correct password', () => {
|
||||
const cookie = authenticate('private', 'secret123');
|
||||
it('returns a Set-Cookie string for the correct password', async () => {
|
||||
const cookie = await authenticate('private', 'secret123');
|
||||
expect(cookie).toBeTruthy();
|
||||
expect(cookie).toContain('lb_auth_private=');
|
||||
expect(cookie).toContain('HttpOnly');
|
||||
expect(cookie).toContain('SameSite=Strict');
|
||||
});
|
||||
|
||||
it('returns null for the wrong password', () => {
|
||||
expect(authenticate('private', 'wrongpass')).toBeNull();
|
||||
it('returns null for the wrong password', async () => {
|
||||
await expect(authenticate('private', 'wrongpass')).resolves.toBeNull();
|
||||
});
|
||||
|
||||
it('returns null for a non-protected slug', () => {
|
||||
expect(authenticate('public', 'anything')).toBeNull();
|
||||
it('returns null for a non-protected slug', async () => {
|
||||
await expect(authenticate('public', 'anything')).resolves.toBeNull();
|
||||
});
|
||||
|
||||
it('accepts a correct scrypt-hashed password', async () => {
|
||||
await expect(authenticate('hashed', 'scrypted-pass')).resolves.toContain('lb_auth_hashed=');
|
||||
});
|
||||
|
||||
it('rejects a wrong password against a scrypt hash', async () => {
|
||||
await expect(authenticate('hashed', 'wrong')).resolves.toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
/**
|
||||
* scryptSync costs ~23ms of blocked main thread per call. The /api/auth limit
|
||||
* is keyed on the client IP, and at the default TRUSTED_PROXY_HOPS=0 that IP
|
||||
* comes from a spoofable header — so unlimited buckets, each buying 23ms of
|
||||
* dead process. The async variant runs on the libuv threadpool instead.
|
||||
*/
|
||||
describe('password hashing does not stall the process', () => {
|
||||
it('never calls the synchronous scrypt', async () => {
|
||||
const sync = vi.spyOn(crypto, 'scryptSync');
|
||||
await authenticate('hashed', 'scrypted-pass');
|
||||
expect(sync).not.toHaveBeenCalled();
|
||||
sync.mockRestore();
|
||||
});
|
||||
|
||||
it('leaves timers free to fire while hashing', async () => {
|
||||
let ticks = 0;
|
||||
const interval = setInterval(() => ticks++, 2);
|
||||
|
||||
await authenticate('hashed', 'scrypted-pass');
|
||||
clearInterval(interval);
|
||||
|
||||
// The synchronous variant yields to nothing for the whole hash, so a 2ms
|
||||
// interval gets at most one tick after it finishes. Async leaves room for
|
||||
// many. A slower machine makes the hash longer, i.e. more ticks — so this
|
||||
// fails on a blocked loop, not on a busy one.
|
||||
expect(ticks).toBeGreaterThan(3);
|
||||
});
|
||||
});
|
||||
|
||||
describe('isAuthenticated', () => {
|
||||
it('returns true when a valid cookie is present', () => {
|
||||
it('returns true when a valid cookie is present', async () => {
|
||||
// First authenticate to get the expected token
|
||||
const cookie = authenticate('private', 'secret123')!;
|
||||
const cookie = (await authenticate('private', 'secret123'))!;
|
||||
const token = cookie.split('=')[1].split(';')[0];
|
||||
|
||||
const getCookie = (name: string) => (name === 'lb_auth_private' ? token : undefined);
|
||||
@@ -95,16 +142,16 @@ describe('isAuthenticated', () => {
|
||||
});
|
||||
|
||||
describe('token expiry', () => {
|
||||
function tokenFor(slug: string, password: string): string {
|
||||
return authenticate(slug, password)!.split('=')[1].split(';')[0];
|
||||
async function tokenFor(slug: string, password: string): Promise<string> {
|
||||
return (await authenticate(slug, password))!.split('=')[1].split(';')[0];
|
||||
}
|
||||
|
||||
afterEach(() => {
|
||||
vi.useRealTimers();
|
||||
});
|
||||
|
||||
it('rejects a token once its embedded expiry has passed', () => {
|
||||
const token = tokenFor('private', 'secret123');
|
||||
it('rejects a token once its embedded expiry has passed', async () => {
|
||||
const token = await tokenFor('private', 'secret123');
|
||||
const getCookie = (name: string) => (name === 'lb_auth_private' ? token : undefined);
|
||||
expect(isAuthenticated('private', getCookie)).toBe(true);
|
||||
|
||||
@@ -115,8 +162,8 @@ describe('token expiry', () => {
|
||||
expect(isAuthenticated('private', getCookie)).toBe(false);
|
||||
});
|
||||
|
||||
it('still accepts a token just before it expires', () => {
|
||||
const token = tokenFor('private', 'secret123');
|
||||
it('still accepts a token just before it expires', async () => {
|
||||
const token = await tokenFor('private', 'secret123');
|
||||
const getCookie = (name: string) => (name === 'lb_auth_private' ? token : undefined);
|
||||
|
||||
vi.useFakeTimers();
|
||||
@@ -124,8 +171,8 @@ describe('token expiry', () => {
|
||||
expect(isAuthenticated('private', getCookie)).toBe(true);
|
||||
});
|
||||
|
||||
it('rejects a token whose expiry was tampered with', () => {
|
||||
const token = tokenFor('private', 'secret123');
|
||||
it('rejects a token whose expiry was tampered with', async () => {
|
||||
const token = await tokenFor('private', 'secret123');
|
||||
const [, sig] = token.split('.');
|
||||
const farFuture = Date.now() + 365 * 24 * 60 * 60 * 1000;
|
||||
|
||||
@@ -143,8 +190,8 @@ describe('token expiry', () => {
|
||||
}
|
||||
});
|
||||
|
||||
it('sets a cookie Max-Age consistent with the embedded expiry', () => {
|
||||
const cookie = authenticate('private', 'secret123')!;
|
||||
it('sets a cookie Max-Age consistent with the embedded expiry', async () => {
|
||||
const cookie = (await authenticate('private', 'secret123'))!;
|
||||
const maxAge = Number(cookie.match(/Max-Age=(\d+)/)![1]);
|
||||
const exp = Number(cookie.split('=')[1].split(';')[0].split('.')[0]);
|
||||
expect(Math.abs(exp - (Date.now() + maxAge * 1000))).toBeLessThan(2000);
|
||||
|
||||
82
lib/__tests__/backup-restore.test.ts
Normal file
82
lib/__tests__/backup-restore.test.ts
Normal file
@@ -0,0 +1,82 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
||||
|
||||
vi.mock('fs/promises', () => ({
|
||||
default: {
|
||||
copyFile: vi.fn(async () => undefined),
|
||||
readFile: vi.fn(),
|
||||
writeFile: vi.fn(),
|
||||
rename: vi.fn(),
|
||||
mkdir: vi.fn(),
|
||||
access: vi.fn(),
|
||||
readdir: vi.fn(async () => []),
|
||||
unlink: vi.fn(),
|
||||
},
|
||||
}));
|
||||
|
||||
import fs from 'fs/promises';
|
||||
import { restoreBackup } from '@/lib/admin/yaml-service';
|
||||
|
||||
/**
|
||||
* restoreBackup joins its argument into a path and copies the result over a
|
||||
* content file, whose contents the admin GET endpoints then return. Before this
|
||||
* guard, `path.join` resolved `..` segments, so any readable file on the host
|
||||
* could be written over content/settings.yaml and read back.
|
||||
*
|
||||
* The function has no callers yet — this pins the guard for whoever wires up the
|
||||
* restore button the admin panel does not have.
|
||||
*/
|
||||
describe('restoreBackup rejects anything that is not a backup it produced', () => {
|
||||
beforeEach(() => vi.clearAllMocks());
|
||||
|
||||
const rejected = [
|
||||
'../../../../etc/passwd',
|
||||
'../gallery.yaml',
|
||||
'.backups/../../gallery.yaml',
|
||||
'/etc/passwd',
|
||||
'gallery.yaml', // the live file, not a backup
|
||||
'gallery.yaml.2026-05-31T17-30-00-000Z.bak.txt',
|
||||
'evil-gallery.yaml.2026-05-31T17-30-00-000Z.bak',
|
||||
'',
|
||||
];
|
||||
|
||||
for (const name of rejected) {
|
||||
it(`refuses ${JSON.stringify(name)}`, async () => {
|
||||
await expect(restoreBackup(name)).rejects.toThrow(/unrecognised backup name/i);
|
||||
expect(fs.copyFile).not.toHaveBeenCalled();
|
||||
});
|
||||
}
|
||||
|
||||
// A traversal that still ended in a plausible-looking name would have picked
|
||||
// the destination too, via the old includes('gallery.yaml') check.
|
||||
it('refuses a traversal that embeds a valid-looking name', async () => {
|
||||
await expect(restoreBackup('../../gallery.yaml.2026-01-01T00-00-00-000Z.bak')).rejects.toThrow(
|
||||
/unrecognised backup name/i,
|
||||
);
|
||||
expect(fs.copyFile).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('restoreBackup accepts the names it writes', () => {
|
||||
beforeEach(() => vi.clearAllMocks());
|
||||
|
||||
it('restores a normal backup', async () => {
|
||||
await expect(
|
||||
restoreBackup('gallery.yaml.2026-05-31T17-30-00-000Z.bak'),
|
||||
).resolves.toBeUndefined();
|
||||
expect(fs.copyFile).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('restores a pre-restore backup', async () => {
|
||||
await expect(
|
||||
restoreBackup('settings.yaml.2026-05-31T17-30-00-000Z.pre-restore.bak'),
|
||||
).resolves.toBeUndefined();
|
||||
});
|
||||
|
||||
it('derives the destination from the matched name, not a substring search', async () => {
|
||||
await restoreBackup('settings.yaml.2026-05-31T17-30-00-000Z.bak');
|
||||
|
||||
// Last copyFile is backup → target; the first is the pre-restore snapshot.
|
||||
const calls = vi.mocked(fs.copyFile).mock.calls;
|
||||
expect(String(calls[calls.length - 1][1])).toMatch(/content\/settings\.yaml$/);
|
||||
});
|
||||
});
|
||||
93
lib/__tests__/config-hero-uuid.test.ts
Normal file
93
lib/__tests__/config-hero-uuid.test.ts
Normal file
@@ -0,0 +1,93 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
||||
|
||||
vi.mock('@/lib/env', () => ({
|
||||
env: {
|
||||
IMMICH_API_URL: 'http://localhost:2283',
|
||||
IMMICH_API_KEY: 'test-key',
|
||||
SITE_TITLE: 'Test Gallery',
|
||||
SITE_SUBTITLE: '',
|
||||
CACHE_TTL: 300,
|
||||
IMMICH_TIMEOUT_MS: 15000,
|
||||
RATE_LIMIT_RPM: 120,
|
||||
TRUSTED_PROXY_HOPS: 0,
|
||||
},
|
||||
}));
|
||||
|
||||
vi.mock('@/lib/secret', () => ({
|
||||
resolveAuthSecret: () => 'test-auth-secret-32-chars-long-min',
|
||||
}));
|
||||
|
||||
// Spy on validateUuid so we can assert *which* values are routed through it.
|
||||
// vi.hoisted because vi.mock factories are hoisted above const declarations.
|
||||
// Two-arg signature, matching the real validateUuid(id, context) — the context
|
||||
// argument is what the second assertion below inspects.
|
||||
const { validateUuidSpy } = vi.hoisted(() => ({
|
||||
validateUuidSpy: vi.fn((id: string, _context: string) => id),
|
||||
}));
|
||||
|
||||
vi.mock('@/lib/config/parser', () => ({
|
||||
loadYaml: vi.fn(),
|
||||
clearYamlCache: vi.fn(),
|
||||
validateUuid: validateUuidSpy,
|
||||
}));
|
||||
|
||||
import { getConfig, invalidateConfigCache } from '@/lib/config';
|
||||
import { loadYaml } from '@/lib/config/parser';
|
||||
|
||||
const ALBUM_ID = '11111111-1111-1111-1111-111111111111';
|
||||
const HERO_ID = '22222222-2222-2222-2222-222222222222';
|
||||
|
||||
/**
|
||||
* Every asset ID in gallery.yaml is routed through validateUuid before it can
|
||||
* reach encodeAssetId, which encrypts whatever it is handed. A per-album
|
||||
* heroImage was the one that slipped through: the album ID (the map key) was
|
||||
* validated, the hero asset ID (the value) was stored raw. A typo there
|
||||
* produced a perfectly well-formed image URL that 404s forever, with nothing in
|
||||
* the log naming the cause.
|
||||
*/
|
||||
describe('gallery.yaml per-album heroImage', () => {
|
||||
beforeEach(() => {
|
||||
validateUuidSpy.mockClear();
|
||||
invalidateConfigCache();
|
||||
vi.mocked(loadYaml).mockImplementation((filename: string) => {
|
||||
if (filename === 'gallery.yaml') {
|
||||
return { albums: [{ [ALBUM_ID]: { title: 'An Album', heroImage: HERO_ID } }] };
|
||||
}
|
||||
if (filename === 'settings.yaml') return {};
|
||||
return null;
|
||||
});
|
||||
});
|
||||
|
||||
it('routes the hero asset ID through validateUuid, not just the album ID', () => {
|
||||
getConfig();
|
||||
|
||||
const validated = validateUuidSpy.mock.calls.map((c) => c[0]);
|
||||
expect(validated).toContain(HERO_ID);
|
||||
});
|
||||
|
||||
it('names the album in the validation context so the warning is actionable', () => {
|
||||
getConfig();
|
||||
|
||||
const heroCall = validateUuidSpy.mock.calls.find((c) => c[0] === HERO_ID);
|
||||
expect(heroCall?.[1]).toContain(ALBUM_ID);
|
||||
});
|
||||
|
||||
it('stores the validated value, keyed by album', () => {
|
||||
expect(getConfig().albumHeroImages[ALBUM_ID]).toBe(HERO_ID);
|
||||
});
|
||||
|
||||
// The substitution the wiring above depends on: validateUuid never throws, so
|
||||
// a bad ID degrades to a 404 image rather than taking the whole page down.
|
||||
it('real validateUuid warns and substitutes rather than throwing', async () => {
|
||||
const actual =
|
||||
await vi.importActual<typeof import('@/lib/config/parser')>('@/lib/config/parser');
|
||||
const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
|
||||
|
||||
const result = actual.validateUuid('not-a-uuid', 'gallery.yaml heroImage');
|
||||
|
||||
expect(result).toBe('00000000-0000-0000-0000-000000000000');
|
||||
expect(warn).toHaveBeenCalled();
|
||||
expect(String(warn.mock.calls[0][0])).toContain('gallery.yaml heroImage');
|
||||
warn.mockRestore();
|
||||
});
|
||||
});
|
||||
116
lib/__tests__/config-safe.test.ts
Normal file
116
lib/__tests__/config-safe.test.ts
Normal file
@@ -0,0 +1,116 @@
|
||||
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
|
||||
|
||||
vi.mock('@/lib/env', () => ({
|
||||
env: {
|
||||
IMMICH_API_URL: 'http://localhost:2283',
|
||||
IMMICH_API_KEY: 'test-key',
|
||||
SITE_TITLE: 'Test Gallery',
|
||||
SITE_SUBTITLE: '',
|
||||
CACHE_TTL: 300,
|
||||
IMMICH_TIMEOUT_MS: 15000,
|
||||
RATE_LIMIT_RPM: 120,
|
||||
TRUSTED_PROXY_HOPS: 0,
|
||||
},
|
||||
}));
|
||||
|
||||
vi.mock('@/lib/secret', () => ({
|
||||
resolveAuthSecret: () => 'test-auth-secret-32-chars-long-min',
|
||||
}));
|
||||
|
||||
vi.mock('@/lib/config/parser', () => ({
|
||||
loadYaml: vi.fn(),
|
||||
clearYamlCache: vi.fn(),
|
||||
validateUuid: (id: string) => id,
|
||||
}));
|
||||
|
||||
import { getConfig, getConfigOrNull, invalidateConfigCache } from '@/lib/config';
|
||||
import { loadYaml } from '@/lib/config/parser';
|
||||
|
||||
const ALBUM_ID = '11111111-1111-1111-1111-111111111111';
|
||||
|
||||
function withGallery(gallery: unknown) {
|
||||
vi.mocked(loadYaml).mockImplementation((filename: string) => {
|
||||
if (filename === 'gallery.yaml') return gallery;
|
||||
if (filename === 'settings.yaml') return {};
|
||||
return null;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* The admin page builder can write each of these, and the root layout renders
|
||||
* /admin inside itself — so a throw here would take down the site together with
|
||||
* the only tool that can undo the save.
|
||||
*/
|
||||
const UNDERIVABLE = {
|
||||
'a gallery with neither albums nor subpages': { albums: [] },
|
||||
'a subpage with no name': { albums: [ALBUM_ID], subpages: [{ albums: [ALBUM_ID] }] },
|
||||
'a subpage with neither albums nor sections': {
|
||||
albums: [ALBUM_ID],
|
||||
subpages: [{ name: 'Empty', albums: [] }],
|
||||
},
|
||||
};
|
||||
|
||||
describe('getConfig() rejects an underivable gallery.yaml', () => {
|
||||
beforeEach(() => invalidateConfigCache());
|
||||
|
||||
// Pins the premise the fix exists for. If these ever stop throwing, the
|
||||
// fallback below is dead weight and should be revisited rather than kept.
|
||||
for (const [label, gallery] of Object.entries(UNDERIVABLE)) {
|
||||
it(`throws on ${label}`, () => {
|
||||
withGallery(gallery);
|
||||
expect(() => getConfig()).toThrow();
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
describe('getConfigOrNull()', () => {
|
||||
let error: ReturnType<typeof vi.spyOn>;
|
||||
|
||||
beforeEach(() => {
|
||||
invalidateConfigCache();
|
||||
error = vi.spyOn(console, 'error').mockImplementation(() => {});
|
||||
});
|
||||
|
||||
afterEach(() => error.mockRestore());
|
||||
|
||||
for (const [label, gallery] of Object.entries(UNDERIVABLE)) {
|
||||
it(`returns null instead of throwing on ${label}`, () => {
|
||||
withGallery(gallery);
|
||||
expect(getConfigOrNull()).toBeNull();
|
||||
});
|
||||
}
|
||||
|
||||
it('logs the underlying error so the cause is diagnosable from the server log', () => {
|
||||
withGallery({ albums: [] });
|
||||
getConfigOrNull();
|
||||
|
||||
expect(error).toHaveBeenCalled();
|
||||
expect(String(error.mock.calls[0][0])).toMatch(/gallery\.yaml/);
|
||||
});
|
||||
|
||||
it('points at the backup directory, since that is the recovery path', () => {
|
||||
withGallery({ albums: [] });
|
||||
getConfigOrNull();
|
||||
expect(String(error.mock.calls[0][0])).toContain('content/.backups/');
|
||||
});
|
||||
|
||||
it('returns the real config untouched when the gallery is valid', () => {
|
||||
withGallery({ albums: [ALBUM_ID] });
|
||||
|
||||
const config = getConfigOrNull();
|
||||
expect(config).not.toBeNull();
|
||||
expect(config?.albums).toEqual([ALBUM_ID]);
|
||||
expect(error).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('does not swallow the needsSetup path, which is a different state', () => {
|
||||
// Missing gallery.yaml is not an error — getConfig() returns a dummy config
|
||||
// with needsSetup so the app can render SetupScreen. That must still work.
|
||||
vi.mocked(loadYaml).mockReturnValue(null);
|
||||
|
||||
const config = getConfigOrNull();
|
||||
expect(config).not.toBeNull();
|
||||
expect(config?.needsSetup).toBe(true);
|
||||
expect(error).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
106
lib/__tests__/derive-gallery.test.ts
Normal file
106
lib/__tests__/derive-gallery.test.ts
Normal file
@@ -0,0 +1,106 @@
|
||||
import { describe, it, expect, vi } from 'vitest';
|
||||
|
||||
vi.mock('@/lib/env', () => ({
|
||||
env: {
|
||||
IMMICH_API_URL: 'http://localhost:2283',
|
||||
IMMICH_API_KEY: 'test-key',
|
||||
SITE_TITLE: 'Test Gallery',
|
||||
SITE_SUBTITLE: '',
|
||||
CACHE_TTL: 300,
|
||||
IMMICH_TIMEOUT_MS: 15000,
|
||||
RATE_LIMIT_RPM: 120,
|
||||
TRUSTED_PROXY_HOPS: 0,
|
||||
},
|
||||
}));
|
||||
|
||||
vi.mock('@/lib/config/parser', () => ({
|
||||
loadYaml: vi.fn(),
|
||||
clearYamlCache: vi.fn(),
|
||||
validateUuid: (id: string) => id,
|
||||
}));
|
||||
|
||||
import { deriveGallery } from '@/lib/config';
|
||||
import type { GalleryYaml } from '@/lib/config/schema';
|
||||
|
||||
const A = '11111111-1111-1111-1111-111111111111';
|
||||
const B = '22222222-2222-2222-2222-222222222222';
|
||||
|
||||
/**
|
||||
* The admin PUT calls this before writing, so that a save the site cannot load
|
||||
* is rejected with a 400 instead of reported as successful. These are the exact
|
||||
* shapes the page builder can produce.
|
||||
*/
|
||||
describe('deriveGallery rejects what the site cannot load', () => {
|
||||
it('rejects a gallery with neither albums nor subpages', () => {
|
||||
expect(() => deriveGallery({ albums: [] } as GalleryYaml)).toThrow(/at least one album/i);
|
||||
});
|
||||
|
||||
it('rejects a subpage with no name', () => {
|
||||
expect(() =>
|
||||
deriveGallery({ albums: [A], subpages: [{ albums: [A] }] } as unknown as GalleryYaml),
|
||||
).toThrow(/must have a name/i);
|
||||
});
|
||||
|
||||
it('rejects a subpage with neither albums nor sections', () => {
|
||||
expect(() =>
|
||||
deriveGallery({
|
||||
albums: [A],
|
||||
subpages: [{ name: 'Empty', albums: [] }],
|
||||
} as unknown as GalleryYaml),
|
||||
).toThrow(/Empty/);
|
||||
});
|
||||
|
||||
// The message reaches the admin UI as the 400 body, so it has to identify
|
||||
// which subpage is at fault — "invalid gallery" would be useless in a builder
|
||||
// with a dozen subpages.
|
||||
it('names the offending subpage so the error is actionable', () => {
|
||||
expect(() =>
|
||||
deriveGallery({
|
||||
albums: [A],
|
||||
subpages: [
|
||||
{ name: 'Fine', albums: [A] },
|
||||
{ name: 'Broken One', albums: [] },
|
||||
],
|
||||
} as unknown as GalleryYaml),
|
||||
).toThrow(/Broken One/);
|
||||
});
|
||||
});
|
||||
|
||||
describe('deriveGallery accepts valid structures', () => {
|
||||
it('derives standalone albums', () => {
|
||||
const result = deriveGallery({ albums: [A, B] } as GalleryYaml);
|
||||
expect(result.albums).toEqual([A, B]);
|
||||
expect(result.standaloneAlbums).toEqual([A, B]);
|
||||
expect(result.subpages).toEqual([]);
|
||||
});
|
||||
|
||||
it('treats an album inside a subpage as no longer standalone', () => {
|
||||
const result = deriveGallery({
|
||||
albums: [A],
|
||||
subpages: [{ name: 'Trips', albums: [B] }],
|
||||
} as unknown as GalleryYaml);
|
||||
|
||||
expect(result.albums).toEqual([A, B]);
|
||||
expect(result.standaloneAlbums).toEqual([A]);
|
||||
expect(result.subpages[0].slug).toBe('trips');
|
||||
});
|
||||
|
||||
it('accepts a subpage that has sections instead of albums', () => {
|
||||
const result = deriveGallery({
|
||||
subpages: [{ name: 'Work', sections: [{ title: 'Recent Work', albums: [A] }] }],
|
||||
} as unknown as GalleryYaml);
|
||||
|
||||
expect(result.subpages[0].sections?.[0].slug).toBe('recent-work');
|
||||
expect(result.albums).toEqual([A]);
|
||||
});
|
||||
|
||||
it('collects per-album overrides and hero images', () => {
|
||||
const result = deriveGallery({
|
||||
albums: [{ [A]: { title: 'Renamed', description: 'A note', heroImage: B } }],
|
||||
} as unknown as GalleryYaml);
|
||||
|
||||
expect(result.albumOverrides[A]).toBe('Renamed');
|
||||
expect(result.albumDescriptions[A]).toBe('A note');
|
||||
expect(result.albumHeroImages[A]).toBe(B);
|
||||
});
|
||||
});
|
||||
61
lib/__tests__/error-pages.test.ts
Normal file
61
lib/__tests__/error-pages.test.ts
Normal file
@@ -0,0 +1,61 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { createElement } from 'react';
|
||||
import { renderToStaticMarkup } from 'react-dom/server';
|
||||
import NotFound from '@/app/not-found';
|
||||
import ErrorPage from '@/app/error';
|
||||
|
||||
// Uses createElement rather than JSX because vitest.config.ts only includes
|
||||
// lib/__tests__/**/*.test.ts — a .tsx file here would never run.
|
||||
|
||||
describe('not-found page', () => {
|
||||
const html = () => renderToStaticMarkup(createElement(NotFound));
|
||||
|
||||
it('uses the themed empty-state styling rather than raw markup', () => {
|
||||
expect(html()).toContain('empty-state');
|
||||
});
|
||||
|
||||
it('offers a way back to the gallery', () => {
|
||||
expect(html()).toContain('href="/"');
|
||||
});
|
||||
|
||||
// notFound() means Immich answered and the content is genuinely gone. If this
|
||||
// page hedged with "try again", a real 404 would look like a transient fault.
|
||||
it('does not suggest the problem is temporary', () => {
|
||||
expect(html()).not.toMatch(/try again|temporar|unavailable/i);
|
||||
});
|
||||
});
|
||||
|
||||
describe('error page', () => {
|
||||
const render = (error: Error & { digest?: string }) =>
|
||||
renderToStaticMarkup(createElement(ErrorPage, { error, reset: () => {} }));
|
||||
|
||||
it('offers a retry and a way back to the gallery', () => {
|
||||
const html = render(new Error('boom'));
|
||||
expect(html).toContain('Try again');
|
||||
expect(html).toContain('href="/"');
|
||||
});
|
||||
|
||||
it('surfaces the Next.js digest so a report can be traced to a log line', () => {
|
||||
const html = render(Object.assign(new Error('boom'), { digest: 'abc123def' }));
|
||||
expect(html).toContain('abc123def');
|
||||
});
|
||||
|
||||
it('omits the reference line when there is no digest', () => {
|
||||
expect(render(new Error('boom'))).not.toContain('Reference:');
|
||||
});
|
||||
|
||||
// Error messages reaching this component can carry internal detail — an
|
||||
// upstream URL, a header, a config value. Never echo them to a visitor.
|
||||
it('does not leak the raw error message', () => {
|
||||
const html = render(new Error('connect ECONNREFUSED 10.0.0.5:2283 x-api-key=hunter2'));
|
||||
expect(html).not.toContain('hunter2');
|
||||
expect(html).not.toContain('10.0.0.5');
|
||||
expect(html).not.toContain('ECONNREFUSED');
|
||||
});
|
||||
|
||||
// The counterpart assertion to the not-found page: this one *should* frame the
|
||||
// failure as transient, because that is what an Immich outage is.
|
||||
it('frames the failure as temporary', () => {
|
||||
expect(render(new Error('boom'))).toMatch(/temporary/i);
|
||||
});
|
||||
});
|
||||
78
lib/__tests__/image-cache-version.test.ts
Normal file
78
lib/__tests__/image-cache-version.test.ts
Normal file
@@ -0,0 +1,78 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
||||
|
||||
vi.mock('@/lib/config', () => ({
|
||||
getConfig: () => ({ authSecret: 'test-auth-secret-32-chars-long-min' }),
|
||||
}));
|
||||
|
||||
const ASSET = '11111111-1111-1111-1111-111111111111';
|
||||
|
||||
/**
|
||||
* Image responses are served `immutable` for a year, so the browser never
|
||||
* revalidates — the ETag is not even consulted. The URL is the only thing that
|
||||
* can invalidate a browser cache, which is why the buster lives there and not
|
||||
* only in the ETag. Immich regenerates thumbnails when a job is re-run or a
|
||||
* photo is rotated, and the asset ID does not change, so nothing else would.
|
||||
*/
|
||||
describe('IMAGE_CACHE_VERSION', () => {
|
||||
beforeEach(() => {
|
||||
vi.resetModules();
|
||||
vi.unstubAllEnvs();
|
||||
});
|
||||
|
||||
async function urls() {
|
||||
const { imageUrl, videoUrl } = await import('@/lib/urls');
|
||||
return { imageUrl, videoUrl };
|
||||
}
|
||||
|
||||
it('leaves URLs byte-identical when unset — the default must not change', async () => {
|
||||
const { imageUrl, videoUrl } = await urls();
|
||||
|
||||
expect(imageUrl(ASSET)).toMatch(/^\/api\/image\/[^?]+\?size=preview$/);
|
||||
expect(imageUrl(ASSET, 'thumbnail')).toMatch(/^\/api\/image\/[^?]+\?size=thumbnail$/);
|
||||
expect(videoUrl(ASSET)).toMatch(/^\/api\/video\/[^?]+$/);
|
||||
});
|
||||
|
||||
it('treats an empty or whitespace-only value as unset', async () => {
|
||||
vi.stubEnv('IMAGE_CACHE_VERSION', ' ');
|
||||
const { imageUrl } = await urls();
|
||||
expect(imageUrl(ASSET)).not.toContain('v=');
|
||||
});
|
||||
|
||||
it('appends the version to image URLs when set', async () => {
|
||||
vi.stubEnv('IMAGE_CACHE_VERSION', '2');
|
||||
const { imageUrl } = await urls();
|
||||
expect(imageUrl(ASSET)).toMatch(/\?size=preview&v=2$/);
|
||||
});
|
||||
|
||||
it('uses a leading ? on video URLs, which carry no other parameter', async () => {
|
||||
vi.stubEnv('IMAGE_CACHE_VERSION', '2');
|
||||
const { videoUrl } = await urls();
|
||||
|
||||
const url = videoUrl(ASSET);
|
||||
expect(url).toMatch(/\?v=2$/);
|
||||
expect(url).not.toContain('?&');
|
||||
});
|
||||
|
||||
it('escapes a value that would otherwise break the query string', async () => {
|
||||
vi.stubEnv('IMAGE_CACHE_VERSION', 'a b&c=d');
|
||||
const { imageUrl } = await urls();
|
||||
|
||||
const url = imageUrl(ASSET);
|
||||
expect(url).toContain('v=a%20b%26c%3Dd');
|
||||
// One '&' only — the separator. An unescaped value would inject parameters.
|
||||
expect(url.split('&')).toHaveLength(2);
|
||||
});
|
||||
|
||||
it('changes the URL when bumped, which is the entire point', async () => {
|
||||
vi.stubEnv('IMAGE_CACHE_VERSION', '1');
|
||||
const before = (await urls()).imageUrl(ASSET);
|
||||
|
||||
vi.resetModules();
|
||||
vi.stubEnv('IMAGE_CACHE_VERSION', '2');
|
||||
const after = (await urls()).imageUrl(ASSET);
|
||||
|
||||
expect(after).not.toBe(before);
|
||||
// The token itself is unchanged: same asset, same encryption, new cache key.
|
||||
expect(after.split('?')[0]).toBe(before.split('?')[0]);
|
||||
});
|
||||
});
|
||||
60
lib/__tests__/image-size.test.ts
Normal file
60
lib/__tests__/image-size.test.ts
Normal file
@@ -0,0 +1,60 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { resolveImageSize, widthToSize } from '../imageSize';
|
||||
|
||||
describe('widthToSize', () => {
|
||||
it('maps widths to Immich tiers at the documented boundaries', () => {
|
||||
expect(widthToSize(250)).toBe('thumbnail');
|
||||
expect(widthToSize(251)).toBe('preview');
|
||||
expect(widthToSize(1440)).toBe('preview');
|
||||
expect(widthToSize(1441)).toBe('original');
|
||||
});
|
||||
});
|
||||
|
||||
describe('resolveImageSize', () => {
|
||||
it('defaults to preview when neither parameter is given', () => {
|
||||
expect(resolveImageSize(null, null)).toBe('preview');
|
||||
});
|
||||
|
||||
it('honours an explicit size on its own', () => {
|
||||
expect(resolveImageSize('thumbnail', null)).toBe('thumbnail');
|
||||
expect(resolveImageSize('original', null)).toBe('original');
|
||||
});
|
||||
|
||||
it('falls back to the width-derived tier when no size is given', () => {
|
||||
expect(resolveImageSize(null, '128')).toBe('thumbnail');
|
||||
expect(resolveImageSize(null, '3840')).toBe('original');
|
||||
});
|
||||
|
||||
it('ignores an unrecognised size rather than trusting it', () => {
|
||||
expect(resolveImageSize('enormous', null)).toBe('preview');
|
||||
});
|
||||
|
||||
it('ignores a non-numeric or non-positive width', () => {
|
||||
expect(resolveImageSize('preview', 'abc')).toBe('preview');
|
||||
expect(resolveImageSize('preview', '0')).toBe('preview');
|
||||
expect(resolveImageSize('preview', '-100')).toBe('preview');
|
||||
});
|
||||
|
||||
// The reason this function exists. ?size= is a ceiling; a width may lower the
|
||||
// tier but must never raise it.
|
||||
describe('when both are present, the smaller tier wins', () => {
|
||||
it('lets a small width narrow the requested size', () => {
|
||||
expect(resolveImageSize('preview', '128')).toBe('thumbnail');
|
||||
});
|
||||
|
||||
// The regression this guards. next/image emits widths up to 3840 and
|
||||
// widthToSize(1920) is 'original' — letting width win would ship full-size
|
||||
// originals to every large display.
|
||||
it('never upgrades past the requested size', () => {
|
||||
expect(resolveImageSize('preview', '1920')).toBe('preview');
|
||||
expect(resolveImageSize('preview', '3840')).toBe('preview');
|
||||
expect(resolveImageSize('thumbnail', '3840')).toBe('thumbnail');
|
||||
});
|
||||
|
||||
it('leaves the real grid case unchanged', () => {
|
||||
// lib/urls.ts writes ?size=preview; next/image's smallest vw-based
|
||||
// deviceSize is 640. This combination must stay on preview.
|
||||
expect(resolveImageSize('preview', '640')).toBe('preview');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,5 +1,5 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
||||
import { immich } from '../immich';
|
||||
import { immich, ImmichUnavailableError } from '../immich';
|
||||
import * as config from '../config';
|
||||
import { cache } from '../cache';
|
||||
|
||||
@@ -16,7 +16,11 @@ vi.mock('../config', async () => {
|
||||
subpages: [],
|
||||
albumOverrides: { 'album-1': 'Override Name' },
|
||||
albumDescriptions: {},
|
||||
cacheTtl: 0,
|
||||
// Non-zero: a 0 TTL expires an entry in the same millisecond it is
|
||||
// written, which would make any caching assertion flaky. Isolation comes
|
||||
// from the cache.clear() in beforeEach, not from an unusable TTL.
|
||||
cacheTtl: 60_000,
|
||||
immichTimeoutMs: 15000,
|
||||
}),
|
||||
};
|
||||
});
|
||||
@@ -57,6 +61,294 @@ describe('ImmichClient', () => {
|
||||
const result = await (immich as any).request('/test');
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
// A null return means "Immich answered: this does not exist" and the page
|
||||
// turns it into notFound(). Every other failure must be distinguishable,
|
||||
// or an outage renders a hard 404 for albums that do exist.
|
||||
describe('distinguishes "gone" from "unavailable"', () => {
|
||||
it('returns null for 410 Gone', async () => {
|
||||
mockFetch.mockResolvedValueOnce({ ok: false, status: 410, statusText: 'Gone' });
|
||||
await expect((immich as any).request('/test')).resolves.toBeNull();
|
||||
});
|
||||
|
||||
it('throws on a 5xx instead of reporting the resource as missing', async () => {
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: false,
|
||||
status: 503,
|
||||
statusText: 'Service Unavailable',
|
||||
});
|
||||
|
||||
await expect((immich as any).request('/test')).rejects.toBeInstanceOf(
|
||||
ImmichUnavailableError,
|
||||
);
|
||||
});
|
||||
|
||||
it('throws on a rejected API key rather than 404-ing every album', async () => {
|
||||
mockFetch.mockResolvedValueOnce({ ok: false, status: 401, statusText: 'Unauthorized' });
|
||||
await expect((immich as any).request('/test')).rejects.toBeInstanceOf(
|
||||
ImmichUnavailableError,
|
||||
);
|
||||
});
|
||||
|
||||
it('throws when the network is unreachable', async () => {
|
||||
mockFetch.mockRejectedValueOnce(new Error('ECONNREFUSED'));
|
||||
await expect((immich as any).request('/test')).rejects.toBeInstanceOf(
|
||||
ImmichUnavailableError,
|
||||
);
|
||||
});
|
||||
|
||||
it('throws when a gateway returns an HTML error page instead of JSON', async () => {
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
headers: { get: () => 'text/html' },
|
||||
json: async () => ({}),
|
||||
});
|
||||
|
||||
await expect((immich as any).request('/test')).rejects.toBeInstanceOf(
|
||||
ImmichUnavailableError,
|
||||
);
|
||||
});
|
||||
|
||||
it('carries the upstream status for logging', async () => {
|
||||
mockFetch.mockResolvedValueOnce({ ok: false, status: 502, statusText: 'Bad Gateway' });
|
||||
await expect((immich as any).request('/test')).rejects.toMatchObject({ status: 502 });
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// Without a budget the only ceiling is undici's default, measured in minutes.
|
||||
// Every page is force-dynamic, so an Immich that accepts connections but never
|
||||
// answers would hold each visitor's render open for that whole window.
|
||||
describe('timeouts', () => {
|
||||
const timeoutError = () => {
|
||||
const err = new Error('The operation was aborted due to timeout');
|
||||
err.name = 'TimeoutError';
|
||||
return err;
|
||||
};
|
||||
|
||||
it('sends an abort signal with every JSON request', async () => {
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
headers: { get: () => 'application/json' },
|
||||
json: async () => ({}),
|
||||
});
|
||||
|
||||
await (immich as any).request('/test');
|
||||
expect(mockFetch.mock.calls[0][1].signal).toBeInstanceOf(AbortSignal);
|
||||
});
|
||||
|
||||
it('reports a timed-out request as unavailable, not as a missing resource', async () => {
|
||||
mockFetch.mockRejectedValueOnce(timeoutError());
|
||||
|
||||
await expect((immich as any).request('/test')).rejects.toBeInstanceOf(ImmichUnavailableError);
|
||||
});
|
||||
|
||||
it('names the budget in the error so a misconfigured timeout is diagnosable', async () => {
|
||||
mockFetch.mockRejectedValueOnce(timeoutError());
|
||||
await expect((immich as any).request('/test')).rejects.toThrow(/15000ms/);
|
||||
});
|
||||
|
||||
// The stream methods deliberately use a headers-only timeout. A whole-request
|
||||
// timeout would truncate a large original photo or a long video mid-transfer.
|
||||
it('stops the clock once stream headers arrive, so a slow body is not truncated', async () => {
|
||||
vi.useFakeTimers();
|
||||
try {
|
||||
let captured: AbortSignal | undefined;
|
||||
mockFetch.mockImplementation(async (_url: string, init: { signal?: AbortSignal }) => {
|
||||
captured = init.signal;
|
||||
return {
|
||||
ok: true,
|
||||
status: 200,
|
||||
body: new ReadableStream(),
|
||||
headers: { get: () => null },
|
||||
};
|
||||
});
|
||||
|
||||
const result = await immich.streamAsset('asset-1');
|
||||
expect(result).not.toBeNull();
|
||||
|
||||
// Far beyond the 15s budget: a whole-request timeout would abort here
|
||||
// and kill an in-progress download.
|
||||
vi.advanceTimersByTime(60 * 60 * 1000);
|
||||
expect(captured?.aborted).toBe(false);
|
||||
} finally {
|
||||
vi.useRealTimers();
|
||||
}
|
||||
});
|
||||
|
||||
it('still aborts a stream that never returns headers', async () => {
|
||||
vi.useFakeTimers();
|
||||
try {
|
||||
let captured: AbortSignal | undefined;
|
||||
mockFetch.mockImplementation(
|
||||
(_url: string, init: { signal?: AbortSignal }) =>
|
||||
new Promise((_resolve, reject) => {
|
||||
captured = init.signal;
|
||||
init.signal?.addEventListener('abort', () => reject(timeoutError()));
|
||||
}),
|
||||
);
|
||||
|
||||
const pending = immich.streamAsset('asset-1');
|
||||
// Attach the rejection handler *before* advancing timers: the abort
|
||||
// fires during advanceTimersByTimeAsync, and a promise that rejects
|
||||
// with no handler yet attached is reported as an unhandled rejection,
|
||||
// which fails the whole vitest run.
|
||||
const rejects = expect(pending).rejects.toBeInstanceOf(ImmichUnavailableError);
|
||||
await vi.advanceTimersByTimeAsync(15001);
|
||||
|
||||
await rejects;
|
||||
expect(captured?.aborted).toBe(true);
|
||||
} finally {
|
||||
vi.useRealTimers();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// The image/video routes serve these URLs with `immutable` on success and turn
|
||||
// a null into a 404. A bare 404 is heuristically cacheable, so an outage that
|
||||
// looked like "missing" could pin a broken image in the browser cache.
|
||||
describe('stream failures distinguish gone from unavailable', () => {
|
||||
const streamRes = (status: number) => ({
|
||||
ok: status >= 200 && status < 300,
|
||||
status,
|
||||
body: null,
|
||||
headers: { get: () => null },
|
||||
});
|
||||
|
||||
it('streamAsset returns null for a genuinely missing asset', async () => {
|
||||
mockFetch.mockResolvedValueOnce(streamRes(404));
|
||||
await expect(immich.streamAsset('asset-1')).resolves.toBeNull();
|
||||
});
|
||||
|
||||
it('streamAsset throws when Immich errors rather than reporting it missing', async () => {
|
||||
mockFetch.mockResolvedValueOnce(streamRes(500));
|
||||
await expect(immich.streamAsset('asset-1')).rejects.toBeInstanceOf(ImmichUnavailableError);
|
||||
});
|
||||
|
||||
it('streamAsset throws when the network is unreachable', async () => {
|
||||
mockFetch.mockRejectedValueOnce(new Error('ECONNREFUSED'));
|
||||
await expect(immich.streamAsset('asset-1')).rejects.toBeInstanceOf(ImmichUnavailableError);
|
||||
});
|
||||
|
||||
it('streamAsset throws on a 200 with no body', async () => {
|
||||
mockFetch.mockResolvedValueOnce(streamRes(200));
|
||||
await expect(immich.streamAsset('asset-1')).rejects.toBeInstanceOf(ImmichUnavailableError);
|
||||
});
|
||||
|
||||
it('streamVideo returns null for a genuinely missing video', async () => {
|
||||
mockFetch.mockResolvedValueOnce(streamRes(404));
|
||||
await expect(immich.streamVideo('asset-1')).resolves.toBeNull();
|
||||
});
|
||||
|
||||
it('streamVideo throws when Immich errors', async () => {
|
||||
mockFetch.mockResolvedValueOnce(streamRes(502));
|
||||
await expect(immich.streamVideo('asset-1')).rejects.toBeInstanceOf(ImmichUnavailableError);
|
||||
});
|
||||
|
||||
it('streamVideo still accepts a 206 partial response for seeking', async () => {
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
status: 206,
|
||||
body: new ReadableStream(),
|
||||
headers: { get: () => null },
|
||||
});
|
||||
|
||||
const result = await immich.streamVideo('asset-1', 'bytes=0-1023');
|
||||
expect(result?.status).toBe(206);
|
||||
});
|
||||
});
|
||||
|
||||
// Measured before the fix: 5 sequential lookups of a missing asset produced 5
|
||||
// upstream fetches. The homepage resolves every gallery.yaml hero ID on each
|
||||
// render and is force-dynamic, so a hero photo deleted from Immich cost one
|
||||
// 404 round-trip per page view, indefinitely.
|
||||
describe('negative caching', () => {
|
||||
const notFound = { ok: false, status: 404, statusText: 'Not Found' };
|
||||
|
||||
it('queries Immich once for a repeatedly-requested missing asset', async () => {
|
||||
mockFetch.mockResolvedValue(notFound);
|
||||
|
||||
for (let i = 0; i < 5; i++) {
|
||||
await expect(immich.getAssetInfo('missing-asset')).resolves.toBeNull();
|
||||
}
|
||||
|
||||
expect(mockFetch).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('queries Immich once for a repeatedly-requested missing album', async () => {
|
||||
mockFetch.mockResolvedValue(notFound);
|
||||
|
||||
for (let i = 0; i < 3; i++) {
|
||||
await expect(immich.getAlbum('album-1')).resolves.toBeNull();
|
||||
}
|
||||
|
||||
// One album request + one metadata-search request, from the first call only.
|
||||
expect(mockFetch).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
it('does not cache an outage, which would outlive the recovery', async () => {
|
||||
mockFetch.mockResolvedValueOnce({ ok: false, status: 503, statusText: 'Unavailable' });
|
||||
await expect(immich.getAssetInfo('asset-1')).rejects.toBeInstanceOf(ImmichUnavailableError);
|
||||
|
||||
// Immich recovers: the very next call must reach it, not replay the failure.
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
headers: { get: () => 'application/json' },
|
||||
json: async () => ({ id: 'asset-1' }),
|
||||
});
|
||||
|
||||
await expect(immich.getAssetInfo('asset-1')).resolves.toMatchObject({ id: 'asset-1' });
|
||||
});
|
||||
|
||||
it('a cached absence is cleared by invalidation, so a fix takes effect at once', async () => {
|
||||
mockFetch.mockResolvedValue(notFound);
|
||||
await expect(immich.getAssetInfo('asset-1')).resolves.toBeNull();
|
||||
|
||||
immich.invalidateAll();
|
||||
|
||||
mockFetch.mockResolvedValue({
|
||||
ok: true,
|
||||
headers: { get: () => 'application/json' },
|
||||
json: async () => ({ id: 'asset-1' }),
|
||||
});
|
||||
|
||||
await expect(immich.getAssetInfo('asset-1')).resolves.toMatchObject({ id: 'asset-1' });
|
||||
});
|
||||
});
|
||||
|
||||
// The regression this whole error type exists to prevent.
|
||||
describe('outage handling', () => {
|
||||
it('getAlbum propagates an outage instead of returning null', async () => {
|
||||
// Not mockResolvedValueOnce: getAlbum fires the album and metadata-search
|
||||
// requests concurrently, so both need the failing response.
|
||||
mockFetch.mockResolvedValue({ ok: false, status: 500, statusText: 'Internal Server Error' });
|
||||
|
||||
await expect(immich.getAlbum('album-1')).rejects.toBeInstanceOf(ImmichUnavailableError);
|
||||
});
|
||||
|
||||
it('getAlbums propagates an outage instead of returning an empty list', async () => {
|
||||
// Returning [] here would render the homepage as "this gallery has no
|
||||
// albums" while Immich is merely down.
|
||||
mockFetch.mockResolvedValue({ ok: false, status: 500, statusText: 'Internal Server Error' });
|
||||
|
||||
await expect(immich.getAlbums()).rejects.toBeInstanceOf(ImmichUnavailableError);
|
||||
});
|
||||
|
||||
it('a failed album does not leave a stale entry in the in-flight map', async () => {
|
||||
mockFetch.mockResolvedValue({ ok: false, status: 500, statusText: 'Internal Server Error' });
|
||||
await expect(immich.getAlbum('album-1')).rejects.toBeInstanceOf(ImmichUnavailableError);
|
||||
|
||||
// A stranded pending promise would make every later call replay the
|
||||
// failure forever, even after Immich recovers.
|
||||
expect((immich as any).pendingAlbumPromises.has('album-1')).toBe(false);
|
||||
expect((immich as any).pendingAlbumsPromise).toBeNull();
|
||||
});
|
||||
|
||||
it('ping reports unreachable as false rather than throwing', async () => {
|
||||
// /api/health and /api/admin/status render this as a status field.
|
||||
mockFetch.mockRejectedValueOnce(new Error('ECONNREFUSED'));
|
||||
await expect(immich.ping()).resolves.toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('getAlbums()', () => {
|
||||
|
||||
56
lib/__tests__/proxy.test.ts
Normal file
56
lib/__tests__/proxy.test.ts
Normal file
@@ -0,0 +1,56 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { NextRequest } from 'next/server';
|
||||
import { proxy, config } from '@/proxy';
|
||||
|
||||
// Next.js 16 renamed the "middleware" file convention to "proxy": the file must
|
||||
// be proxy.ts and must export proxy(), not middleware(). A silent regression here
|
||||
// (wrong filename, wrong export name) means Next.js never invokes this code and
|
||||
// every document response ships without a CSP — with no build error to catch it.
|
||||
describe('proxy', () => {
|
||||
const run = (pathname = '/') => proxy(new NextRequest(`https://example.com${pathname}`));
|
||||
|
||||
it('is exported under the name Next.js 16 expects', () => {
|
||||
expect(typeof proxy).toBe('function');
|
||||
});
|
||||
|
||||
it('sets a Content-Security-Policy on the response', () => {
|
||||
const csp = run().headers.get('Content-Security-Policy');
|
||||
expect(csp).toContain("default-src 'self'");
|
||||
expect(csp).toContain("frame-ancestors 'none'");
|
||||
});
|
||||
|
||||
it('issues a per-request nonce and passes it to pages via x-nonce', () => {
|
||||
const response = run();
|
||||
const nonce = response.headers.get('x-middleware-request-x-nonce');
|
||||
expect(nonce).toBeTruthy();
|
||||
// The nonce in the CSP must be the same one the page receives, otherwise
|
||||
// Next.js stamps scripts with a nonce the policy does not allow.
|
||||
expect(response.headers.get('Content-Security-Policy')).toContain(`'nonce-${nonce}'`);
|
||||
});
|
||||
|
||||
it('generates a different nonce per request', () => {
|
||||
const first = run().headers.get('x-middleware-request-x-nonce');
|
||||
const second = run().headers.get('x-middleware-request-x-nonce');
|
||||
expect(first).not.toBe(second);
|
||||
});
|
||||
|
||||
it('forwards the pathname so the root layout can keep /admin reachable', () => {
|
||||
const response = run('/admin/settings');
|
||||
expect(response.headers.get('x-middleware-request-x-pathname')).toBe('/admin/settings');
|
||||
});
|
||||
|
||||
it('does not set unsafe-inline alongside the nonce', () => {
|
||||
// CSP2-only browsers ignore 'strict-dynamic' and would honour the fallback,
|
||||
// making it strictly worse than having none.
|
||||
expect(run().headers.get('Content-Security-Policy')).not.toContain(
|
||||
"script-src 'self' 'unsafe-inline'",
|
||||
);
|
||||
});
|
||||
|
||||
it('keeps a matcher that excludes api and static assets but covers /admin', () => {
|
||||
const source = config.matcher[0].source;
|
||||
expect(source).toContain('api');
|
||||
expect(source).toContain('_next/static');
|
||||
expect(source).not.toContain('admin');
|
||||
});
|
||||
});
|
||||
@@ -1,4 +1,4 @@
|
||||
import { describe, it, expect, beforeEach, vi } from 'vitest';
|
||||
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
|
||||
import { NextRequest } from 'next/server';
|
||||
|
||||
let mockHops = 0;
|
||||
@@ -6,7 +6,12 @@ vi.mock('@/lib/config', () => ({
|
||||
getConfig: () => ({ trustedProxyHops: mockHops }),
|
||||
}));
|
||||
|
||||
import { checkRateLimit, getClientIp } from '@/lib/rate-limit';
|
||||
import {
|
||||
checkRateLimit,
|
||||
getClientIp,
|
||||
retryAfterSeconds,
|
||||
__resetProxyWarningForTests,
|
||||
} from '@/lib/rate-limit';
|
||||
|
||||
function req(headers: Record<string, string>, ip?: string): NextRequest {
|
||||
return { ...(ip ? { ip } : {}), headers: new Headers(headers) } as unknown as NextRequest;
|
||||
@@ -85,6 +90,86 @@ describe('getClientIp behind two trusted proxies (TRUSTED_PROXY_HOPS=2)', () =>
|
||||
});
|
||||
});
|
||||
|
||||
/**
|
||||
* Falling back to the shared 'unknown' bucket is correct — trusting a spoofable
|
||||
* header would be worse — but silent. Every unidentified request shares one
|
||||
* bucket per endpoint, and a 50-photo grid issues ~50 /api/image requests, so
|
||||
* the default 1500 rpm is collectively spent by ~30 page loads a minute.
|
||||
* Visitors get 429s with nothing in the log naming the cause.
|
||||
*/
|
||||
describe('diagnosing an unidentifiable client', () => {
|
||||
let warn: ReturnType<typeof vi.spyOn>;
|
||||
|
||||
beforeEach(() => {
|
||||
__resetProxyWarningForTests();
|
||||
warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
|
||||
});
|
||||
|
||||
// Without this the spies stack on console.warn across tests and call counts
|
||||
// accumulate, which silently turns every assertion below into a false pass
|
||||
// or a confusing failure.
|
||||
afterEach(() => warn.mockRestore());
|
||||
|
||||
it('warns when the forwarded chain is shorter than the configured hops', () => {
|
||||
mockHops = 2;
|
||||
expect(getClientIp(req({ 'x-forwarded-for': '203.0.113.9' }))).toBe('unknown');
|
||||
|
||||
expect(warn).toHaveBeenCalledOnce();
|
||||
const message = String(warn.mock.calls[0][0]);
|
||||
expect(message).toContain('TRUSTED_PROXY_HOPS is 2');
|
||||
expect(message).toContain('1 entry');
|
||||
});
|
||||
|
||||
it('warns when neither forwarding header is present', () => {
|
||||
mockHops = 1;
|
||||
expect(getClientIp(req({}))).toBe('unknown');
|
||||
expect(String(warn.mock.calls[0][0])).toContain('neither X-Forwarded-For nor X-Real-IP');
|
||||
});
|
||||
|
||||
it('explains why X-Real-IP was not trusted at more than one hop', () => {
|
||||
mockHops = 2;
|
||||
expect(getClientIp(req({ 'x-real-ip': '203.0.113.9' }))).toBe('unknown');
|
||||
expect(String(warn.mock.calls[0][0])).toContain('single hop');
|
||||
});
|
||||
|
||||
it('warns once per process, not once per request', () => {
|
||||
mockHops = 2;
|
||||
for (let i = 0; i < 50; i++) getClientIp(req({}));
|
||||
expect(warn).toHaveBeenCalledOnce();
|
||||
});
|
||||
|
||||
it('stays silent while clients are being identified correctly', () => {
|
||||
mockHops = 1;
|
||||
expect(getClientIp(req({ 'x-forwarded-for': '203.0.113.9' }))).toBe('203.0.113.9');
|
||||
expect(getClientIp(req({ 'x-real-ip': '203.0.113.9' }))).toBe('203.0.113.9');
|
||||
expect(warn).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('stays silent at hops=0, where the shared bucket is expected, not a misconfiguration', () => {
|
||||
mockHops = 0;
|
||||
expect(getClientIp(req({}))).toBe('unknown');
|
||||
expect(warn).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('retryAfterSeconds', () => {
|
||||
it('rounds up, so a client never retries before the window closes', () => {
|
||||
expect(retryAfterSeconds(Date.now() + 1500)).toBe(2);
|
||||
expect(retryAfterSeconds(Date.now() + 30_000)).toBe(30);
|
||||
});
|
||||
|
||||
// The reason this is a function rather than an inline Math.ceil. Every route
|
||||
// had its own copy, and each shared this edge: a window on the point of
|
||||
// expiring gives 0, and `Retry-After: 0` tells the client to retry at once —
|
||||
// the opposite of what a 429 means. A past resetAt gives a negative number,
|
||||
// which is not valid HTTP at all.
|
||||
it('never returns zero or a negative value', () => {
|
||||
expect(retryAfterSeconds(Date.now())).toBe(1);
|
||||
expect(retryAfterSeconds(Date.now() + 10)).toBe(1);
|
||||
expect(retryAfterSeconds(Date.now() - 60_000)).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('checkRateLimit', () => {
|
||||
// Use unique IP prefixes per test to avoid cross-contamination
|
||||
let testIp: string;
|
||||
|
||||
82
lib/__tests__/yaml-write.test.ts
Normal file
82
lib/__tests__/yaml-write.test.ts
Normal file
@@ -0,0 +1,82 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
||||
|
||||
vi.mock('fs/promises', () => ({
|
||||
default: {
|
||||
mkdir: vi.fn(async () => undefined),
|
||||
access: vi.fn(async () => {
|
||||
throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
|
||||
}),
|
||||
copyFile: vi.fn(async () => undefined),
|
||||
readdir: vi.fn(async () => []),
|
||||
unlink: vi.fn(async () => undefined),
|
||||
writeFile: vi.fn(async () => undefined),
|
||||
rename: vi.fn(async () => undefined),
|
||||
readFile: vi.fn(),
|
||||
},
|
||||
}));
|
||||
|
||||
import fs from 'fs/promises';
|
||||
import { writeGalleryYaml } from '@/lib/admin/yaml-service';
|
||||
|
||||
const gallery = { albums: ['11111111-1111-1111-1111-111111111111'] };
|
||||
|
||||
const tmpPaths = () => vi.mocked(fs.writeFile).mock.calls.map((c) => String(c[0]));
|
||||
|
||||
/**
|
||||
* The rename is what makes the write atomic; the temp filename is what did not
|
||||
* used to be. With a constant `gallery.yaml.tmp`, two saves in flight at once
|
||||
* shared it, so the second writeFile could interleave with the first's rename.
|
||||
*/
|
||||
describe('writeYamlFile temp file handling', () => {
|
||||
beforeEach(() => vi.clearAllMocks());
|
||||
|
||||
it('never writes to the bare .tmp path two callers would collide on', async () => {
|
||||
await writeGalleryYaml(gallery);
|
||||
expect(tmpPaths()[0]).not.toMatch(/gallery\.yaml\.tmp$/);
|
||||
});
|
||||
|
||||
it('uses a distinct temp path for every write', async () => {
|
||||
await writeGalleryYaml(gallery);
|
||||
await writeGalleryYaml(gallery);
|
||||
await writeGalleryYaml(gallery);
|
||||
|
||||
const paths = tmpPaths();
|
||||
expect(paths).toHaveLength(3);
|
||||
expect(new Set(paths).size).toBe(3);
|
||||
});
|
||||
|
||||
it('renames the temp file it just wrote, not some other one', async () => {
|
||||
await writeGalleryYaml(gallery);
|
||||
|
||||
const [written] = tmpPaths();
|
||||
const [from, to] = vi.mocked(fs.rename).mock.calls[0].map(String);
|
||||
expect(from).toBe(written);
|
||||
expect(to).toMatch(/content\/gallery\.yaml$/);
|
||||
});
|
||||
|
||||
it('cleans up the temp file when the write fails', async () => {
|
||||
vi.mocked(fs.writeFile).mockRejectedValueOnce(new Error('ENOSPC'));
|
||||
|
||||
await expect(writeGalleryYaml(gallery)).rejects.toThrow('ENOSPC');
|
||||
expect(String(vi.mocked(fs.unlink).mock.calls[0][0])).toBe(tmpPaths()[0]);
|
||||
});
|
||||
|
||||
it('cleans up when the rename fails', async () => {
|
||||
vi.mocked(fs.rename).mockRejectedValueOnce(new Error('EXDEV'));
|
||||
|
||||
await expect(writeGalleryYaml(gallery)).rejects.toThrow('EXDEV');
|
||||
expect(fs.unlink).toHaveBeenCalledOnce();
|
||||
});
|
||||
|
||||
it('does not let a cleanup failure mask the real error', async () => {
|
||||
vi.mocked(fs.writeFile).mockRejectedValueOnce(new Error('ENOSPC'));
|
||||
vi.mocked(fs.unlink).mockRejectedValueOnce(new Error('EACCES'));
|
||||
|
||||
await expect(writeGalleryYaml(gallery)).rejects.toThrow('ENOSPC');
|
||||
});
|
||||
|
||||
it('does not unlink on the happy path', async () => {
|
||||
await writeGalleryYaml(gallery);
|
||||
expect(fs.unlink).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user