start-command 0.38.0 → 0.39.1

package/test/release-push-retry.mjs

@@ -0,0 +1,172 @@
+import { describe, expect, it } from 'bun:test';
+import { execFileSync } from 'node:child_process';
+import {
+  chmodSync,
+  existsSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { $ } from 'command-stream';
+
+import {
+  checked,
+  classifyPushRejection,
+  pushWithRetry,
+} from '../../scripts/release-git.mjs';
+
+function git(cwd, ...args) {
+  return execFileSync('git', args, { cwd, stdio: 'pipe' }).toString().trim();
+}
+
+function clone(dir, remote, name) {
+  const work = join(dir, name);
+  git(dir, 'clone', '-q', remote, work);
+  git(work, 'config', 'user.name', name);
+  git(work, 'config', 'user.email', `${name}@example.com`);
+  return work;
+}
+
+/**
+ * Two writers on one bare `main`: `other` lands first, then `ours` pushes a
+ * commit made on the stale tip - what happens when the main-writer
+ * concurrency group runs two release jobs back to back (#234).
+ */
+async function withWriters({ otherFile, ourFile, rule = false }, callback) {
+  const dir = mkdtempSync(join(tmpdir(), 'release-push-'));
+  const previousCwd = process.cwd();
+  try {
+    const remote = join(dir, 'remote.git');
+    git(dir, 'init', '-q', '--bare', '-b', 'main', remote);
+    const seed = clone(dir, remote, 'seed');
+    writeFileSync(join(seed, 'package.json'), '{"version":"0.1.0"}\n');
+    git(seed, 'add', '.');
+    git(seed, 'commit', '-q', '-m', 'initial');
+    git(seed, 'push', '-q', 'origin', 'main');
+
+    const ours = clone(dir, remote, 'ours');
+    const other = clone(dir, remote, 'other');
+    writeFileSync(join(other, otherFile), 'other writer\n');
+    git(other, 'add', '.');
+    git(other, 'commit', '-q', '-m', 'other release');
+    git(other, 'push', '-q', 'origin', 'main');
+
+    writeFileSync(join(ours, ourFile), 'our release\n');
+    git(ours, 'add', '.');
+    git(ours, 'commit', '-q', '-m', 'our release');
+
+    const pushes = join(dir, 'pushes');
+    const hook = join(remote, 'hooks', 'pre-receive');
+    writeFileSync(
+      hook,
+      rule
+        ? `#!/bin/sh\necho x >> '${pushes}'\necho "error: GH013: Repository rule violations found for refs/heads/main." >&2\nexit 1\n`
+        : `#!/bin/sh\necho x >> '${pushes}'\n`
+    );
+    chmodSync(hook, 0o755);
+    process.chdir(ours);
+    return await callback({ ours, remote, pushes });
+  } finally {
+    process.chdir(previousCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+const noSleep = () => Promise.resolve();
+
+describe('pushWithRetry (#234)', () => {
+  it('reproduces the bug: a writer queued behind another is rejected', async () => {
+    await withWriters(
+      { otherFile: 'Cargo.toml', ourFile: 'package.json' },
+      async () => {
+        await expect(
+          checked(
+            $`git push origin main`.run({ capture: true, mirror: false }),
+            'git push origin main'
+          )
+        ).rejects.toThrow('git push origin main failed with exit code 1');
+      }
+    );
+  });
+
+  it('rebases onto the writer that landed first and pushes', async () => {
+    await withWriters(
+      { otherFile: 'Cargo.toml', ourFile: 'package.json' },
+      async ({ ours, remote }) => {
+        expect(await pushWithRetry($, { sleep: noSleep })).toEqual({
+          attempt: 2,
+        });
+        expect(git(remote, 'log', '--format=%s', 'main')).toBe(
+          'our release\nother release\ninitial'
+        );
+        expect(git(ours, 'status', '--porcelain')).toBe('');
+      }
+    );
+  });
+
+  it('fails loudly when the other writer changed the same files', async () => {
+    await withWriters(
+      { otherFile: 'package.json', ourFile: 'package.json' },
+      async ({ remote }) => {
+        await expect(pushWithRetry($, { sleep: noSleep })).rejects.toThrow(
+          'git pull --rebase origin main'
+        );
+        expect(git(remote, 'log', '-1', '--format=%s', 'main')).toBe(
+          'other release'
+        );
+      }
+    );
+  });
+
+  it('does not retry a push a repository rule rejected', async () => {
+    await withWriters(
+      { otherFile: 'Cargo.toml', ourFile: 'package.json', rule: true },
+      async ({ pushes }) => {
+        // Land on the tip first so only the rule can reject the push.
+        await checked(
+          $`git pull --rebase origin main`.run({
+            capture: true,
+            mirror: false,
+          }),
+          'git pull --rebase'
+        );
+        await expect(pushWithRetry($, { sleep: noSleep })).rejects.toThrow(
+          'blocked by a repository rule'
+        );
+        expect(existsSync(pushes)).toBe(true);
+        expect(execFileSync('wc', ['-l', pushes]).toString()).toMatch(/^\s*1 /);
+      }
+    );
+  });
+
+  it('classifies real git push output', () => {
+    expect(
+      classifyPushRejection(
+        ' ! [rejected]        main -> main (fetch first)\nerror: failed to push some refs'
+      )
+    ).toBe('non-fast-forward');
+    expect(
+      classifyPushRejection(
+        ' ! [rejected]        main -> main (non-fast-forward)'
+      )
+    ).toBe('non-fast-forward');
+    expect(
+      classifyPushRejection(
+        'remote: error: GH013: Repository rule violations found for refs/heads/main.\n ! [remote rejected] main -> main (push declined due to repository rule violations)'
+      )
+    ).toBe('rule');
+    expect(
+      classifyPushRejection(
+        'remote: error: GH006: Protected branch update failed for refs/heads/main.'
+      )
+    ).toBe('rule');
+    expect(
+      classifyPushRejection(
+        "fatal: unable to access 'https://github.com/x/y/': Could not resolve host"
+      )
+    ).toBe('other');
+  });
+});

package/test/run-js-tests.mjs

@@ -28,8 +28,20 @@ describe('run-js-tests timeout defaults', () => {
     ]);
   });
 
-  test('preserves Bun short timeout flag', () => {
-    expect(hasExplicitTimeout(['-t', '45000'])).toBe(true);
-    expect(applyDefaultTimeout(['-t', '45000'])).toEqual(['-t', '45000']);
+  // `bun test -t` is --test-name-pattern, not a timeout (#234).
+  test('keeps the default timeout for a -t name pattern', () => {
+    expect(hasExplicitTimeout(['-t', 'slow'])).toBe(false);
+    expect(applyDefaultTimeout(['-t', 'slow'])).toEqual([
+      '--timeout',
+      '30000',
+      '-t',
+      'slow',
+    ]);
+    expect(applyDefaultTimeout(['--test-name-pattern', 'slow'])).toEqual([
+      '--timeout',
+      '30000',
+      '--test-name-pattern',
+      'slow',
+    ]);
   });
 });

package/test/setup/private-snapshot-lock.js

@@ -0,0 +1,17 @@
+/**
+ * Test preload (bunfig.toml): give this test process its own Docker snapshot
+ * lock. The default lock is host-wide, so a real `start --resume` or another
+ * test process on the same host holding it made every snapshot-resume test
+ * fail after the 1s default wait (issue #234). A path set by the caller wins,
+ * so experiments can still point the tests at a shared lock.
+ */
+const { mkdtempSync } = require('fs');
+const { tmpdir } = require('os');
+const { join } = require('path');
+
+if (!process.env.START_SNAPSHOT_LOCK) {
+  process.env.START_SNAPSHOT_LOCK = join(
+    mkdtempSync(join(tmpdir(), 'start-test-snapshot-lock-')),
+    'snapshot.lock'
+  );
+}

package/test/shared-golden.js

@@ -37,18 +37,45 @@ describe('shared JavaScript and Rust golden contracts', () => {
       );
     });
   }
+  // The fixtures describe the defaults, so a host-wide docker init default
+  // (issue #244) must not leak into them.
+  function parseWithoutHostDefaults(argv) {
+    const saved = process.env.START_COMMAND_DOCKER_INIT;
+    delete process.env.START_COMMAND_DOCKER_INIT;
+    try {
+      return parseArgs(argv);
+    } finally {
+      if (saved !== undefined) {
+        process.env.START_COMMAND_DOCKER_INIT = saved;
+      }
+    }
+  }
   for (const fixture of fixtures['cli-parsing']) {
     it(`CLI parsing: ${fixture.name}`, () => {
       if (fixture.error) {
-        assert.throws(() => parseArgs(fixture.argv), new RegExp(fixture.error));
+        assert.throws(
+          () => parseWithoutHostDefaults(fixture.argv),
+          new RegExp(fixture.error)
+        );
         return;
       }
-      const parsed = parseArgs(fixture.argv);
+      const parsed = parseWithoutHostDefaults(fixture.argv);
       assert.equal(parsed.command, fixture.command);
       assert.deepEqual(parsed.rawCommand, fixture.rawCommand);
       for (const [key, value] of Object.entries(fixture.options)) {
         assert.deepEqual(parsed.wrapperOptions[key], value, key);
       }
+      if (fixture.dockerResourceLimits) {
+        const {
+          resolveResourceOptions,
+        } = require('../src/lib/docker-resource-options');
+        assert.deepEqual(
+          buildDockerRuntimeArgs(
+            resolveResourceOptions(parsed.wrapperOptions)
+          ).sort(),
+          [...fixture.dockerResourceLimits].sort()
+        );
+      }
     });
   }
   for (const fixture of fixtures['isolation-arguments']) {

package/test/transient-links.mjs

@@ -0,0 +1,139 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'bun:test';
+import {
+  parseLycheeFailures,
+  recheckUnanswered,
+} from '../../scripts/recheck-broken-links.mjs';
+
+const root = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '../..'
+);
+
+const url = 'https://github.com/owner/repo/blob/main/src/index.js';
+const base = { accept: '200..=299', userAgent: 'lychee' };
+
+describe('transient link failures', () => {
+  it('classifies cached 503 and rejected 429 as retryable, preserving 404', () => {
+    const failures = parseLycheeFailures(
+      [
+        `- [503] <${url}> | Error (cached)`,
+        `- [ERROR] <${url}> | Rejected status code: 429 Too Many Requests`,
+        `- [404] <${url}> | Not Found`,
+      ].join('\n')
+    );
+    expect(failures.map((item) => item.retryable)).toEqual([true, true, false]);
+  });
+
+  it('backs off between transient answers and recovers only on success', async () => {
+    let now = 0;
+    const waits = [];
+    const statuses = [503, 429, 200];
+    const result = await recheckUnanswered([url], {
+      ...base,
+      nowFn: () => now,
+      sleepFn: async (ms) => {
+        waits.push(ms);
+        now += ms;
+      },
+      fetchImpl: async () => ({ status: statuses.shift() }),
+    });
+    expect(result.recovered).toEqual([url]);
+    expect(waits).toEqual([5000, 10000]);
+  });
+
+  it('uses authenticated contents GET for GitHub blob and tree throttling', async () => {
+    for (const kind of ['blob', 'tree']) {
+      const page = `https://github.com/owner/repo/${kind}/release%2Fv1/src/a%20b.js`;
+      const calls = [];
+      const result = await recheckUnanswered([page], {
+        ...base,
+        githubToken: 'test-token',
+        fetchImpl: async (target, init) => {
+          calls.push({ target, init });
+          return { status: calls.length === 1 ? 503 : 200 };
+        },
+      });
+      expect(result.recovered).toEqual([page]);
+      expect(calls[0].init.headers.authorization).toBe(undefined);
+      expect(calls[1].target).toBe(
+        'https://api.github.com/repos/owner/repo/contents/src/a%20b.js?ref=release%2Fv1'
+      );
+      expect(calls[1].init.method).toBe('GET');
+      expect(calls[1].init.headers.authorization).toBe('Bearer test-token');
+      expect(calls[1].init.redirect).toBe('error');
+    }
+  });
+
+  it('does not recover on an API denial and keeps credentials off unrelated hosts', async () => {
+    let now = 0;
+    const calls = [];
+    const result = await recheckUnanswered(
+      [url, 'https://other.example/page'],
+      {
+        ...base,
+        githubToken: 'test-token',
+        budgetSeconds: 1,
+        nowFn: () => now,
+        fetchImpl: async (target, init) => {
+          calls.push({ target, init });
+          now += 100;
+          return {
+            status: target.startsWith('https://api.github.com/') ? 401 : 503,
+          };
+        },
+      }
+    );
+    expect(result.recovered).toEqual([]);
+    expect(result.stillBroken.length).toBe(2);
+    const other = calls.find((call) =>
+      call.target.startsWith('https://other.example/')
+    );
+    expect(other.init.headers.authorization).toBe(undefined);
+  });
+
+  it('never retries a definitive 404 or uses an API answer to hide it', async () => {
+    let calls = 0;
+    const result = await recheckUnanswered([url], {
+      ...base,
+      githubToken: 'test-token',
+      fetchImpl: async () => {
+        calls++;
+        return { status: 404 };
+      },
+    });
+    expect(calls).toBe(1);
+    expect(result.recovered).toEqual([]);
+  });
+
+  it('bounds persistent 503 errors by the shared wall-clock budget', async () => {
+    let now = 0;
+    let calls = 0;
+    const result = await recheckUnanswered([url], {
+      ...base,
+      budgetSeconds: 16,
+      nowFn: () => now,
+      sleepFn: async (ms) => {
+        now += ms;
+      },
+      fetchImpl: async () => {
+        calls++;
+        return { status: 503 };
+      },
+    });
+    expect(calls).toBe(3);
+    expect(result.recovered).toEqual([]);
+    expect(result.stillBroken.length).toBe(1);
+  });
+
+  it('pins every Bun setup to the supported major line', () => {
+    const workflow = readFileSync(
+      path.join(root, '.github/workflows/js.yml'),
+      'utf8'
+    );
+    expect(workflow).not.toContain('bun-version: latest');
+    expect(workflow).toContain("bun-version: '1.x'");
+  });
+});