imgs.blue / test / index.spec.ts

import { env, createExecutionContext, waitOnExecutionContext, SELF } from 'cloudflare:test';
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { CID } from 'multiformats/cid';
import worker, {
  base62ToBytes,
  detectIdentifierFormat,
  resolveHandleToDID,
  resolvePDSHost,
  fetchBlobCidFromRecord,
  downloadBlobUnauthenticated,
} from '../src/index';

const IncomingRequest = Request<unknown, IncomingRequestCfProperties>;

// Test constants
const TEST_DID = 'did:plc:ewvi7nxzyoun6zhxrhs64oiz';
const TEST_HANDLE = 'bsky.app';
const TEST_CID = 'bafkreihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzjevtenxquvyku';
const TEST_TID = '3jui7kd5354sr';
const TEST_PDS = 'https://bsky.social';

describe('base62ToBytes', () => {
  it('converts empty string to empty Uint8Array', () => {
    const result = base62ToBytes('');
    expect(result).toEqual(new Uint8Array([]));
  });

  it('converts single character correctly', () => {
    const result = base62ToBytes('1');
    expect(result).toEqual(new Uint8Array([1]));
  });

  it('converts known base62 to correct bytes', () => {
    // Test with "10" which is 62 in decimal (1*62 + 0)
    const result = base62ToBytes('10');
    expect(result).toEqual(new Uint8Array([62]));
  });

  it('handles larger numbers correctly', () => {
    // "100" = 1*62^2 + 0*62 + 0 = 3844
    const result = base62ToBytes('100');
    // 3844 = 0x0F04, so bytes are [15, 4]
    expect(result).toEqual(new Uint8Array([15, 4]));
  });

  it('round-trips through CID decode', () => {
    // Create a valid CID, encode to base62-ish bytes, then decode
    const cid = CID.parse(TEST_CID);
    const bytes = cid.bytes;

    // Encode bytes to base62
    const BASE62_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
    let num = 0n;
    for (const byte of bytes) {
      num = num * 256n + BigInt(byte);
    }
    let base62 = '';
    while (num > 0n) {
      base62 = BASE62_CHARS[Number(num % 62n)] + base62;
      num = num / 62n;
    }

    // Now decode back using our function
    const decoded = base62ToBytes(base62);
    const decodedCid = CID.decode(decoded);
    expect(decodedCid.toString()).toBe(TEST_CID);
  });
});

describe('detectIdentifierFormat', () => {
  it('detects base32 CID format (bafkrei prefix)', () => {
    expect(detectIdentifierFormat('bafkreihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzjevtenxquvyku')).toBe('base32');
    expect(detectIdentifierFormat('bafkreiabc')).toBe('base32');
  });

  it('detects TID format (13 chars matching pattern)', () => {
    expect(detectIdentifierFormat('3jui7kd5354sr')).toBe('tid');
    expect(detectIdentifierFormat('3kfg2b5fyjk2i')).toBe('tid');
  });

  it('returns base62 for other formats', () => {
    expect(detectIdentifierFormat('abc123XYZ')).toBe('base62');
    expect(detectIdentifierFormat('shortCID')).toBe('base62');
  });

  it('returns base62 for invalid TID length', () => {
    // Too short
    expect(detectIdentifierFormat('3jui7kd535')).toBe('base62');
    // Too long
    expect(detectIdentifierFormat('3jui7kd5354srx')).toBe('base62');
  });

  it('returns base62 for invalid TID characters', () => {
    // Contains invalid first character (0, 1, or other invalid)
    expect(detectIdentifierFormat('0jui7kd5354sr')).toBe('base62');
    expect(detectIdentifierFormat('1jui7kd5354sr')).toBe('base62');
  });
});

describe('resolveHandleToDID', () => {
  beforeEach(() => {
    vi.stubGlobal('fetch', vi.fn());
  });

  afterEach(() => {
    vi.unstubAllGlobals();
  });

  it('resolves DID via DNS-over-HTTPS', async () => {
    const mockFetch = vi.fn().mockResolvedValueOnce({
      ok: true,
      json: async () => ({
        Answer: [
          { type: 16, data: `"did=${TEST_DID}"` }
        ]
      })
    });
    vi.stubGlobal('fetch', mockFetch);

    const did = await resolveHandleToDID(TEST_HANDLE);
    expect(did).toBe(TEST_DID);
    expect(mockFetch).toHaveBeenCalledWith(
      expect.stringContaining(`_atproto.${TEST_HANDLE}`),
      expect.any(Object)
    );
  });

  it('falls back to HTTPS well-known when DNS fails', async () => {
    const mockFetch = vi.fn()
      // First call (DNS) fails
      .mockResolvedValueOnce({
        ok: false
      })
      // Second call (well-known) succeeds
      .mockResolvedValueOnce({
        status: 200,
        text: async () => TEST_DID
      });
    vi.stubGlobal('fetch', mockFetch);

    const did = await resolveHandleToDID(TEST_HANDLE);
    expect(did).toBe(TEST_DID);
    expect(mockFetch).toHaveBeenCalledTimes(2);
  });

  it('returns null when all resolution methods fail', async () => {
    const mockFetch = vi.fn()
      .mockResolvedValueOnce({ ok: false })
      .mockResolvedValueOnce({ status: 404 });
    vi.stubGlobal('fetch', mockFetch);

    const did = await resolveHandleToDID('nonexistent.handle');
    expect(did).toBeNull();
  });

  it('extracts DID from DNS response with quotes', async () => {
    const mockFetch = vi.fn().mockResolvedValueOnce({
      ok: true,
      json: async () => ({
        Answer: [
          { type: 16, data: '"did=did:plc:z72i7hdynmk6r22z27h6tvur"' }
        ]
      })
    });
    vi.stubGlobal('fetch', mockFetch);

    const did = await resolveHandleToDID('example.com');
    expect(did).toBe('did:plc:z72i7hdynmk6r22z27h6tvur');
  });

  it('resolves DID via native DNS when available', async () => {
    const mockResolveDns = vi.fn().mockResolvedValue(['did=did:plc:nativedns123']);
    vi.stubGlobal('resolveDns', mockResolveDns);

    const did = await resolveHandleToDID('native.test');
    expect(did).toBe('did:plc:nativedns123');
    expect(mockResolveDns).toHaveBeenCalledWith('_atproto.native.test', 'TXT');

    vi.unstubAllGlobals();
  });

  it('handles native DNS throwing exception', async () => {
    const mockResolveDns = vi.fn().mockRejectedValue(new Error('DNS error'));
    vi.stubGlobal('resolveDns', mockResolveDns);

    // DNS throws, should fall back to DNS-over-HTTPS
    const mockFetch = vi.fn().mockResolvedValueOnce({
      ok: true,
      json: async () => ({
        Answer: [{ type: 16, data: '"did=did:plc:fallback123"' }]
      })
    });
    vi.stubGlobal('fetch', mockFetch);

    const did = await resolveHandleToDID('fallback.test');
    expect(did).toBe('did:plc:fallback123');

    vi.unstubAllGlobals();
  });

  it('handles DNS-over-HTTPS fetch exception', async () => {
    const mockFetch = vi.fn()
      // DNS-over-HTTPS throws
      .mockRejectedValueOnce(new Error('Network error'))
      // HTTPS well-known succeeds
      .mockResolvedValueOnce({
        status: 200,
        text: async () => 'did:plc:wellknown123'
      });
    vi.stubGlobal('fetch', mockFetch);

    const did = await resolveHandleToDID('wellknown.test');
    expect(did).toBe('did:plc:wellknown123');
  });

  it('handles HTTPS well-known fetch exception', async () => {
    const mockFetch = vi.fn()
      // DNS-over-HTTPS fails
      .mockResolvedValueOnce({ ok: false })
      // HTTPS well-known throws
      .mockRejectedValueOnce(new Error('Connection refused'));
    vi.stubGlobal('fetch', mockFetch);

    const did = await resolveHandleToDID('error.test');
    expect(did).toBeNull();
  });
});

describe('resolvePDSHost', () => {
  beforeEach(() => {
    vi.stubGlobal('fetch', vi.fn());
  });

  afterEach(() => {
    vi.unstubAllGlobals();
  });

  it('resolves PDS host for did:plc via PLC directory', async () => {
    const mockFetch = vi.fn().mockResolvedValueOnce({
      ok: true,
      json: async () => ({
        service: [
          { id: '#atproto_pds', type: 'AtprotoPersonalDataServer', serviceEndpoint: TEST_PDS }
        ]
      })
    });
    vi.stubGlobal('fetch', mockFetch);

    const pdsHost = await resolvePDSHost(TEST_DID);
    expect(pdsHost).toBe(TEST_PDS);
    expect(mockFetch).toHaveBeenCalled();
  });

  it('resolves PDS host for did:web via well-known', async () => {
    const webDid = 'did:web:example.com';
    const mockFetch = vi.fn().mockResolvedValueOnce({
      ok: true,
      json: async () => ({
        service: [
          { id: '#atproto_pds', type: 'AtprotoPersonalDataServer', serviceEndpoint: 'https://pds.example.com' }
        ]
      })
    });
    vi.stubGlobal('fetch', mockFetch);

    const pdsHost = await resolvePDSHost(webDid);
    expect(pdsHost).toBe('https://pds.example.com');
    expect(mockFetch).toHaveBeenCalled();
  });

  it('returns null when PDS not found', async () => {
    const mockFetch = vi.fn().mockResolvedValueOnce({
      ok: false
    });
    vi.stubGlobal('fetch', mockFetch);

    const pdsHost = await resolvePDSHost(TEST_DID);
    expect(pdsHost).toBeNull();
  });

  it('returns null when service array is missing', async () => {
    const mockFetch = vi.fn().mockResolvedValueOnce({
      ok: true,
      json: async () => ({})
    });
    vi.stubGlobal('fetch', mockFetch);

    const pdsHost = await resolvePDSHost(TEST_DID);
    expect(pdsHost).toBeNull();
  });

  it('returns null when fetch throws exception', async () => {
    const mockFetch = vi.fn().mockRejectedValueOnce(new Error('Network error'));
    vi.stubGlobal('fetch', mockFetch);

    const pdsHost = await resolvePDSHost(TEST_DID);
    expect(pdsHost).toBeNull();
  });
});

describe('fetchBlobCidFromRecord', () => {
  beforeEach(() => {
    vi.stubGlobal('fetch', vi.fn());
  });

  afterEach(() => {
    vi.unstubAllGlobals();
  });

  it('fetches blob CID from record', async () => {
    const mockFetch = vi.fn()
      // First call: resolvePDSHost
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          service: [{ id: '#atproto_pds', serviceEndpoint: TEST_PDS }]
        })
      })
      // Second call: getRecord
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          uri: `at://${TEST_DID}/blue.imgs.blup.image/${TEST_TID}`,
          cid: 'somecid',
          value: {
            blob: {
              ref: { $link: TEST_CID }
            }
          }
        })
      });
    vi.stubGlobal('fetch', mockFetch);

    const blobCid = await fetchBlobCidFromRecord(TEST_DID, TEST_TID);
    expect(blobCid).toBe(TEST_CID);
  });

  it('returns null when PDS resolution fails', async () => {
    const mockFetch = vi.fn().mockResolvedValueOnce({
      ok: false
    });
    vi.stubGlobal('fetch', mockFetch);

    const blobCid = await fetchBlobCidFromRecord(TEST_DID, TEST_TID);
    expect(blobCid).toBeNull();
  });

  it('returns null when record has no blob', async () => {
    const mockFetch = vi.fn()
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          service: [{ id: '#atproto_pds', serviceEndpoint: TEST_PDS }]
        })
      })
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          uri: `at://${TEST_DID}/blue.imgs.blup.image/${TEST_TID}`,
          cid: 'somecid',
          value: {}
        })
      });
    vi.stubGlobal('fetch', mockFetch);

    const blobCid = await fetchBlobCidFromRecord(TEST_DID, TEST_TID);
    expect(blobCid).toBeNull();
  });

  it('returns null when getRecord returns non-OK response', async () => {
    const mockFetch = vi.fn()
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          service: [{ id: '#atproto_pds', serviceEndpoint: TEST_PDS }]
        })
      })
      .mockResolvedValueOnce({
        ok: false,
        status: 404
      });
    vi.stubGlobal('fetch', mockFetch);

    const blobCid = await fetchBlobCidFromRecord(TEST_DID, TEST_TID);
    expect(blobCid).toBeNull();
  });

  it('returns null when getRecord fetch throws exception', async () => {
    const mockFetch = vi.fn()
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          service: [{ id: '#atproto_pds', serviceEndpoint: TEST_PDS }]
        })
      })
      .mockRejectedValueOnce(new Error('Network error'));
    vi.stubGlobal('fetch', mockFetch);

    const blobCid = await fetchBlobCidFromRecord(TEST_DID, TEST_TID);
    expect(blobCid).toBeNull();
  });
});

describe('downloadBlobUnauthenticated', () => {
  beforeEach(() => {
    vi.stubGlobal('fetch', vi.fn());
  });

  afterEach(() => {
    vi.unstubAllGlobals();
  });

  it('downloads blob with correct headers', async () => {
    const mockFetch = vi.fn()
      // resolvePDSHost
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          service: [{ id: '#atproto_pds', serviceEndpoint: TEST_PDS }]
        })
      })
      // getBlob
      .mockResolvedValueOnce({
        status: 200,
        body: new ReadableStream(),
        headers: new Headers({
          'Content-Type': 'image/jpeg',
          'Content-Length': '12345'
        })
      });
    vi.stubGlobal('fetch', mockFetch);

    const ctx = createExecutionContext();
    const response = await downloadBlobUnauthenticated(TEST_DID, TEST_CID, ctx);

    expect(response.status).toBe(200);
    expect(response.headers.get('Content-Type')).toBe('image/jpeg');
    expect(response.headers.get('Cache-Control')).toBe('public, max-age=31536000, immutable');
    expect(response.headers.get('Access-Control-Allow-Origin')).toBe('*');
  });

  it('returns 400 when PDS resolution fails', async () => {
    const mockFetch = vi.fn().mockResolvedValueOnce({
      ok: false
    });
    vi.stubGlobal('fetch', mockFetch);

    const ctx = createExecutionContext();
    const response = await downloadBlobUnauthenticated(TEST_DID, TEST_CID, ctx);

    expect(response.status).toBe(400);
    expect(await response.text()).toBe('Failed to resolve PDS host');
  });

  it('returns 404 when blob not found', async () => {
    const mockFetch = vi.fn()
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          service: [{ id: '#atproto_pds', serviceEndpoint: TEST_PDS }]
        })
      })
      .mockResolvedValueOnce({
        status: 404
      });
    vi.stubGlobal('fetch', mockFetch);

    const ctx = createExecutionContext();
    const response = await downloadBlobUnauthenticated(TEST_DID, TEST_CID, ctx);

    expect(response.status).toBe(404);
  });

  it('returns 500 when fetch throws exception', async () => {
    const mockFetch = vi.fn()
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          service: [{ id: '#atproto_pds', serviceEndpoint: TEST_PDS }]
        })
      })
      .mockRejectedValueOnce(new Error('Network error'));
    vi.stubGlobal('fetch', mockFetch);

    const ctx = createExecutionContext();
    const response = await downloadBlobUnauthenticated(TEST_DID, TEST_CID, ctx);

    expect(response.status).toBe(500);
    expect(await response.text()).toBe('Failed to download blob');
  });
});

describe('Worker fetch handler', () => {
  it('handles CORS preflight requests', async () => {
    const request = new IncomingRequest('http://example.com/test/test', {
      method: 'OPTIONS'
    });
    const ctx = createExecutionContext();
    const response = await worker.fetch(request, env, ctx);
    await waitOnExecutionContext(ctx);

    expect(response.status).toBe(200);
    expect(response.headers.get('Access-Control-Allow-Origin')).toBe('*');
    expect(response.headers.get('Access-Control-Allow-Methods')).toBe('GET, OPTIONS');
  });

  it('returns 400 for invalid paths', async () => {
    const request = new IncomingRequest('http://example.com/');
    const ctx = createExecutionContext();
    const response = await worker.fetch(request, env, ctx);
    await waitOnExecutionContext(ctx);

    expect(response.status).toBe(400);
    expect(await response.text()).toContain('Invalid path');
  });

  it('returns 400 for paths with only handle', async () => {
    const request = new IncomingRequest('http://example.com/bsky.app');
    const ctx = createExecutionContext();
    const response = await worker.fetch(request, env, ctx);
    await waitOnExecutionContext(ctx);

    expect(response.status).toBe(400);
  });

  it('strips file extensions from CID', async () => {
    // This tests that extensions like .jpg, .png are stripped
    // We'll test this by mocking and checking the CID used
    const mockFetch = vi.fn()
      // DNS resolution
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          Answer: [{ type: 16, data: `"did=${TEST_DID}"` }]
        })
      })
      // PDS resolution
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          service: [{ id: '#atproto_pds', serviceEndpoint: TEST_PDS }]
        })
      })
      // Blob download
      .mockResolvedValueOnce({
        status: 200,
        body: new ReadableStream(),
        headers: new Headers({ 'Content-Type': 'image/jpeg' })
      });
    vi.stubGlobal('fetch', mockFetch);

    const request = new IncomingRequest(`http://example.com/${TEST_HANDLE}/${TEST_CID}.jpg`);
    const ctx = createExecutionContext();
    const response = await worker.fetch(request, env, ctx);
    await waitOnExecutionContext(ctx);

    // Should have made it to blob download (extension stripped correctly)
    expect(mockFetch).toHaveBeenCalledTimes(3);

    vi.unstubAllGlobals();
  });

  it('handles DID directly without resolution', async () => {
    const mockFetch = vi.fn()
      // PDS resolution
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          service: [{ id: '#atproto_pds', serviceEndpoint: TEST_PDS }]
        })
      })
      // Blob download
      .mockResolvedValueOnce({
        status: 200,
        body: new ReadableStream(),
        headers: new Headers({ 'Content-Type': 'image/jpeg' })
      });
    vi.stubGlobal('fetch', mockFetch);

    const request = new IncomingRequest(`http://example.com/${TEST_DID}/${TEST_CID}`);
    const ctx = createExecutionContext();
    const response = await worker.fetch(request, env, ctx);
    await waitOnExecutionContext(ctx);

    // Should skip DNS resolution since it's already a DID
    expect(response.status).toBe(200);
    expect(mockFetch).toHaveBeenCalledTimes(2);

    vi.unstubAllGlobals();
  });

  it('returns 404 when handle cannot be resolved', async () => {
    const mockFetch = vi.fn()
      // DNS lookup fails
      .mockResolvedValueOnce({ ok: false })
      // HTTPS well-known fails
      .mockResolvedValueOnce({ status: 404 });
    vi.stubGlobal('fetch', mockFetch);

    const request = new IncomingRequest('http://example.com/nonexistent.handle/somecid');
    const ctx = createExecutionContext();
    const response = await worker.fetch(request, env, ctx);
    await waitOnExecutionContext(ctx);

    expect(response.status).toBe(404);
    expect(await response.text()).toBe('Handle not found');

    vi.unstubAllGlobals();
  });

  it('uses cached DID from KV (plc format)', async () => {
    const mockFetch = vi.fn()
      // PDS resolution
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          service: [{ id: '#atproto_pds', serviceEndpoint: TEST_PDS }]
        })
      })
      // Blob download
      .mockResolvedValueOnce({
        status: 200,
        body: new ReadableStream(),
        headers: new Headers({ 'Content-Type': 'image/jpeg' })
      });
    vi.stubGlobal('fetch', mockFetch);

    // Create a mock env with KV that returns a cached DID
    const mockEnv = {
      USER_CACHE: {
        get: vi.fn().mockResolvedValue('ewvi7nxzyoun6zhxrhs64oiz'),
        put: vi.fn()
      }
    };

    const request = new IncomingRequest(`http://example.com/${TEST_HANDLE}/${TEST_CID}`);
    const ctx = createExecutionContext();
    const response = await worker.fetch(request, mockEnv as any, ctx);
    await waitOnExecutionContext(ctx);

    // Should use cached DID and skip DNS resolution
    expect(response.status).toBe(200);
    expect(mockEnv.USER_CACHE.get).toHaveBeenCalledWith(TEST_HANDLE);
    // Only PDS + blob fetch, no DNS lookup
    expect(mockFetch).toHaveBeenCalledTimes(2);

    vi.unstubAllGlobals();
  });

  it('uses cached DID from KV (web format)', async () => {
    const mockFetch = vi.fn()
      // PDS resolution for did:web
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          service: [{ id: '#atproto_pds', serviceEndpoint: 'https://pds.example.com' }]
        })
      })
      // Blob download
      .mockResolvedValueOnce({
        status: 200,
        body: new ReadableStream(),
        headers: new Headers({ 'Content-Type': 'image/png' })
      });
    vi.stubGlobal('fetch', mockFetch);

    // Create a mock env with KV that returns a cached web DID
    const mockEnv = {
      USER_CACHE: {
        get: vi.fn().mockResolvedValue('web:example.com'),
        put: vi.fn()
      }
    };

    const request = new IncomingRequest(`http://example.com/somehandle/${TEST_CID}`);
    const ctx = createExecutionContext();
    const response = await worker.fetch(request, mockEnv as any, ctx);
    await waitOnExecutionContext(ctx);

    expect(response.status).toBe(200);
    expect(mockEnv.USER_CACHE.get).toHaveBeenCalled();

    vi.unstubAllGlobals();
  });

  it('resolves TID to blob CID', async () => {
    const mockFetch = vi.fn()
      // PDS resolution (for fetchBlobCidFromRecord)
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          service: [{ id: '#atproto_pds', serviceEndpoint: TEST_PDS }]
        })
      })
      // getRecord
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          uri: `at://${TEST_DID}/blue.imgs.blup.image/${TEST_TID}`,
          cid: 'recordcid',
          value: {
            blob: { ref: { $link: TEST_CID } }
          }
        })
      })
      // PDS resolution (for downloadBlobUnauthenticated)
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          service: [{ id: '#atproto_pds', serviceEndpoint: TEST_PDS }]
        })
      })
      // Blob download
      .mockResolvedValueOnce({
        status: 200,
        body: new ReadableStream(),
        headers: new Headers({ 'Content-Type': 'image/jpeg' })
      });
    vi.stubGlobal('fetch', mockFetch);

    const request = new IncomingRequest(`http://example.com/${TEST_DID}/${TEST_TID}`);
    const ctx = createExecutionContext();
    const response = await worker.fetch(request, env, ctx);
    await waitOnExecutionContext(ctx);

    expect(response.status).toBe(200);

    vi.unstubAllGlobals();
  });

  it('returns 404 when TID record not found', async () => {
    const mockFetch = vi.fn()
      // PDS resolution
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          service: [{ id: '#atproto_pds', serviceEndpoint: TEST_PDS }]
        })
      })
      // getRecord returns no blob
      .mockResolvedValueOnce({
        ok: true,
        json: async () => ({
          uri: `at://${TEST_DID}/blue.imgs.blup.image/${TEST_TID}`,
          cid: 'recordcid',
          value: {}
        })
      });
    vi.stubGlobal('fetch', mockFetch);

    const request = new IncomingRequest(`http://example.com/${TEST_DID}/${TEST_TID}`);
    const ctx = createExecutionContext();
    const response = await worker.fetch(request, env, ctx);
    await waitOnExecutionContext(ctx);

    expect(response.status).toBe(404);
    expect(await response.text()).toBe('Record not found');

    vi.unstubAllGlobals();
  });

  it('returns 400 for invalid base62 CID encoding', async () => {
    // Use a string that's detected as base62 but produces invalid CID bytes
    // 'AAAA' is valid base62 but won't decode to a valid CID
    const invalidBase62 = 'AAAA';

    const request = new IncomingRequest(`http://example.com/${TEST_DID}/${invalidBase62}`);
    const ctx = createExecutionContext();
    const response = await worker.fetch(request, env, ctx);
    await waitOnExecutionContext(ctx);

    expect(response.status).toBe(400);
    expect(await response.text()).toBe('Invalid CID encoding');
  });
});