@joystick.js/db-canary 0.0.0-canary.2242 → 0.0.0-canary.2244

package/tests/client/index.test.js

@@ -1230,3 +1230,396 @@ test('collection chaining API handles errors properly', async (t) => {
   
   t.truthy(error);
 });
+
+// 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);
+  });
+  
+  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);
+  });
+  
+  // Insert test documents
+  await client.db('default').collection('delete_many_test').insert_one({ group: 'admin', name: 'Alice' });
+  await client.db('default').collection('delete_many_test').insert_one({ group: 'admin', name: 'Bob' });
+  await client.db('default').collection('delete_many_test').insert_one({ group: 'user', name: 'Carol' });
+  
+  // Use main client delete_many method
+  const result = await client.delete_many('delete_many_test', { group: 'admin' });
+  
+  t.is(result.ok, 1);
+  t.is(result.deleted_count, 2);
+  t.truthy(result.operation_time);
+  
+  // Verify remaining documents
+  const remaining = await client.db('default').collection('delete_many_test').find({});
+  t.is(remaining.length, 1);
+  t.is(remaining[0].name, 'Carol');
+});
+
+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);
+  });
+  
+  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('delete_many_chain_test');
+  
+  // Insert test documents
+  await collection.insert_one({ status: 'inactive', name: 'User1' });
+  await collection.insert_one({ status: 'inactive', name: 'User2' });
+  await collection.insert_one({ status: 'inactive', name: 'User3' });
+  await collection.insert_one({ status: 'active', name: 'User4' });
+  
+  // Use collection chaining delete_many method
+  const result = await collection.delete_many({ status: 'inactive' });
+  
+  t.is(result.ok, 1);
+  t.is(result.deleted_count, 3);
+  t.truthy(result.operation_time);
+  
+  // Verify remaining documents
+  const remaining = await collection.find({});
+  t.is(remaining.length, 1);
+  t.is(remaining[0].name, 'User4');
+});
+
+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);
+  });
+  
+  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('delete_many_limit_test');
+  
+  // Insert test documents
+  await collection.insert_one({ category: 'temp', value: 1 });
+  await collection.insert_one({ category: 'temp', value: 2 });
+  await collection.insert_one({ category: 'temp', value: 3 });
+  await collection.insert_one({ category: 'temp', value: 4 });
+  
+  // Delete with limit
+  const result = await collection.delete_many({ category: 'temp' }, { limit: 2 });
+  
+  t.is(result.ok, 1);
+  t.is(result.deleted_count, 2);
+  
+  // Verify remaining documents
+  const remaining = await collection.find({});
+  t.is(remaining.length, 2);
+});
+
+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);
+  });
+  
+  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('delete_many_no_match_test');
+  
+  // Insert test documents
+  await collection.insert_one({ type: 'keep', name: 'Document1' });
+  await collection.insert_one({ type: 'keep', name: 'Document2' });
+  
+  // Try to delete non-matching documents
+  const result = await collection.delete_many({ type: 'nonexistent' });
+  
+  t.is(result.ok, 1);
+  t.is(result.deleted_count, 0);
+  t.truthy(result.operation_time);
+  
+  // Verify all documents remain
+  const remaining = await collection.find({});
+  t.is(remaining.length, 2);
+});
+
+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);
+  });
+  
+  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('delete_many_all_test');
+  
+  // Insert test documents
+  await collection.insert_one({ name: 'Doc1' });
+  await collection.insert_one({ name: 'Doc2' });
+  await collection.insert_one({ name: 'Doc3' });
+  
+  // Delete all documents with empty filter
+  const result = await collection.delete_many({});
+  
+  t.is(result.ok, 1);
+  t.is(result.deleted_count, 3);
+  
+  // Verify no documents remain
+  const remaining = await collection.find({});
+  t.is(remaining.length, 0);
+});
+
+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);
+  });
+  
+  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('delete_many_complex_test');
+  
+  // Insert test documents
+  await collection.insert_one({ age: 25, active: true, role: 'admin' });
+  await collection.insert_one({ age: 25, active: false, role: 'user' });
+  await collection.insert_one({ age: 30, active: true, role: 'admin' });
+  await collection.insert_one({ age: 30, active: true, role: 'user' });
+  
+  // Delete with complex filter
+  const result = await collection.delete_many({ age: 25, active: true });
+  
+  t.is(result.ok, 1);
+  t.is(result.deleted_count, 1);
+  
+  // Verify correct documents remain
+  const remaining = await collection.find({});
+  t.is(remaining.length, 3);
+  t.false(remaining.some(doc => doc.age === 25 && doc.active === true));
+});
+
+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);
+  });
+  
+  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('method_check_test');
+  
+  // Verify delete_many method exists
+  t.is(typeof collection.delete_many, 'function');
+  t.is(typeof client.delete_many, 'function');
+});
+
+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);
+  });
+  
+  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_handling_test');
+  
+  // Test invalid filter
+  const error1 = await t.throwsAsync(async () => {
+    await collection.delete_many(null);
+  });
+  t.truthy(error1.message.includes('Filter must be a valid object'));
+  
+  // Test invalid limit
+  const error2 = await t.throwsAsync(async () => {
+    await collection.delete_many({}, { limit: -1 });
+  });
+  t.truthy(error2.message.includes('Limit must be a non-negative number'));
+});

package/tests/server/cluster/master_read_write_operations.test.js

@@ -180,9 +180,10 @@ test.serial('master node handles read operations - find_one', async (t) => {
     });
     const find_response = await client.receive();
     t.is(find_response.ok, 1);
-    t.truthy(find_response.name, 'Response should have name field');
-    t.is(find_response.name, 'test_doc');
-    t.is(find_response.value, 42);
+    t.truthy(find_response.document, 'Response should have document field');
+    t.truthy(find_response.document.name, 'Document should have name field');
+    t.is(find_response.document.name, 'test_doc');
+    t.is(find_response.document.value, 42);
     
   } finally {
     if (client) {
@@ -410,8 +411,8 @@ test.serial('master node handles mixed read and write operations', async (t) =>
     });
     const find_response = await client.receive();
     t.is(find_response.ok, 1);
-    t.is(find_response.name, unique_doc_name);
-    t.is(find_response.status, 'active');
+    t.is(find_response.document.name, unique_doc_name);
+    t.is(find_response.document.status, 'active');
     
     // 3. Write: Update document
     client.send({ 
@@ -439,7 +440,7 @@ test.serial('master node handles mixed read and write operations', async (t) =>
     });
     const find_updated_response = await client.receive();
     t.is(find_updated_response.ok, 1);
-    t.is(find_updated_response.status, 'updated');
+    t.is(find_updated_response.document.status, 'updated');
     
     // 5. Write: Create index
     client.send({ 

package/tests/server/lib/operations/delete_many.test.js

@@ -0,0 +1,263 @@
+import test from 'ava';
+import sinon from 'sinon';
+import delete_many from '../../../../src/server/lib/operations/delete_many.js';
+import insert_one from '../../../../src/server/lib/operations/insert_one.js';
+import find from '../../../../src/server/lib/operations/find.js';
+import { initialize_database, get_database, cleanup_database } from '../../../../src/server/lib/query_engine.js';
+
+test.beforeEach(() => {
+  initialize_database('./test_data');
+  const db = get_database();
+  db.clearSync();
+});
+
+test.afterEach(async () => {
+  await cleanup_database();
+});
+
+test('delete_many - should delete multiple documents by filter', async (t) => {
+  await insert_one('default', 'users', { name: 'Alice', group: 'admin' });
+  await insert_one('default', 'users', { name: 'Bob', group: 'admin' });
+  await insert_one('default', 'users', { name: 'Carol', group: 'user' });
+  
+  const result = await delete_many('default', 'users', { group: 'admin' });
+  
+  t.true(result.acknowledged);
+  t.is(result.deleted_count, 2);
+  t.truthy(result.operation_time);
+  
+  const remaining_docs = await find('default', 'users', {});
+  t.is(remaining_docs.length, 1);
+  t.is(remaining_docs[0].name, 'Carol');
+});
+
+test('delete_many - should delete all documents with empty filter', async (t) => {
+  await insert_one('default', 'users', { name: 'Alice' });
+  await insert_one('default', 'users', { name: 'Bob' });
+  await insert_one('default', 'users', { name: 'Carol' });
+  
+  const result = await delete_many('default', 'users', {});
+  
+  t.true(result.acknowledged);
+  t.is(result.deleted_count, 3);
+  
+  const remaining_docs = await find('default', 'users', {});
+  t.is(remaining_docs.length, 0);
+});
+
+test('delete_many - should respect limit option', async (t) => {
+  await insert_one('default', 'users', { name: 'Alice', group: 'test' });
+  await insert_one('default', 'users', { name: 'Bob', group: 'test' });
+  await insert_one('default', 'users', { name: 'Carol', group: 'test' });
+  await insert_one('default', 'users', { name: 'Dan', group: 'test' });
+  
+  const result = await delete_many('default', 'users', { group: 'test' }, { limit: 2 });
+  
+  t.true(result.acknowledged);
+  t.is(result.deleted_count, 2);
+  
+  const remaining_docs = await find('default', 'users', {});
+  t.is(remaining_docs.length, 2);
+});
+
+test('delete_many - should return deleted_count 0 if no matches', async (t) => {
+  await insert_one('default', 'users', { name: 'Alice', group: 'admin' });
+  await insert_one('default', 'users', { name: 'Bob', group: 'user' });
+  
+  const result = await delete_many('default', 'users', { group: 'nonexistent' });
+  
+  t.true(result.acknowledged);
+  t.is(result.deleted_count, 0);
+  
+  const remaining_docs = await find('default', 'users', {});
+  t.is(remaining_docs.length, 2);
+});
+
+test('delete_many - should handle limit of 0', async (t) => {
+  await insert_one('default', 'users', { name: 'Alice', group: 'test' });
+  await insert_one('default', 'users', { name: 'Bob', group: 'test' });
+  
+  const result = await delete_many('default', 'users', { group: 'test' }, { limit: 0 });
+  
+  t.true(result.acknowledged);
+  t.is(result.deleted_count, 0);
+  
+  const remaining_docs = await find('default', 'users', {});
+  t.is(remaining_docs.length, 2);
+});
+
+test('delete_many - should handle limit of 1', async (t) => {
+  await insert_one('default', 'users', { name: 'Alice', group: 'test' });
+  await insert_one('default', 'users', { name: 'Bob', group: 'test' });
+  
+  const result = await delete_many('default', 'users', { group: 'test' }, { limit: 1 });
+  
+  t.true(result.acknowledged);
+  t.is(result.deleted_count, 1);
+  
+  const remaining_docs = await find('default', 'users', {});
+  t.is(remaining_docs.length, 1);
+});
+
+test('delete_many - should work with complex filters', async (t) => {
+  await insert_one('default', 'users', { name: 'Alice', age: 25, active: true });
+  await insert_one('default', 'users', { name: 'Bob', age: 30, active: true });
+  await insert_one('default', 'users', { name: 'Carol', age: 25, active: false });
+  await insert_one('default', 'users', { name: 'Dan', age: 30, active: false });
+  
+  const result = await delete_many('default', 'users', { age: 25, active: true });
+  
+  t.true(result.acknowledged);
+  t.is(result.deleted_count, 1);
+  
+  const remaining_docs = await find('default', 'users', {});
+  t.is(remaining_docs.length, 3);
+  t.false(remaining_docs.some(doc => doc.name === 'Alice'));
+});
+
+test('delete_many - should work across different collections', async (t) => {
+  await insert_one('default', 'users', { name: 'Alice', type: 'temp' });
+  await insert_one('default', 'users', { name: 'Bob', type: 'temp' });
+  await insert_one('default', 'posts', { title: 'Post 1', type: 'temp' });
+  await insert_one('default', 'posts', { title: 'Post 2', type: 'temp' });
+  
+  const users_result = await delete_many('default', 'users', { type: 'temp' });
+  const posts_result = await delete_many('default', 'posts', { type: 'temp' });
+  
+  t.is(users_result.deleted_count, 2);
+  t.is(posts_result.deleted_count, 2);
+  
+  const remaining_users = await find('default', 'users', {});
+  const remaining_posts = await find('default', 'posts', {});
+  t.is(remaining_users.length, 0);
+  t.is(remaining_posts.length, 0);
+});
+
+test('delete_many - should work with different databases', async (t) => {
+  await insert_one('db1', 'users', { name: 'Alice', group: 'test' });
+  await insert_one('db1', 'users', { name: 'Bob', group: 'test' });
+  await insert_one('db2', 'users', { name: 'Carol', group: 'test' });
+  await insert_one('db2', 'users', { name: 'Dan', group: 'test' });
+  
+  const db1_result = await delete_many('db1', 'users', { group: 'test' });
+  
+  t.is(db1_result.deleted_count, 2);
+  
+  const db1_remaining = await find('db1', 'users', {});
+  const db2_remaining = await find('db2', 'users', {});
+  t.is(db1_remaining.length, 0);
+  t.is(db2_remaining.length, 2);
+});
+
+test('delete_many - should handle documents with parsing errors gracefully', async (t) => {
+  const db = get_database();
+  
+  // Insert valid documents
+  await insert_one('default', 'users', { name: 'Alice', group: 'test' });
+  await insert_one('default', 'users', { name: 'Bob', group: 'test' });
+  
+  // Insert invalid JSON directly
+  db.put('default:users:invalid', 'invalid-json-data');
+  
+  const result = await delete_many('default', 'users', { group: 'test' });
+  
+  t.true(result.acknowledged);
+  t.is(result.deleted_count, 2);
+  
+  // Invalid document should still exist
+  const invalid_doc = db.get('default:users:invalid');
+  t.is(invalid_doc, 'invalid-json-data');
+});
+
+// Error handling tests
+test('delete_many - should throw if database name is missing', async (t) => {
+  await t.throwsAsync(
+    () => delete_many('', 'users', { name: 'Alice' }),
+    { message: 'Database name is required' }
+  );
+});
+
+test('delete_many - should throw if collection name is missing', async (t) => {
+  await t.throwsAsync(
+    () => delete_many('default', '', { name: 'Alice' }),
+    { message: 'Collection name is required' }
+  );
+});
+
+test('delete_many - should throw if filter is not an object', async (t) => {
+  await t.throwsAsync(
+    () => delete_many('default', 'users', null),
+    { message: 'Filter must be a valid object' }
+  );
+  
+  await t.throwsAsync(
+    () => delete_many('default', 'users', 'not-an-object'),
+    { message: 'Filter must be a valid object' }
+  );
+  
+  await t.throwsAsync(
+    () => delete_many('default', 'users', 123),
+    { message: 'Filter must be a valid object' }
+  );
+});
+
+test('delete_many - should throw if limit is not a valid number', async (t) => {
+  await t.throwsAsync(
+    () => delete_many('default', 'users', {}, { limit: -1 }),
+    { message: 'Limit must be a non-negative number' }
+  );
+  
+  await t.throwsAsync(
+    () => delete_many('default', 'users', {}, { limit: 'invalid' }),
+    { message: 'Limit must be a non-negative number' }
+  );
+  
+  await t.throwsAsync(
+    () => delete_many('default', 'users', {}, { limit: null }),
+    { message: 'Limit must be a non-negative number' }
+  );
+});
+
+// Performance and edge case tests
+test('delete_many - should handle large number of documents efficiently', async (t) => {
+  // Insert 100 documents
+  const insert_promises = [];
+  for (let i = 0; i < 100; i++) {
+    insert_promises.push(insert_one('default', 'users', { 
+      name: `User${i}`, 
+      group: i < 50 ? 'delete' : 'keep' 
+    }));
+  }
+  await Promise.all(insert_promises);
+  
+  const start_time = Date.now();
+  const result = await delete_many('default', 'users', { group: 'delete' });
+  const end_time = Date.now();
+  
+  t.true(result.acknowledged);
+  t.is(result.deleted_count, 50);
+  
+  const remaining_docs = await find('default', 'users', {});
+  t.is(remaining_docs.length, 50);
+  
+  // Should complete within reasonable time (less than 1 second)
+  t.true(end_time - start_time < 1000);
+});
+
+test('delete_many - should handle empty collection', async (t) => {
+  const result = await delete_many('default', 'empty_collection', {});
+  
+  t.true(result.acknowledged);
+  t.is(result.deleted_count, 0);
+  t.truthy(result.operation_time);
+});
+
+test('delete_many - should return proper operation_time format', async (t) => {
+  await insert_one('default', 'users', { name: 'Alice' });
+  
+  const result = await delete_many('default', 'users', {});
+  
+  t.truthy(result.operation_time);
+  t.true(typeof result.operation_time === 'string');
+  t.true(new Date(result.operation_time).getTime() > 0);
+});