lobe-chat

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

3
import { imageToBase64, imageUrlToBase64 } from './imageToBase64';
4

5
describe('imageToBase64', () => {
6
  let mockImage: HTMLImageElement;
7
  let mockCanvas: HTMLCanvasElement;
8
  let mockContext: CanvasRenderingContext2D;
9

10
  beforeEach(() => {
11
    mockImage = {
12
      width: 200,
13
      height: 100,
14
    } as HTMLImageElement;
15

16
    mockContext = {
17
      drawImage: vi.fn(),
18
    } as unknown as CanvasRenderingContext2D;
19

20
    mockCanvas = {
21
      width: 0,
22
      height: 0,
23
      getContext: vi.fn().mockReturnValue(mockContext),
24
      toDataURL: vi.fn().mockReturnValue('data:image/webp;base64,mockBase64Data'),
25
    } as unknown as HTMLCanvasElement;
26

27
    vi.spyOn(document, 'createElement').mockReturnValue(mockCanvas);
28
  });
29

30
  afterEach(() => {
31
    vi.restoreAllMocks();
32
  });
33

34
  it('should convert image to base64 with correct size and type', () => {
35
    const result = imageToBase64({ img: mockImage, size: 100, type: 'image/jpeg' });
36

37
    expect(document.createElement).toHaveBeenCalledWith('canvas');
38
    expect(mockCanvas.width).toBe(100);
39
    expect(mockCanvas.height).toBe(100);
40
    expect(mockCanvas.getContext).toHaveBeenCalledWith('2d');
41
    expect(mockContext.drawImage).toHaveBeenCalledWith(mockImage, 50, 0, 100, 100, 0, 0, 100, 100);
42
    expect(mockCanvas.toDataURL).toHaveBeenCalledWith('image/jpeg');
43
    expect(result).toBe('data:image/webp;base64,mockBase64Data');
44
  });
45

46
  it('should use default type when not specified', () => {
47
    imageToBase64({ img: mockImage, size: 100 });
48
    expect(mockCanvas.toDataURL).toHaveBeenCalledWith('image/webp');
49
  });
50

51
  it('should handle taller images correctly', () => {
52
    mockImage.width = 100;
53
    mockImage.height = 200;
54
    imageToBase64({ img: mockImage, size: 100 });
55
    expect(mockContext.drawImage).toHaveBeenCalledWith(mockImage, 0, 50, 100, 100, 0, 0, 100, 100);
56
  });
57
});
58

59
describe('imageUrlToBase64', () => {
60
  const mockFetch = vi.fn();
61
  const mockArrayBuffer = new ArrayBuffer(8);
62

63
  beforeEach(() => {
64
    global.fetch = mockFetch;
65
    global.btoa = vi.fn().mockReturnValue('mockBase64String');
66
  });
67

68
  afterEach(() => {
69
    vi.restoreAllMocks();
70
  });
71

72
  it('should convert image URL to base64 string', async () => {
73
    mockFetch.mockResolvedValue({
74
      arrayBuffer: () => Promise.resolve(mockArrayBuffer),
75
      blob: () => Promise.resolve(new Blob([mockArrayBuffer], { type: 'image/jpg' })),
76
    });
77

78
    const result = await imageUrlToBase64('https://example.com/image.jpg');
79

80
    expect(mockFetch).toHaveBeenCalledWith('https://example.com/image.jpg');
81
    expect(global.btoa).toHaveBeenCalled();
82
    expect(result).toEqual({ base64: 'mockBase64String', mimeType: 'image/jpg' });
83
  });
84

85
  it('should throw an error when fetch fails', async () => {
86
    const mockError = new Error('Fetch failed');
87
    mockFetch.mockRejectedValue(mockError);
88

89
    await expect(imageUrlToBase64('https://example.com/image.jpg')).rejects.toThrow('Fetch failed');
90
  });
91
});
92