test: implement custom Vitest matchers for task order and status assertions (#243)

chore: remove other changelog libraries

Author: nam-hle

.changeset/README.md

@@ -1,3 +1,5 @@
+name: Release Please
+
 on:
   push:
     branches:
@@ -7,8 +9,6 @@ permissions:
   contents: write
   pull-requests: write
 
-name: release-please
-
 jobs:
   release-please:
     runs-on: ubuntu-latest

.changeset/config.json

@@ -44,8 +44,3 @@ jobs:
         run: |
           npm config set "//registry.npmjs.org/:_authToken" "${NPM_TOKEN}" # pnpm config set is broken
           pnpm publish -r --no-git-checks
-
-      - name: Generate Changelog
-        run: npx changelogithub
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/release-please.yml

@@ -7,13 +7,11 @@
 		"start": "pnpm -r --parallel start"
 	},
 	"devDependencies": {
-		"@changesets/cli": "^2.29.4",
 		"@eslint/js": "^9.29.0",
 		"@microsoft/api-extractor": "^7.52.8",
 		"@stylistic/eslint-plugin": "^4.4.1",
 		"@types/node": "^20.19.0",
 		"@vitest/eslint-plugin": "^1.2.7",
-		"changelogithub": "^13.15.0",
 		"cspell": "^9.1.1",
 		"eslint": "^9.29.0",
 		"eslint-plugin-import": "^2.31.0",

.github/workflows/release.yml

@@ -41,6 +41,7 @@
 		"@types/node": "^20.19.0",
 		"@types/object-hash": "^3.0.6",
 		"@types/yargs": "^17.0.33",
+		"@vitest/expect": "^3.2.4",
 		"fixturify": "^3.0.0",
 		"knip": "^5.61.0",
 		"size-limit": "^11.2.0",

package.json

@@ -0,0 +1,27 @@
+import type { SyncExpectationResult } from "@vitest/expect";
+
+export function toDoneInOrder(stdout: string, ...tasks: string[]): SyncExpectationResult {
+	for (let firstTaskIndex = 0; firstTaskIndex < tasks.length - 1; firstTaskIndex++) {
+		for (let secondTaskIndex = firstTaskIndex + 1; secondTaskIndex < tasks.length; secondTaskIndex++) {
+			const firstTask = tasks[firstTaskIndex];
+			const secondTask = tasks[secondTaskIndex];
+
+			const firstTaskDoneIndex = stdout.indexOf(`Task ${firstTask} DONE`);
+			const secondTaskDoneIndex = stdout.indexOf(`Task ${secondTask} DONE`);
+
+			const pass = firstTaskDoneIndex < secondTaskDoneIndex;
+
+			if (!pass) {
+				return {
+					pass,
+					message: () => `Expected task '${firstTask}' to be done before '${secondTask}', but it did not. Stdout:\n${stdout}`
+				};
+			}
+		}
+	}
+
+	return {
+		pass: true,
+		message: () => `All tasks done in the expected order.`
+	};
+}

packages/nadle/package.json

@@ -0,0 +1,54 @@
+import { type SyncExpectationResult } from "@vitest/expect";
+
+export function toRunInOrder(stdout: string, ...groups: (string[] | string)[]): SyncExpectationResult {
+	for (let firstGroupIndex = 0; firstGroupIndex < groups.length - 1; firstGroupIndex++) {
+		for (let secondGroupIndex = firstGroupIndex + 1; secondGroupIndex < groups.length; secondGroupIndex++) {
+			const firstGroup = (Array.isArray(groups[firstGroupIndex]) ? groups[firstGroupIndex] : [groups[firstGroupIndex]]) as string[];
+			const secondGroup = (Array.isArray(groups[secondGroupIndex]) ? groups[secondGroupIndex] : [groups[secondGroupIndex]]) as string[];
+
+			for (const firstTask of firstGroup) {
+				for (const secondTask of secondGroup) {
+					const result = assertOrder(stdout, firstTask, secondTask);
+
+					if (!result.pass) {
+						return result;
+					}
+				}
+			}
+		}
+	}
+
+	return {
+		pass: true,
+		message: () => `All tasks ran in the expected order.`
+	};
+}
+
+function assertOrder(stdout: string, firstTask: string, secondTask: string) {
+	const firstTaskDoneIndex = stdout.indexOf(`Task ${firstTask} DONE`);
+	const secondTaskStartedIndex = stdout.indexOf(`Task ${secondTask} STARTED`);
+
+	if (firstTaskDoneIndex === -1) {
+		return {
+			pass: false,
+			message: () => `Expected task '${firstTask}' to have run, but it did not. Stdout:\n${stdout}`
+		};
+	}
+
+	if (secondTaskStartedIndex === -1) {
+		return {
+			pass: false,
+			message: () => `Expected task '${secondTask}' to have run, but it did not. Stdout:\n${stdout}`
+		};
+	}
+
+	const pass = firstTaskDoneIndex < secondTaskStartedIndex;
+
+	return {
+		pass,
+		message: () =>
+			pass
+				? `Expected task '${firstTask}' not to run before '${secondTask}', but it did. Stdout:\n${stdout}`
+				: `Expected task '${firstTask}' to run before '${secondTask}', but the order was incorrect. Stdout:\n${stdout}`
+	};
+}

packages/nadle/test/__setup__/matchers/to-done-in-order.ts

@@ -0,0 +1,17 @@
+import { type ExpectationResult } from "@vitest/expect";
+
+export function toSettle(stdout: string, taskName: string, status: "done" | "up-to-date" | "from-cache" | "failed"): ExpectationResult {
+	const taskDoneIndex = stdout.indexOf(`Task ${taskName} ${status.toUpperCase()}`);
+
+	if (taskDoneIndex === -1) {
+		return {
+			pass: false,
+			message: () => `Expected task '${taskName}' to have been marked as '${status}', but it did not. Stdout:\n${stdout}`
+		};
+	}
+
+	return {
+		pass: true,
+		message: () => `Task '${taskName}' was successfully marked as '${status}'.`
+	};
+}

packages/nadle/test/__setup__/matchers/to-run-in-order.ts

@@ -1,85 +1,10 @@
 import { expect } from "vitest";
 
 import { serialize } from "./serialize.js";
+import { toSettle } from "./matchers/to-settle.js";
+import { toRunInOrder } from "./matchers/to-run-in-order.js";
+import { toDoneInOrder } from "./matchers/to-done-in-order.js";
 
 expect.addSnapshotSerializer({ serialize, test: (val) => typeof val === "string" });
 
-expect.extend({
-	toDoneInOrder(stdout: string, ...tasks: string[]) {
-		for (let firstTaskIndex = 0; firstTaskIndex < tasks.length - 1; firstTaskIndex++) {
-			for (let secondTaskIndex = firstTaskIndex + 1; secondTaskIndex < tasks.length; secondTaskIndex++) {
-				const firstTask = tasks[firstTaskIndex];
-				const secondTask = tasks[secondTaskIndex];
-
-				const firstTaskDoneIndex = stdout.indexOf(`Task ${firstTask} DONE`);
-				const secondTaskDoneIndex = stdout.indexOf(`Task ${secondTask} DONE`);
-
-				const pass = firstTaskDoneIndex < secondTaskDoneIndex;
-
-				if (!pass) {
-					return {
-						pass,
-						message: () => `Expected task '${firstTask}' to be done before '${secondTask}', but it did not. Stdout:\n${stdout}`
-					};
-				}
-			}
-		}
-
-		return {
-			pass: true,
-			message: () => `All tasks done in the expected order.`
-		};
-	},
-	toRunInOrder(stdout: string, ...groups: (string[] | string)[]) {
-		for (let firstGroupIndex = 0; firstGroupIndex < groups.length - 1; firstGroupIndex++) {
-			for (let secondGroupIndex = firstGroupIndex + 1; secondGroupIndex < groups.length; secondGroupIndex++) {
-				const firstGroup = (Array.isArray(groups[firstGroupIndex]) ? groups[firstGroupIndex] : [groups[firstGroupIndex]]) as string[];
-				const secondGroup = (Array.isArray(groups[secondGroupIndex]) ? groups[secondGroupIndex] : [groups[secondGroupIndex]]) as string[];
-
-				for (const firstTask of firstGroup) {
-					for (const secondTask of secondGroup) {
-						const result = assertOrder(stdout, firstTask, secondTask);
-
-						if (!result.pass) {
-							return result;
-						}
-					}
-				}
-			}
-		}
-
-		return {
-			pass: true,
-			message: () => `All tasks ran in the expected order.`
-		};
-	}
-});
-
-function assertOrder(stdout: string, firstTask: string, secondTask: string) {
-	const firstTaskDoneIndex = stdout.indexOf(`Task ${firstTask} DONE`);
-	const secondTaskStartedIndex = stdout.indexOf(`Task ${secondTask} STARTED`);
-
-	if (firstTaskDoneIndex === -1) {
-		return {
-			pass: false,
-			message: () => `Expected task '${firstTask}' to have run, but it did not. Stdout:\n${stdout}`
-		};
-	}
-
-	if (secondTaskStartedIndex === -1) {
-		return {
-			pass: false,
-			message: () => `Expected task '${secondTask}' to have run, but it did not. Stdout:\n${stdout}`
-		};
-	}
-
-	const pass = firstTaskDoneIndex < secondTaskStartedIndex;
-
-	return {
-		pass,
-		message: () =>
-			pass
-				? `Expected task '${firstTask}' not to run before '${secondTask}', but it did. Stdout:\n${stdout}`
-				: `Expected task '${firstTask}' to run before '${secondTask}', but the order was incorrect. Stdout:\n${stdout}`
-	};
-}
+expect.extend({ toSettle, toRunInOrder, toDoneInOrder });