browser-commander 0.16.1 → 0.17.1

package/tests/unit/scripts/cargo-lock-sync.test.js

@@ -0,0 +1,110 @@
+/**
+ * Guard for the lockfile half of RC-C.
+ *
+ * `rust/scripts/version-and-commit.mjs` writes the new version into
+ * Cargo.toml. Cargo.lock carries the workspace member's own version too, so a
+ * bump that touches only the manifest leaves the two disagreeing, and every
+ * job that builds the release commit with `cargo build --locked` fails with
+ * "the lock file needs to be updated but --locked was passed".
+ *
+ * The drift was invisible while RC-C was live: the release commit was never
+ * pushed, so main kept a Cargo.toml and a Cargo.lock that still agreed.
+ * Fixing RC-C is what makes this reachable.
+ *
+ * Analysis: dev/log/issues/83/pulls/84/analysis/root-causes.md, RC-C
+ */
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, it } from 'node:test';
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), '../../../..');
+
+/**
+ * Read the version of a named package out of a Cargo.lock.
+ *
+ * The line separator is `\r?\n` because a Windows runner checks the file out
+ * with CRLF: `git config core.autocrlf` is `true` on GitHub's windows-latest
+ * image, so a pattern anchored on a bare `\n` matches nothing there and the
+ * lookup silently returns `undefined` -- a guard that passes on two operating
+ * systems and fails on the third for a reason that has nothing to do with what
+ * it guards.
+ *
+ * @param {string} lock
+ * @param {string} name
+ * @returns {string | undefined}
+ */
+function lockedVersion(lock, name) {
+  const pattern = new RegExp(
+    `\\[\\[package\\]\\]\\r?\\nname = "${name}"\\r?\\nversion = "([^"]+)"`
+  );
+  return pattern.exec(lock)?.[1];
+}
+
+describe('Cargo.lock stays in step with the release bump', () => {
+  const cargoToml = readFileSync(join(repoRoot, 'rust/Cargo.toml'), 'utf8');
+  const cargoLock = readFileSync(join(repoRoot, 'rust/Cargo.lock'), 'utf8');
+  const script = readFileSync(
+    join(repoRoot, 'rust/scripts/version-and-commit.mjs'),
+    'utf8'
+  );
+
+  it('records the manifest version in the lockfile today', () => {
+    const manifestVersion = /^\[package\][\s\S]*?^version = "([^"]+)"/m.exec(
+      cargoToml
+    )?.[1];
+    assert.ok(manifestVersion, 'Cargo.toml has no [package] version');
+    assert.equal(
+      lockedVersion(cargoLock, 'browser-commander'),
+      manifestVersion,
+      'a build with --locked would refuse this tree'
+    );
+  });
+
+  it('reads a lockfile that was checked out with CRLF line endings', () => {
+    const crlf = cargoLock.replace(/\r?\n/g, '\r\n');
+    assert.equal(
+      lockedVersion(crlf, 'browser-commander'),
+      lockedVersion(cargoLock, 'browser-commander'),
+      'the same lockfile must read the same on a Windows checkout'
+    );
+  });
+
+  it('refreshes the lockfile as part of the bump', () => {
+    assert.match(
+      script,
+      /cargo update --workspace/,
+      'bumping Cargo.toml without refreshing Cargo.lock breaks --locked builds'
+    );
+  });
+
+  it('refreshes the lockfile after the manifest, not before', () => {
+    const bump = script.indexOf('updateCargoToml(newVersion)');
+    const refresh = script.indexOf('cargo update --workspace');
+    assert.ok(bump > 0 && refresh > 0);
+    assert.ok(
+      bump < refresh,
+      'refreshing before the bump would re-lock the old version'
+    );
+  });
+
+  it('stages the lockfile in the release commit', () => {
+    const add = /git add -A ([^`]+)`/.exec(script)?.[1] ?? '';
+    assert.ok(
+      add.split(/\s+/).includes('Cargo.lock'),
+      `Cargo.lock is refreshed but never committed (staged: ${add.trim()})`
+    );
+  });
+
+  it('is what the release job later builds with --locked', () => {
+    // If the workflow stopped passing --locked the drift would go unnoticed
+    // again, so the guard is only meaningful while this flag is there.
+    const workflow = readFileSync(
+      join(repoRoot, '.github/workflows/rust.yml'),
+      'utf8'
+    );
+    assert.match(workflow, /cargo build --locked/);
+  });
+});

package/tests/unit/scripts/changelog-collection-order.test.js

@@ -0,0 +1,144 @@
+/**
+ * Guard for RC-I: collecting the changelog before the version bump.
+ *
+ * Both manual-release jobs used to collect fragments in a workflow step that
+ * ran ahead of the bump, and both named the section wrongly as a result:
+ *
+ *   rust.yml    `node scripts/collect-changelog.mjs` reads the version out of
+ *               Cargo.toml, which at that point still held the version that
+ *               was already released, so the notes were filed under it and
+ *               the version being released got none.
+ *   python.yml  `scriv collect --version "$BUMP_TYPE"`. `--version` names the
+ *               new changelog section rather than selecting a bump, so a
+ *               release wrote a section titled "patch".
+ *
+ * Either way the release notes went missing: create-github-release looks for
+ * the version it is releasing and falls back to a bare "Release <version>".
+ *
+ * Collection now happens inside the version-and-commit scripts, after the
+ * bump has computed the version. These assertions are on the workflows,
+ * because that is where the ordering lived.
+ *
+ * Analysis: dev/log/issues/83/pulls/84/analysis/root-causes.md
+ * Reproduction: experiments/scriv-collect-version/run.sh
+ */
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, it } from 'node:test';
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), '../../../..');
+
+/**
+ * Read a workflow with its comment lines removed.
+ *
+ * The comments explain the very mistakes these assertions look for, so
+ * matching against the raw file would find the explanation and report the bug
+ * as still present.
+ * @param {string} name
+ * @returns {string}
+ */
+function workflow(name) {
+  return readFileSync(join(repoRoot, '.github/workflows', name), 'utf8')
+    .split('\n')
+    .filter((line) => !/^\s*#/.test(line))
+    .join('\n');
+}
+
+describe('changelog fragments are collected after the version bump', () => {
+  it('never passes a bump type where a version name is expected', () => {
+    // `scriv collect --version` is documented as "The version name to use for
+    // this entry", so "$BUMP_TYPE" lands in the changelog verbatim.
+    assert.doesNotMatch(
+      workflow('python.yml'),
+      /scriv collect --version "\$BUMP_TYPE"/,
+      'scriv would head the release section with the word "patch"'
+    );
+  });
+
+  it('has no workflow step that collects ahead of the bump', () => {
+    for (const [name, collector] of [
+      ['rust.yml', 'collect-changelog.mjs'],
+      ['python.yml', 'scriv collect'],
+    ]) {
+      const content = workflow(name);
+      const collect = content.indexOf(collector);
+      if (collect < 0) {
+        continue;
+      }
+      const bump = content.indexOf('name: Version and commit');
+      assert.ok(
+        bump < 0 || collect > bump,
+        `${name} collects the changelog before the bump names the version`
+      );
+    }
+  });
+
+  it('collects inside the scripts that know the new version', () => {
+    const rust = readFileSync(
+      join(repoRoot, 'rust/scripts/version-and-commit.mjs'),
+      'utf8'
+    );
+    assert.match(rust, /updateChangelog\('\.', newVersion, fragments\)/);
+
+    const python = readFileSync(
+      join(repoRoot, 'python/scripts/version_and_commit.py'),
+      'utf8'
+    );
+    assert.match(python, /collect_changelog\(new_version, project_root\)/);
+  });
+
+  it('orders collection after the bump inside those scripts', () => {
+    const rust = readFileSync(
+      join(repoRoot, 'rust/scripts/version-and-commit.mjs'),
+      'utf8'
+    );
+    assert.ok(
+      rust.indexOf('const newVersion = await findNextAvailableVersion') <
+        rust.indexOf('collectFragments()')
+    );
+
+    const python = readFileSync(
+      join(repoRoot, 'python/scripts/version_and_commit.py'),
+      'utf8'
+    );
+    assert.ok(
+      python.indexOf('new_version = bump_version(') <
+        python.indexOf('collect_changelog(new_version')
+    );
+  });
+
+  it('writes headings at the level the release scripts read', () => {
+    // scriv defaults to level 1 while create_github_release.py extracts from
+    // `## <version>`, so the two could never meet.
+    const pyproject = readFileSync(
+      join(repoRoot, 'python/pyproject.toml'),
+      'utf8'
+    );
+    assert.match(pyproject, /^md_header_level = "2"$/m);
+
+    const release = readFileSync(
+      join(repoRoot, 'python/scripts/create_github_release.py'),
+      'utf8'
+    );
+    assert.match(release, /rf"\^## \{re\.escape\(version\)\}/);
+  });
+
+  it('says so in the run summary when the notes are missing anyway', () => {
+    // The fallback body is a silent downgrade: the release still goes out and
+    // the job still passes.
+    for (const path of [
+      'js/scripts/create-github-release.mjs',
+      'rust/scripts/create-github-release.mjs',
+      'python/scripts/create_github_release.py',
+    ]) {
+      assert.match(
+        readFileSync(join(repoRoot, path), 'utf8'),
+        /::warning::/,
+        `${path} drops the release notes without a word`
+      );
+    }
+  });
+});

package/tests/unit/scripts/changeset-formatter.test.js

@@ -0,0 +1,108 @@
+/**
+ * Guard for RC-G: `changeset version` aborting on a formatter that is not
+ * installed.
+ *
+ * @changesets/cli v3 formats the changelog it writes. With the default
+ * `"format": "auto"`, @changesets/format walks `defaultDetectOrder` --
+ * dprint, deno, oxfmt, biome, prettier -- and picks the first formatter whose
+ * config file it finds. `js/deno.json` existed -- orphaned configuration no
+ * workflow ever used -- so deno won over the prettier this package actually
+ * depends on. deno is the one entry in that table with
+ * no `packageName`, so it is spawned straight off PATH with no existence
+ * check and no npx fallback; GitHub's ubuntu-latest runner has no deno.
+ *
+ * `changeset version` therefore bumped package.json, wrote CHANGELOG.md, and
+ * then died with `spawn deno ENOENT` before deleting the changeset it had
+ * just consumed. The release still shipped -- 0.17.0 is on npm -- but
+ * `merged-loud-river.md` survived to be released a second time, and the
+ * half-written CHANGELOG.md kept trailing whitespace that fails
+ * `prettier --check`.
+ *
+ * Reproduction: experiments/ci-repro/repro-changeset-deno-formatter.mjs
+ * Analysis: dev/log/issues/83/pulls/84/analysis/root-causes.md, RC-G
+ */
+
+import assert from 'node:assert/strict';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, it } from 'node:test';
+
+const packageRoot = join(dirname(fileURLToPath(import.meta.url)), '../../..');
+const require = createRequire(import.meta.url);
+
+const config = JSON.parse(
+  readFileSync(join(packageRoot, '.changeset/config.json'), 'utf-8')
+);
+
+describe('changesets formatter', () => {
+  it('pins a formatter instead of auto-detecting one', () => {
+    assert.notEqual(
+      config.format,
+      undefined,
+      'omitting `format` means "auto", which detects whichever formatter ' +
+        'config happens to sit beside package.json and then fails on a ' +
+        'runner that has no such binary'
+    );
+    assert.notEqual(config.format, 'auto', 'same as omitting it');
+  });
+
+  it('pins a formatter this package can actually run', () => {
+    // `false` disables formatting, which is also a safe answer.
+    if (config.format === false) {
+      return;
+    }
+
+    const { defaultDetectOrder } = require('@changesets/format');
+    assert.ok(
+      defaultDetectOrder.includes(config.format),
+      `unknown formatter ${JSON.stringify(config.format)}; expected one of ${defaultDetectOrder.join(
+        ', '
+      )}`
+    );
+
+    // @changesets/format keeps the formatter table private, so mirror the
+    // one fact this test needs: which formatters it resolves through
+    // node_modules and which it spawns straight off PATH. `deno` is the
+    // single entry with no package, which is why it cannot be relied on.
+    const packageNames = {
+      dprint: 'dprint',
+      deno: null,
+      oxfmt: 'oxfmt',
+      biome: '@biomejs/biome',
+      prettier: 'prettier',
+    };
+    const packageName = packageNames[config.format];
+    assert.ok(
+      packageName,
+      `${config.format} is spawned straight off PATH with no npx fallback, ` +
+        'so it cannot be relied on inside a release job'
+    );
+    assert.ok(
+      existsSync(join(packageRoot, 'node_modules', packageName)),
+      `${packageName} is not installed in this package`
+    );
+  });
+
+  it('leaves no consumed changeset behind', () => {
+    const changesetDir = join(packageRoot, '.changeset');
+    const pending = readdirSync(changesetDir).filter(
+      (file) => file.endsWith('.md') && file !== 'README.md'
+    );
+
+    const changelog = readFileSync(join(packageRoot, 'CHANGELOG.md'), 'utf-8');
+    for (const file of pending) {
+      const body = readFileSync(join(changesetDir, file), 'utf-8')
+        .replace(/^---\s*\n[\s\S]*?\n---\s*\n/, '')
+        .trim();
+      const firstLine = body.split('\n')[0].trim();
+      assert.ok(
+        firstLine.length === 0 || !changelog.includes(firstLine),
+        `.changeset/${file} describes a change that CHANGELOG.md already ` +
+          'records as released; `changeset version` consumed it but did not ' +
+          'delete it, so the next release will publish it again'
+      );
+    }
+  });
+});

package/tests/unit/scripts/check-pipeline-status.test.js

@@ -0,0 +1,133 @@
+/**
+ * The gate that makes a cancelled job visible.
+ *
+ * GitHub reports a job killed by its `timeout-minutes` as *cancelled*, not
+ * *failed*, and a run whose only casualty is a cancelled job is filed under
+ * `cancelled` as well - run 24045269874 of this repository is one such run on
+ * `main`. scripts/check-pipeline-status.sh is the only thing that looks at
+ * that, so these tests pin the four readings it has to get right: a failure is
+ * always an error, a cancellation off the default branch is a warning, a
+ * cancellation on the default branch is an error unless a newer run has already
+ * taken over the branch head.
+ *
+ * See docs/CI-TIMEOUT-BUDGETS.md.
+ */
+
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { describe, it } from 'node:test';
+
+import {
+  BASH_AVAILABLE,
+  REPO_ROOT,
+  repoPath,
+  runBashScript,
+} from '../../helpers/repo.js';
+
+const SCRIPT = repoPath('scripts/check-pipeline-status.sh');
+
+function runGate(needs, env = {}, options = {}) {
+  return runBashScript(SCRIPT, [], {
+    cwd: options.cwd,
+    env: { NEEDS_JSON: JSON.stringify(needs), ...env },
+  });
+}
+
+function results(map) {
+  return Object.fromEntries(
+    Object.entries(map).map(([job, result]) => [job, { result }])
+  );
+}
+
+describe('check-pipeline-status.sh', { skip: !BASH_AVAILABLE }, () => {
+  it('passes when every job succeeded or was legitimately skipped', () => {
+    const { status, output } = runGate(
+      results({ lint: 'success', release: 'skipped' }),
+      { IS_MAIN: 'true', RUN_SHA: 'abc', BRANCH_HEAD_SHA: 'abc' }
+    );
+
+    assert.equal(status, 0);
+    assert.match(
+      output,
+      /All required jobs succeeded or were legitimately skipped/
+    );
+  });
+
+  it('fails on a failed job and names it', () => {
+    const { status, output } = runGate(
+      results({ lint: 'failure', test: 'success' }),
+      { IS_MAIN: 'true', RUN_SHA: 'abc', BRANCH_HEAD_SHA: 'abc' }
+    );
+
+    assert.equal(status, 1);
+    assert.match(output, /::error::Pipeline failed\. Failing jobs: lint/);
+  });
+
+  it('only warns about a cancellation off the default branch', () => {
+    const { status, output } = runGate(results({ test: 'cancelled' }), {
+      IS_MAIN: 'false',
+      RUN_SHA: 'abc',
+      BRANCH_HEAD_SHA: 'abc',
+    });
+
+    assert.equal(status, 0);
+    assert.match(output, /::warning::Cancelled jobs: test/);
+  });
+
+  it('fails on a cancellation on the default branch head', () => {
+    const { status, output } = runGate(results({ test: 'cancelled' }), {
+      IS_MAIN: 'true',
+      RUN_SHA: 'abc',
+      BRANCH_HEAD_SHA: 'abc',
+    });
+
+    assert.equal(status, 1);
+    assert.match(output, /::error::Pipeline has cancelled jobs on main: test/);
+  });
+
+  it('only warns when a newer commit already superseded the run', () => {
+    const { status, output } = runGate(results({ test: 'cancelled' }), {
+      IS_MAIN: 'true',
+      RUN_SHA: 'abc',
+      BRANCH_HEAD_SHA: 'def',
+    });
+
+    assert.equal(status, 0);
+    assert.match(output, /This run tests abc; main is at def/);
+    assert.match(output, /::warning::Cancelled jobs: test/);
+  });
+
+  it('fails rather than guesses when the branch head cannot be resolved', () => {
+    // A missed supersede costs one noisy warning; a missed overrun on main
+    // costs a silent failure, so the unresolvable case has to be the loud one.
+    const directory = mkdtempSync(path.join(tmpdir(), 'pipeline-status-'));
+
+    try {
+      const { status, output } = runGate(
+        results({ test: 'cancelled' }),
+        { IS_MAIN: 'true', RUN_SHA: 'abc', BRANCH_HEAD_SHA: '' },
+        { cwd: directory }
+      );
+
+      assert.equal(status, 1);
+      assert.match(output, /assuming it is current/);
+      assert.match(output, /::error::Pipeline has cancelled jobs on main/);
+    } finally {
+      rmSync(directory, { force: true, recursive: true });
+    }
+  });
+
+  it('refuses to run without the job results', () => {
+    const result = spawnSync('bash', [SCRIPT], {
+      cwd: REPO_ROOT,
+      encoding: 'utf8',
+      env: { ...process.env, NEEDS_JSON: '' },
+    });
+
+    assert.notEqual(result.status, 0);
+    assert.match(result.stderr, /NEEDS_JSON is required/);
+  });
+});

package/tests/unit/scripts/check-release-format.test.js

@@ -0,0 +1,131 @@
+/**
+ * Guard for RC-E: the release commit that no workflow run ever checks.
+ *
+ * `version-and-commit.mjs` pushes the bump with `GITHUB_TOKEN`, and a push
+ * authenticated with `GITHUB_TOKEN` does not start a workflow run. When
+ * `changeset version` wrote a CHANGELOG.md that Prettier rejects, main's
+ * `format:check` went red and stayed red: the runs that could have reported it
+ * were exactly the ones the push never triggered.
+ *
+ * Analysis: dev/log/issues/83/pulls/84/analysis/root-causes.md, RC-E
+ */
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, it } from 'node:test';
+
+import {
+  FORMAT_CHECK_COMMAND,
+  assertGeneratedFilesAreFormatted,
+  formatFailureAnnotation,
+  formatFailureDetails,
+} from '../../../scripts/check-release-format.mjs';
+
+const jsRoot = join(dirname(fileURLToPath(import.meta.url)), '../../..');
+
+/** @returns {{log: (m: string) => void, error: (m: string) => void, lines: string[], errors: string[]}} */
+function recorder() {
+  const lines = [];
+  const errors = [];
+  return {
+    lines,
+    errors,
+    log: (message) => lines.push(String(message)),
+    error: (message) => errors.push(String(message)),
+  };
+}
+
+describe('release commit formatting gate', () => {
+  it('lets a formatted release commit through', async () => {
+    const console_ = recorder();
+    let ran = 0;
+
+    await assertGeneratedFilesAreFormatted(async () => {
+      ran += 1;
+    }, console_);
+
+    assert.equal(ran, 1);
+    assert.equal(console_.errors.length, 0);
+    assert.ok(console_.lines.some((line) => line.includes('is formatted')));
+  });
+
+  it('stops the release when the generated files fail the gate', async () => {
+    const console_ = recorder();
+    const failure = Object.assign(
+      new Error('Command failed with exit code 1'),
+      { stdout: '[warn] CHANGELOG.md\n', stderr: '' }
+    );
+
+    await assert.rejects(
+      assertGeneratedFilesAreFormatted(async () => {
+        throw failure;
+      }, console_),
+      // Rethrown unchanged: the caller's catch reports it and exits non-zero,
+      // so the push never happens.
+      (error) => error === failure
+    );
+
+    assert.ok(console_.errors[0].startsWith('::error title='));
+    assert.ok(console_.errors.includes('[warn] CHANGELOG.md'));
+  });
+
+  it('keeps the annotation on one line', () => {
+    // A workflow command ends at the first newline; anything after it is
+    // printed as plain log text and never becomes an annotation.
+    assert.ok(!formatFailureAnnotation().includes('\n'));
+    assert.ok(formatFailureAnnotation().startsWith('::error title='));
+  });
+
+  it('reads the reason out of the captured streams, not the message', () => {
+    // With errexit on, `error.message` is only "Command failed with exit code
+    // N". A call site that reported `message` would say nothing useful.
+    const details = formatFailureDetails({
+      message: 'Command failed with exit code 1',
+      stdout: '  [warn] CHANGELOG.md  ',
+      stderr: 'prettier: not found',
+    });
+
+    assert.equal(details, '[warn] CHANGELOG.md\nprettier: not found');
+    assert.equal(formatFailureDetails(new Error('boom')), '');
+    assert.equal(formatFailureDetails(undefined), '');
+  });
+
+  it('runs the same gate the lint job runs', () => {
+    // A gate that drifts from the one CI uses would pass here and fail there.
+    const workflow = readFileSync(
+      join(jsRoot, '../.github/workflows/js.yml'),
+      'utf8'
+    );
+    assert.ok(
+      workflow.includes(`run: ${FORMAT_CHECK_COMMAND}`),
+      `${FORMAT_CHECK_COMMAND} is no longer the workflow's formatting gate`
+    );
+
+    const script = readFileSync(
+      join(jsRoot, 'scripts/version-and-commit.mjs'),
+      'utf8'
+    );
+    assert.ok(
+      script.includes(FORMAT_CHECK_COMMAND),
+      'version-and-commit.mjs must run the same command it documents'
+    );
+  });
+
+  it('checks before it commits, not after it pushes', () => {
+    const script = readFileSync(
+      join(jsRoot, 'scripts/version-and-commit.mjs'),
+      'utf8'
+    );
+    const check = script.indexOf('assertGeneratedFilesAreFormatted(() =>');
+    const commit = script.indexOf('git commit');
+    const push = script.indexOf('git push origin main');
+
+    assert.ok(check > 0 && commit > 0 && push > 0);
+    assert.ok(
+      check < commit && check < push,
+      'a check that runs after the push cannot stop a bad release commit'
+    );
+  });
+});