modelfusion 0.92.0 → 0.92.1

package/model-provider/openai/OpenAIError.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { ApiCallError } from "../../core/api/ApiCallError.js";
 import { ZodSchema } from "../../core/schema/ZodSchema.js";
 import { parseJSON } from "../../core/schema/parseJSON.js";
-export const openAIErrorDataSchema = new ZodSchema(z.object({
+const openAIErrorDataSchema = new ZodSchema(z.object({
     error: z.object({
         message: z.string(),
         type: z.string(),
@@ -10,27 +10,6 @@ export const openAIErrorDataSchema = new ZodSchema(z.object({
         code: z.string().nullable(),
     }),
 }));
-export class OpenAIError extends ApiCallError {
-    constructor({ data, statusCode, url, requestBodyValues, message, }) {
-        super({
-            message,
-            statusCode,
-            requestBodyValues,
-            url,
-            isRetryable: (statusCode === 429 &&
-                // insufficient_quota is also reported as a 429, but it's not retryable:
-                data?.error.type !== "insufficient_quota") ||
-                statusCode >= 500,
-        });
-        Object.defineProperty(this, "data", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.data = data;
-    }
-}
 export const failedOpenAICallResponseHandler = async ({ response, url, requestBodyValues }) => {
     const responseBody = await response.text();
     // resilient parsing in case the response is not JSON or does not match the schema:
@@ -39,20 +18,26 @@ export const failedOpenAICallResponseHandler = async ({ response, url, requestBo
             text: responseBody,
             schema: openAIErrorDataSchema,
         });
-        return new OpenAIError({
+        return new ApiCallError({
+            message: parsedError.error.message,
             url,
             requestBodyValues,
             statusCode: response.status,
-            message: parsedError.error.message,
+            responseBody,
             data: parsedError,
+            isRetryable: (response.status === 429 &&
+                // insufficient_quota is also reported as a 429, but it's not retryable:
+                parsedError?.error.type !== "insufficient_quota") ||
+                response.status >= 500,
         });
     }
     catch (parseError) {
-        return new OpenAIError({
+        return new ApiCallError({
+            message: responseBody.trim() !== "" ? responseBody : response.statusText,
             url,
             requestBodyValues,
             statusCode: response.status,
-            message: responseBody.trim() !== "" ? responseBody : response.statusText,
+            responseBody,
         });
     }
 };

package/model-provider/openai/index.cjs

@@ -26,13 +26,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAIChatPromptFormat = exports.openai = exports.OpenAIError = void 0;
+exports.OpenAIChatPromptFormat = exports.openai = void 0;
 __exportStar(require("./AzureOpenAIApiConfiguration.cjs"), exports);
 __exportStar(require("./OpenAIApiConfiguration.cjs"), exports);
 __exportStar(require("./OpenAICompletionModel.cjs"), exports);
 __exportStar(require("./OpenAICostCalculator.cjs"), exports);
-var OpenAIError_js_1 = require("./OpenAIError.cjs");
-Object.defineProperty(exports, "OpenAIError", { enumerable: true, get: function () { return OpenAIError_js_1.OpenAIError; } });
 exports.openai = __importStar(require("./OpenAIFacade.cjs"));
 __exportStar(require("./OpenAIImageGenerationModel.cjs"), exports);
 __exportStar(require("./OpenAISpeechModel.cjs"), exports);

package/model-provider/openai/index.d.ts

@@ -2,7 +2,7 @@ export * from "./AzureOpenAIApiConfiguration.js";
 export * from "./OpenAIApiConfiguration.js";
 export * from "./OpenAICompletionModel.js";
 export * from "./OpenAICostCalculator.js";
-export { OpenAIError, OpenAIErrorData } from "./OpenAIError.js";
+export { OpenAIErrorData } from "./OpenAIError.js";
 export * as openai from "./OpenAIFacade.js";
 export * from "./OpenAIImageGenerationModel.js";
 export * from "./OpenAISpeechModel.js";

package/model-provider/openai/index.js

@@ -2,7 +2,6 @@ export * from "./AzureOpenAIApiConfiguration.js";
 export * from "./OpenAIApiConfiguration.js";
 export * from "./OpenAICompletionModel.js";
 export * from "./OpenAICostCalculator.js";
-export { OpenAIError } from "./OpenAIError.js";
 export * as openai from "./OpenAIFacade.js";
 export * from "./OpenAIImageGenerationModel.js";
 export * from "./OpenAISpeechModel.js";

package/model-provider/whispercpp/WhisperCppTranscriptionModel.cjs

@@ -72,15 +72,12 @@ class WhisperCppTranscriptionModel extends AbstractModel_js_1.AbstractModel {
     }
 }
 exports.WhisperCppTranscriptionModel = WhisperCppTranscriptionModel;
-const whisperCppTranscriptionJsonSchema = zod_1.z.union([
-    zod_1.z.object({ text: zod_1.z.string() }),
-    zod_1.z.object({ error: zod_1.z.string() }),
-]);
+const whisperCppTranscriptionJsonSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.union([zod_1.z.object({ text: zod_1.z.string() }), zod_1.z.object({ error: zod_1.z.string() })]));
 const successfulResponseHandler = async ({ response, url, requestBodyValues }) => {
     const responseBody = await response.text();
     const parsedResult = (0, parseJSON_js_1.safeParseJSON)({
         text: responseBody,
-        schema: new ZodSchema_js_1.ZodSchema(whisperCppTranscriptionJsonSchema),
+        schema: whisperCppTranscriptionJsonSchema,
     });
     if (!parsedResult.success) {
         throw new ApiCallError_js_1.ApiCallError({
@@ -106,12 +103,12 @@ const successfulResponseHandler = async ({ response, url, requestBodyValues }) =
     };
 };
 const failedResponseHandler = async ({ response, url, requestBodyValues, }) => {
-    const message = await response.text();
+    const responseBody = await response.text();
     return new ApiCallError_js_1.ApiCallError({
-        message,
+        message: responseBody,
         url,
         requestBodyValues,
         statusCode: response.status,
-        responseBody: message,
+        responseBody,
     });
 };

package/model-provider/whispercpp/WhisperCppTranscriptionModel.js

@@ -68,15 +68,12 @@ export class WhisperCppTranscriptionModel extends AbstractModel {
         return new WhisperCppTranscriptionModel(Object.assign({}, this.settings, additionalSettings));
     }
 }
-const whisperCppTranscriptionJsonSchema = z.union([
-    z.object({ text: z.string() }),
-    z.object({ error: z.string() }),
-]);
+const whisperCppTranscriptionJsonSchema = new ZodSchema(z.union([z.object({ text: z.string() }), z.object({ error: z.string() })]));
 const successfulResponseHandler = async ({ response, url, requestBodyValues }) => {
     const responseBody = await response.text();
     const parsedResult = safeParseJSON({
         text: responseBody,
-        schema: new ZodSchema(whisperCppTranscriptionJsonSchema),
+        schema: whisperCppTranscriptionJsonSchema,
     });
     if (!parsedResult.success) {
         throw new ApiCallError({
@@ -102,12 +99,12 @@ const successfulResponseHandler = async ({ response, url, requestBodyValues }) =
     };
 };
 const failedResponseHandler = async ({ response, url, requestBodyValues, }) => {
-    const message = await response.text();
+    const responseBody = await response.text();
     return new ApiCallError({
-        message,
+        message: responseBody,
         url,
         requestBodyValues,
         statusCode: response.status,
-        responseBody: message,
+        responseBody,
     });
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "The TypeScript library for building multi-modal AI applications.",
-  "version": "0.92.0",
+  "version": "0.92.1",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [
@@ -62,8 +62,8 @@
     "build": "npm run build:esm && npm run build:cjs",
     "build:esm": "tsc --outDir dist/",
     "build:cjs": "tsc --outDir build/cjs/ -p tsconfig.cjs.json && node bin/prepare-cjs.js",
-    "test": "vitest run src",
-    "test-interactive": "vitest watch",
+    "test": "vitest --config vitest.config.js --run src",
+    "test:watch": "vitest watch--config vitest.config.js",
     "dist": "npm run clean && npm run lint && npm run test && npm run build && npm run dist:copy-files",
     "dist:copy-files": "copyfiles package.json README.md LICENSE dist"
   },
@@ -87,9 +87,10 @@
     "fastify": "^4.0.0",
     "husky": "^8.0.3",
     "lint-staged": "15.1.0",
+    "msw": "2.0.10",
     "prettier": "3.1.0",
     "rimraf": "5.0.5",
     "typescript": "5.2.2",
-    "vitest": "^0.34.5"
+    "vitest": "1.0.4"
   }
 }

package/util/AsyncQueue.test.cjs

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
 const delay_js_1 = require("./delay.cjs");
 const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
-(0, vitest_1.test)("receive values in order for single iterator created before pushing", async () => {
+it("should receive values in order for single iterator created before pushing", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     const receivedValues = [];
     const receiveValuesPromise = (async () => {
@@ -16,9 +15,9 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
     asyncQueue.push(3);
     asyncQueue.close();
     await receiveValuesPromise;
-    (0, vitest_1.expect)(receivedValues).toEqual([1, 2, 3]);
+    expect(receivedValues).toEqual([1, 2, 3]);
 });
-(0, vitest_1.test)("receive values in order for single iterator created after closing", async () => {
+it("should receive values in order for single iterator created after closing", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     asyncQueue.push(1);
     asyncQueue.push(2);
@@ -31,9 +30,9 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
         }
     })();
     await receiveValuesPromise;
-    (0, vitest_1.expect)(receivedValues).toEqual([1, 2, 3]);
+    expect(receivedValues).toEqual([1, 2, 3]);
 });
-(0, vitest_1.test)("handle delayed pushing", async () => {
+it("should handle delayed pushing", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     setTimeout(() => {
         asyncQueue.push(1);
@@ -44,12 +43,12 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
     for await (const value of asyncQueue) {
         receivedValues.push(value);
     }
-    (0, vitest_1.expect)(receivedValues).toEqual([1, 2]);
+    expect(receivedValues).toEqual([1, 2]);
 });
-(0, vitest_1.test)("error handling in consumer", async () => {
+it("should error handling in consumer", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     asyncQueue.push(1);
-    await (0, vitest_1.expect)((async () => {
+    await expect((async () => {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         for await (const _value of asyncQueue) {
             throw new Error("Consumer error");
@@ -62,23 +61,23 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
     for await (const value of asyncQueue) {
         receivedValues.push(value);
     }
-    (0, vitest_1.expect)(receivedValues).toEqual([1, 2]);
+    expect(receivedValues).toEqual([1, 2]);
 });
-(0, vitest_1.test)("behavior on empty queue closing", async () => {
+it("should behavior on empty queue closing", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     asyncQueue.close();
     const receivedValues = [];
     for await (const value of asyncQueue) {
         receivedValues.push(value);
     }
-    (0, vitest_1.expect)(receivedValues).toEqual([]);
+    expect(receivedValues).toEqual([]);
 });
-(0, vitest_1.test)("multiple closings", async () => {
+it("should multiple closings", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     asyncQueue.close();
-    (0, vitest_1.expect)(() => asyncQueue.close()).not.toThrow();
+    expect(() => asyncQueue.close()).not.toThrow();
 });
-(0, vitest_1.test)("receive all values in multiple independent consumers", async () => {
+it("should receive all values in multiple independent consumers", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     const consumerPromises = [1, 2].map(async () => {
         const receivedValues = [];
@@ -97,10 +96,10 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
     asyncQueue.close();
     const allReceivedValues = await Promise.all(consumerPromises);
     allReceivedValues.forEach((receivedValues) => {
-        (0, vitest_1.expect)(receivedValues).toEqual([1, 2, 3]);
+        expect(receivedValues).toEqual([1, 2, 3]);
     });
 });
-(0, vitest_1.test)("each consumer receives all pushed values under varying conditions", async () => {
+it("should each consumer receives all pushed values under varying conditions", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     // Start the first consumer, which will await values.
     const receivedValues1 = [];
@@ -128,11 +127,11 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
     asyncQueue.close();
     await Promise.all([consumer1, consumer2]);
     // Both consumers should have received all values, even if they started at different times.
-    (0, vitest_1.expect)(receivedValues1).toEqual([1, 2, 3]);
-    (0, vitest_1.expect)(receivedValues2).toEqual([1, 2, 3]); // This will likely fail because consumer2 started late.
+    expect(receivedValues1).toEqual([1, 2, 3]);
+    expect(receivedValues2).toEqual([1, 2, 3]); // This will likely fail because consumer2 started late.
 });
-(0, vitest_1.test)("throw error when pushing to a closed queue", async () => {
+it("should throw error when pushing to a closed queue", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     asyncQueue.close();
-    (0, vitest_1.expect)(() => asyncQueue.push(1)).toThrowError("Cannot push value to closed queue.");
+    expect(() => asyncQueue.push(1)).toThrowError("Cannot push value to closed queue.");
 });

package/util/AsyncQueue.test.js

@@ -1,7 +1,6 @@
-import { expect, test } from "vitest";
 import { delay } from "./delay.js";
 import { AsyncQueue } from "./AsyncQueue.js";
-test("receive values in order for single iterator created before pushing", async () => {
+it("should receive values in order for single iterator created before pushing", async () => {
     const asyncQueue = new AsyncQueue();
     const receivedValues = [];
     const receiveValuesPromise = (async () => {
@@ -16,7 +15,7 @@ test("receive values in order for single iterator created before pushing", async
     await receiveValuesPromise;
     expect(receivedValues).toEqual([1, 2, 3]);
 });
-test("receive values in order for single iterator created after closing", async () => {
+it("should receive values in order for single iterator created after closing", async () => {
     const asyncQueue = new AsyncQueue();
     asyncQueue.push(1);
     asyncQueue.push(2);
@@ -31,7 +30,7 @@ test("receive values in order for single iterator created after closing", async
     await receiveValuesPromise;
     expect(receivedValues).toEqual([1, 2, 3]);
 });
-test("handle delayed pushing", async () => {
+it("should handle delayed pushing", async () => {
     const asyncQueue = new AsyncQueue();
     setTimeout(() => {
         asyncQueue.push(1);
@@ -44,7 +43,7 @@ test("handle delayed pushing", async () => {
     }
     expect(receivedValues).toEqual([1, 2]);
 });
-test("error handling in consumer", async () => {
+it("should error handling in consumer", async () => {
     const asyncQueue = new AsyncQueue();
     asyncQueue.push(1);
     await expect((async () => {
@@ -62,7 +61,7 @@ test("error handling in consumer", async () => {
     }
     expect(receivedValues).toEqual([1, 2]);
 });
-test("behavior on empty queue closing", async () => {
+it("should behavior on empty queue closing", async () => {
     const asyncQueue = new AsyncQueue();
     asyncQueue.close();
     const receivedValues = [];
@@ -71,12 +70,12 @@ test("behavior on empty queue closing", async () => {
     }
     expect(receivedValues).toEqual([]);
 });
-test("multiple closings", async () => {
+it("should multiple closings", async () => {
     const asyncQueue = new AsyncQueue();
     asyncQueue.close();
     expect(() => asyncQueue.close()).not.toThrow();
 });
-test("receive all values in multiple independent consumers", async () => {
+it("should receive all values in multiple independent consumers", async () => {
     const asyncQueue = new AsyncQueue();
     const consumerPromises = [1, 2].map(async () => {
         const receivedValues = [];
@@ -98,7 +97,7 @@ test("receive all values in multiple independent consumers", async () => {
         expect(receivedValues).toEqual([1, 2, 3]);
     });
 });
-test("each consumer receives all pushed values under varying conditions", async () => {
+it("should each consumer receives all pushed values under varying conditions", async () => {
     const asyncQueue = new AsyncQueue();
     // Start the first consumer, which will await values.
     const receivedValues1 = [];
@@ -129,7 +128,7 @@ test("each consumer receives all pushed values under varying conditions", async
     expect(receivedValues1).toEqual([1, 2, 3]);
     expect(receivedValues2).toEqual([1, 2, 3]); // This will likely fail because consumer2 started late.
 });
-test("throw error when pushing to a closed queue", async () => {
+it("should throw error when pushing to a closed queue", async () => {
     const asyncQueue = new AsyncQueue();
     asyncQueue.close();
     expect(() => asyncQueue.push(1)).toThrowError("Cannot push value to closed queue.");

package/util/isDeepEqualData.test.cjs

@@ -4,9 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_assert_1 = __importDefault(require("node:assert"));
-const vitest_1 = require("vitest");
 const isDeepEqualData_js_1 = require("./isDeepEqualData.cjs");
-(0, vitest_1.test)("checks if two primitives are equal", async () => {
+it("should check if two primitives are equal", async () => {
     let x = 1;
     let y = 1;
     let result = (0, isDeepEqualData_js_1.isDeepEqualData)(x, y);
@@ -16,48 +15,48 @@ const isDeepEqualData_js_1 = require("./isDeepEqualData.cjs");
     result = (0, isDeepEqualData_js_1.isDeepEqualData)(x, y);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("returns false for different types", async () => {
+it("should return false for different types", async () => {
     const obj = { a: 1 };
     const num = 1;
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj, num);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("returns false for null values compared with objects", async () => {
+it("should return false for null values compared with objects", async () => {
     const obj = { a: 1 };
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj, null);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("identifies two equal objects", async () => {
+it("should identify two equal objects", async () => {
     const obj1 = { a: 1, b: 2 };
     const obj2 = { a: 1, b: 2 };
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj1, obj2);
     node_assert_1.default.equal(result, true);
 });
-(0, vitest_1.test)("identifies two objects with different values", async () => {
+it("should identify two objects with different values", async () => {
     const obj1 = { a: 1, b: 2 };
     const obj2 = { a: 1, b: 3 };
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj1, obj2);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("identifies two objects with different number of keys", async () => {
+it("should identify two objects with different number of keys", async () => {
     const obj1 = { a: 1, b: 2 };
     const obj2 = { a: 1, b: 2, c: 3 };
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj1, obj2);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("handles nested objects", async () => {
+it("should handle nested objects", async () => {
     const obj1 = { a: { c: 1 }, b: 2 };
     const obj2 = { a: { c: 1 }, b: 2 };
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj1, obj2);
     node_assert_1.default.equal(result, true);
 });
-(0, vitest_1.test)("detects inequality in nested objects", async () => {
+it("should detect inequality in nested objects", async () => {
     const obj1 = { a: { c: 1 }, b: 2 };
     const obj2 = { a: { c: 2 }, b: 2 };
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj1, obj2);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("compares arrays correctly", async () => {
+it("should compare arrays correctly", async () => {
     const arr1 = [1, 2, 3];
     const arr2 = [1, 2, 3];
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(arr1, arr2);
@@ -67,18 +66,18 @@ const isDeepEqualData_js_1 = require("./isDeepEqualData.cjs");
     const result2 = (0, isDeepEqualData_js_1.isDeepEqualData)(arr3, arr4);
     node_assert_1.default.equal(result2, false);
 });
-(0, vitest_1.test)("returns false for null comparison with object", () => {
+it("should return false for null comparison with object", () => {
     const obj = { a: 1 };
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj, null);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("distinguishes between array and object with same enumerable properties", () => {
+it("should distinguish between array and object with same enumerable properties", () => {
     const obj = { 0: "one", 1: "two", length: 2 };
     const arr = ["one", "two"];
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj, arr);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("returns false when comparing objects with different prototypes", () => {
+it("should return false when comparing objects with different prototypes", () => {
     const obj1 = Object.create({ a: 1 });
     const obj2 = Object.create(null);
     obj1.b = 2;
@@ -86,14 +85,14 @@ const isDeepEqualData_js_1 = require("./isDeepEqualData.cjs");
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj1, obj2);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("handles date object comparisons correctly", () => {
+it("should handle date object comparisons correctly", () => {
     const date1 = new Date(2000, 0, 1);
     const date2 = new Date(2000, 0, 1);
     const date3 = new Date(2000, 0, 2);
     node_assert_1.default.equal((0, isDeepEqualData_js_1.isDeepEqualData)(date1, date2), true);
     node_assert_1.default.equal((0, isDeepEqualData_js_1.isDeepEqualData)(date1, date3), false);
 });
-(0, vitest_1.test)("handles function comparisons", () => {
+it("should handle function comparisons", () => {
     const func1 = () => {
         console.log("hello");
     };

package/util/isDeepEqualData.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert";
-import { test } from "vitest";
 import { isDeepEqualData } from "./isDeepEqualData.js";
-test("checks if two primitives are equal", async () => {
+it("should check if two primitives are equal", async () => {
     let x = 1;
     let y = 1;
     let result = isDeepEqualData(x, y);
@@ -11,48 +10,48 @@ test("checks if two primitives are equal", async () => {
     result = isDeepEqualData(x, y);
     assert.equal(result, false);
 });
-test("returns false for different types", async () => {
+it("should return false for different types", async () => {
     const obj = { a: 1 };
     const num = 1;
     const result = isDeepEqualData(obj, num);
     assert.equal(result, false);
 });
-test("returns false for null values compared with objects", async () => {
+it("should return false for null values compared with objects", async () => {
     const obj = { a: 1 };
     const result = isDeepEqualData(obj, null);
     assert.equal(result, false);
 });
-test("identifies two equal objects", async () => {
+it("should identify two equal objects", async () => {
     const obj1 = { a: 1, b: 2 };
     const obj2 = { a: 1, b: 2 };
     const result = isDeepEqualData(obj1, obj2);
     assert.equal(result, true);
 });
-test("identifies two objects with different values", async () => {
+it("should identify two objects with different values", async () => {
     const obj1 = { a: 1, b: 2 };
     const obj2 = { a: 1, b: 3 };
     const result = isDeepEqualData(obj1, obj2);
     assert.equal(result, false);
 });
-test("identifies two objects with different number of keys", async () => {
+it("should identify two objects with different number of keys", async () => {
     const obj1 = { a: 1, b: 2 };
     const obj2 = { a: 1, b: 2, c: 3 };
     const result = isDeepEqualData(obj1, obj2);
     assert.equal(result, false);
 });
-test("handles nested objects", async () => {
+it("should handle nested objects", async () => {
     const obj1 = { a: { c: 1 }, b: 2 };
     const obj2 = { a: { c: 1 }, b: 2 };
     const result = isDeepEqualData(obj1, obj2);
     assert.equal(result, true);
 });
-test("detects inequality in nested objects", async () => {
+it("should detect inequality in nested objects", async () => {
     const obj1 = { a: { c: 1 }, b: 2 };
     const obj2 = { a: { c: 2 }, b: 2 };
     const result = isDeepEqualData(obj1, obj2);
     assert.equal(result, false);
 });
-test("compares arrays correctly", async () => {
+it("should compare arrays correctly", async () => {
     const arr1 = [1, 2, 3];
     const arr2 = [1, 2, 3];
     const result = isDeepEqualData(arr1, arr2);
@@ -62,18 +61,18 @@ test("compares arrays correctly", async () => {
     const result2 = isDeepEqualData(arr3, arr4);
     assert.equal(result2, false);
 });
-test("returns false for null comparison with object", () => {
+it("should return false for null comparison with object", () => {
     const obj = { a: 1 };
     const result = isDeepEqualData(obj, null);
     assert.equal(result, false);
 });
-test("distinguishes between array and object with same enumerable properties", () => {
+it("should distinguish between array and object with same enumerable properties", () => {
     const obj = { 0: "one", 1: "two", length: 2 };
     const arr = ["one", "two"];
     const result = isDeepEqualData(obj, arr);
     assert.equal(result, false);
 });
-test("returns false when comparing objects with different prototypes", () => {
+it("should return false when comparing objects with different prototypes", () => {
     const obj1 = Object.create({ a: 1 });
     const obj2 = Object.create(null);
     obj1.b = 2;
@@ -81,14 +80,14 @@ test("returns false when comparing objects with different prototypes", () => {
     const result = isDeepEqualData(obj1, obj2);
     assert.equal(result, false);
 });
-test("handles date object comparisons correctly", () => {
+it("should handle date object comparisons correctly", () => {
     const date1 = new Date(2000, 0, 1);
     const date2 = new Date(2000, 0, 1);
     const date3 = new Date(2000, 0, 2);
     assert.equal(isDeepEqualData(date1, date2), true);
     assert.equal(isDeepEqualData(date1, date3), false);
 });
-test("handles function comparisons", () => {
+it("should handle function comparisons", () => {
     const func1 = () => {
         console.log("hello");
     };