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,23 @@
+import { expect } from "vitest";
+
+export function toIncludeSameMembers<T>(actual: T[], expected: T[]): { pass: boolean; message: () => string } {
+    let pass = false;
+    try {
+        expect(actual).toEqual(expect.arrayContaining(expected as unknown[]));
+        expect(expected).toEqual(expect.arrayContaining(actual as unknown[]));
+        pass = true;
+    } catch {
+        pass = false;
+    }
+
+    return {
+        pass,
+        message: () => {
+            if (pass) {
+                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"],