Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

8.8 KB
Raw Blame
import { spawnSync } from 'node:child_process';
import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
import { dirname, join, relative } from 'node:path';
import { fileURLToPath } from 'node:url';
import { afterAll, describe, expect, test } from 'vitest';
import { createTempDirFactory } from '../test-support/temp-dir.test-helper.ts';
import {
  escapingReads,
  globalDependencyCovers,
  KNOWN_UNSWEPT,
  knownUnsweptWitness,
  missingKnownUnswept,
  packageRelativeGlobCovers,
  uncoveredReads,
} from './check-server-test-inputs.mjs';
import { memberDirs } from './check-typescript-resolution.mjs';
import { readJsoncOrError } from './read-jsonc.mjs';

const makeTempDir = createTempDirFactory(afterAll);

const OK_ROOT = fileURLToPath(new URL('..', import.meta.url));
const TASK = '@inkeep/open-knowledge-server#test';

function fixtureRootWithout(glob) {
  const turbo = JSON.parse(readFileSync(join(OK_ROOT, 'turbo.json'), 'utf-8'));
  const inputs = turbo.tasks[TASK].inputs;
  expect(inputs, `fixture precondition: ${glob} must be declared`).toContain(glob);
  turbo.tasks[TASK].inputs = inputs.filter((entry) => entry !== glob);

  const root = makeTempDir('ok-server-inputs-');
  writeFileSync(join(root, 'turbo.json'), JSON.stringify(turbo, null, 2));

  for (const [target, readers] of escapingReads(OK_ROOT)) {
    for (const reader of readers) {
      const dest = join(root, 'packages/server', reader);
      mkdirSync(dirname(dest), { recursive: true });
      writeFileSync(dest, readFileSync(join(OK_ROOT, 'packages/server', reader), 'utf-8'));
    }
    const targetPath = join(root, target);
    mkdirSync(dirname(targetPath), { recursive: true });
    writeFileSync(targetPath, '');
  }
  return root;
}

describe('check-server-test-inputs', () => {
  test('the live tree is clean: every escaping read is a declared input', () => {
    expect(uncoveredReads()).toEqual([]);
  });

  test('the sweep finds a corpus, so a green is not vacuous', () => {
    expect(escapingReads().size).toBeGreaterThan(0);
  });

  test.each([['../../test-support/*.ts', 'test-support/']])(
    'reds when %s is dropped from the task inputs',
    (glob, expectedTarget) => {
      const uncovered = uncoveredReads(fixtureRootWithout(glob));
      expect(uncovered.length).toBeGreaterThan(0);
      expect(uncovered.map((entry) => entry.target).join('\n')).toContain(expectedTarget);
    },
  );

  function fixtureRootReading(testFile) {
    const root = makeTempDir('ok-server-inputs-');
    mkdirSync(join(root, 'packages/server/src'), { recursive: true });
    mkdirSync(join(root, 'docs'), { recursive: true });
    writeFileSync(join(root, 'docs/guide.md'), '');
    writeFileSync(
      join(root, 'packages/server/src', testFile),
      "const guide = join(REPO_ROOT, 'docs', 'guide.md');\n",
    );
    writeFileSync(
      join(root, 'turbo.json'),
      JSON.stringify({ tasks: { [TASK]: { inputs: ['$TURBO_DEFAULT$'] } } }),
    );
    return root;
  }

  test('a read composed through join(<*ROOT*>, ...) is derived, not only a quoted ../ literal', () => {
    expect(uncoveredReads(fixtureRootReading('reads-docs.test.ts'))).toEqual([
      { target: 'docs/guide.md', readers: ['src/reads-docs.test.ts'] },
    ]);
  });

  test('a test with the .uncached.test suffix is outside the sweep, because the uncached tier runs it', () => {
    expect(uncoveredReads(fixtureRootReading('reads-docs.uncached.test.ts'))).toEqual([]);
  });

  test.each(Object.keys(KNOWN_UNSWEPT))(
    'reds when %s is dropped, even though the sweep cannot see its reader',
    (glob) => {
      const root = fixtureRootWithout(glob);
      expect(missingKnownUnswept(root)).toEqual([glob]);
    },
  );

  test('every KNOWN_UNSWEPT glob is genuinely in the blind spot, not just listed', () => {
    for (const glob of Object.keys(KNOWN_UNSWEPT)) {
      const root = fixtureRootWithout(glob);
      expect(
        uncoveredReads(root),
        `${glob} IS derivable now - drop it from KNOWN_UNSWEPT rather than pinning it twice`,
      ).toEqual([]);
    }
  });

  test('every KNOWN_UNSWEPT entry carries a reason', () => {
    for (const [glob, reason] of Object.entries(KNOWN_UNSWEPT)) {
      expect(reason, glob).toMatch(/\S/);
    }
  });

  test('a trailing /** covers the directory itself, not only paths beneath it', () => {
    expect(packageRelativeGlobCovers('../cli/src/**', 'packages/cli/src')).toBe(true);
    expect(packageRelativeGlobCovers('../cli/src/**', 'packages/cli/src/index.ts')).toBe(true);
    expect(packageRelativeGlobCovers('../cli/src/**', 'packages/cli/tsdown.config.ts')).toBe(false);
  });

  test('a single-segment * does not cross a directory boundary', () => {
    expect(packageRelativeGlobCovers('../*/package.json', 'packages/app/package.json')).toBe(true);
    expect(packageRelativeGlobCovers('../*/package.json', 'packages/app/src/package.json')).toBe(
      false,
    );
  });

  test('globalDependencyCovers escapes glob metacharacters before matching', () => {
    expect(globalDependencyCovers('turbo-cache-key.json', 'turbo-cache-key.json')).toBe(true);
    expect(globalDependencyCovers('turbo-cache-key.json', 'turbo-cache-keyXjson')).toBe(false);
    expect(globalDependencyCovers('patches/*.patch', 'patches/a.patch')).toBe(true);
    expect(globalDependencyCovers('patches/*.patch', 'patches/nested/a.patch')).toBe(false);
  });

  test('globalDependencyCovers honours a trailing globstar like its sibling', () => {
    expect(globalDependencyCovers('generated/**', 'generated')).toBe(true);
    expect(globalDependencyCovers('generated/**', 'generated/a/b.ts')).toBe(true);
    expect(globalDependencyCovers('generated/**', 'generated-other')).toBe(false);
  });

  test('a KNOWN_UNSWEPT pin is satisfied by coverage, not by its exact spelling', () => {
    const root = fixtureRootWithout('../app/src/editor/observers.ts');
    const turboPath = join(root, 'turbo.json');
    const turbo = JSON.parse(readFileSync(turboPath, 'utf-8'));
    turbo.tasks[TASK].inputs.push('../app/src/**');
    writeFileSync(turboPath, JSON.stringify(turbo, null, 2));
    expect(missingKnownUnswept(root)).toEqual([]);
  });

  test('a KNOWN_UNSWEPT pin whose coverage is actually gone still reds', () => {
    expect(missingKnownUnswept(fixtureRootWithout('../app/src/editor/observers.ts'))).toEqual([
      '../app/src/editor/observers.ts',
    ]);
  });

  test('knownUnsweptWitness trims only a trailing globstar', () => {
    expect(knownUnsweptWitness('../../lint-plugins/**')).toBe('../../lint-plugins');
    expect(knownUnsweptWitness('../../oxlint.config.ts')).toBe('../../oxlint.config.ts');
  });

  test('the CLI entry point exits 0 and prints its OK line on the real tree', () => {
    const script = fileURLToPath(new URL('./check-server-test-inputs.mjs', import.meta.url));
    const run = spawnSync(process.execPath, [script], { encoding: 'utf-8' });
    expect(run.status, run.stderr).toBe(0);
    expect(run.stdout).toMatch(/check:server-test-inputs: OK/);
  });
});

describe('the uncached tier is a root task of its own', () => {
  test('the tier is never cached, and no finite task carries a with sibling', () => {
    const turbo = JSON.parse(readFileSync(join(OK_ROOT, 'turbo.json'), 'utf-8'));
    const refused = [];
    const members = memberDirs(
      OK_ROOT,
      readFileSync(join(OK_ROOT, 'pnpm-workspace.yaml'), 'utf-8'),
      (entry) => refused.push(`unreadable: ${entry}`),
      (pattern) => refused.push(`no member: ${pattern}`),
    );
    expect(
      refused,
      'pnpm-workspace.yaml has entries this derivation cannot read or that name no member, so their turbo configs would leave the scan',
    ).toEqual([]);
    expect(members.map((dir) => relative(OK_ROOT, dir))).toEqual(
      expect.arrayContaining(['packages/server', 'docs']),
    );
    const configs = [['turbo.json', turbo]];
    for (const dir of members) {
      for (const name of ['turbo.json', 'turbo.jsonc']) {
        const read = readJsoncOrError(join(dir, name));
        if (read.code === 'ENOENT') continue;
        expect(read.ok, read.reason).toBe(true);
        configs.push([relative(OK_ROOT, join(dir, name)), read.value]);
      }
    }
    const finiteWith = configs.flatMap(([path, config]) =>
      Object.entries(config.tasks ?? {})
        .filter(
          ([name, task]) =>
            task.with !== undefined && (task.persistent ?? turbo.tasks[name]?.persistent) !== true,
        )
        .map(([name]) => `${path}: ${name}`),
    );
    expect(
      finiteWith,
      'turbo 2.11.3 and later stop a `with` task once its parent exits, so a finite parent cuts its sibling short and the run still passes; name the sibling in the turbo run instead, as every whole-suite run names test:uncached',
    ).toEqual([]);
    expect(turbo.tasks['//#test:uncached']).toMatchObject({ cache: false });
    const pkg = JSON.parse(readFileSync(join(OK_ROOT, 'package.json'), 'utf-8'));
    expect(pkg.scripts['test:uncached']).toBe('vitest run --config vitest.uncached.config.ts');
  });
});