Shade/packages/shade-files/tests/integration/thumbnail.test.ts

import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
import { sha256 } from '@noble/hashes/sha2.js';
import { ConflictError, NotFoundError } from '../../src/index.js';
import { setupFileRig, type FileTestRig } from './helpers/rig.js';

function bytesToHex(b: Uint8Array): string {
  return Array.from(b, (x) => x.toString(16).padStart(2, '0')).join('');
}

// Minimal valid PNG: 8-byte signature + IHDR + zero-byte IDAT + IEND. We
// use realistic magic bytes so the format-hardening check accepts it.
function tinyPng(): Uint8Array {
  const sig = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
  const filler = new Uint8Array(20);
  const out = new Uint8Array(sig.length + filler.length);
  out.set(sig, 0);
  out.set(filler, sig.length);
  return out;
}

function tinyJpeg(): Uint8Array {
  const head = new Uint8Array([0xff, 0xd8, 0xff, 0xe0]);
  const filler = new Uint8Array(12);
  const out = new Uint8Array(head.length + filler.length);
  out.set(head, 0);
  out.set(filler, head.length);
  return out;
}

function tinyWebp(): Uint8Array {
  // 'RIFF' + sizeLE + 'WEBP' + 'VP8 ' (or 'VP8L' / 'VP8X')
  const out = new Uint8Array(20);
  out.set([0x52, 0x49, 0x46, 0x46], 0);            // 'RIFF'
  out.set([0x0c, 0x00, 0x00, 0x00], 4);            // size little-endian (12 bytes follow)
  out.set([0x57, 0x45, 0x42, 0x50], 8);            // 'WEBP'
  out.set([0x56, 0x50, 0x38, 0x20], 12);           // 'VP8 '
  return out;
}

describe('Content I/O — getThumbnail E2E with format hardening', () => {
  let rig: FileTestRig;
  // Map: path → (size → { bytes, format })
  const thumbnails = new Map<string, Map<number, { bytes: Uint8Array; format: 'png' | 'webp' | 'jpeg' }>>();

  beforeAll(async () => {
    thumbnails.clear();
    thumbnails.set(
      '/photo.png',
      new Map([
        [64, { bytes: tinyPng(), format: 'png' }],
        [128, { bytes: tinyPng(), format: 'png' }],
      ]),
    );
    thumbnails.set(
      '/holiday.jpg',
      new Map([[256, { bytes: tinyJpeg(), format: 'jpeg' }]]),
    );
    thumbnails.set(
      '/icon.webp',
      new Map([[64, { bytes: tinyWebp(), format: 'webp' }]]),
    );
    // Mismatched format: server returns PNG bytes but claims JPEG.
    thumbnails.set('/lying.png', new Map([[64, { bytes: tinyPng(), format: 'jpeg' }]]));

    rig = await setupFileRig({
      getThumbnail: async (ctx) => {
        const sizes = thumbnails.get(ctx.path);
        if (sizes === undefined) throw new NotFoundError(ctx.path);
        const entry = sizes.get(ctx.args.size);
        if (entry === undefined) throw new NotFoundError(`${ctx.path}@${ctx.args.size}`);
        return {
          bytes: entry.bytes,
          format: entry.format,
          width: ctx.args.size,
          height: ctx.args.size,
        };
      },
    });
  });

  afterAll(async () => {
    await rig.teardown();
  });

  test('PNG thumbnail round-trips with computed sha256', async () => {
    const result = await rig.fs.getThumbnail('/photo.png', 64);
    expect(result.format).toBe('png');
    expect(result.width).toBe(64);
    expect(result.height).toBe(64);
    expect(result.sha256).toBe(bytesToHex(sha256(result.bytes)));
    // Verify magic bytes survived
    expect(Array.from(result.bytes.slice(0, 8))).toEqual([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
  });

  test('JPEG thumbnail round-trips', async () => {
    const result = await rig.fs.getThumbnail('/holiday.jpg', 256);
    expect(result.format).toBe('jpeg');
    expect(result.width).toBe(256);
    expect(Array.from(result.bytes.slice(0, 3))).toEqual([0xff, 0xd8, 0xff]);
  });

  test('WebP thumbnail round-trips', async () => {
    const result = await rig.fs.getThumbnail('/icon.webp', 64);
    expect(result.format).toBe('webp');
    expect(Array.from(result.bytes.slice(0, 4))).toEqual([0x52, 0x49, 0x46, 0x46]);
    expect(Array.from(result.bytes.slice(8, 12))).toEqual([0x57, 0x45, 0x42, 0x50]);
  });

  test('PNG bytes claimed as JPEG → format-hardening rejects', async () => {
    await expect(rig.fs.getThumbnail('/lying.png', 64)).rejects.toBeInstanceOf(ConflictError);
  });

  test('non-existent path → NotFoundError', async () => {
    await expect(rig.fs.getThumbnail('/missing.png', 64)).rejects.toBeInstanceOf(NotFoundError);
  });

  test('different sizes return different thumbnails', async () => {
    const small = await rig.fs.getThumbnail('/photo.png', 64);
    const big = await rig.fs.getThumbnail('/photo.png', 128);
    expect(small.width).toBe(64);
    expect(big.width).toBe(128);
  });
});