@joystick.js/db-canary 0.0.0-canary.2209

package/tests/client/index.test.js

@@ -0,0 +1,1232 @@
+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/auth_manager.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;
+};
+
+test.beforeEach(async () => {
+  await reset_auth_state();
+  
+  // Clean up database files to ensure test isolation
+  try {
+    if (existsSync('./data/data.mdb')) {
+      unlinkSync('./data/data.mdb');
+    }
+    if (existsSync('./data/lock.mdb')) {
+      unlinkSync('./data/lock.mdb');
+    }
+  } catch (error) {
+    // Ignore cleanup errors
+  }
+});
+
+test.afterEach(async () => {
+  if (client) {
+    client.disconnect();
+    client = null;
+  }
+  
+  if (server) {
+    await server.cleanup();
+    server.close();
+    server = null;
+  }
+  
+  await reset_auth_state();
+});
+
+test('client can be created with custom options', (t) => {
+  client = joystickdb.client({
+    host: '127.0.0.1',
+    port: 9999,
+    timeout: 10000,
+    reconnect: false,
+    max_reconnect_attempts: 5,
+    reconnect_delay: 2000,
+    password: 'test_password',
+    auto_connect: false
+  });
+  
+  t.is(client.host, '127.0.0.1');
+  t.is(client.port, 9999);
+  t.is(client.timeout, 10000);
+  t.is(client.reconnect, false);
+  t.is(client.max_reconnect_attempts, 5);
+  t.is(client.reconnect_delay, 2000);
+  t.is(client.password, 'test_password');
+});
+
+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 result = await client.setup();
+  
+  t.is(result.ok, 1);
+  t.truthy(result.password);
+  t.truthy(result.message);
+});
+
+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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  t.is(client.is_authenticated, true);
+});
+
+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);
+    });
+  });
+  
+  const setup_client = joystickdb.client({
+    port: test_port,
+    reconnect: false
+  });
+  
+  await new Promise((resolve) => {
+    setup_client.on('connect', resolve);
+  });
+  
+  await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: 'invalid_password'
+  });
+  
+  const error = await new Promise((resolve) => {
+    client.on('error', resolve);
+  });
+  
+  t.truthy(error.message.includes('Authentication'));
+});
+
+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 result = await client.ping();
+  
+  t.is(result.ok, 1);
+});
+
+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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  const insert_result = await client.db('default').collection('test_collection').insert_one({
+    name: 'John Doe',
+    age: 30
+  });
+  
+  t.is(insert_result.ok, 1);
+  t.truthy(insert_result.inserted_id);
+  
+  const find_result = await client.db('default').collection('test_collection').find_one({
+    name: 'John Doe'
+  });
+  
+  t.is(find_result.name, 'John Doe');
+  t.is(find_result.age, 30);
+  
+  const update_result = await client.db('default').collection('test_collection').update_one({
+    name: 'John Doe'
+  }, {
+    $set: { age: 31 }
+  });
+  
+  t.is(update_result.ok, 1);
+  t.is(update_result.modified_count, 1);
+  
+  const updated_doc = await client.db('default').collection('test_collection').find_one({
+    name: 'John Doe'
+  });
+  
+  t.is(updated_doc.age, 31);
+  
+  const delete_result = await client.db('default').collection('test_collection').delete_one({
+    name: 'John Doe'
+  });
+  
+  t.is(delete_result.ok, 1);
+  t.is(delete_result.deleted_count, 1);
+  
+  const deleted_doc = await client.db('default').collection('test_collection').find_one({
+    name: 'John Doe'
+  });
+  
+  t.is(deleted_doc, null);
+});
+
+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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  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 });
+  
+  const find_result = await client.db('default').collection('test_collection').find({
+    category: 'test'
+  });
+  
+  t.truthy(find_result);
+  t.is(find_result.length, 3);
+  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));
+});
+
+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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  const bulk_operations = [
+    { insert_one: { document: { name: 'Alice', age: 25 } } },
+    { insert_one: { document: { name: 'Bob', age: 30 } } },
+    { insert_one: { document: { name: 'Charlie', age: 35 } } }
+  ];
+  
+  const bulk_result = await client.db('default').collection('test_collection').bulk_write(bulk_operations);
+  
+  t.is(bulk_result.ok, 1);
+  t.is(bulk_result.inserted_count, 3);
+  
+  const find_result = await client.db('default').collection('test_collection').find({});
+  t.truthy(find_result);
+  t.is(find_result.length, 3);
+});
+
+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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  const create_index_result = await client.db('default').collection('test_collection').create_index('name');
+  
+  t.is(create_index_result.ok, 1);
+  t.truthy(create_index_result.message);
+  
+  const get_indexes_result = await client.db('default').collection('test_collection').get_indexes();
+  
+  t.is(get_indexes_result.ok, 1);
+  t.truthy(get_indexes_result.indexes.find(index => index.field === 'name'));
+  
+  const drop_index_result = await client.db('default').collection('test_collection').drop_index('name');
+  
+  t.is(drop_index_result.ok, 1);
+  t.truthy(drop_index_result.message);
+});
+
+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 setup_client = joystickdb.client({
+    port: test_port,
+    reconnect: false
+  });
+  
+  await new Promise((resolve) => {
+    setup_client.on('connect', resolve);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  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 collections_result = await database.list_collections();
+  t.is(collections_result.ok, 1);
+  t.truthy(collections_result.collections.some(col => col.name === 'admin_test'));
+  
+  const documents_result = await database.list_documents('admin_test');
+  t.is(documents_result.ok, 1);
+  t.is(documents_result.documents.length, 1);
+  
+  const document_id = documents_result.documents[0]._id;
+  const get_doc_result = await database.get_document('admin_test', document_id);
+  t.is(get_doc_result.ok, 1);
+  t.is(get_doc_result.document.test, 'data');
+  
+  const query_result = await database.query_documents('admin_test', { test: 'data' });
+  t.is(query_result.ok, 1);
+  t.is(query_result.documents.length, 1);
+  
+  const insert_doc_result = await database.insert_document('admin_test', { admin: 'insert' });
+  t.is(insert_doc_result.ok, 1);
+  
+  const update_doc_result = await database.update_document('admin_test', document_id, { $set: { updated: true } });
+  t.is(update_doc_result.ok, 1);
+  
+  const delete_doc_result = await database.delete_document('admin_test', document_id);
+  t.is(delete_doc_result.ok, 1);
+});
+
+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);
+    });
+  });
+  
+  client = joystickdb.client({
+    port: test_port,
+    timeout: 100,
+    reconnect: false
+  });
+  
+  await new Promise((resolve) => {
+    client.on('connect', resolve);
+  });
+  
+  client.socket.write = () => {};
+  
+  const error = await t.throwsAsync(async () => {
+    await client.ping();
+  });
+  
+  t.is(error.message, 'Request timeout');
+});
+
+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 setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  const insert_promise = client.db('default').collection('queue_test').insert_one({ queued: true });
+  
+  t.is(client.request_queue.length, 1);
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  const result = await insert_promise;
+  
+  t.is(result.ok, 1);
+  t.is(client.request_queue.length, 0);
+});
+
+test('client handles connection errors gracefully', async (t) => {
+  client = joystickdb.client({
+    port: 9999,
+    reconnect: false,
+    timeout: 1000
+  });
+  
+  const error = await new Promise((resolve) => {
+    client.on('error', resolve);
+  });
+  
+  t.truthy(error);
+});
+
+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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  const reload_result = await client.reload();
+  
+  t.is(reload_result.ok, 1);
+  t.truthy(reload_result.message);
+});
+
+// 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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  const collection = client.db('default').collection('test_collection');
+  
+  t.truthy(collection);
+  t.is(collection.collection_name, 'test_collection');
+  t.is(collection.client, client);
+  t.is(typeof collection.insert_one, 'function');
+  t.is(typeof collection.find_one, 'function');
+  t.is(typeof collection.find, 'function');
+  t.is(typeof collection.update_one, 'function');
+  t.is(typeof collection.delete_one, 'function');
+  t.is(typeof collection.bulk_write, 'function');
+  t.is(typeof collection.create_index, 'function');
+  t.is(typeof collection.drop_index, 'function');
+  t.is(typeof collection.get_indexes, 'function');
+});
+
+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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  const collection = client.db('default').collection('chain_test');
+  
+  const insert_result = await collection.insert_one({
+    name: 'Jane Doe',
+    age: 25
+  });
+  
+  t.is(insert_result.ok, 1);
+  t.truthy(insert_result.inserted_id);
+  
+  const find_result = await collection.find_one({
+    name: 'Jane Doe'
+  });
+  
+  t.is(find_result.name, 'Jane Doe');
+  t.is(find_result.age, 25);
+  
+  const update_result = await collection.update_one({
+    name: 'Jane Doe'
+  }, {
+    $set: { age: 26 }
+  });
+  
+  t.is(update_result.ok, 1);
+  t.is(update_result.modified_count, 1);
+  
+  const updated_doc = await collection.find_one({
+    name: 'Jane Doe'
+  });
+  
+  t.is(updated_doc.age, 26);
+  
+  const delete_result = await collection.delete_one({
+    name: 'Jane Doe'
+  });
+  
+  t.is(delete_result.ok, 1);
+  t.is(delete_result.deleted_count, 1);
+  
+  const deleted_doc = await collection.find_one({
+    name: 'Jane Doe'
+  });
+  
+  t.is(deleted_doc, null);
+});
+
+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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  const collection = client.db('default').collection('chain_find_test');
+  
+  await collection.insert_one({ category: 'chain_test', value: 10 });
+  await collection.insert_one({ category: 'chain_test', value: 20 });
+  await collection.insert_one({ category: 'chain_test', value: 30 });
+  
+  const find_result = await collection.find({
+    category: 'chain_test'
+  });
+  
+  t.truthy(find_result);
+  t.is(find_result.length, 3);
+  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));
+});
+
+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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  const collection = client.db('default').collection('chain_bulk_test');
+  
+  const bulk_operations = [
+    { insert_one: { document: { name: 'Alice', age: 25 } } },
+    { insert_one: { document: { name: 'Bob', age: 30 } } },
+    { insert_one: { document: { name: 'Charlie', age: 35 } } }
+  ];
+  
+  const bulk_result = await collection.bulk_write(bulk_operations);
+  
+  t.is(bulk_result.ok, 1);
+  t.is(bulk_result.inserted_count, 3);
+  
+  const find_result = await collection.find({});
+  t.truthy(find_result);
+  t.is(find_result.length, 3);
+});
+
+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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  const collection = client.db('default').collection('chain_index_test');
+  
+  const create_index_result = await collection.create_index('email');
+  
+  t.is(create_index_result.ok, 1);
+  t.truthy(create_index_result.message);
+  
+  const get_indexes_result = await collection.get_indexes();
+  
+  t.is(get_indexes_result.ok, 1);
+  t.truthy(get_indexes_result.indexes.find(index => index.field === 'email'));
+  
+  const drop_index_result = await collection.drop_index('email');
+  
+  t.is(drop_index_result.ok, 1);
+  t.truthy(drop_index_result.message);
+});
+
+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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  // Test upsert creating new index
+  const create_result = await client.db('default').collection('upsert_test').upsert_index('email');
+  
+  t.is(create_result.ok, 1);
+  t.is(create_result.operation_type, 'created');
+  t.truthy(create_result.message.includes('created'));
+  
+  // Test upsert with same options (should be unchanged)
+  const unchanged_result = await client.db('default').collection('upsert_test').upsert_index('email');
+  
+  t.is(unchanged_result.ok, 1);
+  t.is(unchanged_result.operation_type, 'unchanged');
+  t.truthy(unchanged_result.message.includes('already exists'));
+  
+  // Test upsert with different options (should update)
+  const update_result = await client.db('default').collection('upsert_test').upsert_index('email', { unique: true });
+  
+  t.is(update_result.ok, 1);
+  t.is(update_result.operation_type, 'updated');
+  t.truthy(update_result.message.includes('updated'));
+  
+  // Verify the index was updated
+  const get_indexes_result = await client.db('default').collection('upsert_test').get_indexes();
+  
+  t.is(get_indexes_result.ok, 1);
+  const email_index = get_indexes_result.indexes.find(index => index.field === 'email');
+  t.truthy(email_index);
+  t.is(email_index.unique, true);
+});
+
+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 setup_client = joystickdb.client({
+    port: test_port,
+    reconnect: false
+  });
+  
+  await new Promise((resolve) => {
+    setup_client.on('connect', resolve);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  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');
+  
+  t.is(create_result.ok, 1);
+  t.is(create_result.operation_type, 'created');
+  t.truthy(create_result.message.includes('created'));
+  
+  // Test upsert with same options (should be unchanged)
+  const unchanged_result = await collection.upsert_index('name');
+  
+  t.is(unchanged_result.ok, 1);
+  t.is(unchanged_result.operation_type, 'unchanged');
+  t.truthy(unchanged_result.message.includes('already exists'));
+  
+  // Test upsert with different options (should update)
+  const update_result = await collection.upsert_index('name', { sparse: true });
+  
+  t.is(update_result.ok, 1);
+  t.is(update_result.operation_type, 'updated');
+  t.truthy(update_result.message.includes('updated'));
+  
+  // Verify the index was updated
+  const get_indexes_result = await collection.get_indexes();
+  
+  t.is(get_indexes_result.ok, 1);
+  const name_index = get_indexes_result.indexes.find(index => index.field === 'name');
+  t.truthy(name_index);
+  t.is(name_index.sparse, true);
+});
+
+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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  const collection = client.db('default').collection('unique_constraint_test');
+  
+  // Insert documents with duplicate values
+  await collection.insert_one({ email: 'duplicate@example.com', name: 'User 1' });
+  await collection.insert_one({ email: 'duplicate@example.com', name: 'User 2' });
+  
+  // Create non-unique index first
+  const create_result = await collection.upsert_index('email', { unique: false });
+  t.is(create_result.ok, 1);
+  t.is(create_result.operation_type, 'created');
+  
+  // Try to update to unique index - should fail due to duplicates
+  const error = await t.throwsAsync(async () => {
+    await collection.upsert_index('email', { unique: true });
+  });
+  
+  t.truthy(error.message.includes('Duplicate value for unique index'));
+});
+
+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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  const collection = client.db('default').collection('chain_options_test');
+  
+  const insert_result = await collection.insert_one({
+    name: 'Test User',
+    email: 'test@example.com'
+  }, { 
+    validate: true 
+  });
+  
+  t.is(insert_result.ok, 1);
+  t.truthy(insert_result.inserted_id);
+  
+  const find_result = await collection.find_one({
+    name: 'Test User'
+  }, {
+    projection: { name: 1 }
+  });
+  
+  t.is(find_result.name, 'Test User');
+  
+  const update_result = await collection.update_one({
+    name: 'Test User'
+  }, {
+    $set: { updated: true }
+  }, {
+    upsert: false
+  });
+  
+  t.is(update_result.ok, 1);
+  t.is(update_result.modified_count, 1);
+  
+  const delete_result = await collection.delete_one({
+    name: 'Test User'
+  }, {
+    limit: 1
+  });
+  
+  t.is(delete_result.ok, 1);
+  t.is(delete_result.deleted_count, 1);
+});
+
+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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  // Use database API style
+  const db_insert_result = await client.db('default').collection('mixed_test').insert_one({
+    method: 'db_api',
+    value: 100
+  });
+  
+  t.is(db_insert_result.ok, 1);
+  t.truthy(db_insert_result.inserted_id);
+  
+  // Use collection chaining API style
+  const collection = client.db('default').collection('mixed_test');
+  const collection_insert_result = await collection.insert_one({
+    method: 'collection_api',
+    value: 200
+  });
+  
+  t.is(collection_insert_result.ok, 1);
+  t.truthy(collection_insert_result.inserted_id);
+  
+  // Verify both documents exist using database API
+  const db_find_result = await client.db('default').collection('mixed_test').find({});
+  t.truthy(db_find_result);
+  t.is(db_find_result.length, 2);
+  
+  // Verify both documents exist using collection API
+  const collection_find_result = await collection.find({});
+  t.truthy(collection_find_result);
+  t.is(collection_find_result.length, 2);
+  
+  // Check specific documents
+  const db_doc = await client.db('default').collection('mixed_test').find_one({ method: 'db_api' });
+  const collection_doc = await collection.find_one({ method: 'collection_api' });
+  
+  t.is(db_doc.value, 100);
+  t.is(collection_doc.value, 200);
+});
+
+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);
+  });
+  
+  const setup_result = await setup_client.setup();
+  setup_client.disconnect();
+  
+  client = joystickdb.client({
+    port: test_port,
+    reconnect: false,
+    password: setup_result.password
+  });
+  
+  await new Promise((resolve) => {
+    client.on('authenticated', resolve);
+  });
+  
+  const collection = client.db('default').collection('error_test');
+  
+  // Test error handling by trying to update with invalid filter
+  const error = await t.throwsAsync(async () => {
+    await collection.update_one(null, { $set: { test: true } });
+  });
+  
+  t.truthy(error);
+});