test: add tests and refactoring

Author: Timo Notheisen

.github/workflows/test.yml

@@ -13,3 +13,4 @@ jobs:
           node-version: current
       - run: npm ci
       - run: npm run lint
+      - run: npm test

package-lock.json

@@ -6,13 +6,15 @@
         "lint": "npm run lint:prettier && npm run lint:tsc",
         "lint:prettier": "prettier --check .",
         "lint:tsc": "tsc -p release-dependency-updates/tsconfig.json --noEmit",
+        "test": "node --import tsx --test release-dependency-updates/src/*.test.ts",
         "release-dependency-updates": "node --import tsx release-dependency-updates/src/index.ts"
     },
     "dependencies": {
         "@actions/core": "^3.0.1",
         "@actions/github": "^9.1.1"
     },
     "devDependencies": {
+        "@octokit/plugin-rest-endpoint-methods": "^17.0.0",
         "@types/node": "^25.9.1",
         "prettier": "^3.8.3",
         "tsx": "^4.21.0",

package.json

@@ -1,26 +1,15 @@
 import * as core from "@actions/core"
 import * as github from "@actions/github"
+import type { RestEndpointMethodTypes } from "@octokit/plugin-rest-endpoint-methods"
+
+import { checkReleaseCommits, type ReleaseCheckCommit, type ReleaseCommit } from "./release-check.js"
 
 type Octokit = ReturnType<typeof github.getOctokit>
-type CompareResponse = Awaited<ReturnType<Octokit["rest"]["repos"]["compareCommitsWithBasehead"]>>["data"]
-type ListedCommit = Awaited<ReturnType<Octokit["rest"]["repos"]["listCommits"]>>["data"][number]
-type ReleaseCommit = CompareResponse["commits"][number] | ListedCommit
-type LatestRelease = Awaited<ReturnType<Octokit["rest"]["repos"]["getLatestRelease"]>>["data"]
+type LatestRelease = RestEndpointMethodTypes["repos"]["getLatestRelease"]["response"]["data"]
 
 const initialVersion = "0.1.0"
 const patchVersionPattern = /^(v?)(\d+)\.(\d+)\.(\d+)$/
 
-const botAuthorLogins = new Set(["renovate[bot]", "dependabot[bot]"])
-const botAuthorNames = new Set(["renovate bot", "renovate[bot]", "dependabot[bot]", "dependabot"])
-const dependencyPullRequestLabels = new Set(["dependencies"])
-const maintenancePullRequestLabels = new Set(["test", "chore", "refactoring", "ci"])
-const botEmailFragments = [
-    "renovate[bot]@users.noreply.github.com",
-    "bot@renovateapp.com",
-    "dependabot[bot]@users.noreply.github.com",
-    "dependabot@github.com"
-]
-
 run().catch((error: unknown) => {
     core.setFailed(error instanceof Error ? error.message : String(error))
 })
@@ -44,7 +33,7 @@ async function run() {
     }
 
     const { commitCount, commits, nextTag, revisionDescription } = releasePreparation
-    const { blockingCommits, hasDependencyUpdateCommit } = await checkReleaseCommits(octokit, owner, repo, commits)
+    const { blockingCommits, hasDependencyUpdateCommit } = await getReleaseCheck(octokit, owner, repo, commits)
     if (blockingCommits.length > 0) {
         const commitList = blockingCommits
             .slice(0, 10)
@@ -223,49 +212,25 @@ async function listCommits(octokit: Octokit, owner: string, repo: string, branch
     })
 }
 
-async function checkReleaseCommits(octokit: Octokit, owner: string, repo: string, commits: ReleaseCommit[]) {
-    const blockingCommits = []
-    let hasDependencyUpdateCommit = false
-
-    for (const commit of commits) {
-        const pullRequestLabels = await getAssociatedPullRequestLabels(octokit, owner, repo, commit)
-
-        if (isDependencyUpdateCommit(commit, pullRequestLabels)) {
-            hasDependencyUpdateCommit = true
-            continue
-        }
-
-        if (isMaintenanceCommit(pullRequestLabels)) {
-            continue
-        }
-
-        blockingCommits.push(commit)
-    }
+async function getReleaseCheck(octokit: Octokit, owner: string, repo: string, commits: ReleaseCommit[]) {
+    const releaseCheckCommits = await getReleaseCheckCommits(octokit, owner, repo, commits)
+    const { blockingCommits, hasDependencyUpdateCommit } = checkReleaseCommits(releaseCheckCommits)
 
     return { blockingCommits, hasDependencyUpdateCommit }
 }
 
-function isDependencyUpdateCommit(commit: ReleaseCommit, pullRequestLabels: string[]) {
-    return isDependencyBotCommit(commit) || hasPullRequestLabel(pullRequestLabels, dependencyPullRequestLabels)
-}
-
-function isMaintenanceCommit(pullRequestLabels: string[]) {
-    return hasPullRequestLabel(pullRequestLabels, maintenancePullRequestLabels)
-}
-
-function isDependencyBotCommit(commit: ReleaseCommit) {
-    const login = commit.author?.login.toLowerCase()
-    if (login && botAuthorLogins.has(login)) {
-        return true
-    }
+async function getReleaseCheckCommits(octokit: Octokit, owner: string, repo: string, commits: ReleaseCommit[]) {
+    const releaseCheckCommits: Array<ReleaseCommit & ReleaseCheckCommit> = []
 
-    const authorName = commit.commit.author?.name?.toLowerCase()
-    if (authorName && botAuthorNames.has(authorName)) {
-        return true
+    for (const commit of commits) {
+        const pullRequestLabels = await getAssociatedPullRequestLabels(octokit, owner, repo, commit)
+        releaseCheckCommits.push({
+            ...commit,
+            pullRequestLabels
+        })
     }
 
-    const authorEmail = commit.commit.author?.email?.toLowerCase()
-    return Boolean(authorEmail && botEmailFragments.some((fragment) => authorEmail.includes(fragment)))
+    return releaseCheckCommits
 }
 
 async function getAssociatedPullRequestLabels(octokit: Octokit, owner: string, repo: string, commit: ReleaseCommit) {
@@ -278,10 +243,6 @@ async function getAssociatedPullRequestLabels(octokit: Octokit, owner: string, r
     return pullRequests.flatMap((pullRequest) => pullRequest.labels.map((label) => label.name.toLowerCase()))
 }
 
-function hasPullRequestLabel(labelNames: string[], matchingLabels: Set<string>) {
-    return labelNames.some((labelName) => matchingLabels.has(labelName))
-}
-
 async function tagExists(octokit: Octokit, owner: string, repo: string, tag: string) {
     try {
         await octokit.rest.git.getRef({ owner, repo, ref: `tags/${tag}` })

release-dependency-updates/src/index.ts

@@ -0,0 +1,120 @@
+import assert from "node:assert/strict"
+import { describe, it } from "node:test"
+
+import { checkReleaseCommits, type ReleaseCheckCommit } from "./release-check.js"
+
+let commitId = 0
+
+function commit(options: { authorEmail?: string; authorLogin?: string; authorName?: string; labels?: string[] } = {}) {
+    return {
+        author: options.authorLogin ? { login: options.authorLogin } : null,
+        commit: {
+            author: {
+                email: options.authorEmail,
+                name: options.authorName
+            },
+            id: String(commitId++)
+        },
+        pullRequestLabels: options.labels ?? []
+    } as unknown as ReleaseCheckCommit
+}
+
+describe("checkReleaseCommits", () => {
+    it("creates a release for a dependency bot commit", () => {
+        const result = checkReleaseCommits([commit({ authorLogin: "renovate[bot]" })])
+
+        assert.equal(result.shouldCreateRelease, true)
+        assert.equal(result.hasDependencyUpdateCommit, true)
+        assert.deepEqual(result.blockingCommits, [])
+    })
+
+    it("creates a release for dependency bot author names", () => {
+        const result = checkReleaseCommits([commit({ authorName: "dependabot" })])
+
+        assert.equal(result.shouldCreateRelease, true)
+        assert.equal(result.hasDependencyUpdateCommit, true)
+        assert.deepEqual(result.blockingCommits, [])
+    })
+
+    it("creates a release for dependency bot author emails", () => {
+        const result = checkReleaseCommits([commit({ authorEmail: "renovate[bot]@users.noreply.github.com" })])
+
+        assert.equal(result.shouldCreateRelease, true)
+        assert.equal(result.hasDependencyUpdateCommit, true)
+        assert.deepEqual(result.blockingCommits, [])
+    })
+
+    it("creates a release for a commit with a dependencies pull request label", () => {
+        const result = checkReleaseCommits([commit({ labels: ["dependencies"] })])
+
+        assert.equal(result.shouldCreateRelease, true)
+        assert.equal(result.hasDependencyUpdateCommit, true)
+        assert.deepEqual(result.blockingCommits, [])
+    })
+
+    it("matches pull request labels case-insensitively", () => {
+        const result = checkReleaseCommits([commit({ labels: ["Dependencies"] }), commit({ labels: ["CI"] })])
+
+        assert.equal(result.shouldCreateRelease, true)
+        assert.equal(result.hasDependencyUpdateCommit, true)
+        assert.deepEqual(result.blockingCommits, [])
+    })
+
+    it("creates a release for dependency update commits with maintenance commits", () => {
+        const result = checkReleaseCommits([
+            commit({ labels: ["dependencies"] }),
+            commit({ labels: ["test"] }),
+            commit({ labels: ["chore"] }),
+            commit({ labels: ["refactoring"] }),
+            commit({ labels: ["ci"] })
+        ])
+
+        assert.equal(result.shouldCreateRelease, true)
+        assert.equal(result.hasDependencyUpdateCommit, true)
+        assert.deepEqual(result.blockingCommits, [])
+    })
+
+    it("does not create a release when there are no commits", () => {
+        const result = checkReleaseCommits([])
+
+        assert.equal(result.shouldCreateRelease, false)
+        assert.equal(result.hasDependencyUpdateCommit, false)
+        assert.deepEqual(result.blockingCommits, [])
+    })
+
+    it("does not create a release for only maintenance commits", () => {
+        const result = checkReleaseCommits([
+            commit({ labels: ["test"] }),
+            commit({ labels: ["chore"] }),
+            commit({ labels: ["refactoring"] }),
+            commit({ labels: ["ci"] })
+        ])
+
+        assert.equal(result.shouldCreateRelease, false)
+        assert.equal(result.hasDependencyUpdateCommit, false)
+        assert.deepEqual(result.blockingCommits, [])
+    })
+
+    it("does not create a release for only blocking commits", () => {
+        const commits = [commit(), commit({ labels: ["feature"] })]
+        const result = checkReleaseCommits(commits)
+
+        assert.equal(result.shouldCreateRelease, false)
+        assert.equal(result.hasDependencyUpdateCommit, false)
+        assert.deepEqual(result.blockingCommits, commits)
+    })
+
+    it("does not create a release when dependency updates are mixed with blocking commits", () => {
+        const commits = [
+            commit({ authorLogin: "dependabot[bot]" }),
+            commit({ labels: ["feature"] }),
+            commit({ labels: ["ci"] }),
+            commit()
+        ]
+        const result = checkReleaseCommits(commits)
+
+        assert.equal(result.shouldCreateRelease, false)
+        assert.equal(result.hasDependencyUpdateCommit, true)
+        assert.deepEqual(result.blockingCommits, [commits[1], commits[3]])
+    })
+})

release-dependency-updates/src/release-check.test.ts

@@ -0,0 +1,71 @@
+import type { RestEndpointMethodTypes } from "@octokit/plugin-rest-endpoint-methods"
+
+type CompareCommit =
+    RestEndpointMethodTypes["repos"]["compareCommitsWithBasehead"]["response"]["data"]["commits"][number]
+type ListedCommit = RestEndpointMethodTypes["repos"]["listCommits"]["response"]["data"][number]
+
+export type ReleaseCommit = CompareCommit | ListedCommit
+export type ReleaseCheckCommit = {
+    pullRequestLabels: readonly string[]
+} & ReleaseCommit
+
+const botAuthorLogins = new Set(["renovate[bot]", "dependabot[bot]"])
+const botAuthorNames = new Set(["renovate bot", "renovate[bot]", "dependabot[bot]", "dependabot"])
+const botEmailFragments = [
+    "renovate[bot]@users.noreply.github.com",
+    "bot@renovateapp.com",
+    "dependabot[bot]@users.noreply.github.com",
+    "dependabot@github.com"
+]
+
+export function checkReleaseCommits<TCommit extends ReleaseCheckCommit>(commits: readonly TCommit[]) {
+    const blockingCommits = []
+    let hasDependencyUpdateCommit = false
+
+    for (const commit of commits) {
+        if (isDependencyUpdateCommit(commit)) {
+            hasDependencyUpdateCommit = true
+            continue
+        }
+
+        if (isMaintenanceCommit(commit)) {
+            continue
+        }
+
+        blockingCommits.push(commit)
+    }
+
+    return {
+        blockingCommits,
+        hasDependencyUpdateCommit,
+        shouldCreateRelease: hasDependencyUpdateCommit && blockingCommits.length === 0
+    }
+}
+
+function isDependencyUpdateCommit(commit: ReleaseCheckCommit) {
+    return isDependencyBotCommit(commit) || hasPullRequestLabel(commit.pullRequestLabels, ["dependencies"])
+}
+
+function isMaintenanceCommit(commit: ReleaseCheckCommit) {
+    return hasPullRequestLabel(commit.pullRequestLabels, ["test", "chore", "refactoring", "ci"])
+}
+
+function isDependencyBotCommit(commit: ReleaseCheckCommit) {
+    const login = commit.author?.login?.toLowerCase()
+    if (login && botAuthorLogins.has(login)) {
+        return true
+    }
+
+    const authorName = commit.commit.author?.name?.toLowerCase()
+    if (authorName && botAuthorNames.has(authorName)) {
+        return true
+    }
+
+    const authorEmail = commit.commit.author?.email?.toLowerCase()
+    return Boolean(authorEmail && botEmailFragments.some((fragment) => authorEmail.includes(fragment)))
+}
+
+function hasPullRequestLabel(labelNames: readonly string[], matchingLabels: readonly string[]) {
+    const normalizedLabels = new Set(labelNames.map((labelName) => labelName.toLowerCase()))
+    return matchingLabels.some((labelName) => normalizedLabels.has(labelName))
+}