figlet.test.ts

// test/node-figlet.test.ts
import {describe, it, vi, beforeEach, afterEach, expect, beforeAll, MockInstance} from 'vitest';
import fs from 'fs';
import path from 'path';
import figlet from '../src/figlet'; // Import from src instead of lib
import fontData from '../importable-fonts/Standard'
import miniwi from '../importable-fonts/miniwi'

describe('figlet', () => {
  let fetchSpy: MockInstance<{
    (input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
    (input: string | URL | globalThis.Request, init?: RequestInit): Promise<Response>;
  }>;

  // Helper function to read expected output files
  const readExpected = (filename: string): string => {
    return fs.readFileSync(path.join(__dirname, `expected/${filename}`), 'utf8');
  };

  // Setup for font registration tests
  beforeEach(() => {
    fetchSpy = vi.spyOn(global, 'fetch');
  });

  afterEach(() => {
    fetchSpy.mockRestore(); // Restore the original fetch after each test
    figlet.clearLoadedFonts();
    figlet.defaults({
      fetchFontIfMissing: true,
    });
  });

  describe('preloadFonts tests', () => {

    it('preloadFonts should execute without error when valid data is given', async () => {

      const localPath = import.meta.url;
      const lastSlashIndex = localPath.lastIndexOf("/");
      const directoryPath = localPath.substring(0, lastSlashIndex);

      const mockResponse = {
        ok: true,
        statusText: 'OK',
        text: () => Promise.resolve(fontData),
      };
      // @ts-ignore
      fetchSpy.mockReturnValue(Promise.resolve(mockResponse));

      figlet.defaults({
        fontPath: `${directoryPath}/../fonts`,
      });

      expect(figlet.loadedFonts()).toStrictEqual([]);

      await figlet.preloadFonts(['Standard', 'Graffiti']);

      expect(figlet.loadedFonts()).toStrictEqual(['Standard', 'Graffiti']);
    });

    it('preloadFonts should execute without error and execute its callback', async () => {

      const localPath = import.meta.url;
      const lastSlashIndex = localPath.lastIndexOf("/");
      const directoryPath = localPath.substring(0, lastSlashIndex);
      const mockCallback = vi.fn();

      const mockResponse = {
        ok: true,
        statusText: 'OK',
        text: () => Promise.resolve(fontData),
      };
      // @ts-ignore
      fetchSpy.mockReturnValue(Promise.resolve(mockResponse));

      figlet.defaults({
        fontPath: `${directoryPath}/../fonts`,
      });

      expect(figlet.loadedFonts()).toStrictEqual([]);

      figlet.preloadFonts(['Standard', 'Graffiti'], mockCallback);

      await new Promise(resolve => setTimeout(resolve, 100)); // give time for the callback to execute

      expect(mockCallback).toHaveBeenCalledWith();
      expect(figlet.loadedFonts()).toStrictEqual(['Standard', 'Graffiti']);
    });

    it('preloadFonts should throw an error when fetch fails', async () => {

      const localPath = import.meta.url;
      const lastSlashIndex = localPath.lastIndexOf("/");
      const directoryPath = localPath.substring(0, lastSlashIndex);

      const mockResponse = {
        ok: false,
        statusText: 'Oopsy!',
        text: () => Promise.resolve(fontData),
      };
      // @ts-ignore
      fetchSpy.mockReturnValue(Promise.resolve(mockResponse));

      figlet.defaults({
        fontPath: `${directoryPath}/../fonts`,
      });

      await expect(figlet.preloadFonts(['Standard', 'Graffiti'])).rejects.toThrow();
    });

    it('preloadFonts should pass the error to its callback if its provided', async () => {

      const localPath = import.meta.url;
      const lastSlashIndex = localPath.lastIndexOf("/");
      const directoryPath = localPath.substring(0, lastSlashIndex);
      const mockCallback = vi.fn();

      const mockResponse = {
        ok: false,
        statusText: 'Oopsy!',
        text: () => Promise.resolve(fontData),
      };
      // @ts-ignore
      fetchSpy.mockReturnValue(Promise.resolve(mockResponse));

      figlet.defaults({
        fontPath: `${directoryPath}/../fonts`,
      });

      figlet.preloadFonts(['Standard', 'Graffiti'], mockCallback);

      await new Promise(resolve => setTimeout(resolve, 100)); // give time for the callback to execute

      expect(mockCallback).toHaveBeenCalledWith(expect.any(Error));
    });
  });

  // -------------------------------------------------------------------------------------------------------------------

  describe('loadFont tests', () => {

    beforeEach(() => {
      figlet.clearLoadedFonts();
    });

    const standardMeta = {
      hardBlank: '$',
      height: 6,
      baseline: 5,
      maxLength: 16,
      oldLayout: 15,
      numCommentLines: 13,
      printDirection: 0,
      fullLayout: 24463,
      codeTagCount: 229,
      fittingRules: {
        vLayout: 3,
        vRule5: true,
        vRule4: true,
        vRule3: true,
        vRule2: true,
        vRule1: true,
        hLayout: 3,
        hRule6: false,
        hRule5: false,
        hRule4: true,
        hRule3: true,
        hRule2: true,
        hRule1: true
      }
    };

    it('loadFont should execute without error for valid inputs', async () => {

      const localPath = import.meta.url;
      const lastSlashIndex = localPath.lastIndexOf("/");
      const directoryPath = localPath.substring(0, lastSlashIndex);

      const mockResponse = {
        ok: true,
        statusText: 'OK',
        text: () => Promise.resolve(fontData),
      };
      // @ts-ignore
      fetchSpy.mockReturnValue(Promise.resolve(mockResponse));

      figlet.defaults({
        fontPath: `${directoryPath}/../fonts`,
      });

      expect(figlet.loadedFonts()).toStrictEqual([]);

      const meta = await figlet.loadFont('Standard');
      expect(meta).toEqual(standardMeta);
      expect(figlet.loadedFonts()).toStrictEqual(['Standard']);
    });

    it('loadFont should execute without error for valid inputs and pass its return data to its callback', async () => {

      const localPath = import.meta.url;
      const lastSlashIndex = localPath.lastIndexOf("/");
      const directoryPath = localPath.substring(0, lastSlashIndex);
      const mockCallback = vi.fn();

      const mockResponse = {
        ok: true,
        statusText: 'OK',
        text: () => Promise.resolve(fontData),
      };
      // @ts-ignore
      fetchSpy.mockReturnValue(Promise.resolve(mockResponse));

      figlet.defaults({
        fontPath: `${directoryPath}/../fonts`,
      });

      figlet.loadFont('Standard', mockCallback);

      await new Promise(resolve => setTimeout(resolve, 100)); // give time for the callback to execute

      expect(mockCallback).toHaveBeenCalledWith(null, standardMeta);

    });

    it('loadFont should throw an error when fetch fails', async () => {

      const localPath = import.meta.url;
      const lastSlashIndex = localPath.lastIndexOf("/");
      const directoryPath = localPath.substring(0, lastSlashIndex);

      const mockResponse = {
        ok: false,
        statusText: 'Oopsy!',
        text: () => Promise.resolve(fontData),
      };
      // @ts-ignore
      fetchSpy.mockReturnValue(Promise.resolve(mockResponse));

      figlet.defaults({
        fontPath: `${directoryPath}/../fonts`,
      });

      await expect(figlet.loadFont('Standard')).rejects.toThrow();
    });

    it('loadFont should pass the error to its callback if its provided', async () => {

      const localPath = import.meta.url;
      const lastSlashIndex = localPath.lastIndexOf("/");
      const directoryPath = localPath.substring(0, lastSlashIndex);
      const mockCallback = vi.fn();

      const mockResponse = {
        ok: false,
        statusText: 'Oopsy!',
        text: () => Promise.resolve(fontData),
      };
      // @ts-ignore
      fetchSpy.mockReturnValue(Promise.resolve(mockResponse));

      figlet.defaults({
        fontPath: `${directoryPath}/../fonts`,
      });

      figlet.loadFont('Standard', mockCallback);

      await new Promise(resolve => setTimeout(resolve, 100)); // give time for the callback to execute

      expect(mockCallback).toHaveBeenCalledWith(expect.any(Error));
    });

    it('fetchFontIfMissing should be respected when false', async () => {

      figlet.defaults({
        fetchFontIfMissing: false,
      });

      expect(figlet.loadedFonts()).toStrictEqual([]);

      await expect(figlet.loadFont('Unknown-Font')).rejects.toThrow();

      expect(fetchSpy).not.toHaveBeenCalled();
      expect(figlet.loadedFonts()).toStrictEqual([]);
    });

    it('fetchFontIfMissing should be respected when true', async () => {

      figlet.defaults({
        fetchFontIfMissing: true,
      });

      expect(figlet.loadedFonts()).toStrictEqual([]);

      await expect(figlet.loadFont('Unknown-Font')).rejects.toThrow();

      expect(fetchSpy).toHaveBeenCalled();
      expect(figlet.loadedFonts()).toStrictEqual([]);
    });
  });

  // -------------------------------------------------------------------------------------------------------------------
  describe('text tests', () => {

    const expected = readExpected('standard_default');
    const text = 'FIGlet\nFonts';

    it('text should execute without error for valid inputs', async () => {

      const localPath = import.meta.url;
      const lastSlashIndex = localPath.lastIndexOf("/");
      const directoryPath = localPath.substring(0, lastSlashIndex);

      const mockResponse = {
        ok: true,
        statusText: 'OK',
        text: () => Promise.resolve(fontData),
      };
      // @ts-ignore
      fetchSpy.mockReturnValue(Promise.resolve(mockResponse));

      figlet.defaults({
        fontPath: `${directoryPath}/../fonts`,
      });

      expect(figlet.loadedFonts()).toStrictEqual([]);

      const output = await figlet.text(text, 'Standard');
      const output2 = await figlet(text, 'Standard');

      expect(output).toEqual(expected);
      expect(output2).toEqual(expected);
      expect(figlet.loadedFonts()).toStrictEqual(['Standard']);
    });

    it('text should execute without error for valid inputs and pass its return data to its callback', async () => {

      const localPath = import.meta.url;
      const lastSlashIndex = localPath.lastIndexOf("/");
      const directoryPath = localPath.substring(0, lastSlashIndex);
      const mockCallback = vi.fn();
      const mockCallback2 = vi.fn();

      const mockResponse = {
        ok: true,
        statusText: 'OK',
        text: () => Promise.resolve(fontData),
      };
      // @ts-ignore
      fetchSpy.mockReturnValue(Promise.resolve(mockResponse));

      figlet.defaults({
        fontPath: `${directoryPath}/../fonts`,
      });

      expect(figlet.loadedFonts()).toStrictEqual([]);

      await figlet.text(text, 'Standard', mockCallback);
      await figlet(text, 'Standard', mockCallback2);

      await new Promise(resolve => setTimeout(resolve, 100)); // give time for the callback to execute

      expect(mockCallback).toHaveBeenCalledWith(null, expected);
      expect(mockCallback2).toHaveBeenCalledWith(null, expected);
      expect(figlet.loadedFonts()).toStrictEqual(['Standard']);

    });

    it('text should allow empty lines in output', async () => {

      const localPath = import.meta.url;
      const lastSlashIndex = localPath.lastIndexOf("/");
      const directoryPath = localPath.substring(0, lastSlashIndex);

      const expected = readExpected('miniwi_multiline');
      const multilineText = 'This\n\nis\n\n\na test'

      const mockResponse = {
        ok: true,
        statusText: 'OK',
        text: () => Promise.resolve(miniwi),
      };
      // @ts-ignore
      fetchSpy.mockReturnValue(Promise.resolve(mockResponse));

      figlet.defaults({
        fontPath: `${directoryPath}/../fonts`,
      });

      expect(figlet.loadedFonts()).toStrictEqual([]);

      const output = await figlet.text(multilineText, 'miniwi');
      const output2 = await figlet(multilineText, 'miniwi');

      expect(output).toEqual(expected);
      expect(output2).toEqual(expected);
      expect(figlet.loadedFonts()).toStrictEqual(['miniwi']);
    });
  });

  describe('code point rendering', () => {

    // Builds a minimal 3-line font where every required character renders as
    // itself padded to 3 columns, plus (optionally) two code-tagged extras:
    // an emoji (outside the BMP) and the code-0 "missing character" glyph.
    const buildTestFont = (withMissingCharGlyph: boolean): string => {
      const required: number[] = [];
      for (let i = 32; i <= 126; i++) required.push(i);
      required.push(196, 214, 220, 228, 246, 252, 223);

      const glyph = (art: string): string => {
        const line = (art + '   ').slice(0, 3);
        return `${line}@\n${line}@\n${line}@@\n`;
      };

      const codeTagCount = withMissingCharGlyph ? 2 : 1;
      let out = `flf2a$ 3 3 5 -1 1 0 0 ${codeTagCount}\n`;
      out += 'code point rendering test font\n';
      for (const code of required) {
        out += glyph(String.fromCodePoint(code));
      }
      out += '0x1F604 grinning face\n' + glyph(':-D');
      if (withMissingCharGlyph) {
        out += '0 missing character\n' + glyph('???');
      }
      return out;
    };

    const trimmed = (txt: string): string[] =>
      txt.split('\n').map((line) => line.trimEnd());

    // beforeEach (not beforeAll): the suite-wide afterEach clears loaded fonts
    beforeEach(() => {
      figlet.parseFont('CodePointTest', buildTestFont(true));
      figlet.parseFont('CodePointTestNoFallback', buildTestFont(false));
    });

    it('renders characters outside the BMP (emoji)', () => {
      const output = figlet.textSync('😄', { font: 'CodePointTest' });
      expect(trimmed(output)).toEqual([':-D', ':-D', ':-D']);
    });

    it('renders emoji mixed with BMP text without splitting surrogate pairs', () => {
      const output = figlet.textSync('A😄B', { font: 'CodePointTest' });
      expect(trimmed(output)).toEqual(['A  :-DB', 'A  :-DB', 'A  :-DB']);
    });

    it('reverses by code point when printDirection is right-to-left', () => {
      const output = figlet.textSync('A😄', {
        font: 'CodePointTest',
        printDirection: 1,
      });
      expect(trimmed(output)).toEqual([':-DA', ':-DA', ':-DA']);
    });

    it('falls back to the code-0 missing character glyph', () => {
      const output = figlet.textSync('Ω', { font: 'CodePointTest' });
      expect(trimmed(output)).toEqual(['???', '???', '???']);
    });

    it('uses the fallback glyph only for the characters that are missing', () => {
      const output = figlet.textSync('AΩ', { font: 'CodePointTest' });
      expect(trimmed(output)).toEqual(['A  ???', 'A  ???', 'A  ???']);
    });

    it('still skips unknown characters when the font has no code-0 glyph', () => {
      const output = figlet.textSync('AΩB', {
        font: 'CodePointTestNoFallback',
      });
      expect(trimmed(output)).toEqual(['A  B', 'A  B', 'A  B']);
    });
  });
});