Shade/packages/shade-files/tests/unit/inline-threshold.test.ts

import { describe, expect, test } from 'bun:test';
import { decideInline, INLINE_THRESHOLD } from '../../src/client/inline-threshold.js';

const KIB = 1024;

function streamOf(...chunks: Uint8Array[]): ReadableStream<Uint8Array> {
  let i = 0;
  return new ReadableStream<Uint8Array>({
    pull(controller) {
      if (i < chunks.length) {
        controller.enqueue(chunks[i]!);
        i++;
      } else {
        controller.close();
      }
    },
  });
}

async function drainStream(s: ReadableStream<Uint8Array>): Promise<Uint8Array> {
  const reader = s.getReader();
  const parts: Uint8Array[] = [];
  let total = 0;
  while (true) {
    const { value, done } = await reader.read();
    if (done) break;
    if (value === undefined) continue;
    parts.push(value);
    total += value.byteLength;
  }
  reader.releaseLock();
  const out = new Uint8Array(total);
  let offset = 0;
  for (const p of parts) {
    out.set(p, offset);
    offset += p.byteLength;
  }
  return out;
}

describe('decideInline (Uint8Array)', () => {
  test('1 KiB → inline', async () => {
    const bytes = new Uint8Array(KIB).fill(0xab);
    const decision = await decideInline(bytes);
    expect(decision.kind).toBe('inline');
    if (decision.kind === 'inline') {
      expect(decision.bytes.byteLength).toBe(KIB);
    }
  });

  test('exactly 256 KiB → inline (boundary)', async () => {
    const bytes = new Uint8Array(INLINE_THRESHOLD).fill(0xcd);
    const decision = await decideInline(bytes);
    expect(decision.kind).toBe('inline');
  });

  test('256 KiB + 1 → streams (boundary +1)', async () => {
    const bytes = new Uint8Array(INLINE_THRESHOLD + 1).fill(0xef);
    const decision = await decideInline(bytes);
    expect(decision.kind).toBe('streams');
    if (decision.kind === 'streams') {
      expect(decision.size).toBe(INLINE_THRESHOLD + 1);
      const drained = await drainStream(decision.stream);
      expect(drained.byteLength).toBe(INLINE_THRESHOLD + 1);
    }
  });
});

describe('decideInline (Blob)', () => {
  test('small Blob → inline + propagates contentType', async () => {
    const blob = new Blob([new Uint8Array(100).fill(7)], { type: 'application/octet-stream' });
    const decision = await decideInline(blob);
    expect(decision.kind).toBe('inline');
    if (decision.kind === 'inline') {
      expect(decision.contentType).toBe('application/octet-stream');
      expect(decision.bytes.byteLength).toBe(100);
    }
  });

  test('large Blob → streams + propagates size + contentType', async () => {
    const big = new Uint8Array(INLINE_THRESHOLD + KIB).fill(1);
    const blob = new Blob([big], { type: 'image/png' });
    const decision = await decideInline(blob);
    expect(decision.kind).toBe('streams');
    if (decision.kind === 'streams') {
      expect(decision.size).toBe(big.byteLength);
      expect(decision.contentType).toBe('image/png');
    }
  });

  test('empty Blob.type → no contentType', async () => {
    const blob = new Blob([new Uint8Array(10)]);
    const decision = await decideInline(blob);
    expect(decision.kind).toBe('inline');
    if (decision.kind === 'inline') {
      expect(decision.contentType).toBeUndefined();
    }
  });
});

describe('decideInline (ReadableStream — bare)', () => {
  test('EOF before threshold → inline', async () => {
    const stream = streamOf(new Uint8Array(100), new Uint8Array(200));
    const decision = await decideInline(stream);
    expect(decision.kind).toBe('inline');
    if (decision.kind === 'inline') {
      expect(decision.bytes.byteLength).toBe(300);
    }
  });

  test('crosses threshold mid-chunk → streams + remainder available', async () => {
    // 256 KiB + 1 byte across two chunks
    const a = new Uint8Array(200 * KIB).fill(0x10);
    const b = new Uint8Array(100 * KIB).fill(0x20);
    const stream = streamOf(a, b);
    const decision = await decideInline(stream);
    expect(decision.kind).toBe('streams');
    if (decision.kind === 'streams') {
      const drained = await drainStream(decision.stream);
      expect(drained.byteLength).toBe(a.byteLength + b.byteLength);
      expect(drained[0]).toBe(0x10);
      expect(drained[drained.length - 1]).toBe(0x20);
    }
  });

  test('empty stream → inline (zero bytes)', async () => {
    const stream = streamOf();
    const decision = await decideInline(stream);
    expect(decision.kind).toBe('inline');
    if (decision.kind === 'inline') {
      expect(decision.bytes.byteLength).toBe(0);
    }
  });
});

describe('decideInline ({ stream, size })', () => {
  test('declared size ≤ threshold → inline', async () => {
    const bytes = new Uint8Array(KIB).fill(9);
    const decision = await decideInline({ stream: streamOf(bytes), size: KIB, contentType: 'text/plain' });
    expect(decision.kind).toBe('inline');
    if (decision.kind === 'inline') {
      expect(decision.bytes.byteLength).toBe(KIB);
      expect(decision.contentType).toBe('text/plain');
    }
  });

  test('declared size > threshold → streams', async () => {
    const big = new Uint8Array(500 * KIB).fill(2);
    const decision = await decideInline({ stream: streamOf(big), size: big.byteLength });
    expect(decision.kind).toBe('streams');
    if (decision.kind === 'streams') {
      expect(decision.size).toBe(big.byteLength);
    }
  });
});

describe('decideInline (errors)', () => {
  test('unsupported input throws TypeError', async () => {
    await expect(decideInline(42 as unknown as Uint8Array)).rejects.toThrow(TypeError);
  });
});