@joystick.js/db-canary 0.0.0-canary.2299 → 0.0.0-canary.2301

package/tests/client/index.test.js

@@ -1,56 +1,44 @@
 import test from 'ava';
-import { create_server } from '../../src/server/index.js';
 import joystickdb from '../../src/client/index.js';
-import { writeFileSync, unlinkSync, existsSync } from 'fs';
-import { reset_auth_state } from '../../src/server/lib/user_auth_manager.js';
+import { create_server } from '../../src/server/index.js';
+import { create_isolated_test_context, wait_for_condition, retry_operation } from '../test_helpers.js';
+import { 
+  create_test_server,
+  create_test_client,
+  create_authenticated_test_client,
+  setup_test_authentication,
+  create_complete_test_environment,
+  create_crud_test_environment,
+  cleanup_test_client,
+  TEST_CONFIG
+} from '../common_test_utilities.js';
 
-let server;
-let client;
 
-// NOTE: Simple port allocation using a fixed range to avoid conflicts.
-let current_port = 2000;
-const get_next_port = () => {
-  return ++current_port;
-};
+let test_context;
+let client;
+let server_context;
 
-test.beforeEach(async () => {
-  await reset_auth_state();
-  
-  // Clean up database files to ensure test isolation
-  try {
-    if (existsSync('./.joystick/data/joystickdb_1983/data.mdb')) {
-      unlinkSync('./.joystick/data/joystickdb_1983/data.mdb');
-    }
-    if (existsSync('./.joystick/data/joystickdb_1983/lock.mdb')) {
-      unlinkSync('./.joystick/data/joystickdb_1983/lock.mdb');
-    }
-    // Also clean up old location for backward compatibility
-    if (existsSync('./data/data.mdb')) {
-      unlinkSync('./data/data.mdb');
-    }
-    if (existsSync('./data/lock.mdb')) {
-      unlinkSync('./data/lock.mdb');
-    }
-  } catch (error) {
-    // Ignore cleanup errors
-  }
+test.beforeEach(async (t) => {
+  const test_name = `client_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  test_context = await create_isolated_test_context(test_name);
+  t.context = test_context;
 });
 
-test.afterEach(async () => {
+test.afterEach(async (t) => {
   if (client) {
-    client.disconnect();
+    await cleanup_test_client(client, t.title);
     client = null;
   }
   
-  if (server) {
-    await server.cleanup();
-    await new Promise((resolve) => {
-      server.close(resolve);
-    });
-    server = null;
+  if (server_context) {
+    await server_context.cleanup();
+    server_context = null;
   }
   
-  await reset_auth_state();
+  if (test_context) {
+    await test_context.cleanup();
+    test_context = null;
+  }
 });
 
 test('client can be created with custom options and authentication object', (t) => {
@@ -91,14 +79,7 @@ test('client rejects old password-only authentication format', (t) => {
 });
 
 test('client can setup initial admin and authenticate with username/password', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
+  const test_port = t.context.port;
   
   client = joystickdb.client({
     port: test_port,
@@ -139,34 +120,15 @@ test('client can setup initial admin and authenticate with username/password', a
 });
 
 test('client authentication fails with invalid username/password', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  // Setup admin first
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123'
+  const env = await create_complete_test_environment({
+    test_name: 'client_auth_fails_invalid_password',
+    setup_auth: true
   });
-  setup_client.disconnect();
+  server_context = env.server;
   
   // Try to connect with invalid credentials
   client = joystickdb.client({
-    port: test_port,
+    port: env.port,
     reconnect: false,
     authentication: {
       username: 'admin',
@@ -179,51 +141,19 @@ test('client authentication fails with invalid username/password', async (t) =>
   });
   
   t.truthy(error.message.includes('Authentication') || error.message.includes('Invalid credentials'));
+  
+  await env.cleanup();
 });
 
 test('client can create and authenticate multiple users', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  // Setup admin
-  const admin_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    admin_client.on('connect', resolve);
-  });
-  
-  await admin_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123'
-  });
-  
-  admin_client.disconnect();
-  
-  // Connect as admin
-  const admin_auth_client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    admin_auth_client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_multiple_users_auth',
+    setup_auth: true
   });
+  server_context = env.server;
   
-  // Create regular user
-  const create_user_result = await admin_auth_client.admin('create_user', {
+  // Create regular user using admin client
+  const create_user_result = await env.client.client.admin('create_user', {
     username: 'user1',
     password: 'user123',
     email: 'user1@test.com'
@@ -232,11 +162,9 @@ test('client can create and authenticate multiple users', async (t) => {
   t.is(create_user_result.ok, 1);
   t.truthy(create_user_result.message.includes('User created successfully'));
   
-  admin_auth_client.disconnect();
-  
   // Connect as the new user
   client = joystickdb.client({
-    port: test_port,
+    port: env.port,
     reconnect: false,
     authentication: {
       username: 'user1',
@@ -249,26 +177,17 @@ test('client can create and authenticate multiple users', async (t) => {
   });
   
   t.is(client.is_authenticated, true);
+  
+  await env.cleanup();
 });
 
 test('client can setup authentication', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    client.on('connect', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_setup_auth',
+    setup_auth: false
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const result = await client.admin('setup_initial_admin', {
     username: 'admin',
@@ -278,80 +197,33 @@ test('client can setup authentication', async (t) => {
   
   t.is(result.ok, 1);
   t.truthy(result.message.includes('Initial admin user created'));
+  
+  await env.cleanup();
 });
 
 test('client can authenticate with valid password', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  // Connect with authentication object format
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_valid_password_auth',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   t.is(client.is_authenticated, true);
+  
+  await env.cleanup();
 });
 
 test('client authentication fails with invalid password', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  // Setup admin first
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123'
+  const env = await create_complete_test_environment({
+    test_name: 'client_invalid_password_auth',
+    setup_auth: true
   });
-  setup_client.disconnect();
+  server_context = env.server;
   
   // Try with invalid password using authentication object
   client = joystickdb.client({
-    port: test_port,
+    port: env.port,
     reconnect: false,
     authentication: {
       username: 'admin',
@@ -364,58 +236,34 @@ test('client authentication fails with invalid password', async (t) => {
   });
   
   t.truthy(error.message.includes('Authentication'));
+  
+  await env.cleanup();
 });
 
 test('client can perform ping operation', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    client.on('connect', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_ping_operation',
+    setup_auth: false
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const result = await client.ping();
   
   t.is(result.ok, 1);
+  
+  await env.cleanup();
 });
 
 test('client can perform CRUD operations', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
+  // Use isolated test context instead of manual server setup
+  const crud_context = await create_isolated_test_context(
+    `crud_test_${Date.now()}`, 
+    { setup_auth: true }
+  );
+  const test_port = crud_context.port;
+  
+  // Skip auth setup since isolated context handles it
   client = joystickdb.client({
     port: test_port,
     reconnect: false,
@@ -425,9 +273,12 @@ test('client can perform CRUD operations', async (t) => {
     }
   });
   
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
-  });
+  await wait_for_condition(
+    () => client.is_authenticated,
+    5000,
+    100,
+    'client authentication'
+  );
   
   const insert_result = await client.db('default').collection('test_collection').insert_one({
     name: 'John Doe',
@@ -474,49 +325,20 @@ test('client can perform CRUD operations', async (t) => {
 });
 
 test('client can perform find operation with multiple results', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
+  // Use complete test environment for simplified setup
+  const env = await create_complete_test_environment({
+    test_name: 'find_multiple_results',
+    setup_auth: true
   });
   
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
-  });
+  client = env.client.client;
+  server_context = env.server;
   
-  await client.db('default').collection('test_collection').insert_one({ category: 'test', value: 1 });
-  await client.db('default').collection('test_collection').insert_one({ category: 'test', value: 2 });
-  await client.db('default').collection('test_collection').insert_one({ category: 'test', value: 3 });
+  await env.client.client.db('default').collection('test_collection').insert_one({ category: 'test', value: 1 });
+  await env.client.client.db('default').collection('test_collection').insert_one({ category: 'test', value: 2 });
+  await env.client.client.db('default').collection('test_collection').insert_one({ category: 'test', value: 3 });
   
-  const find_result = await client.db('default').collection('test_collection').find({
+  const find_result = await env.client.client.db('default').collection('test_collection').find({
     category: 'test'
   });
   
@@ -525,46 +347,18 @@ test('client can perform find operation with multiple results', async (t) => {
   t.truthy(find_result.find(doc => doc.value === 1));
   t.truthy(find_result.find(doc => doc.value === 2));
   t.truthy(find_result.find(doc => doc.value === 3));
+  
+  await env.cleanup();
 });
 
 test('client can perform bulk write operations', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
+  env = await create_complete_test_environment({
+    test_name: 'bulk_write_operations',
+    setup_auth: true
   });
-  setup_client.disconnect();
   
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
-  });
+  client = env.client.client;
+  server_context = env.server;
   
   const bulk_operations = [
     { insert_one: { document: { name: 'Alice', age: 25 } } },
@@ -580,46 +374,17 @@ test('client can perform bulk write operations', async (t) => {
   const find_result = await client.db('default').collection('test_collection').find({});
   t.truthy(find_result);
   t.is(find_result.length, 3);
+  
+  await env.cleanup();
 });
 
 test('client can perform index operations', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_index_operations',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const create_index_result = await client.db('default').collection('test_collection').create_index('name');
   
@@ -635,54 +400,25 @@ test('client can perform index operations', async (t) => {
   
   t.is(drop_index_result.ok, 1);
   t.truthy(drop_index_result.message);
+  
+  await env.cleanup();
 });
 
 test('client can perform admin operations', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
+  const env = await create_complete_test_environment({
+    test_name: 'client_admin_operations',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
+  await client.db('default').collection('admin_test').insert_one({ test: 'data' });
   
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
+  const database = client.db('default');
   
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
-  });
-  
-  await client.db('default').collection('admin_test').insert_one({ test: 'data' });
-  
-  const database = client.db('default');
-  
-  const stats_result = await database.get_stats();
-  t.is(stats_result.ok, 1);
-  t.truthy(stats_result.database);
+  const stats_result = await database.get_stats();
+  t.is(stats_result.ok, 1);
+  t.truthy(stats_result.database);
   
   const collections_result = await database.list_collections();
   t.is(collections_result.ok, 1);
@@ -709,20 +445,19 @@ test('client can perform admin operations', async (t) => {
   
   const delete_doc_result = await database.delete_document('admin_test', document_id);
   t.is(delete_doc_result.ok, 1);
+  
+  await env.cleanup();
 });
 
 test('client handles request timeout', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
+  const env = await create_complete_test_environment({
+    test_name: 'client_request_timeout',
+    setup_auth: false
   });
+  server_context = env.server;
   
   client = joystickdb.client({
-    port: test_port,
+    port: env.port,
     timeout: 100,
     reconnect: false
   });
@@ -738,36 +473,19 @@ test('client handles request timeout', async (t) => {
   });
   
   t.is(error.message, 'Request timeout');
+  
+  await env.cleanup();
 });
 
 test('client queues requests when not authenticated', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_request_queuing',
+    setup_auth: true
   });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
+  server_context = env.server;
   
   client = joystickdb.client({
-    port: test_port,
+    port: env.port,
     reconnect: false,
     authentication: {
       username: 'admin',
@@ -787,6 +505,8 @@ test('client queues requests when not authenticated', async (t) => {
   
   t.is(result.ok, 1);
   t.is(client.request_queue.length, 0);
+  
+  await env.cleanup();
 });
 
 test('client handles connection errors gracefully', async (t) => {
@@ -804,89 +524,29 @@ test('client handles connection errors gracefully', async (t) => {
 });
 
 test('client can reload server configuration', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_reload_configuration',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const reload_result = await client.reload();
   
   t.is(reload_result.ok, 1);
   t.truthy(reload_result.message);
+  
+  await env.cleanup();
 });
 
 // NOTE: Collection chaining API tests.
 test('client.collection() returns a collection interface', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'collection_interface_test',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const collection = client.db('default').collection('test_collection');
   
@@ -902,46 +562,17 @@ test('client.collection() returns a collection interface', async (t) => {
   t.is(typeof collection.create_index, 'function');
   t.is(typeof collection.drop_index, 'function');
   t.is(typeof collection.get_indexes, 'function');
+  
+  await env.cleanup();
 });
 
 test('collection chaining API can perform CRUD operations', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'collection_chaining_crud',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const collection = client.db('default').collection('chain_test');
   
@@ -987,46 +618,17 @@ test('collection chaining API can perform CRUD operations', async (t) => {
   });
   
   t.is(deleted_doc, null);
+  
+  await env.cleanup();
 });
 
 test('collection chaining API can perform find operation with multiple results', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'collection_chaining_find_multiple',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const collection = client.db('default').collection('chain_find_test');
   
@@ -1043,46 +645,17 @@ test('collection chaining API can perform find operation with multiple results',
   t.truthy(find_result.find(doc => doc.value === 10));
   t.truthy(find_result.find(doc => doc.value === 20));
   t.truthy(find_result.find(doc => doc.value === 30));
+  
+  await env.cleanup();
 });
 
 test('collection chaining API can perform bulk write operations', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'collection_chaining_bulk_write',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const collection = client.db('default').collection('chain_bulk_test');
   
@@ -1100,46 +673,17 @@ test('collection chaining API can perform bulk write operations', async (t) => {
   const find_result = await collection.find({});
   t.truthy(find_result);
   t.is(find_result.length, 3);
+  
+  await env.cleanup();
 });
 
 test('collection chaining API can perform index operations', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'collection_chaining_index_ops',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const collection = client.db('default').collection('chain_index_test');
   
@@ -1157,46 +701,17 @@ test('collection chaining API can perform index operations', async (t) => {
   
   t.is(drop_index_result.ok, 1);
   t.truthy(drop_index_result.message);
+  
+  await env.cleanup();
 });
 
 test('client can perform upsert_index operations', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_upsert_index_operations',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   // Test upsert creating new index
   const create_result = await client.db('default').collection('upsert_test').upsert_index('email');
@@ -1226,51 +741,22 @@ test('client can perform upsert_index operations', async (t) => {
   const email_index = get_indexes_result.indexes.find(index => index.field === 'email');
   t.truthy(email_index);
   t.is(email_index.unique, true);
+  
+  await env.cleanup();
 });
 
 test('collection chaining API can perform upsert_index operations', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
+  const env = await create_complete_test_environment({
+    test_name: 'collection_chaining_upsert_index',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
+  const collection = client.db('default').collection('chain_upsert_test');
   
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
-  });
-  
-  const collection = client.db('default').collection('chain_upsert_test');
-  
-  // Test upsert creating new index
-  const create_result = await collection.upsert_index('name');
+  // Test upsert creating new index
+  const create_result = await collection.upsert_index('name');
   
   t.is(create_result.ok, 1);
   t.is(create_result.operation_type, 'created');
@@ -1297,46 +783,17 @@ test('collection chaining API can perform upsert_index operations', async (t) =>
   const name_index = get_indexes_result.indexes.find(index => index.field === 'name');
   t.truthy(name_index);
   t.is(name_index.sparse, true);
+  
+  await env.cleanup();
 });
 
 test('upsert_index handles unique constraint violations properly', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'upsert_index_unique_constraint_violations',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const collection = client.db('default').collection('unique_constraint_test');
   
@@ -1355,46 +812,17 @@ test('upsert_index handles unique constraint violations properly', async (t) =>
   });
   
   t.truthy(error.message.includes('Duplicate value for unique index'));
+  
+  await env.cleanup();
 });
 
 test('collection chaining API works with options', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'collection_chaining_with_options',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const collection = client.db('default').collection('chain_options_test');
   
@@ -1435,46 +863,17 @@ test('collection chaining API works with options', async (t) => {
   
   t.is(delete_result.ok, 1);
   t.is(delete_result.deleted_count, 1);
+  
+  await env.cleanup();
 });
 
 test('both old and new API styles work simultaneously', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'mixed_api_styles_simultaneous',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   // Use database API style
   const db_insert_result = await client.db('default').collection('mixed_test').insert_one({
@@ -1511,46 +910,17 @@ test('both old and new API styles work simultaneously', async (t) => {
   
   t.is(db_doc.value, 100);
   t.is(collection_doc.value, 200);
+  
+  await env.cleanup();
 });
 
 test('collection chaining API handles errors properly', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'collection_chaining_error_handling',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const collection = client.db('default').collection('error_test');
   
@@ -1560,6 +930,8 @@ test('collection chaining API handles errors properly', async (t) => {
   });
   
   t.truthy(error);
+  
+  await env.cleanup();
 });
 
 // list_databases operation tests
@@ -1576,43 +948,12 @@ test('client has list_databases method available', (t) => {
 });
 
 test('client can perform list_databases operation', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_list_databases_operation',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const result = await client.list_databases();
   
@@ -1620,46 +961,17 @@ test('client can perform list_databases operation', async (t) => {
   t.truthy(result.databases);
   t.true(Array.isArray(result.databases));
   t.truthy(result.databases.some(db => db.name === 'default'));
+  
+  await env.cleanup();
 });
 
 test('client list_databases returns default database after data insertion', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_list_databases_after_data_insertion',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   // Insert some data to ensure default database exists
   await client.db('default').collection('test_data').insert_one({ test: 'value' });
@@ -1674,46 +986,17 @@ test('client list_databases returns default database after data insertion', asyn
   t.truthy(default_db);
   t.is(default_db.name, 'default');
   t.truthy(default_db.collections_count >= 1);
+  
+  await env.cleanup();
 });
 
 test('client list_databases method is properly bound to instance', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_list_databases_method_binding',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   // Test method exists and is callable
   t.is(typeof client.list_databases, 'function');
@@ -1729,47 +1012,18 @@ test('client list_databases method is properly bound to instance', async (t) =>
   // Test calling the destructured method (this would fail if binding is wrong)
   const result2 = await list_databases.call(client);
   t.is(result2.ok, 1);
+  
+  await env.cleanup();
 });
 
 // delete_many operation tests
 test('client can perform delete_many operation via main client method', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_delete_many_main_method',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   // Insert test documents
   await client.db('default').collection('delete_many_test').insert_one({ group: 'admin', name: 'Alice' });
@@ -1787,46 +1041,17 @@ test('client can perform delete_many operation via main client method', async (t
   const remaining = await client.db('default').collection('delete_many_test').find({});
   t.is(remaining.length, 1);
   t.is(remaining[0].name, 'Carol');
+  
+  await env.cleanup();
 });
 
 test('client can perform delete_many operation via collection chaining', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_delete_many_collection_chaining',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const collection = client.db('default').collection('delete_many_chain_test');
   
@@ -1847,46 +1072,17 @@ test('client can perform delete_many operation via collection chaining', async (
   const remaining = await collection.find({});
   t.is(remaining.length, 1);
   t.is(remaining[0].name, 'User4');
+  
+  await env.cleanup();
 });
 
 test('client delete_many respects limit option', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_delete_many_limit_option',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const collection = client.db('default').collection('delete_many_limit_test');
   
@@ -1905,46 +1101,17 @@ test('client delete_many respects limit option', async (t) => {
   // Verify remaining documents
   const remaining = await collection.find({});
   t.is(remaining.length, 2);
+  
+  await env.cleanup();
 });
 
 test('client delete_many returns zero count when no matches', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_delete_many_no_matches',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const collection = client.db('default').collection('delete_many_no_match_test');
   
@@ -1962,46 +1129,17 @@ test('client delete_many returns zero count when no matches', async (t) => {
   // Verify all documents remain
   const remaining = await collection.find({});
   t.is(remaining.length, 2);
+  
+  await env.cleanup();
 });
 
 test('client delete_many deletes all documents with empty filter', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_delete_many_empty_filter',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const collection = client.db('default').collection('delete_many_all_test');
   
@@ -2019,46 +1157,17 @@ test('client delete_many deletes all documents with empty filter', async (t) =>
   // Verify no documents remain
   const remaining = await collection.find({});
   t.is(remaining.length, 0);
+  
+  await env.cleanup();
 });
 
 test('client delete_many handles complex filters', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_delete_many_complex_filters',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const collection = client.db('default').collection('delete_many_complex_test');
   
@@ -2078,92 +1187,34 @@ test('client delete_many handles complex filters', async (t) => {
   const remaining = await collection.find({});
   t.is(remaining.length, 3);
   t.false(remaining.some(doc => doc.age === 25 && doc.active === true));
+  
+  await env.cleanup();
 });
 
 test('client delete_many method exists on collection interface', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_delete_many_method_exists',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const collection = client.db('default').collection('method_check_test');
   
   // Verify delete_many method exists
   t.is(typeof collection.delete_many, 'function');
   t.is(typeof client.delete_many, 'function');
+  
+  await env.cleanup();
 });
 
 test('client delete_many handles error scenarios properly', async (t) => {
-  const test_port = get_next_port();
-  server = await create_server();
-  
-  await new Promise((resolve) => {
-    server.listen(test_port, () => {
-      setTimeout(resolve, 100);
-    });
-  });
-  
-  const setup_client = joystickdb.client({
-    port: test_port,
-    reconnect: false
-  });
-  
-  await new Promise((resolve) => {
-    setup_client.on('connect', resolve);
-  });
-  
-  await setup_client.admin('setup_initial_admin', {
-    username: 'admin',
-    password: 'admin123',
-    email: 'admin@test.com'
-  });
-  setup_client.disconnect();
-  
-  client = joystickdb.client({
-    port: test_port,
-    reconnect: false,
-    authentication: {
-      username: 'admin',
-      password: 'admin123'
-    }
-  });
-  
-  await new Promise((resolve) => {
-    client.on('authenticated', resolve);
+  const env = await create_complete_test_environment({
+    test_name: 'client_delete_many_error_scenarios',
+    setup_auth: true
   });
+  client = env.client.client;
+  server_context = env.server;
   
   const collection = client.db('default').collection('error_handling_test');
   
@@ -2178,4 +1229,6 @@ test('client delete_many handles error scenarios properly', async (t) => {
     await collection.delete_many({}, { limit: -1 });
   });
   t.truthy(error2.message.includes('Limit must be a non-negative number'));
+  
+  await env.cleanup();
 });