Skip to content

An open source design system that's fully customizable and agent ready

TypeScript
8.0 KB
Raw Blame
// Copyright (c) Meta Platforms, Inc. and affiliates.

/**
 * @file A stable release publishes only from a cut commit whose canonical
 * release-check passed.
 *
 * @input  a stubbed GitHub REST client with ci.yml runs and their jobs
 * @output proofs that the receipt is the exact commit's passing release-check
 *   join, and that anything else fails naming main's last checked commit
 *   (spec:AST-030 FR12, DEC-11)
 * @position focused suite for scripts/release/release-check-receipt.mjs
 */

import {describe, expect, it} from 'vitest';
import {
  findReleaseCheck,
  requireReleaseCheck,
  requireUnitRun,
} from './release-check-receipt.mjs';

const CUT = 'c'.repeat(40);
const OTHER = 'd'.repeat(40);

const run = (id, headSha, conclusion = 'success') => ({
  id,
  head_sha: headSha,
  conclusion,
  html_url: `https://github.com/o/r/actions/runs/${id}`,
});
const join = conclusion => ({name: 'release-check', conclusion});
/** A Main run dispatched for `sha`, as the scheduler names it. */
const unitRunFor = (id, headSha, conclusion = 'success') => ({
  ...run(id, headSha, conclusion),
  display_title: `Main validation of ${headSha}`,
});

/** `runs` are newest first; `jobs` maps a run id to its jobs. */
function fake({runs = [], units, jobs = {}} = {}) {
  const listed = [];
  return {
    listed,
    github: {
      rest: {
        actions: {
          listWorkflowRuns: async params => {
            listed.push(params);
            return {
              data: {
                workflow_runs: (params.workflow_id === 'deploy.yml'
                  ? (units ?? runs)
                  : runs
                ).filter(
                  item =>
                    (!params.head_sha || item.head_sha === params.head_sha) &&
                    item.conclusion === params.status,
                ),
              },
            };
          },
          listJobsForWorkflowRun: async ({run_id}) => ({
            data: {jobs: jobs[run_id] ?? []},
          }),
        },
      },
    },
  };
}

async function require_(options, sha = CUT) {
  const {github, listed} = fake(options);
  const messages = {info: [], failed: []};
  const core = {
    info: message => messages.info.push(message),
    setFailed: message => messages.failed.push(message),
  };
  const result = await requireReleaseCheck({
    github,
    core,
    owner: 'o',
    repo: 'r',
    sha,
  });
  return {result, messages, listed};
}

describe('the release-check receipt for a cut commit', () => {
  it('accepts the exact cut commit whose release-check join passed', async () => {
    const {result, messages, listed} = await require_({
      runs: [run(7, CUT)],
      jobs: {7: [join('success')]},
    });
    expect(result.id).toBe(7);
    expect(messages.failed).toEqual([]);
    expect(listed[0]).toEqual({
      owner: 'o',
      repo: 'r',
      workflow_id: 'ci.yml',
      event: 'workflow_dispatch',
      branch: 'main',
      status: 'success',
      per_page: 30,
      head_sha: CUT,
    });
  });

  it('does not take a maintenance capture of the same commit for a release-check', async () => {
    const {github} = fake({
      runs: [run(8, CUT), run(7, CUT)],
      jobs: {
        8: [{name: 'maintenance-request', conclusion: 'success'}],
        7: [join('success')],
      },
    });
    expect(
      (await findReleaseCheck({github, owner: 'o', repo: 'r', sha: CUT})).id,
    ).toBe(7);
  });

  it("fails naming main's last commit with both receipts when the cut commit has no passing release-check", async () => {
    const NEWER = 'e'.repeat(40);
    const {result, messages} = await require_({
      // NEWER passed its release-check but its unit run failed.
      runs: [run(10, NEWER), run(9, CUT, 'failure'), run(8, OTHER)],
      units: [unitRunFor(21, NEWER, 'failure'), unitRunFor(20, OTHER)],
      jobs: {
        10: [join('success')],
        9: [join('failure')],
        8: [join('success')],
        20: [
          {name: 'test-ui (1/4)', conclusion: 'success'},
          {name: 'test-node (1/4)', conclusion: 'success'},
        ],
      },
    });
    expect(result).toBeNull();
    expect(messages.failed).toEqual([
      `No passing release-check for the cut commit ${CUT}. Re-cut the release from main's last commit with both a passing release-check and a passing full unit run, ${OTHER}, or wait for main's next checks and cut from them.`,
    ]);
  });

  it('fails when the run passed but its release-check join did not run', async () => {
    const {result, messages} = await require_({
      runs: [run(7, CUT)],
      jobs: {7: [join('skipped')]},
    });
    expect(result).toBeNull();
    expect(messages.failed[0]).toMatch(
      /^No passing release-check for the cut commit/,
    );
    expect(messages.failed[0]).toMatch(
      /No recent main commit has both a passing release-check and a passing full unit run/,
    );
  });

  it('refuses a cut commit that is not a full SHA', async () => {
    const {result, messages, listed} = await require_({}, 'main');
    expect(result).toBeNull();
    expect(listed).toEqual([]);
    expect(messages.failed).toEqual([
      "The release marker's cut commit is not a full SHA: main",
    ]);
  });
});

describe('the full unit run receipt for a cut commit (spec:AST-030 FR21)', () => {
  const legs = conclusion => [
    ...[1, 2, 3, 4].map(n => ({name: `test-ui (${n})`, conclusion})),
    ...[1, 2, 3, 4].map(n => ({name: `test-node (${n})`, conclusion})),
    {name: 'typecheck', conclusion: 'success'},
  ];
  async function unit(options, sha = CUT) {
    const {github, listed} = fake(options);
    const messages = {info: [], failed: []};
    const core = {
      info: message => messages.info.push(message),
      setFailed: message => messages.failed.push(message),
    };
    const result = await requireUnitRun({
      github,
      core,
      owner: 'o',
      repo: 'r',
      sha,
    });
    return {result, messages, listed};
  }

  it("accepts the cut commit's run where every unit leg passed", async () => {
    const {result, messages, listed} = await unit({
      runs: [unitRunFor(5, CUT)],
      jobs: {5: legs('success')},
    });
    expect(result.id).toBe(5);
    expect(messages.failed).toEqual([]);
    expect(listed[0]).toEqual({
      owner: 'o',
      repo: 'r',
      workflow_id: 'deploy.yml',
      branch: 'main',
      status: 'success',
      head_sha: CUT,
      per_page: 30,
    });
  });

  it('does not take an unnamed run, which tests whatever was the tip when it started', async () => {
    const {result} = await unit({
      runs: [run(9, CUT)],
      jobs: {9: legs('success')},
    });
    expect(result).toBeNull();
  });

  it('takes a validation that names the cut commit, and not one that names another', async () => {
    const LATER = 'f'.repeat(40);
    const named = (id, tested) => ({
      ...run(id, LATER),
      display_title: `Main validation of ${tested}`,
    });
    const {result} = await unit({
      runs: [named(31, OTHER), named(30, CUT)],
      jobs: {30: legs('success'), 31: legs('success')},
    });
    expect(result.id).toBe(30);
    const none = await unit({
      runs: [{...run(32, CUT), display_title: `Main validation of ${OTHER}`}],
      jobs: {32: legs('success')},
    });
    expect(none.result).toBeNull();
  });

  it('does not take a push run, whose unit legs skipped, for a unit run', async () => {
    const {result, messages} = await unit({
      runs: [run(6, CUT)],
      jobs: {6: legs('skipped')},
    });
    expect(result).toBeNull();
    expect(messages.failed).toEqual([
      `No passing full unit run for the cut commit ${CUT}. No recent main commit has both a passing release-check and a passing full unit run; wait for main's next checks and cut from them.`,
    ]);
  });

  it('refuses a run with no unit legs at all', async () => {
    const {result} = await unit({
      runs: [run(7, CUT)],
      jobs: {7: [{name: 'typecheck', conclusion: 'success'}]},
    });
    expect(result).toBeNull();
  });

  it("ignores another commit's passing run", async () => {
    const {result} = await unit({
      runs: [run(8, OTHER)],
      jobs: {8: legs('success')},
    });
    expect(result).toBeNull();
  });
});