280 lines
10 KiB
TypeScript
280 lines
10 KiB
TypeScript
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
||
import { NextRequest, NextResponse } from 'next/server';
|
||
import {
|
||
LAT,
|
||
asciiOf,
|
||
cameraHeic,
|
||
cameraJpeg,
|
||
chunked,
|
||
contains,
|
||
exifOf,
|
||
heicExif,
|
||
latin1,
|
||
parseTiff,
|
||
} from '@/lib/__tests__/fixtures/location';
|
||
|
||
/**
|
||
* GET /api/zoom/[album]/[id] (#467): the full-resolution file behind the
|
||
* lightbox zoom. Every refusal is the same 404; the route checks are tested
|
||
* here, the per-route zoom/password resolution in lib/__tests__/auth-zoom.
|
||
*/
|
||
|
||
vi.mock('@/lib/config', () => ({ getConfig: vi.fn() }));
|
||
vi.mock('@/lib/tokens', () => ({
|
||
decodeAssetId: vi.fn((t: string) => (t.startsWith('tok-') ? t.replace('tok-', '') : null)),
|
||
}));
|
||
vi.mock('@/lib/immich', () => ({
|
||
immich: { getAlbum: vi.fn(), streamAsset: vi.fn(), streamFullsize: vi.fn() },
|
||
ImmichUnavailableError: class ImmichUnavailableError extends Error {},
|
||
}));
|
||
vi.mock('@/lib/rate-limit', () => ({
|
||
checkRateLimit: vi.fn(() => ({ success: true, resetAt: 0 })),
|
||
getClientIp: vi.fn(() => '127.0.0.1'),
|
||
retryAfterSeconds: vi.fn(() => 60),
|
||
}));
|
||
vi.mock('@/lib/auth', () => ({
|
||
siteLockResponse: vi.fn(() => null),
|
||
isAlbumZoomReachable: vi.fn(() => true),
|
||
}));
|
||
vi.mock('@/lib/publishedAssets', () => ({ isPublishedAsset: vi.fn(async () => true) }));
|
||
vi.mock('next/headers', () => ({
|
||
cookies: vi.fn(() => Promise.resolve({ get: () => undefined })),
|
||
}));
|
||
|
||
import { GET } from '../route';
|
||
import { getConfig } from '@/lib/config';
|
||
import { immich, ImmichUnavailableError } from '@/lib/immich';
|
||
import { checkRateLimit } from '@/lib/rate-limit';
|
||
import { isAlbumZoomReachable, siteLockResponse } from '@/lib/auth';
|
||
import { isPublishedAsset } from '@/lib/publishedAssets';
|
||
|
||
const mocked = <T>(fn: T) => fn as unknown as ReturnType<typeof vi.fn>;
|
||
|
||
const asset = (id: string, originalMimeType: string, type = 'IMAGE') => ({
|
||
id,
|
||
type,
|
||
originalMimeType,
|
||
originalFileName: `${id}.bin`,
|
||
});
|
||
|
||
const ALBUM = {
|
||
id: 'album',
|
||
albumName: 'Album',
|
||
assets: [
|
||
asset('jpeg', 'image/jpeg'),
|
||
asset('avif', 'image/avif'),
|
||
asset('heic', 'image/heic'),
|
||
asset('png', 'image/png'),
|
||
asset('webp', 'image/webp'),
|
||
asset('mov', 'video/quicktime', 'VIDEO'),
|
||
{ ...asset('edited', 'image/jpeg'), isEdited: true },
|
||
{ ...asset('edited-heic', 'image/heic'), isEdited: true },
|
||
],
|
||
};
|
||
|
||
function upstream(data: Uint8Array, contentType: string) {
|
||
return { stream: chunked(data, 1000), contentType, contentLength: String(data.length) };
|
||
}
|
||
|
||
const zoom = (assetToken = 'tok-jpeg', albumToken = 'tok-album') =>
|
||
GET(new NextRequest(`http://localhost/api/zoom/${albumToken}/${assetToken}`), {
|
||
params: Promise.resolve({ album: albumToken, id: assetToken }),
|
||
});
|
||
|
||
/** A HEIF-family file branded as AVIF, as Lightroom writes one. */
|
||
function avifFile() {
|
||
const { file } = cameraHeic();
|
||
const out = file.slice();
|
||
out.set([0x61, 0x76, 0x69, 0x66], 8); // major brand → 'avif'
|
||
return out;
|
||
}
|
||
|
||
beforeEach(() => {
|
||
vi.clearAllMocks();
|
||
mocked(getConfig).mockReturnValue({ albums: ['album'] });
|
||
mocked(immich.getAlbum).mockResolvedValue(ALBUM);
|
||
});
|
||
|
||
describe('refusals', () => {
|
||
it('answers a locked site with the lock, before anything else', async () => {
|
||
mocked(siteLockResponse).mockReturnValueOnce(
|
||
NextResponse.json(
|
||
{ error: 'locked' },
|
||
{ status: 401, headers: { 'Cache-Control': 'no-store' } },
|
||
),
|
||
);
|
||
const res = await zoom();
|
||
expect(res.status).toBe(401);
|
||
expect(immich.getAlbum).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('rate-limits in its own bucket', async () => {
|
||
mocked(checkRateLimit).mockReturnValueOnce({ success: false, resetAt: Date.now() + 1000 });
|
||
const res = await zoom();
|
||
expect(res.status).toBe(429);
|
||
expect(res.headers.get('cache-control')).toBe('no-store');
|
||
expect(res.headers.get('retry-after')).toBe('60');
|
||
expect(checkRateLimit).toHaveBeenCalledWith('zoom:127.0.0.1', 20);
|
||
});
|
||
|
||
it.each([
|
||
['an undecodable album token', () => zoom('tok-jpeg', 'garbage')],
|
||
['an undecodable asset token', () => zoom('garbage')],
|
||
])('refuses %s', async (_name, call) => {
|
||
const res = await call();
|
||
expect(res.status).toBe(404);
|
||
expect(res.headers.get('cache-control')).toBe('no-store');
|
||
});
|
||
|
||
it('refuses an album that is not on the allowlist', async () => {
|
||
mocked(getConfig).mockReturnValue({ albums: ['other'] });
|
||
expect((await zoom()).status).toBe(404);
|
||
expect(isAlbumZoomReachable).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('refuses when zoom is off, or the album is locked, hidden behind an offline page …', async () => {
|
||
// isAlbumZoomReachable covers each of those (lib/__tests__/auth-zoom).
|
||
mocked(isAlbumZoomReachable).mockReturnValueOnce(false);
|
||
const res = await zoom();
|
||
expect(res.status).toBe(404);
|
||
expect(isAlbumZoomReachable).toHaveBeenCalledWith('album', expect.any(Function));
|
||
expect(immich.streamAsset).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('refuses an asset the site no longer publishes', async () => {
|
||
mocked(isPublishedAsset).mockResolvedValueOnce(false);
|
||
expect((await zoom()).status).toBe(404);
|
||
expect(immich.getAlbum).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('refuses an asset from another album', async () => {
|
||
expect((await zoom('tok-elsewhere')).status).toBe(404);
|
||
expect(immich.streamAsset).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it.each(['png', 'webp', 'mov'])('never streams a %s', async (id) => {
|
||
expect((await zoom(`tok-${id}`)).status).toBe(404);
|
||
expect(immich.streamAsset).not.toHaveBeenCalled();
|
||
expect(immich.streamFullsize).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('answers 503 while Immich is down', async () => {
|
||
mocked(immich.getAlbum).mockRejectedValueOnce(new ImmichUnavailableError('down'));
|
||
const res = await zoom();
|
||
expect(res.status).toBe(503);
|
||
expect(res.headers.get('cache-control')).toBe('no-store');
|
||
});
|
||
});
|
||
|
||
describe('the JPEG original', () => {
|
||
it('goes out without GPS, inline, privately cached, length intact', async () => {
|
||
const { file } = cameraJpeg(true);
|
||
mocked(immich.streamAsset).mockResolvedValue(upstream(file, 'image/jpeg'));
|
||
|
||
const res = await zoom();
|
||
expect(res.status).toBe(200);
|
||
expect(immich.streamAsset).toHaveBeenCalledWith('jpeg', 'original');
|
||
expect(immich.streamFullsize).not.toHaveBeenCalled();
|
||
expect(res.headers.get('content-type')).toBe('image/jpeg');
|
||
expect(res.headers.get('content-disposition')).toBe('inline');
|
||
expect(res.headers.get('x-content-type-options')).toBe('nosniff');
|
||
expect(res.headers.get('cache-control')).toBe('private, max-age=3600');
|
||
expect(res.headers.get('content-length')).toBe(String(file.length));
|
||
|
||
const body = new Uint8Array(await res.arrayBuffer());
|
||
expect(body.length).toBe(file.length);
|
||
const tiff = parseTiff(exifOf(body)!);
|
||
expect(tiff.gps).toBeNull();
|
||
expect(asciiOf(tiff.ifd0.get(0x0110))).toBe('Canon EOS R5');
|
||
expect(contains(body, LAT.value(true))).toBe(false);
|
||
expect(latin1(body)).not.toMatch(/exif:GPS/);
|
||
});
|
||
|
||
it('is refused when its metadata cannot be located', async () => {
|
||
mocked(immich.streamAsset).mockResolvedValue({
|
||
stream: chunked(new Uint8Array([0xff, 0xd8, 0xff, 0xe1, 0x40, 0x00, 0x45, 0x78]), 8),
|
||
contentType: 'image/jpeg',
|
||
contentLength: '8',
|
||
});
|
||
expect((await zoom()).status).toBe(404);
|
||
});
|
||
|
||
it('is refused when the bytes are not a JPEG at all', async () => {
|
||
// Labelled JPEG, actually a PNG: the scrubber would pass it through
|
||
// untouched, eXIf chunk and all.
|
||
const png = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 1, 2, 3]);
|
||
mocked(immich.streamAsset).mockResolvedValue(upstream(png, 'image/jpeg'));
|
||
expect((await zoom()).status).toBe(404);
|
||
});
|
||
});
|
||
|
||
describe('the AVIF original', () => {
|
||
it('goes out without GPS', async () => {
|
||
const file = avifFile();
|
||
mocked(immich.streamAsset).mockResolvedValue(upstream(file, 'image/avif'));
|
||
const res = await zoom('tok-avif');
|
||
expect(res.status).toBe(200);
|
||
expect(res.headers.get('content-type')).toBe('image/avif');
|
||
const body = new Uint8Array(await res.arrayBuffer());
|
||
expect(body.length).toBe(file.length);
|
||
expect(parseTiff(heicExif(body)!).gps).toBeNull();
|
||
});
|
||
});
|
||
|
||
describe('a HEIC (not browser-displayable)', () => {
|
||
it('uses Immich’s full-size rendition, scrubbed', async () => {
|
||
const { file } = cameraJpeg(false);
|
||
mocked(immich.streamFullsize).mockResolvedValue(upstream(file, 'image/jpeg'));
|
||
const res = await zoom('tok-heic');
|
||
expect(res.status).toBe(200);
|
||
expect(immich.streamFullsize).toHaveBeenCalledWith('heic', false);
|
||
expect(immich.streamAsset).not.toHaveBeenCalled();
|
||
const body = new Uint8Array(await res.arrayBuffer());
|
||
expect(parseTiff(exifOf(body)!).gps).toBeNull();
|
||
});
|
||
|
||
it('is 404 when Immich has no rendition', async () => {
|
||
mocked(immich.streamFullsize).mockResolvedValue(null);
|
||
const res = await zoom('tok-heic');
|
||
expect(res.status).toBe(404);
|
||
expect(res.headers.get('cache-control')).toBe('no-store');
|
||
});
|
||
|
||
it('never sends the HEIC original itself', async () => {
|
||
mocked(immich.streamFullsize).mockResolvedValue(upstream(cameraHeic().file, 'image/heic'));
|
||
expect((await zoom('tok-heic')).status).toBe(404);
|
||
});
|
||
|
||
it('refuses a WebP rendition, whose metadata is not scrubbed', async () => {
|
||
const webp = new TextEncoder().encode('RIFF\x10\x00\x00\x00WEBPVP8 ');
|
||
mocked(immich.streamFullsize).mockResolvedValue(upstream(webp, 'image/webp'));
|
||
expect((await zoom('tok-heic')).status).toBe(404);
|
||
});
|
||
});
|
||
|
||
describe('a photo edited in Immich (#831)', () => {
|
||
it.each(['edited', 'edited-heic'])(
|
||
'zooms a %s into the edited full-size rendition, never the original',
|
||
async (id) => {
|
||
// Immich's edited rendition is a JPEG; given one with GPS here, the
|
||
// scrubber still has to take it out.
|
||
const { file } = cameraJpeg(true);
|
||
mocked(immich.streamFullsize).mockResolvedValue(upstream(file, 'image/jpeg'));
|
||
const res = await zoom(`tok-${id}`);
|
||
expect(res.status).toBe(200);
|
||
expect(immich.streamFullsize).toHaveBeenCalledWith(id, true);
|
||
expect(immich.streamAsset).not.toHaveBeenCalled();
|
||
const body = new Uint8Array(await res.arrayBuffer());
|
||
expect(parseTiff(exifOf(body)!).gps).toBeNull();
|
||
expect(contains(body, LAT.value(true))).toBe(false);
|
||
},
|
||
);
|
||
|
||
it('is 404 when Immich has no edited rendition', async () => {
|
||
mocked(immich.streamFullsize).mockResolvedValue(null);
|
||
const res = await zoom('tok-edited');
|
||
expect(res.status).toBe(404);
|
||
expect(res.headers.get('cache-control')).toBe('no-store');
|
||
});
|
||
});
|