wehub-resource-sync
706 lines
25 KiB
TypeScript
706 lines
25 KiB
TypeScript
import { describe, it, expect } from "vitest";
|
|
import { buildReleaseNotification } from "./build-release-notification.js";
|
|
import type { BuildReleaseNotificationInput } from "./build-release-notification.js";
|
|
|
|
const RUN_URL = "https://github.com/CopilotKit/CopilotKit/actions/runs/123";
|
|
const RELEASE_URL =
|
|
"https://github.com/CopilotKit/CopilotKit/releases/tag/v1.2.3";
|
|
const NPM_URL = "https://www.npmjs.com/org/copilotkit";
|
|
const ANGULAR_NPM_URL = "https://www.npmjs.com/package/@copilotkit/angular";
|
|
const PY_URL = "https://pypi.org/project/copilotkit/0.9.0/";
|
|
|
|
// A neutral baseline where nothing has acted. Each test overrides only the
|
|
// fields relevant to its truth-table row.
|
|
function base(
|
|
overrides: Partial<BuildReleaseNotificationInput> = {},
|
|
): BuildReleaseNotificationInput {
|
|
return {
|
|
mode: "",
|
|
npmResult: "skipped",
|
|
npmVer: "",
|
|
buildResult: "skipped",
|
|
npmIntended: "false",
|
|
pyPub: "false",
|
|
pyIntended: "false",
|
|
pyResult: "skipped",
|
|
pyBuildResult: "skipped",
|
|
pyVer: "",
|
|
scope: "monorepo",
|
|
dryRun: false,
|
|
packageCount: 16,
|
|
runUrl: RUN_URL,
|
|
releaseUrl: RELEASE_URL,
|
|
npmUrl: NPM_URL,
|
|
pyUrl: PY_URL,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
describe("buildReleaseNotification", () => {
|
|
// ---- dry-run --------------------------------------------------------------
|
|
it("suppresses dry-run — no post", () => {
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "stable",
|
|
npmResult: "success",
|
|
npmVer: "1.2.3",
|
|
dryRun: true,
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
// ---- npm lane: prerelease canary fully suppressed -------------------------
|
|
it("suppresses prerelease (canary) success — no post", () => {
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "prerelease",
|
|
npmResult: "success",
|
|
npmVer: "1.2.3-canary.1",
|
|
buildResult: "success",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
it("suppresses prerelease (canary) npm failure — no post", () => {
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "prerelease",
|
|
npmIntended: "true",
|
|
npmResult: "failure",
|
|
buildResult: "success",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
it("suppresses prerelease (canary) build failure — no post (would otherwise fire)", () => {
|
|
// Slot-6 strengthening: this row would emit a lane-level failure if the
|
|
// prerelease suppression on the npm lane regressed. buildResult=failure
|
|
// alone fires the alert UNLESS mode === "prerelease".
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "prerelease",
|
|
npmIntended: "true",
|
|
npmResult: "skipped",
|
|
buildResult: "failure",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
// ---- npm lane: stable success --------------------------------------------
|
|
it("stable npm success → npm success line (monorepo, N packages)", () => {
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "stable",
|
|
npmResult: "success",
|
|
npmVer: "1.2.3",
|
|
buildResult: "success",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toBe(
|
|
"🚀 *CopilotKit monorepo v1.2.3* published to npm (`latest`, 16 packages) · " +
|
|
`<${RELEASE_URL}|Release notes> · <${NPM_URL}|npm>`,
|
|
);
|
|
});
|
|
|
|
it("stable npm success with empty releaseUrl → success line, NO broken Release-notes link", () => {
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "stable",
|
|
npmResult: "success",
|
|
npmVer: "1.2.3",
|
|
buildResult: "success",
|
|
releaseUrl: "",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toBe(
|
|
"🚀 *CopilotKit monorepo v1.2.3* published to npm (`latest`, 16 packages) · " +
|
|
`<${NPM_URL}|npm>`,
|
|
);
|
|
// The broken "/releases/tag/" empty link must never appear.
|
|
expect(r.message).not.toContain("Release notes");
|
|
expect(r.message).not.toContain("<|");
|
|
});
|
|
|
|
it("angular scope uses the angular package npm URL", () => {
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "stable",
|
|
npmResult: "success",
|
|
npmVer: "2.0.0",
|
|
buildResult: "success",
|
|
scope: "angular",
|
|
packageCount: 1,
|
|
npmUrl: ANGULAR_NPM_URL,
|
|
}),
|
|
);
|
|
expect(r.message).toContain(`<${ANGULAR_NPM_URL}|npm>`);
|
|
expect(r.message).toContain("*CopilotKit angular v2.0.0*");
|
|
expect(r.message).toContain("(`latest`, 1 package)");
|
|
});
|
|
|
|
// ---- npm lane: failure (lane-level wording) -------------------------------
|
|
it("stable npm failure → lane-level red alert (NOT 'npm publish failed')", () => {
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "stable",
|
|
npmIntended: "true",
|
|
npmResult: "failure",
|
|
buildResult: "success",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toBe(
|
|
`🔴 *CopilotKit monorepo release failed* · <${RUN_URL}|View run>`,
|
|
);
|
|
// A post-publish step (tag/release) may have failed while publish itself
|
|
// succeeded — never claim "publish failed".
|
|
expect(r.message).not.toContain("publish failed");
|
|
});
|
|
|
|
it("stable npm publish step SUCCEEDED (version emitted) but JOB failed at a later step → FAILURE line, NOT success (if/else ordering)", () => {
|
|
// The central npm-lane design claim: a populated version does NOT force a
|
|
// success line. The publish step can succeed and emit a version while the
|
|
// JOB still ends in `failure` (e.g. a later tag/release step broke). The
|
|
// success arm requires npmResult === "success"; here npmResult is "failure",
|
|
// so the `else if (npmResult === "failure" ...)` branch wins → lane-level
|
|
// "release failed". This locks the if/else ORDERING: failure result beats a
|
|
// populated version. Wording stays lane-level ("release failed"), never
|
|
// "publish failed", precisely because publish itself may have succeeded.
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "stable",
|
|
npmIntended: "true",
|
|
npmResult: "failure",
|
|
npmVer: "1.2.3",
|
|
buildResult: "success",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toBe(
|
|
`🔴 *CopilotKit monorepo release failed* · <${RUN_URL}|View run>`,
|
|
);
|
|
// Must NOT render a success line despite the populated version.
|
|
expect(r.message).not.toContain("🚀");
|
|
expect(r.message).not.toContain("published to npm");
|
|
// Lane-level, never step-level.
|
|
expect(r.message).not.toContain("publish failed");
|
|
});
|
|
|
|
it("build failure (mode='', npm skipped) → lane-level npm/build red alert", () => {
|
|
// A failure in the build job before the publish job ran: npmResult is
|
|
// "skipped" and mode is empty, but buildResult is "failure".
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "",
|
|
npmIntended: "true",
|
|
npmResult: "skipped",
|
|
buildResult: "failure",
|
|
scope: "monorepo",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toBe(
|
|
`🔴 *CopilotKit monorepo release failed* · <${RUN_URL}|View run>`,
|
|
);
|
|
expect(r.message).not.toContain("publish failed");
|
|
});
|
|
|
|
it("npm publish failure with empty mode (npmResult='failure') → lane-level red alert (no mode-coupling swallow)", () => {
|
|
// The npm FAILURE arm keys off npmIntended (the notify job's event-derived
|
|
// release intent) AND the job result — NOT on mode === "stable" (that would
|
|
// swallow a real stable publish failure whose mode output came back empty).
|
|
// An empty mode with a real publish failure on a genuine release attempt
|
|
// still pages.
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "",
|
|
npmIntended: "true",
|
|
npmResult: "failure",
|
|
buildResult: "success",
|
|
scope: "monorepo",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toBe(
|
|
`🔴 *CopilotKit monorepo release failed* · <${RUN_URL}|View run>`,
|
|
);
|
|
expect(r.message).not.toContain("publish failed");
|
|
});
|
|
|
|
// ---- npm lane: EVENT-DERIVED intent gate ---------------------------------
|
|
it("npmIntended='true' + buildResult='failure' → npm red ALERT (intent gate open)", () => {
|
|
// The notify job determined an npm release was actually attempted
|
|
// (release/publish/* merge or a workflow_dispatch). A build-job failure on a
|
|
// genuine npm release must page — independent of needs.build outputs.
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "",
|
|
npmIntended: "true",
|
|
npmResult: "skipped",
|
|
buildResult: "failure",
|
|
scope: "monorepo",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toBe(
|
|
`🔴 *CopilotKit monorepo release failed* · <${RUN_URL}|View run>`,
|
|
);
|
|
});
|
|
|
|
it("npmIntended='false' + buildResult='failure' → NEUTRAL (no npm release attempted)", () => {
|
|
// The notify job runs on EVERY merged PR. A routine non-release merge whose
|
|
// build job flakes (or a stray failure) carries no npm release intent
|
|
// (not a release/publish/* merge, not a dispatch), so the lane stays quiet.
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "",
|
|
npmIntended: "false",
|
|
npmResult: "skipped",
|
|
buildResult: "failure",
|
|
scope: "monorepo",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
// ---- PyPI lane: independent of MODE --------------------------------------
|
|
it("PyPI success → only PyPI line", () => {
|
|
const r = buildReleaseNotification(
|
|
base({ pyPub: "true", pyResult: "success", pyVer: "0.9.0" }),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toBe(
|
|
"🐍 *copilotkit (Python SDK) v0.9.0* published to PyPI · " +
|
|
`<${PY_URL}|PyPI>`,
|
|
);
|
|
});
|
|
|
|
it("PyPI failure → lane-level PyPI red alert", () => {
|
|
const r = buildReleaseNotification(
|
|
base({ pyIntended: "true", pyPub: "true", pyResult: "failure" }),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toBe(
|
|
`🔴 *copilotkit (Python SDK) release failed* · <${RUN_URL}|View run>`,
|
|
);
|
|
});
|
|
|
|
it("build-python failure during a REAL Python release (pyPub='true', publish-python skipped) → PyPI red alert", () => {
|
|
// The previously-silent gap: on a genuine Python release where build-python
|
|
// FAILS, publish-python is skipped (its `if` requires
|
|
// build-python.result == 'success') → pyResult === 'skipped'. Keying the
|
|
// failure lane off pyBuildResult catches this so a real release that broke
|
|
// at build still pages, instead of posting nothing.
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
pyIntended: "true",
|
|
pyPub: "true",
|
|
pyResult: "skipped",
|
|
pyBuildResult: "failure",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toBe(
|
|
`🔴 *copilotkit (Python SDK) release failed* · <${RUN_URL}|View run>`,
|
|
);
|
|
});
|
|
|
|
it("build-python CANCELLED during a real Python release → NEUTRAL (no false red on deliberate cancel)", () => {
|
|
// A cancelled build-python reports result 'cancelled' (NOT 'failure'), even
|
|
// when it hits timeout-minutes. The failure lane keys off
|
|
// pyBuildResult === 'failure', so a cancel stays neutral.
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
pyIntended: "true",
|
|
pyPub: "true",
|
|
pyResult: "skipped",
|
|
pyBuildResult: "cancelled",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
it("build-python failure WITHOUT intent (pyIntended='false', pyBuildResult='failure') → NO post (routine PR flake)", () => {
|
|
// build-python runs on EVERY merged PR; a transient build-python failure on
|
|
// an unrelated PR (no release intent) must NOT page. The pyIntended === 'true'
|
|
// gate is what prevents this false-RED.
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
pyIntended: "false",
|
|
pyPub: "",
|
|
pyResult: "skipped",
|
|
pyBuildResult: "failure",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
it("build-python without intent (pyIntended='false') → NO post (routine PR, no false red)", () => {
|
|
// build-python runs on EVERY merged PR; only its inner steps are
|
|
// pyproject-gated. A transient build-python failure on an unrelated
|
|
// (docs/npm-only) PR must NOT page a PyPI failure — the notify job's
|
|
// event-derived pyIntended is false (no Python release attempted).
|
|
const r = buildReleaseNotification(
|
|
base({ pyIntended: "false", pyPub: "", pyResult: "skipped" }),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
// ---- PyPI lane: EARLY-INTENT failure gate (closes the should_publish gap) -
|
|
it("build-python failure AT/BEFORE detect on a genuine Python release (pyIntended='true', pyPub='' — detect never emitted) → PyPI red ALERT", () => {
|
|
// THE CLOSED GAP. should_publish (pyPub) is emitted at the END of the detect
|
|
// step. A build-python failure at/before detect (PyPI API outage,
|
|
// setup-python failure, malformed pyproject) on a genuine Python release
|
|
// never reaches the should_publish echo → pyPub="". Gating the failure arm
|
|
// on pyPub silently swallowed this. The notify job's event-derived
|
|
// pyIntended (computed independently of the build jobs) catches it.
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
pyIntended: "true",
|
|
pyPub: "",
|
|
pyResult: "skipped",
|
|
pyBuildResult: "failure",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toBe(
|
|
`🔴 *copilotkit (Python SDK) release failed* · <${RUN_URL}|View run>`,
|
|
);
|
|
});
|
|
|
|
it("routine PR build-python flake (pyIntended='false', pyBuildResult='failure') → NEUTRAL (no false-RED)", () => {
|
|
// build-python runs on EVERY merged PR; an npm/docs-only PR's transient
|
|
// build-python failure carries no release intent (the notify job's
|
|
// pyIntended is false — the merged PR did not change sdk-python/pyproject.toml
|
|
// and this is not a python_publish dispatch), so the lane stays quiet.
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
pyIntended: "false",
|
|
pyPub: "",
|
|
pyResult: "skipped",
|
|
pyBuildResult: "failure",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
it("python release intended (pyIntended='true', pyBuildResult='failure') → PyPI red ALERT", () => {
|
|
// An explicit Python release intent (a python_publish=true dispatch, or a
|
|
// merged PR that bumped sdk-python/pyproject.toml). A build failure before
|
|
// detect emits no should_publish, but the event-derived pyIntended signal
|
|
// still fires the alert.
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
pyIntended: "true",
|
|
pyPub: "",
|
|
pyResult: "skipped",
|
|
pyBuildResult: "failure",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toBe(
|
|
`🔴 *copilotkit (Python SDK) release failed* · <${RUN_URL}|View run>`,
|
|
);
|
|
});
|
|
|
|
it("prerelease + BOTH lanes failing → ONLY the PyPI red line, npm fully suppressed (canary)", () => {
|
|
// A mode=prerelease dispatch where the npm lane fails AND the PyPI lane
|
|
// fails. The npm failure is canary noise → fully suppressed by
|
|
// mode === "prerelease". The PyPI lane is mode-independent, so its real
|
|
// failure (pyPub="true", pyResult="failure") still pages. Exactly one red
|
|
// line, the PyPI one.
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "prerelease",
|
|
npmIntended: "true",
|
|
npmResult: "failure",
|
|
buildResult: "failure",
|
|
pyIntended: "true",
|
|
pyPub: "true",
|
|
pyResult: "failure",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
// No npm line: the npm failure marker "*CopilotKit" (the npm line's bold
|
|
// prefix) must be absent. NB: the RUN_URL contains "CopilotKit/CopilotKit",
|
|
// so assert on the line prefix, not the bare org name.
|
|
expect(r.message).not.toContain("*CopilotKit");
|
|
expect(r.message).toBe(
|
|
`🔴 *copilotkit (Python SDK) release failed* · <${RUN_URL}|View run>`,
|
|
);
|
|
});
|
|
|
|
it("prerelease + python_publish success → npm suppressed, PyPI line still posts", () => {
|
|
// A mode=prerelease dispatch that also runs the Python lane must still
|
|
// announce the real PyPI publish — the canary suppression is npm-only.
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "prerelease",
|
|
npmResult: "success",
|
|
npmVer: "1.2.3-canary.1",
|
|
buildResult: "success",
|
|
pyPub: "true",
|
|
pyResult: "success",
|
|
pyVer: "0.9.0",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).not.toContain("🚀");
|
|
expect(r.message).not.toContain("canary");
|
|
expect(r.message).toBe(
|
|
"🐍 *copilotkit (Python SDK) v0.9.0* published to PyPI · " +
|
|
`<${PY_URL}|PyPI>`,
|
|
);
|
|
});
|
|
|
|
// ---- cancelled is NEUTRAL everywhere -------------------------------------
|
|
it("npm cancelled (mode=stable) → no line (neutral, no false red)", () => {
|
|
const r = buildReleaseNotification(
|
|
base({ mode: "stable", npmResult: "cancelled", buildResult: "success" }),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
it("build cancelled → no line (neutral)", () => {
|
|
const r = buildReleaseNotification(
|
|
base({ mode: "", npmResult: "skipped", buildResult: "cancelled" }),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
it("PyPI cancelled → no line (neutral)", () => {
|
|
const r = buildReleaseNotification(
|
|
base({ pyPub: "true", pyResult: "cancelled" }),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
it("build-python succeeded but publish-python cancelled (should_publish=true) → no line (neutral)", () => {
|
|
// Distinct from the row above: here build-python passed (pyBuildResult
|
|
// 'success') and the publish job was cancelled. Neither a build failure nor
|
|
// a publish failure → neutral, no false red.
|
|
const r = buildReleaseNotification(
|
|
base({ pyPub: "true", pyResult: "cancelled", pyBuildResult: "success" }),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
// ---- skipped lanes contribute nothing ------------------------------------
|
|
it("python-only run (npm lane skipped) → only PyPI line, NO false red", () => {
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "",
|
|
npmResult: "skipped",
|
|
buildResult: "skipped",
|
|
pyPub: "true",
|
|
pyResult: "success",
|
|
pyVer: "0.9.0",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).not.toContain("🔴");
|
|
expect(r.message).toBe(
|
|
"🐍 *copilotkit (Python SDK) v0.9.0* published to PyPI · " +
|
|
`<${PY_URL}|PyPI>`,
|
|
);
|
|
});
|
|
|
|
it("npm-only run (PyPI lane not acting) → only npm line", () => {
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "stable",
|
|
npmResult: "success",
|
|
npmVer: "1.2.3",
|
|
buildResult: "success",
|
|
pyPub: "false",
|
|
pyResult: "skipped",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toContain("🚀 *CopilotKit monorepo v1.2.3*");
|
|
expect(r.message).not.toContain("🐍");
|
|
expect(r.message).not.toContain("🔴");
|
|
});
|
|
|
|
// ---- both lanes ----------------------------------------------------------
|
|
it("both lanes succeed → one message with both lines", () => {
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "stable",
|
|
npmResult: "success",
|
|
npmVer: "1.2.3",
|
|
buildResult: "success",
|
|
pyPub: "true",
|
|
pyResult: "success",
|
|
pyVer: "0.9.0",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
const expected =
|
|
"🚀 *CopilotKit monorepo v1.2.3* published to npm (`latest`, 16 packages) · " +
|
|
`<${RELEASE_URL}|Release notes> · <${NPM_URL}|npm>\n` +
|
|
"🐍 *copilotkit (Python SDK) v0.9.0* published to PyPI · " +
|
|
`<${PY_URL}|PyPI>`;
|
|
expect(r.message).toBe(expected);
|
|
});
|
|
|
|
it("both lanes fail → one message with both lane-level red lines", () => {
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "stable",
|
|
npmIntended: "true",
|
|
npmResult: "failure",
|
|
buildResult: "success",
|
|
pyIntended: "true",
|
|
pyPub: "true",
|
|
pyResult: "failure",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toBe(
|
|
`🔴 *CopilotKit monorepo release failed* · <${RUN_URL}|View run>\n` +
|
|
`🔴 *copilotkit (Python SDK) release failed* · <${RUN_URL}|View run>`,
|
|
);
|
|
});
|
|
|
|
// ---- nothing acted -------------------------------------------------------
|
|
it("nothing acted (npm skipped, PyPI not publishing) → no post, empty message", () => {
|
|
const r = buildReleaseNotification(base());
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
// ---- no-false-success guards ---------------------------------------------
|
|
it("stable npm success with empty version → no npm success line (no false success)", () => {
|
|
// npmResult=success but no version is an anomalous state — do not claim
|
|
// success. With buildResult=success there is also no failure to report.
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "stable",
|
|
npmResult: "success",
|
|
npmVer: "",
|
|
buildResult: "success",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
it("PyPI success with empty version → no PyPI success line (no false success)", () => {
|
|
const r = buildReleaseNotification(
|
|
base({ pyPub: "true", pyResult: "success", pyVer: "" }),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
|
|
it("pluralization: monorepo scope with N packages → 'N packages'", () => {
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "stable",
|
|
npmResult: "success",
|
|
npmVer: "1.2.3",
|
|
buildResult: "success",
|
|
packageCount: 16,
|
|
}),
|
|
);
|
|
expect(r.message).toContain("(`latest`, 16 packages)");
|
|
});
|
|
|
|
it("packageCount=0 (unknown/degraded) → success line WITHOUT a packages count parenthetical", () => {
|
|
// A degraded/missing release.config.json resolves to 0 packages. The
|
|
// builder must NOT render the self-contradictory "(`latest`, 0 packages)";
|
|
// it omits the count parenthetical entirely → "published to npm (`latest`)".
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "stable",
|
|
npmResult: "success",
|
|
npmVer: "1.2.3",
|
|
buildResult: "success",
|
|
packageCount: 0,
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toContain("published to npm (`latest`)");
|
|
expect(r.message).not.toContain("packages");
|
|
expect(r.message).not.toContain("0 package");
|
|
expect(r.message).toBe(
|
|
"🚀 *CopilotKit monorepo v1.2.3* published to npm (`latest`) · " +
|
|
`<${RELEASE_URL}|Release notes> · <${NPM_URL}|npm>`,
|
|
);
|
|
});
|
|
|
|
// ---- empty-scope rendering (no doubled words / double spaces) -------------
|
|
it("empty scope on the FAILURE path → clean 'CopilotKit release failed' (no 'release release')", () => {
|
|
// A stable build failure where scope is empty must not render
|
|
// "CopilotKit release release failed".
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "",
|
|
npmIntended: "true",
|
|
npmResult: "skipped",
|
|
buildResult: "failure",
|
|
scope: "",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).toBe(
|
|
`🔴 *CopilotKit release failed* · <${RUN_URL}|View run>`,
|
|
);
|
|
expect(r.message).not.toContain("release release");
|
|
expect(r.message).not.toContain(" ");
|
|
});
|
|
|
|
it("empty scope on the SUCCESS path → clean version line (no double space)", () => {
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "stable",
|
|
npmResult: "success",
|
|
npmVer: "1.2.3",
|
|
buildResult: "success",
|
|
scope: "",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(true);
|
|
expect(r.message).not.toContain(" ");
|
|
expect(r.message).toBe(
|
|
"🚀 *CopilotKit v1.2.3* published to npm (`latest`, 16 packages) · " +
|
|
`<${RELEASE_URL}|Release notes> · <${NPM_URL}|npm>`,
|
|
);
|
|
});
|
|
|
|
it("npm success but mode not stable (defensive) → no npm success line", () => {
|
|
// mode "" with a success result must not produce an npm success line.
|
|
// buildResult=success means no failure either → nothing posts.
|
|
const r = buildReleaseNotification(
|
|
base({
|
|
mode: "",
|
|
npmResult: "success",
|
|
npmVer: "1.2.3",
|
|
buildResult: "success",
|
|
}),
|
|
);
|
|
expect(r.shouldPost).toBe(false);
|
|
expect(r.message).toBe("");
|
|
});
|
|
});
|