start-command 0.37.9 → 0.39.0

package/test/shared-golden.js

@@ -9,6 +9,8 @@ const {
   formatRecord,
   enrichDetachedStatus,
 } = require('../src/lib/status-formatter');
+const { executionAliases } = require('../src/lib/execution-identity');
+const { buildChain, identityTextLines } = require('../src/lib/execution-chain');
 const fixtures = JSON.parse(
   readFileSync(resolve(__dirname, '../../parity/fixtures/contracts.json'))
 );
@@ -35,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']) {
@@ -80,6 +109,19 @@ describe('shared JavaScript and Rust golden contracts', () => {
       fixture.text
     );
   });
+  it('reports execution names and the continuation chain (issue #231)', () => {
+    const fixture = fixtures['status-identity'];
+    const records = fixture.records.map((r) => ExecutionRecord.fromObject(r));
+    const record = records.find((r) => r.uuid === fixture.uuid);
+    const aliases = executionAliases(record);
+    const chain = buildChain(records, record).map((r) => r.uuid);
+    assert.deepEqual(aliases, fixture.aliases);
+    assert.deepEqual(chain, fixture.chain);
+    assert.deepEqual(
+      identityTextLines({ aliases, continues: record.continues, chain }),
+      fixture.text
+    );
+  });
   for (const fixture of fixtures['execution-record-format']) {
     it(`preserves the complete execution record format (exit ${fixture.exitCode})`, () => {
       assert.deepEqual(ExecutionRecord.fromObject(fixture).toObject(), fixture);

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'");
+  });
+});