refactor(tests): migrate to describe/it pattern

Author: joaotonaco

src/modules/files.ts

@@ -1,5 +1,5 @@
-import { readFile } from "fs/promises";
 import { join } from "path";
+import { readFile } from "fs/promises";
 
 import { assertPathLike, assertString } from "@/assertions/literal";
 import { Routes } from "@/lib/routes";

test/api.test.js

@@ -1,20 +1,20 @@
 import assert from "node:assert/strict";
-import test from "node:test";
+import { describe, it } from "node:test";
 import { APIService } from "../lib/services/api.js";
 
-test("APIService", async (t) => {
+describe("APIService", async () => {
 	const service = new APIService("123-test-key");
 
-	await t.test("should initialize with correct properties", () => {
+	await it("should initialize with correct properties", () => {
 		assert.strictEqual(service.baseUrl, "https://api.squarecloud.app");
 		assert.strictEqual(service.version, "v2");
 		assert.strictEqual(service.userId, "123");
 	});
 
-	await t.test("should parse request options correctly", async (t) => {
+	await it("should parse request options correctly", async (t) => {
 		const originalFetch = global.fetch;
 
-		await t.test("should handle basic GET request", async () => {
+		await it("should handle basic GET request", async () => {
 			let requestUrl;
 			let requestInit;
 
@@ -35,7 +35,7 @@ test("APIService", async (t) => {
 			assert.strictEqual(requestInit.headers.Accept, "application/json");
 		});
 
-		await t.test("should handle query parameters", async () => {
+		await it("should handle query parameters", async () => {
 			let requestUrl;
 
 			global.fetch = async (url, init) => {
@@ -51,7 +51,7 @@ test("APIService", async (t) => {
 			assert.ok(requestUrl.toString().includes("param2=value2"));
 		});
 
-		await t.test("should handle JSON body", async () => {
+		await it("should handle JSON body", async () => {
 			let requestInit;
 
 			global.fetch = async (url, init) => {
@@ -72,7 +72,7 @@ test("APIService", async (t) => {
 			assert.strictEqual(requestInit.body, JSON.stringify(body));
 		});
 
-		await t.test("should handle FormData body", async () => {
+		await it("should handle FormData body", async () => {
 			let requestInit;
 
 			global.fetch = async (url, init) => {
@@ -90,7 +90,7 @@ test("APIService", async (t) => {
 			assert.ok(!requestInit.headers["Content-Type"]);
 		});
 
-		await t.test("should handle error responses", async () => {
+		await it("should handle error responses", async () => {
 			global.fetch = async () => {
 				return new Response(
 					JSON.stringify({ status: "error", code: "TEST_ERROR" }),
@@ -103,7 +103,7 @@ test("APIService", async (t) => {
 			});
 		});
 
-		await t.test("should handle network errors", async () => {
+		await it("should handle network errors", async () => {
 			global.fetch = async () => {
 				throw new Error("Network error");
 			};
@@ -113,7 +113,7 @@ test("APIService", async (t) => {
 			});
 		});
 
-		await t.test("should handle specific HTTP status codes", async () => {
+		await it("should handle specific HTTP status codes", async () => {
 			const statusTests = [
 				{ status: 413, code: "Payload Too Large" },
 				{ status: 429, code: "Rate Limit Exceeded" },

test/applications.test.js

@@ -1,87 +1,77 @@
 import assert from "node:assert/strict";
-import test from "node:test";
-import { setTimeout } from "node:timers/promises";
+import { describe, it } from "node:test";
 import path from "path";
 import { fileURLToPath } from "url";
 import { readFile } from "fs/promises";
 import { SquareCloudAPI } from "../lib/index.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-test("ApplicationsModule", async (t) => {
+describe("ApplicationsModule", async () => {
 	const client = new SquareCloudAPI(process.env.SQUARE_API_KEY);
 
-	await t.test("should list all applications", async () => {
+	await it("should list all applications", async () => {
 		const applications = await client.applications.get();
 		assert.ok(applications);
 		assert.ok(applications.size >= 0);
 	});
 
-	await t.test("should handle application lifecycle", async (t) => {
+	await describe("Lifecycle", async (t) => {
 		const testAppPath = path.join(__dirname, "fixtures/test-app.zip");
 		const fileContent = await readFile(testAppPath);
 
 		const createdApp = await client.applications.create(fileContent);
 
-		await t.test("should create application", async () => {
+		await it("should create application", async () => {
 			assert.ok(createdApp);
 			assert.ok(createdApp.id);
 		});
 
 		const app = await client.applications.fetch(createdApp.id);
 
-		await t.test("should fetch application", async () => {
+		await it("should fetch application", async () => {
 			assert.strictEqual(app.id, createdApp.id);
 		});
 
-		await t.test("should get status", async () => {
+		await it("should get status", async () => {
 			const status = await app.getStatus();
 			assert.strictEqual(status.applicationId, createdApp.id);
 		});
 
-		await t.test("should get application logs", async () => {
+		await it("should get application logs", async () => {
 			const logs = await app.getLogs();
 			assert.ok(typeof logs === "string");
 		});
 
 		const testFilePath = path.join(__dirname, "fixtures/test-file.txt");
 
-		await t.test("should commit files as buffer to application", async () => {
-			const fileContent = await readFile(testFilePath);
-
-			const bufferResult = await app.commit(fileContent, "test-file.txt");
-			assert.strictEqual(bufferResult, true);
-		});
-
-		await setTimeout(10000);
-
-		await t.test("should commit files as path to application", async () => {
-			const pathResult = await app.commit(testFilePath, "test-file2.txt");
+		await it("should commit file to application", async () => {
+			const pathResult = await app.commit(testFilePath, "test-file.txt");
 			assert.strictEqual(pathResult, true);
 		});
 
-		await t.test("should start application", async () => {
-			const result = await app.start();
+		await it("should stop application", async () => {
+			const result = await app.stop();
 			assert.strictEqual(result, true);
 		});
 
-		await t.test("should restart application", async () => {
-			const result = await app.restart();
+		await it("should start application", async () => {
+			const result = await app.start();
 			assert.strictEqual(result, true);
 		});
 
-		await t.test("should stop application", async () => {
-			const result = await app.stop();
+		await it("should restart application", async () => {
+			const result = await app.restart();
 			assert.strictEqual(result, true);
 		});
 
-		await t.test("should delete application", async () => {
+		await it("should delete application", async () => {
 			const deleteResult = await app.delete();
 			assert.strictEqual(deleteResult, true);
 		});
 	});
 
-	await t.test("should get status for all applications", async () => {
+	await it("should get status for all applications", async () => {
 		const statuses = await client.applications.statusAll();
 		assert.ok(Array.isArray(statuses));
 	});

test/backups.test.js

@@ -1,13 +1,14 @@
 import assert from "node:assert/strict";
-import test from "node:test";
+import { before, describe, it } from "node:test";
 import { SquareCloudAPI } from "../lib/index.js";
 
-test("BackupsModule", async (t) => {
+describe("BackupsModule", async () => {
 	const client = new SquareCloudAPI(process.env.SQUARE_API_KEY);
+
 	/** @type import("../lib").Application */
 	let testApp;
 
-	t.before(async () => {
+	before(async () => {
 		const apps = await client.applications.get();
 		testApp = apps.first();
 
@@ -16,7 +17,7 @@ test("BackupsModule", async (t) => {
 		}
 	});
 
-	await t.test("should create backup", async (t) => {
+	await it("should create backup", async (t) => {
 		try {
 			const backup = await testApp.backups.create();
 			assert.ok(backup.url);
@@ -28,14 +29,14 @@ test("BackupsModule", async (t) => {
 		}
 	});
 
-	await t.test("should download backup", async () => {
+	await it("should download backup", async () => {
 		const backups = await testApp.backups.list();
 		const buffer = await backups[0].download();
 		assert.ok(Buffer.isBuffer(buffer));
 		assert.ok(buffer.length > 0);
 	});
 
-	await t.test("should list backups", async () => {
+	await it("should list backups", async () => {
 		const backups = await testApp.backups.list();
 
 		assert.ok(Array.isArray(backups));
@@ -46,14 +47,14 @@ test("BackupsModule", async (t) => {
 		}
 	});
 
-	await t.test("should update cache on backups list", async () => {
+	await it("should update cache on backups list", async () => {
 		const backups = await testApp.backups.list();
 		const cachedBackups = testApp.cache.get("backups");
 
 		assert.deepStrictEqual(cachedBackups, backups);
 	});
 
-	await t.test("should emit backupsUpdate event", async () => {
+	await it("should emit backupsUpdate event", async () => {
 		let emitted = false;
 		const oldBackups = testApp.cache.get("backups");
 

test/files.test.js

@@ -1,13 +1,14 @@
 import assert from "node:assert/strict";
-import test from "node:test";
+import { before, describe, it } from "node:test";
 import { SquareCloudAPI } from "../lib/index.js";
 
-test("FilesModule", async (t) => {
+describe("FilesModule", async () => {
 	const client = new SquareCloudAPI(process.env.SQUARE_API_KEY);
+
 	/** @type {import("../lib").Application} */
 	let testApp;
 
-	t.before(async () => {
+	before(async () => {
 		const apps = await client.applications.get();
 		testApp = apps.first();
 
@@ -16,7 +17,7 @@ test("FilesModule", async (t) => {
 		}
 	});
 
-	await t.test("should list files in root directory", async () => {
+	await it("should list files in root directory", async () => {
 		const files = await testApp.files.list();
 		assert.ok(Array.isArray(files));
 		if (files.length > 0) {
@@ -30,7 +31,7 @@ test("FilesModule", async (t) => {
 		}
 	});
 
-	await t.test("should create and read file", async () => {
+	await it("should create and read file", async () => {
 		const testContent = "test content";
 		const fileName = "test.txt";
 
@@ -45,7 +46,7 @@ test("FilesModule", async (t) => {
 		assert.strictEqual(fileContent?.toString(), testContent);
 	});
 
-	await t.test("should edit existing file", async () => {
+	await it("should edit existing file", async () => {
 		const newContent = "updated content";
 		const fileName = "test.txt";
 
@@ -59,7 +60,7 @@ test("FilesModule", async (t) => {
 		assert.strictEqual(fileContent?.toString(), newContent);
 	});
 
-	await t.test("should move/rename file", async () => {
+	await it("should move/rename file", async () => {
 		const oldPath = "/test.txt";
 		const newPath = "/test2.txt";
 
@@ -70,20 +71,20 @@ test("FilesModule", async (t) => {
 		assert.ok(files.some((file) => file.name === "test2.txt"));
 	});
 
-	await t.test("should handle non-existent file read", async () => {
+	await it("should handle non-existent file read", async () => {
 		const content = await testApp.files.read("/non-existent.txt");
 		assert.ok(content.byteLength === 0);
 	});
 
-	await t.test("should delete file", async () => {
+	await it("should delete file", async () => {
 		const deleteResult = await testApp.files.delete("/test2.txt");
 		assert.strictEqual(deleteResult, true);
 
 		const files = await testApp.files.list();
 		assert.ok(!files.some((file) => file.name === "test2.txt"));
 	});
 
-	await t.test("should handle directory operations", async () => {
+	await it("should handle directory operations", async () => {
 		await testApp.files.create(Buffer.from("file1"), "file1.txt", "/testdir");
 		await testApp.files.create(Buffer.from("file2"), "file2.txt", "/testdir");
 

test/user.test.js

@@ -1,11 +1,11 @@
 import assert from "node:assert/strict";
-import test from "node:test";
+import { describe, it } from "node:test";
 import { SquareCloudAPI } from "../lib/index.js";
 
-test("UserModule", async (t) => {
+describe("UserModule", async () => {
 	const client = new SquareCloudAPI(process.env.SQUARE_API_KEY);
 
-	await t.test("should get user information", async () => {
+	await it("should get user information", async () => {
 		const user = await client.user.get();
 
 		assert.ok(user);
@@ -16,15 +16,15 @@ test("UserModule", async (t) => {
 		assert.ok(user.applications.size >= 0);
 	});
 
-	await t.test("should update cache on user fetch", async () => {
+	await it("should update cache on user fetch", async () => {
 		const firstUser = await client.user.get();
 		const cachedUser = client.cache.get("user");
 
 		assert.strictEqual(cachedUser?.id, firstUser.id);
 		assert.strictEqual(cachedUser?.email, firstUser.email);
 	});
 
-	await t.test("should emit userUpdate event", async () => {
+	await it("should emit userUpdate event", async () => {
 		let emitted = false;
 		const oldUser = client.cache.get("user");