oblique-strategies-cli/src/__tests__/readers.test.ts

import * as obliqueStrategiesCore from '@theoryofnekomata/oblique-strategies-core';
import {
  afterAll, afterEach,
  beforeAll, beforeEach,
  describe,
  expect,
  it, vi,
} from 'vitest';
import * as file from '../readers/file';
import * as text from '../readers/text';
import * as http from '../readers/http';
import * as https from '../readers/https';
import { main } from '../app';
import * as presenters from '../presenters';

vi.mock('@theoryofnekomata/oblique-strategies-core');
vi.mock('chalk');
vi.mock('wrap-ansi');
vi.mock('../readers/file');
vi.mock('../readers/http');
vi.mock('../readers/https');
vi.mock('../readers/text');
vi.mock('../presenters');

describe('readers', () => {
  let defaultConsole: typeof console;
  beforeAll(() => {
    defaultConsole = console;
    global.console = {
      log: () => {
        // noop
      },
    } as unknown as typeof console;
  });

  afterAll(() => {
    global.console = defaultConsole;
  });

  beforeAll(() => {
    vi.mocked(presenters.plain).mockReturnValue(vi.fn());
  });

  afterAll(() => {
    vi.mocked(presenters.plain).mockReset();
  });

  describe('default reader', () => {
    it('reads from default source', async () => {
      await main({
        cards: ['default'],
        formatted: false,
        presentation: 'plain',
      });

      expect(obliqueStrategiesCore.getDefaultCards).toBeCalled();
    });
  });

  describe.each([
    { type: 'file', prefix: 'file:///', reader: file },
    { type: 'text', prefix: 'text:', reader: text },
    { type: 'http', prefix: 'http://', reader: http },
    { type: 'https', prefix: 'https://', reader: https },
  ])('%s', ({ reader, prefix }) => {
    it('reads from source', async () => {
      await main({
        cards: [`${prefix}foo`],
        formatted: false,
        presentation: 'plain',
      });

      expect(reader.read).toBeCalled();
    });
  });

  describe('unknown reader', () => {
    it('throws an error', async () => {
      await expect(() => main({
        cards: ['unknown'],
        formatted: false,
        presentation: 'plain',
      }))
        .rejects
        .toThrowError();
    });
  });
});