Genarrative/src/services/image-editor/editorImageReference.test.ts

import { afterEach, describe, expect, it, vi } from 'vitest';

import {
  compressEditorImageReferenceDataUrlForGeneration,
  resolveEditorImageReferenceDataUrl,
} from './editorImageReference';

describe('editorImageReference', () => {
  afterEach(() => {
    vi.useRealTimers();
    vi.restoreAllMocks();
    vi.unstubAllGlobals();
  });

  it('passes through base64 image data urls without fetching', async () => {
    vi.spyOn(globalThis, 'fetch');

    await expect(
      resolveEditorImageReferenceDataUrl('data:image/png;base64,c291cmNl'),
    ).resolves.toBe('data:image/png;base64,c291cmNl');
    expect(globalThis.fetch).not.toHaveBeenCalled();
  });

  it('converts public image paths to base64 image data urls', async () => {
    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
      new Response(new Uint8Array([104, 101, 108, 108, 111]), {
        status: 200,
        headers: {
          'Content-Type': 'image/webp',
        },
      }),
    );

    await expect(
      resolveEditorImageReferenceDataUrl(
        '/creation-type-references/puzzle.webp',
      ),
    ).resolves.toBe('data:image/webp;base64,aGVsbG8=');
  });

  it('keeps generation references unchanged when browser canvas is unavailable', async () => {
    await expect(
      compressEditorImageReferenceDataUrlForGeneration(
        'data:image/png;base64,large-reference',
      ),
    ).resolves.toBe('data:image/png;base64,large-reference');
  });

  it('falls back to the original generation reference when browser image decoding stalls', async () => {
    vi.useFakeTimers();
    vi.stubGlobal('document', {
      createElement: vi.fn(),
    } as unknown as Document);
    vi.stubGlobal(
      'Image',
      class PendingImage {
        onload: (() => void) | null = null;
        onerror: (() => void) | null = null;

        set src(_value: string) {
          void _value;
        }
      } as unknown as typeof Image,
    );

    const result = compressEditorImageReferenceDataUrlForGeneration(
      'data:image/png;base64,pending-reference',
    );

    vi.advanceTimersByTime(251);

    await expect(result).resolves.toBe(
      'data:image/png;base64,pending-reference',
    );
  });
});