Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

11.6 KB
Raw Blame
import { spawnSync } from 'node:child_process';
import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { dirname, join, resolve, win32 } from 'node:path';
import { fileURLToPath } from 'node:url';
import { afterEach, beforeAll, describe, expect, onTestFinished, test, vi } from 'vitest';
import { createVitest, type TestProject } from 'vitest/node';
import { gitCleanEnv } from '../scripts/git-clean-env.mjs';
import tierConfig from '../vitest.uncached.config';
import { configureTestGitRepository } from './configure-git-fixture.test-helper.ts';
import { listUncachedTestFiles, uncachedTierProblems } from './uncached-tier-reconcile';

const roots: string[] = [];

afterEach(() => {
  while (roots.length > 0) rmSync(roots.pop() as string, { recursive: true, force: true });
});

function workspace(files: Record<string, string>): string {
  const root = mkdtempSync(join(tmpdir(), 'ok-uncached-tier-'));
  roots.push(root);
  for (const [path, body] of Object.entries(files)) {
    mkdirSync(dirname(join(root, path)), { recursive: true });
    writeFileSync(join(root, path), body);
  }
  return root;
}

function git(root: string, args: string[]): void {
  const result = spawnSync('git', args, {
    cwd: root,
    encoding: 'utf8',
    env: {
      ...gitCleanEnv(),
      GIT_AUTHOR_NAME: 'fixture',
      GIT_AUTHOR_EMAIL: '[email protected]',
      GIT_COMMITTER_NAME: 'fixture',
      GIT_COMMITTER_EMAIL: '[email protected]',
    },
  });
  expect(result.status, result.stderr).toBe(0);
}

const SERVER = 'packages/server/src/reads-app.uncached.test.ts';
const privateInfix = (stem: string, suffix: string) => `${stem}.private.${suffix}`;
const TRANSPOSED = privateInfix('packages/server/src/reads-app.uncached', 'test.ts');
const INFIXED = privateInfix('packages/server/src/reads-app', 'uncached.test.ts');
const server = (collected: string[]) => ({
  name: 'packages/server/vitest.config.ts',
  dir: 'packages/server',
  collected,
});
const scripts = (collected: string[]) => ({
  name: 'vitest.scripts.config.ts',
  dir: '.',
  collected,
});
const packages = () =>
  workspace({
    'package.json': '{}',
    'packages/server/package.json': '{}',
    'packages/core/package.json': '{}',
  });

describe('the uncached tier reconciles the suffixed files git lists against what its projects collect', () => {
  test('a listed file one project collects passes', () => {
    expect(uncachedTierProblems(packages(), [SERVER], [server([SERVER]), scripts([])])).toEqual([]);
  });

  test('a listed file its covering project does not collect names that project config', () => {
    expect(uncachedTierProblems(packages(), [SERVER], [server([]), scripts([])])).toEqual([
      expect.stringContaining(
        `${SERVER} takes the .uncached.test suffix and sits under packages/server, but that project's include and exclude do not collect it, so no tier would run it. Fix packages/server/vitest.config.ts's include or exclude`,
      ),
    ]);
  });

  test('a listed file in a package no project covers is misplaced', () => {
    const misplaced = 'packages/core/src/reads-server.uncached.test.ts';
    expect(
      uncachedTierProblems(packages(), [SERVER, misplaced], [server([SERVER]), scripts([])]),
    ).toEqual([
      expect.stringContaining(
        `${misplaced} takes the .uncached.test suffix, but no project here covers its package`,
      ),
    ]);
  });

  test('a file two projects collect runs twice, and fails', () => {
    expect(
      uncachedTierProblems(packages(), [SERVER], [server([SERVER]), scripts([SERVER])]),
    ).toEqual([expect.stringContaining(`${SERVER} is collected by more than one project`)]);
  });

  test('a file the tier collects but git does not list fails, because CI would never see it', () => {
    const ignored = 'packages/server/src/scratch/local.uncached.test.ts';
    expect(
      uncachedTierProblems(packages(), [SERVER], [server([SERVER, ignored]), scripts([])]),
    ).toEqual([
      expect.stringContaining(
        `${ignored} takes the .uncached.test suffix and the tier collects it, but git ignores it`,
      ),
    ]);
  });

  test('a test named for the tier with .uncached. short of its closing suffix fails, since no tier project collects it', () => {
    expect(
      uncachedTierProblems(packages(), [SERVER, TRANSPOSED], [server([SERVER]), scripts([])]),
    ).toEqual([expect.stringContaining(`${TRANSPOSED} names the uncached tier, but`)]);
  });

  test('the same infix ahead of the closing .uncached.test suffix passes', () => {
    expect(
      uncachedTierProblems(packages(), [SERVER, INFIXED], [server([SERVER, INFIXED]), scripts([])]),
    ).toEqual([]);
  });

  test('an empty listing fails rather than passing having run nothing', () => {
    expect(uncachedTierProblems(packages(), [], [server([]), scripts([])])).toEqual([
      'git lists no file with the .uncached.test suffix, so the tier would pass having run nothing.',
    ]);
  });
});

describe('reconcile() under win32 path semantics, where relative() emits backslashes', () => {
  test('a listed file its covering project leaves uncollected is the only problem, and names that project', async () => {
    const root = fileURLToPath(new URL('..', import.meta.url));
    const listed = listUncachedTestFiles(root);
    const inServer = (path: string) => path.startsWith('packages/server/');
    const uncollected = listed.find(inServer);
    expect(uncollected).toBeDefined();
    const project = (name: string, dir: string, files: string[]) => ({
      name,
      config: { root: resolve(root, dir) },
      globTestFiles: async () => ({ testFiles: files.map((file) => resolve(root, file)) }),
    });
    vi.doMock('node:path', () => {
      const onWindows = { ...win32, join };
      return { ...onWindows, default: onWindows };
    });
    onTestFinished(() => {
      vi.doUnmock('node:path');
      vi.resetModules();
    });
    vi.resetModules();
    const { default: reconcile } = await import('./uncached-tier-reconcile');
    const tier = {
      vitest: {
        projects: [
          project(
            'packages/server/vitest.config.ts',
            'packages/server',
            listed.filter((path) => inServer(path) && path !== uncollected),
          ),
          project(
            'vitest.scripts.config.ts',
            '.',
            listed.filter((path) => !inServer(path)),
          ),
        ],
        config: {
          projects: [
            { test: { name: 'packages/server/vitest.config.ts' } },
            { test: { name: 'vitest.scripts.config.ts' } },
          ],
        },
      },
    } as unknown as TestProject;
    const failure = await reconcile(tier).catch((error: Error) => error);
    expect(failure instanceof Error ? failure.message.split('\n  ') : failure).toEqual([
      'vitest.uncached.config.ts:',
      expect.stringContaining(
        `${uncollected} takes the .uncached.test suffix and sits under packages/server, but that project's include and exclude do not collect it, so no tier would run it. Fix packages/server/vitest.config.ts's include or exclude`,
      ),
    ]);
  });
});

describe('reconcile() over the real tier config, as Vitest resolves it under a --project filter', () => {
  const root = fileURLToPath(new URL('..', import.meta.url));
  const SERVER_PROJECT = 'packages/server/vitest.config.ts';
  const SCRIPTS_PROJECT = 'vitest.scripts.config.ts';

  async function reconcileUnder(project: string[] | undefined) {
    const vitest = await createVitest({
      root,
      config: 'vitest.uncached.config.ts',
      watch: false,
      ...(project === undefined ? {} : { project }),
    });
    try {
      const resolved = vitest.projects.map(({ name }) => name).sort();
      expect(resolved.length).toBeGreaterThan(0);
      Reflect.deleteProperty(globalThis, Symbol.for('open-knowledge.uncached-tier.reconciled'));
      const { default: reconcile } = await import('./uncached-tier-reconcile');
      const failure = await reconcile(vitest.projects[0] as TestProject).then(
        () => undefined,
        (error: Error) => error,
      );
      return { resolved, failure };
    } finally {
      await vitest.close();
    }
  }

  let declared: string[] = [];

  beforeAll(async () => {
    const { resolved, failure } = await reconcileUnder(undefined);
    expect(failure).toBeUndefined();
    declared = resolved;
  });

  test('every declared project is a Vitest config on disk, the server and root scripts configs among them', () => {
    expect(declared).toEqual(expect.arrayContaining([SERVER_PROJECT, SCRIPTS_PROJECT]));
    expect(declared.filter((name) => !existsSync(join(root, name)))).toEqual([]);
  });

  test.each([
    { filter: [SCRIPTS_PROJECT], kept: () => [SCRIPTS_PROJECT] },
    {
      filter: [`!${SCRIPTS_PROJECT}`],
      kept: () => declared.filter((name) => name !== SCRIPTS_PROJECT),
    },
  ])(
    'a run narrowed by --project=$filter refuses once, naming the filter rather than SOURCES',
    async ({ filter, kept }) => {
      const { resolved, failure } = await reconcileUnder(filter);
      expect(resolved).toEqual(kept());
      expect(failure).toBeInstanceOf(Error);
      const message = failure instanceof Error ? failure.message : '';
      expect(message).toContain('--project');
      expect(message).not.toContain('SOURCES');
      expect(listUncachedTestFiles(root).filter((path) => message.includes(path))).toEqual([]);
    },
  );

  test.each([
    { form: 'the * glob', filter: () => ['*'] },
    { form: 'every declared project by name', filter: () => declared },
  ])(
    'a run whose filter ($form) keeps every declared project reconciles cleanly',
    async ({ filter }) => {
      const { resolved, failure } = await reconcileUnder(filter());
      expect(resolved).toEqual(declared);
      expect(failure).toBeUndefined();
    },
  );
});

describe("the tier's discovery domain: what git lists, and what every project excludes", () => {
  test('git lists tracked and untracked suffixed files, never an ignored one or one under node_modules', () => {
    const root = workspace({
      '.gitignore': 'node_modules/\nscratch/\n',
      'packages/server/src/tracked.uncached.test.ts': '',
      'packages/server/src/untracked.uncached.test.ts': '',
      'packages/server/src/scratch/ignored.uncached.test.ts': '',
      'packages/server/node_modules/vendored/vendored.uncached.test.ts': '',
      'packages/server/src/cached.test.ts': '',
    });
    git(root, ['init', '-q']);
    configureTestGitRepository(root);
    git(root, ['add', '.gitignore', 'packages/server/src/tracked.uncached.test.ts']);
    git(root, ['commit', '-qm', 'base']);
    expect(listUncachedTestFiles(root).sort()).toEqual([
      'packages/server/src/tracked.uncached.test.ts',
      'packages/server/src/untracked.uncached.test.ts',
    ]);
  });

  test('git lists a test that carries .uncached. short of its closing suffix, and no file that is not a test', () => {
    const root = workspace({
      [SERVER]: '',
      [TRANSPOSED]: '',
      'packages/server/src/reads-app.uncached.test-helper.ts': '',
      'packages/server/src/__snapshots__/reads-app.uncached.test.ts.snap': '',
      [`${SERVER}.orig`]: '',
      'vitest.uncached.config.ts': '',
    });
    git(root, ['init', '-q']);
    configureTestGitRepository(root);
    expect(listUncachedTestFiles(root).sort()).toEqual([SERVER, TRANSPOSED].sort());
  });

  test('every tier project excludes node_modules, so a vendored suffixed file is in neither view', () => {
    const projects = (tierConfig.test?.projects ?? []) as Array<{ test?: { exclude?: string[] } }>;
    expect(projects.length).toBeGreaterThan(0);
    for (const project of projects) expect(project.test?.exclude).toContain('**/node_modules/**');
  });
});