feat: use custom toIncludeSameMembers matcher

Author: gagik

tests/integration/tools/mongodb/create/createCollection.test.ts

@@ -55,7 +55,7 @@ describeWithMongoDB("createCollection tool", (integration) => {
             expect(content).toEqual(`Collection "collection2" created in database "${integration.randomDbName()}".`);
             collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
             expect(collections).toHaveLength(2);
-            expect(collections.map((c) => c.name)).toEqual(expect.arrayContaining(["collection1", "collection2"]));
+            expect(collections.map((c) => c.name)).toIncludeSameMembers(["collection1", "collection2"]);
         });
 
         it("does nothing if collection already exists", async () => {

tests/integration/tools/mongodb/metadata/listCollections.test.ts

@@ -56,9 +56,10 @@ describeWithMongoDB("listCollections tool", (integration) => {
             });
             const items2 = getResponseElements(response2.content);
             expect(items2).toHaveLength(2);
-            expect(items2.map((item) => item.text)).toEqual(
-                expect.arrayContaining(['Name: "collection-1"', 'Name: "collection-2"'])
-            );
+            expect(items2.map((item) => item.text)).toIncludeSameMembers([
+                'Name: "collection-1"',
+                'Name: "collection-2"',
+            ]);
         });
     });
 

tests/integration/tools/mongodb/metadata/listDatabases.test.ts

@@ -35,7 +35,7 @@ describeWithMongoDB("listDatabases tool", (integration) => {
 
             const response = await integration.mcpClient().callTool({ name: "list-databases", arguments: {} });
             const dbNames = getDbNames(response.content);
-            expect(dbNames).toEqual(expect.arrayContaining([...defaultDatabases, "foo", "baz"]));
+            expect(dbNames).toIncludeSameMembers([...defaultDatabases, "foo", "baz"]);
         });
     });
 

tests/matchers/toIncludeSameMembers.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+
+describe("toIncludeSameMembers matcher", () => {
+    it("should pass when arrays contain the same elements in different order", () => {
+        const array1 = [1, 2, 3];
+        const array2 = [3, 1, 2];
+
+        expect(array1).toIncludeSameMembers(array2);
+    });
+
+    it("should pass when arrays contain the same elements in same order", () => {
+        const array1 = [1, 2, 3];
+        const array2 = [1, 2, 3];
+
+        expect(array1).toIncludeSameMembers(array2);
+    });
+
+    it("should fail when arrays have different lengths", () => {
+        const array1 = [1, 2, 3];
+        const array2 = [1, 2];
+
+        expect(() => expect(array1).toIncludeSameMembers(array2)).toThrow();
+    });
+
+    it("should fail when arrays contain different elements", () => {
+        const array1 = [1, 2, 3];
+        const array2 = [4, 5, 6];
+
+        expect(() => expect(array1).toIncludeSameMembers(array2)).toThrow();
+    });
+
+    it("should work with string arrays", () => {
+        const array1 = ["apple", "banana", "cherry"];
+        const array2 = ["cherry", "apple", "banana"];
+
+        expect(array1).toIncludeSameMembers(array2);
+    });
+
+    it("should work with object arrays", () => {
+        const array1 = [{ name: "Alice" }, { name: "Bob" }];
+        const array2 = [{ name: "Bob" }, { name: "Alice" }];
+
+        expect(array1).toIncludeSameMembers(array2);
+    });
+
+    it("should work with mixed type arrays", () => {
+        const array1 = [1, "hello", { key: "value" }];
+        const array2 = [{ key: "value" }, 1, "hello"];
+
+        expect(array1).toIncludeSameMembers(array2);
+    });
+
+    it("should work with empty arrays", () => {
+        const array1: unknown[] = [];
+        const array2: unknown[] = [];
+
+        expect(array1).toIncludeSameMembers(array2);
+    });
+});

tests/matchers/toIncludeSameMembers.ts

@@ -0,0 +1,61 @@
+import { expect } from "vitest";
+
+export function toIncludeSameMembers<T>(actual: T[], expected: T[]): { pass: boolean; message: () => string } {
+    if (!Array.isArray(actual)) {
+        return {
+            pass: false,
+            message: () => `Expected ${String(actual)} to be an array`,
+        };
+    }
+
+    if (!Array.isArray(expected)) {
+        return {
+            pass: false,
+            message: () => `Expected ${String(expected)} to be an array`,
+        };
+    }
+
+    if (actual.length !== expected.length) {
+        return {
+            pass: false,
+            message: () =>
+                `Expected arrays to have the same length.\nExpected: ${expected.length}\nReceived: ${actual.length}`,
+        };
+    }
+
+    // Create copies to avoid modifying original arrays
+    const actualCopy = [...actual];
+    const expectedCopy = [...expected];
+
+    // Sort both arrays for comparison
+    // Handle primitive values and objects differently
+    const sortComparator = (a: T, b: T): number => {
+        const aStr = JSON.stringify(a);
+        const bStr = JSON.stringify(b);
+        return aStr.localeCompare(bStr);
+    };
+
+    actualCopy.sort(sortComparator);
+    expectedCopy.sort(sortComparator);
+
+    // Check if sorted arrays are equal
+    const areEqual = actualCopy.every((item, index) => {
+        try {
+            expect(item).toEqual(expectedCopy[index]);
+            return true;
+        } catch {
+            return false;
+        }
+    });
+
+    return {
+        pass: areEqual,
+        message: () => {
+            if (areEqual) {
+                return `Expected arrays not to include the same members`;
+            } else {
+                return `Expected arrays to include the same members.\nExpected: ${JSON.stringify(expected)}\nReceived: ${JSON.stringify(actual)}`;
+            }
+        },
+    };
+}

tests/setup.ts

@@ -0,0 +1,7 @@
+import { expect } from "vitest";
+import { toIncludeSameMembers } from "./matchers/toIncludeSameMembers.js";
+
+// Extend vitest's expect with custom matchers
+expect.extend({
+    toIncludeSameMembers,
+});

tests/vitest.d.ts

@@ -0,0 +1,11 @@
+import "vitest";
+
+declare module "vitest" {
+    interface Assertion<T = unknown> {
+        toIncludeSameMembers<U>(expected: U[]): T;
+    }
+
+    interface AsymmetricMatchersContaining {
+        toIncludeSameMembers<T>(expected: T[]): unknown;
+    }
+}

vitest.config.ts

@@ -6,6 +6,7 @@ export default defineConfig({
         testTimeout: 3600000,
         hookTimeout: 3600000,
         include: ["**/*.test.ts"],
+        setupFiles: ["./tests/setup.ts"],
         coverage: {
             exclude: ["node_modules", "tests", "dist"],
             reporter: ["lcov"],