@better-auth/test-utils 1.5.0-beta.9

package/.turbo/turbo-build.log

@@ -0,0 +1,17 @@
+
+> @better-auth/test-utils@1.5.0-beta.9 build /home/runner/work/better-auth/better-auth/packages/test-utils
+> tsdown
+
+ℹ tsdown v0.19.0 powered by rolldown v1.0.0-beta.59
+ℹ config file: /home/runner/work/better-auth/better-auth/packages/test-utils/tsdown.config.ts 
+ℹ entry: src/adapter/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ dist/adapter.mjs               0.15 kB │ gzip: 0.10 kB
+ℹ dist/create-test-suite.mjs    15.94 kB │ gzip: 3.97 kB
+ℹ dist/test-adapter.mjs          8.11 kB │ gzip: 1.97 kB
+ℹ dist/adapter.d.mts             0.27 kB │ gzip: 0.16 kB
+ℹ dist/create-test-suite.d.mts   5.13 kB │ gzip: 1.69 kB
+ℹ dist/test-adapter.d.mts        2.17 kB │ gzip: 0.85 kB
+ℹ 6 files, total: 31.77 kB
+✔ Build complete in 10721ms

package/LICENSE.md

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+Copyright (c) 2024 - present, Bereket Engida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/dist/adapter.d.mts

@@ -0,0 +1,3 @@
+import { Logger, testAdapter } from "./test-adapter.mjs";
+import { InsertRandomFn, TestEntry, TestSuiteStats, createTestSuite } from "./create-test-suite.mjs";
+export { type InsertRandomFn, type Logger, type TestEntry, type TestSuiteStats, createTestSuite, testAdapter };

package/dist/adapter.mjs

@@ -0,0 +1,4 @@
+import { createTestSuite } from "./create-test-suite.mjs";
+import { testAdapter } from "./test-adapter.mjs";
+
+export { createTestSuite, testAdapter };

package/dist/create-test-suite.d.mts

@@ -0,0 +1,118 @@
+import { Logger } from "./test-adapter.mjs";
+import { Account, Session, User, Verification } from "@better-auth/core/db";
+import { DBAdapter } from "@better-auth/core/db/adapter";
+import { betterAuth } from "better-auth";
+import { BetterAuthOptions } from "@better-auth/core";
+
+//#region src/adapter/create-test-suite.d.ts
+
+/**
+ * Test entry type that supports both callback and object formats.
+ * Object format allows specifying migration options that will be applied before the test runs.
+ */
+type TestEntry = ((context: {
+  readonly skip: {
+    (note?: string | undefined): never;
+    (condition: boolean, note?: string | undefined): void;
+  };
+}) => Promise<void>) | {
+  migrateBetterAuth?: BetterAuthOptions;
+  test: (context: {
+    readonly skip: {
+      (note?: string | undefined): never;
+      (condition: boolean, note?: string | undefined): void;
+    };
+  }) => Promise<void>;
+};
+/**
+ * Statistics tracking for test suites.
+ */
+type TestSuiteStats = {
+  migrationCount: number;
+  totalMigrationTime: number;
+  testCount: number;
+  suiteStartTime: number;
+  suiteDuration: number;
+  suiteName: string;
+  groupingStats?: {
+    totalGroups: number;
+    averageTestsPerGroup: number;
+    largestGroupSize: number;
+    smallestGroupSize: number;
+    groupsWithMultipleTests: number;
+    totalTestsInGroups: number;
+  };
+};
+type GenerateFn = <M extends "user" | "session" | "verification" | "account">(Model: M) => Promise<M extends "user" ? User : M extends "session" ? Session : M extends "verification" ? Verification : M extends "account" ? Account : undefined>;
+type Success<T> = {
+  data: T;
+  error: null;
+};
+type Failure<E> = {
+  data: null;
+  error: E;
+};
+type Result<T, E = Error> = Success<T> | Failure<E>;
+type InsertRandomFn = <M extends "user" | "session" | "verification" | "account", Count extends number = 1>(model: M, count?: Count | undefined) => Promise<Count extends 1 ? M extends "user" ? [User] : M extends "session" ? [User, Session] : M extends "verification" ? [Verification] : M extends "account" ? [User, Account] : [undefined] : Array<M extends "user" ? [User] : M extends "session" ? [User, Session] : M extends "verification" ? [Verification] : M extends "account" ? [User, Account] : [undefined]>>;
+declare const createTestSuite: <Tests extends Record<string, TestEntry>, AdditionalOptions extends Record<string, any> = {}>(suiteName: string, config: {
+  defaultBetterAuthOptions?: BetterAuthOptions | undefined;
+  /**
+   * Helpful if the default better auth options require migrations to be run.
+   */
+  alwaysMigrate?: boolean | undefined;
+  prefixTests?: string | undefined;
+  customIdGenerator?: () => any | Promise<any> | undefined;
+}, tests: (helpers: {
+  adapter: DBAdapter<BetterAuthOptions>;
+  log: Logger;
+  generate: GenerateFn;
+  insertRandom: InsertRandomFn;
+  /**
+   * A light cleanup function that will only delete rows it knows about.
+   */
+  cleanup: () => Promise<void>;
+  /**
+   * A hard cleanup function that will delete all rows from the database.
+   */
+  hardCleanup: () => Promise<void>;
+  modifyBetterAuthOptions: (options: BetterAuthOptions, shouldRunMigrations: boolean) => Promise<BetterAuthOptions>;
+  getBetterAuthOptions: () => BetterAuthOptions;
+  sortModels: (models: Array<Record<string, any> & {
+    id: string;
+  }>, by?: ("id" | "createdAt") | undefined) => (Record<string, any> & {
+    id: string;
+  })[];
+  getAuth: () => Promise<ReturnType<typeof betterAuth>>;
+  tryCatch<T, E = Error>(promise: Promise<T>): Promise<Result<T, E>>;
+  customIdGenerator?: () => any | Promise<any> | undefined;
+  transformIdOutput?: (id: any) => string | undefined;
+  /**
+   * Some adapters may change the ID type, this function allows you to pass the entire model
+   * data and it will return the correct better-auth-expected transformed data.
+   *
+   * Eg:
+   * MongoDB uses ObjectId for IDs, but it's possible the user can disable that option in the adapter config.
+   * Because of this, the expected data would be a string.
+   * These sorts of conversions will cause issues with the test when you use the `generate` function.
+   * This is because the `generate` function will return the raw data expected to be saved in DB, not the excpected BA output.
+   */
+  transformGeneratedModel: (data: Record<string, any>) => Record<string, any>;
+}, additionalOptions?: AdditionalOptions | undefined) => Tests) => (options?: ({
+  disableTests?: Partial<Record<keyof Tests, boolean> & {
+    ALL?: boolean;
+  }>;
+} & AdditionalOptions) | undefined) => (helpers: {
+  adapter: () => Promise<DBAdapter<BetterAuthOptions>>;
+  log: Logger;
+  adapterDisplayName: string;
+  getBetterAuthOptions: () => BetterAuthOptions;
+  modifyBetterAuthOptions: (options: BetterAuthOptions) => Promise<BetterAuthOptions>;
+  cleanup: () => Promise<void>;
+  runMigrations: () => Promise<void>;
+  prefixTests?: string | undefined;
+  onTestFinish: (stats: TestSuiteStats) => Promise<void>;
+  customIdGenerator?: () => any | Promise<any> | undefined;
+  transformIdOutput?: (id: any) => string | undefined;
+}) => Promise<void>;
+//#endregion
+export { InsertRandomFn, TestEntry, TestSuiteStats, createTestSuite };

package/dist/create-test-suite.mjs

@@ -0,0 +1,461 @@
+import { getAuthTables } from "@better-auth/core/db";
+import { createAdapterFactory, deepmerge, initGetDefaultModelName } from "@better-auth/core/db/adapter";
+import { TTY_COLORS } from "@better-auth/core/env";
+import { generateId } from "@better-auth/core/utils/id";
+import { betterAuth } from "better-auth";
+import { test } from "vitest";
+
+//#region src/adapter/create-test-suite.ts
+/**
+* Deep equality comparison for BetterAuthOptions.
+* Handles nested objects, arrays, and primitive values.
+*/
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (a == null || b == null) return a === b;
+	if (typeof a !== typeof b) return false;
+	if (typeof a === "object") {
+		if (Array.isArray(a) !== Array.isArray(b)) return false;
+		if (Array.isArray(a)) {
+			if (a.length !== b.length) return false;
+			for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;
+			return true;
+		}
+		const keysA = Object.keys(a);
+		const keysB = Object.keys(b);
+		if (keysA.length !== keysB.length) return false;
+		for (const key of keysA) {
+			if (!keysB.includes(key)) return false;
+			if (!deepEqual(a[key], b[key])) return false;
+		}
+		return true;
+	}
+	return false;
+}
+async function tryCatch(promise) {
+	try {
+		return {
+			data: await promise,
+			error: null
+		};
+	} catch (error) {
+		return {
+			data: null,
+			error
+		};
+	}
+}
+const createTestSuite = (suiteName, config, tests) => {
+	return (options) => {
+		return async (helpers) => {
+			const createdRows = {};
+			let adapter = await helpers.adapter();
+			const wrapperAdapter = (overrideOptions) => {
+				const options$1 = deepmerge(deepmerge(helpers.getBetterAuthOptions(), config?.defaultBetterAuthOptions || {}), overrideOptions || {});
+				const adapterConfig = {
+					adapterId: helpers.adapterDisplayName,
+					...adapter.options?.adapterConfig || {},
+					adapterName: `Wrapped ${adapter.options?.adapterConfig.adapterName}`,
+					disableTransformOutput: true,
+					disableTransformInput: true,
+					disableTransformJoin: true
+				};
+				const adapterCreator = (options$2) => createAdapterFactory({
+					config: {
+						...adapterConfig,
+						transaction: adapter.transaction
+					},
+					adapter: ({ getDefaultModelName }) => {
+						adapter.transaction = void 0;
+						return {
+							count: async (args) => {
+								adapter = await helpers.adapter();
+								return await adapter.count(args);
+							},
+							deleteMany: async (args) => {
+								adapter = await helpers.adapter();
+								return await adapter.deleteMany(args);
+							},
+							delete: async (args) => {
+								adapter = await helpers.adapter();
+								return await adapter.delete(args);
+							},
+							findOne: async (args) => {
+								adapter = await helpers.adapter();
+								return await adapter.findOne(args);
+							},
+							findMany: async (args) => {
+								adapter = await helpers.adapter();
+								return await adapter.findMany(args);
+							},
+							update: async (args) => {
+								adapter = await helpers.adapter();
+								return await adapter.update(args);
+							},
+							updateMany: async (args) => {
+								adapter = await helpers.adapter();
+								return await adapter.updateMany(args);
+							},
+							createSchema: adapter.createSchema,
+							async create({ data, model, select }) {
+								const defaultModelName = getDefaultModelName(model);
+								adapter = await helpers.adapter();
+								const res = await adapter.create({
+									data,
+									model: defaultModelName,
+									select,
+									forceAllowId: true
+								});
+								createdRows[model] = [...createdRows[model] || [], res];
+								return res;
+							},
+							options: adapter.options
+						};
+					}
+				})(options$2);
+				return adapterCreator(options$1);
+			};
+			const resetDebugLogs = () => {
+				wrapperAdapter()?.adapterTestDebugLogs?.resetDebugLogs();
+			};
+			const printDebugLogs = () => {
+				wrapperAdapter()?.adapterTestDebugLogs?.printDebugLogs();
+			};
+			const cleanupCreatedRows = async () => {
+				adapter = await helpers.adapter();
+				for (const model of Object.keys(createdRows)) for (const row of createdRows[model]) {
+					const schema = getAuthTables(helpers.getBetterAuthOptions());
+					const getDefaultModelName = initGetDefaultModelName({
+						schema,
+						usePlural: adapter.options?.adapterConfig.usePlural
+					});
+					let defaultModelName;
+					try {
+						defaultModelName = getDefaultModelName(model);
+					} catch {
+						continue;
+					}
+					if (!schema[defaultModelName]) continue;
+					try {
+						await adapter.delete({
+							model,
+							where: [{
+								field: "id",
+								value: row.id
+							}]
+						});
+					} catch {}
+					if (createdRows[model].length === 1) delete createdRows[model];
+				}
+			};
+			let currentAppliedOptions = null;
+			const stats = {
+				migrationCount: 0,
+				totalMigrationTime: 0,
+				testCount: 0,
+				suiteStartTime: performance.now(),
+				suiteDuration: 0,
+				suiteName
+			};
+			/**
+			* Apply BetterAuth options and run migrations if needed.
+			* Tracks migration statistics.
+			*/
+			const applyOptionsAndMigrate = async (options$1, forceMigrate = false) => {
+				const finalOptions = deepmerge(config?.defaultBetterAuthOptions || {}, options$1 || {});
+				if (!deepEqual(currentAppliedOptions, finalOptions) || forceMigrate) {
+					adapter = await helpers.adapter();
+					await helpers.modifyBetterAuthOptions(finalOptions);
+					if (config.alwaysMigrate || forceMigrate) {
+						const migrationStart = performance.now();
+						await helpers.runMigrations();
+						const migrationTime = performance.now() - migrationStart;
+						stats.migrationCount++;
+						stats.totalMigrationTime += migrationTime;
+						adapter = await helpers.adapter();
+					}
+					currentAppliedOptions = finalOptions;
+				} else currentAppliedOptions = finalOptions;
+				return finalOptions;
+			};
+			const transformGeneratedModel = (data) => {
+				const newData = { ...data };
+				if (helpers.transformIdOutput) newData.id = helpers.transformIdOutput(newData.id);
+				return newData;
+			};
+			const idGenerator = async () => {
+				if (config.customIdGenerator) return config.customIdGenerator();
+				if (helpers.customIdGenerator) return helpers.customIdGenerator();
+				return generateId();
+			};
+			const generateModel = async (model) => {
+				const id = await idGenerator();
+				const randomDate = /* @__PURE__ */ new Date(Date.now() - Math.random() * 1e3 * 60 * 60 * 24 * 365);
+				if (model === "user") return {
+					id,
+					createdAt: randomDate,
+					updatedAt: /* @__PURE__ */ new Date(),
+					email: `user-${helpers.transformIdOutput?.(id) ?? id}@email.com`.toLowerCase(),
+					emailVerified: true,
+					name: `user-${helpers.transformIdOutput?.(id) ?? id}`,
+					image: null
+				};
+				if (model === "session") return {
+					id,
+					createdAt: randomDate,
+					updatedAt: /* @__PURE__ */ new Date(),
+					expiresAt: /* @__PURE__ */ new Date(),
+					token: generateId(32),
+					userId: generateId(),
+					ipAddress: "127.0.0.1",
+					userAgent: "Some User Agent"
+				};
+				if (model === "verification") return {
+					id,
+					createdAt: randomDate,
+					updatedAt: /* @__PURE__ */ new Date(),
+					expiresAt: /* @__PURE__ */ new Date(),
+					identifier: `test:${generateId()}`,
+					value: generateId()
+				};
+				if (model === "account") return {
+					id,
+					createdAt: randomDate,
+					updatedAt: /* @__PURE__ */ new Date(),
+					accountId: generateId(),
+					providerId: "test",
+					userId: generateId(),
+					accessToken: generateId(),
+					refreshToken: generateId(),
+					idToken: generateId(),
+					accessTokenExpiresAt: /* @__PURE__ */ new Date(),
+					refreshTokenExpiresAt: /* @__PURE__ */ new Date(),
+					scope: "test"
+				};
+				throw new Error(`Unknown model type: ${model}`);
+			};
+			const insertRandom = async (model, count = 1) => {
+				const res = [];
+				const a = wrapperAdapter();
+				for (let i = 0; i < count; i++) {
+					const modelResults = [];
+					if (model === "user") {
+						const user = await generateModel("user");
+						modelResults.push(await a.create({
+							data: user,
+							model: "user",
+							forceAllowId: true
+						}));
+					}
+					if (model === "session") {
+						const user = await generateModel("user");
+						const userRes = await a.create({
+							data: user,
+							model: "user",
+							forceAllowId: true
+						});
+						const session = await generateModel("session");
+						session.userId = userRes.id;
+						const sessionRes = await a.create({
+							data: session,
+							model: "session",
+							forceAllowId: true
+						});
+						modelResults.push(userRes, sessionRes);
+					}
+					if (model === "verification") {
+						const verification = await generateModel("verification");
+						modelResults.push(await a.create({
+							data: verification,
+							model: "verification",
+							forceAllowId: true
+						}));
+					}
+					if (model === "account") {
+						const user = await generateModel("user");
+						const account = await generateModel("account");
+						const userRes = await a.create({
+							data: user,
+							model: "user",
+							forceAllowId: true
+						});
+						account.userId = userRes.id;
+						const accRes = await a.create({
+							data: account,
+							model: "account",
+							forceAllowId: true
+						});
+						modelResults.push(userRes, accRes);
+					}
+					res.push(modelResults);
+				}
+				return res.length === 1 ? res[0] : res;
+			};
+			const sortModels = (models, by = "id") => {
+				return models.sort((a, b) => {
+					if (by === "createdAt") return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
+					return a.id.localeCompare(b.id);
+				});
+			};
+			const modifyBetterAuthOptions = async (opts, shouldRunMigrations) => {
+				return await applyOptionsAndMigrate(opts, shouldRunMigrations);
+			};
+			const additionalOptions = { ...options };
+			additionalOptions.disableTests = void 0;
+			const fullTests = tests({
+				adapter: new Proxy({}, { get(target, prop) {
+					const adapter$1 = wrapperAdapter();
+					if (prop === "transaction") return adapter$1.transaction;
+					const value = adapter$1[prop];
+					if (typeof value === "function") return value.bind(adapter$1);
+					return value;
+				} }),
+				getAuth: async () => {
+					adapter = await helpers.adapter();
+					return betterAuth({
+						...helpers.getBetterAuthOptions(),
+						...config?.defaultBetterAuthOptions || {},
+						database: (options$1) => {
+							return wrapperAdapter(options$1);
+						}
+					});
+				},
+				log: helpers.log,
+				generate: generateModel,
+				cleanup: cleanupCreatedRows,
+				hardCleanup: helpers.cleanup,
+				insertRandom,
+				modifyBetterAuthOptions,
+				getBetterAuthOptions: helpers.getBetterAuthOptions,
+				sortModels,
+				tryCatch,
+				customIdGenerator: helpers.customIdGenerator,
+				transformGeneratedModel,
+				transformIdOutput: helpers.transformIdOutput
+			}, additionalOptions);
+			const dash = `─`;
+			const allDisabled = options?.disableTests?.ALL ?? false;
+			test(`\n${TTY_COLORS.fg.white}${" ".repeat(3)}${dash.repeat(35)} [${TTY_COLORS.fg.magenta}${suiteName}${TTY_COLORS.fg.white}] ${dash.repeat(35)}`, async () => {
+				try {
+					await helpers.cleanup();
+				} catch {}
+				if (config.defaultBetterAuthOptions && !allDisabled) await applyOptionsAndMigrate(config.defaultBetterAuthOptions, config.alwaysMigrate);
+			});
+			/**
+			* Extract test function and migration options from a test entry.
+			*/
+			const extractTestEntry = (entry) => {
+				if (typeof entry === "function") return { testFn: entry };
+				return {
+					testFn: entry.test,
+					migrateBetterAuth: entry.migrateBetterAuth
+				};
+			};
+			const testEntries = Object.entries(fullTests).map(([name, entry]) => {
+				const { testFn, migrateBetterAuth } = extractTestEntry(entry);
+				return {
+					name,
+					testFn,
+					migrateBetterAuth
+				};
+			});
+			const groupTestsByMigrationOptions = () => {
+				const groups = [];
+				let currentGroup = null;
+				for (let i = 0; i < testEntries.length; i++) {
+					const { migrateBetterAuth } = testEntries[i];
+					if (allDisabled && options?.disableTests?.[testEntries[i].name] !== false || (options?.disableTests?.[testEntries[i].name] ?? false)) {
+						if (currentGroup) {
+							groups.push(currentGroup);
+							currentGroup = null;
+						}
+						groups.push({
+							migrationOptions: migrateBetterAuth,
+							testIndices: [i]
+						});
+						continue;
+					}
+					if (currentGroup && deepEqual(currentGroup.migrationOptions, migrateBetterAuth)) currentGroup.testIndices.push(i);
+					else {
+						if (currentGroup) groups.push(currentGroup);
+						currentGroup = {
+							migrationOptions: migrateBetterAuth,
+							testIndices: [i]
+						};
+					}
+				}
+				if (currentGroup) groups.push(currentGroup);
+				return groups;
+			};
+			const testGroups = groupTestsByMigrationOptions();
+			const calculateGroupingStats = () => {
+				const nonSkippedGroups = testGroups.filter((group) => group.testIndices.length > 0);
+				const groupSizes = nonSkippedGroups.map((group) => group.testIndices.length);
+				if (groupSizes.length === 0) return {
+					totalGroups: 0,
+					averageTestsPerGroup: 0,
+					largestGroupSize: 0,
+					smallestGroupSize: 0,
+					groupsWithMultipleTests: 0,
+					totalTestsInGroups: 0
+				};
+				const totalTestsInGroups = groupSizes.reduce((sum, size) => sum + size, 0);
+				const groupsWithMultipleTests = groupSizes.filter((size) => size > 1).length;
+				return {
+					totalGroups: nonSkippedGroups.length,
+					averageTestsPerGroup: totalTestsInGroups / nonSkippedGroups.length,
+					largestGroupSize: Math.max(...groupSizes),
+					smallestGroupSize: Math.min(...groupSizes),
+					groupsWithMultipleTests,
+					totalTestsInGroups
+				};
+			};
+			const onFinish = async (testName) => {
+				await cleanupCreatedRows();
+				if (testEntries.findIndex(({ name }) => name === testName) === testEntries.length - 1) {
+					stats.suiteDuration = performance.now() - stats.suiteStartTime;
+					stats.groupingStats = calculateGroupingStats();
+					await helpers.onTestFinish(stats);
+				}
+			};
+			let currentGroupMigrationOptions = null;
+			for (let i = 0; i < testEntries.length; i++) {
+				const { name: testName, testFn, migrateBetterAuth } = testEntries[i];
+				const testGroup = testGroups.find((group) => group.testIndices.includes(i));
+				const isFirstInGroup = testGroup && testGroup.testIndices[0] === i;
+				const shouldSkip = allDisabled && options?.disableTests?.[testName] !== false || (options?.disableTests?.[testName] ?? false);
+				let displayName = testName.replace(" - ", ` ${TTY_COLORS.dim}${dash}${TTY_COLORS.undim} `);
+				if (config.prefixTests) displayName = `${config.prefixTests} ${TTY_COLORS.dim}>${TTY_COLORS.undim} ${displayName}`;
+				if (helpers.prefixTests) displayName = `[${TTY_COLORS.dim}${helpers.prefixTests}${TTY_COLORS.undim}] ${displayName}`;
+				test.skipIf(shouldSkip)(displayName, { timeout: 3e4 }, async ({ onTestFailed, skip }) => {
+					resetDebugLogs();
+					await (async () => {
+						if (shouldSkip) return;
+						const thisMigration = deepmerge(config.defaultBetterAuthOptions || {}, migrateBetterAuth || {});
+						if (isFirstInGroup && testGroup) {
+							const groupMigrationOptions = testGroup.migrationOptions;
+							const groupFinalOptions = deepmerge(config.defaultBetterAuthOptions || {}, groupMigrationOptions || {});
+							if (!deepEqual(currentGroupMigrationOptions, groupMigrationOptions)) {
+								await applyOptionsAndMigrate(groupFinalOptions, true);
+								currentGroupMigrationOptions = groupMigrationOptions;
+							}
+						} else if (!deepEqual(currentGroupMigrationOptions, migrateBetterAuth)) {
+							await applyOptionsAndMigrate(thisMigration, true);
+							currentGroupMigrationOptions = migrateBetterAuth;
+						}
+					})();
+					stats.testCount++;
+					onTestFailed(async () => {
+						printDebugLogs();
+						await onFinish(testName);
+					});
+					await testFn({ skip });
+					await onFinish(testName);
+				});
+			}
+		};
+	};
+};
+
+//#endregion
+export { createTestSuite };