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

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

@@ -0,0 +1,42 @@
+import test from 'ava';
+import sinon from 'sinon';
+import insert_one from '../../../../src/server/lib/operations/insert_one.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 (t) => {
+  await cleanup_database();
+});
+
+test('insert_one - should insert a document and return acknowledged', async (t) => {
+  const result = await insert_one('default', 'users', { name: 'Alice' });
+  t.true(result.acknowledged);
+  t.truthy(result.inserted_id);
+  const db = get_database();
+  const key = `default:users:${result.inserted_id}`;
+  const doc = JSON.parse(db.get(key));
+  t.is(doc.name, 'Alice');
+  t.is(doc._id, result.inserted_id);
+  t.truthy(doc._created_at);
+  t.truthy(doc._updated_at);
+});
+
+test('insert_one - should throw if collection name is missing', async (t) => {
+  await t.throwsAsync(() => insert_one('default', '', { name: 'Bob' }), { message: 'Collection name is required' });
+});
+
+test('insert_one - should throw if document is not an object', async (t) => {
+  await t.throwsAsync(() => insert_one('default', 'users', null), { message: 'Document must be a valid object' });
+  await t.throwsAsync(() => insert_one('default', 'users', 'not-an-object'), { message: 'Document must be a valid object' });
+});
+
+test('insert_one - should throw if document with same _id exists', async (t) => {
+  const doc = { _id: 'fixed_id', name: 'Carol' };
+  await insert_one('default', 'users', doc);
+  await t.throwsAsync(() => insert_one('default', 'users', doc), { message: 'Document with _id fixed_id already exists' });
+});

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

@@ -0,0 +1,89 @@
+import test from 'ava';
+import sinon from 'sinon';
+import update_one from '../../../../src/server/lib/operations/update_one.js';
+import insert_one from '../../../../src/server/lib/operations/insert_one.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 (t) => {
+  await cleanup_database();
+});
+
+test('update_one - should update a document with $set', async (t) => {
+  const { inserted_id } = await insert_one('default', 'users', { name: 'Alice', age: 20 });
+  const result = await update_one('default', 'users', { _id: inserted_id }, { $set: { age: 21 } });
+  t.true(result.acknowledged);
+  t.is(result.matched_count, 1);
+  t.is(result.modified_count, 1);
+  const db = get_database();
+  const doc = JSON.parse(db.get(`default:users:${inserted_id}`));
+  t.is(doc.age, 21);
+});
+
+test('update_one - should update a document with $unset', async (t) => {
+  const { inserted_id } = await insert_one('default', 'users', { name: 'Bob', age: 30 });
+  await update_one('default', 'users', { _id: inserted_id }, { $unset: { age: true } });
+  const db = get_database();
+  const doc = JSON.parse(db.get(`default:users:${inserted_id}`));
+  t.falsy(doc.age);
+});
+
+test('update_one - should update a document with $inc', async (t) => {
+  const { inserted_id } = await insert_one('default', 'users', { name: 'Carol', count: 1 });
+  await update_one('default', 'users', { _id: inserted_id }, { $inc: { count: 2 } });
+  const db = get_database();
+  const doc = JSON.parse(db.get(`default:users:${inserted_id}`));
+  t.is(doc.count, 3);
+});
+
+test('update_one - should update a document with $push', async (t) => {
+  const { inserted_id } = await insert_one('default', 'users', { name: 'Dan', tags: ['a'] });
+  await update_one('default', 'users', { _id: inserted_id }, { $push: { tags: 'b' } });
+  const db = get_database();
+  const doc = JSON.parse(db.get(`default:users:${inserted_id}`));
+  t.deepEqual(doc.tags, ['a', 'b']);
+});
+
+test('update_one - should update a document with $pull', async (t) => {
+  const { inserted_id } = await insert_one('default', 'users', { name: 'Eve', tags: ['a', 'b', 'c'] });
+  await update_one('default', 'users', { _id: inserted_id }, { $pull: { tags: 'b' } });
+  const db = get_database();
+  const doc = JSON.parse(db.get(`default:users:${inserted_id}`));
+  t.deepEqual(doc.tags, ['a', 'c']);
+});
+
+test('update_one - should upsert if no match and upsert option is true', async (t) => {
+  const result = await update_one('default', 'users', { name: 'Frank' }, { $set: { age: 40 } }, { upsert: true });
+  t.true(result.acknowledged);
+  t.is(result.matched_count, 0);
+  t.is(result.modified_count, 0);
+  t.truthy(result.upserted_id);
+  const db = get_database();
+  const doc = JSON.parse(db.get(`default:users:${result.upserted_id}`));
+  t.is(doc.name, 'Frank');
+  t.is(doc.age, 40);
+});
+
+test('update_one - should throw if collection name is missing', async (t) => {
+  await t.throwsAsync(() => update_one('default', '', { _id: 'x' }, { $set: { a: 1 } }), { message: 'Collection name is required' });
+});
+
+test('update_one - should throw if filter is not an object', async (t) => {
+  await t.throwsAsync(() => update_one('default', 'users', null, { $set: { a: 1 } }), { message: 'Filter must be a valid object' });
+  await t.throwsAsync(() => update_one('default', 'users', 'not-an-object', { $set: { a: 1 } }), { message: 'Filter must be a valid object' });
+});
+
+test('update_one - should throw if update is not an object', async (t) => {
+  await t.throwsAsync(() => update_one('default', 'users', { _id: 'x' }, null), { message: 'Update must be a valid object' });
+  await t.throwsAsync(() => update_one('default', 'users', { _id: 'x' }, 'not-an-object'), { message: 'Update must be a valid object' });
+});
+
+test('update_one - should throw on unsupported operator', async (t) => {
+  const { inserted_id } = await insert_one('default', 'users', { name: 'Grace' });
+  await t.throwsAsync(() => update_one('default', 'users', { _id: inserted_id }, { $foo: { a: 1 } }), { message: 'Unsupported update operator: $foo' });
+});

package/tests/server/lib/performance_monitor.test.js

@@ -0,0 +1,185 @@
+import test from 'ava';
+import { PerformanceMonitor } from '../../../src/server/lib/performance_monitor.js';
+
+test('PerformanceMonitor - should initialize with empty metrics', t => {
+  const monitor = new PerformanceMonitor();
+  const stats = monitor.get_performance_stats();
+  
+  t.is(stats.total_requests, 0);
+  t.is(stats.total_errors, 0);
+  t.is(stats.ops_per_second, 0);
+  t.is(stats.avg_response_time_ms, 0);
+  t.is(stats.error_rate_percent, 0);
+});
+
+test('PerformanceMonitor - should track successful operations', t => {
+  const monitor = new PerformanceMonitor();
+  
+  monitor.track_operation('find_one', 50, 'success');
+  monitor.track_operation('insert_one', 100, 'success');
+  
+  const stats = monitor.get_performance_stats();
+  
+  t.is(stats.total_requests, 2);
+  t.is(stats.total_errors, 0);
+  t.is(stats.error_rate_percent, 0);
+  t.true(stats.ops_per_second >= 0);
+  t.true(stats.avg_response_time_ms > 0);
+});
+
+test('PerformanceMonitor - should track failed operations', t => {
+  const monitor = new PerformanceMonitor();
+  
+  monitor.track_operation('find_one', 25, 'error', 'Document not found');
+  monitor.track_operation('insert_one', 75, 'success');
+  
+  const stats = monitor.get_performance_stats();
+  
+  t.is(stats.total_requests, 2);
+  t.is(stats.total_errors, 1);
+  t.is(stats.error_rate_percent, 50);
+  t.is(stats.top_errors.length, 1);
+  t.is(stats.top_errors[0].error, 'Document not found');
+  t.is(stats.top_errors[0].count, 1);
+});
+
+test('PerformanceMonitor - should track operation breakdown', t => {
+  const monitor = new PerformanceMonitor();
+  
+  monitor.track_operation('find_one', 50, 'success');
+  monitor.track_operation('find_one', 100, 'error', 'Timeout');
+  monitor.track_operation('insert_one', 75, 'success');
+  
+  const stats = monitor.get_performance_stats();
+  
+  t.truthy(stats.operations.find_one);
+  t.is(stats.operations.find_one.count, 2);
+  t.is(stats.operations.find_one.error_count, 1);
+  t.is(stats.operations.find_one.error_rate, 50);
+  t.is(stats.operations.find_one.avg_duration_ms, 75);
+  
+  t.truthy(stats.operations.insert_one);
+  t.is(stats.operations.insert_one.count, 1);
+  t.is(stats.operations.insert_one.error_count, 0);
+  t.is(stats.operations.insert_one.error_rate, 0);
+  t.is(stats.operations.insert_one.avg_duration_ms, 75);
+});
+
+test('PerformanceMonitor - should get memory stats', t => {
+  const monitor = new PerformanceMonitor();
+  const memory_stats = monitor.get_memory_stats();
+  
+  t.true(typeof memory_stats.rss_mb === 'number');
+  t.true(typeof memory_stats.heap_total_mb === 'number');
+  t.true(typeof memory_stats.heap_used_mb === 'number');
+  t.true(typeof memory_stats.heap_used_percent === 'number');
+  t.true(typeof memory_stats.external_mb === 'number');
+  
+  t.true(memory_stats.rss_mb > 0);
+  t.true(memory_stats.heap_total_mb > 0);
+  t.true(memory_stats.heap_used_mb > 0);
+  t.true(memory_stats.heap_used_percent >= 0 && memory_stats.heap_used_percent <= 100);
+});
+
+test('PerformanceMonitor - should get system stats', t => {
+  const monitor = new PerformanceMonitor();
+  const system_stats = monitor.get_system_stats();
+  
+  t.true(typeof system_stats.node_version === 'string');
+  t.true(typeof system_stats.platform === 'string');
+  t.true(typeof system_stats.arch === 'string');
+  t.true(typeof system_stats.pid === 'number');
+  t.true(typeof system_stats.cpu_user_ms === 'number');
+  t.true(typeof system_stats.cpu_system_ms === 'number');
+  
+  t.true(system_stats.pid > 0);
+  t.true(system_stats.cpu_user_ms >= 0);
+  t.true(system_stats.cpu_system_ms >= 0);
+});
+
+test('PerformanceMonitor - should log structured operations', t => {
+  const monitor = new PerformanceMonitor();
+  
+  // This should not throw
+  t.notThrows(() => {
+    monitor.log_structured_operation(
+      'client_123',
+      'find_one',
+      'users',
+      45,
+      'success',
+      null,
+      1024,
+      2048
+    );
+  });
+  
+  const stats = monitor.get_performance_stats();
+  t.is(stats.total_requests, 1);
+  t.is(stats.total_errors, 0);
+});
+
+test('PerformanceMonitor - should log structured operations with errors', t => {
+  const monitor = new PerformanceMonitor();
+  
+  monitor.log_structured_operation(
+    'client_456',
+    'insert_one',
+    'users',
+    100,
+    'error',
+    'Validation failed',
+    512,
+    0
+  );
+  
+  const stats = monitor.get_performance_stats();
+  t.is(stats.total_requests, 1);
+  t.is(stats.total_errors, 1);
+  t.is(stats.error_rate_percent, 100);
+});
+
+test('PerformanceMonitor - should reset metrics', t => {
+  const monitor = new PerformanceMonitor();
+  
+  monitor.track_operation('find_one', 50, 'success');
+  monitor.track_operation('insert_one', 100, 'error', 'Test error');
+  
+  let stats = monitor.get_performance_stats();
+  t.is(stats.total_requests, 2);
+  t.is(stats.total_errors, 1);
+  
+  monitor.reset_metrics();
+  
+  stats = monitor.get_performance_stats();
+  t.is(stats.total_requests, 0);
+  t.is(stats.total_errors, 0);
+  t.is(stats.ops_per_second, 0);
+  t.is(stats.avg_response_time_ms, 0);
+  t.is(stats.error_rate_percent, 0);
+});
+
+test('PerformanceMonitor - should limit response times array size', t => {
+  const monitor = new PerformanceMonitor();
+  
+  // Add more than max_response_times (1000) operations
+  for (let i = 0; i < 1200; i++) {
+    monitor.track_operation('test_op', 10, 'success');
+  }
+  
+  const stats = monitor.get_performance_stats();
+  t.is(stats.total_requests, 1200);
+  
+  // Response times array should be limited
+  t.true(monitor.metrics.response_times.length <= monitor.max_response_times);
+});
+
+test('PerformanceMonitor - should handle database stats gracefully', t => {
+  const monitor = new PerformanceMonitor();
+  
+  // This should not throw even if database is not available
+  t.notThrows(() => {
+    const db_stats = monitor.get_database_stats();
+    t.true(typeof db_stats === 'object');
+  });
+});

package/tests/server/lib/query_engine.test.js

@@ -0,0 +1,46 @@
+import test from 'ava';
+import sinon from 'sinon';
+import {
+  initialize_database,
+  get_database,
+  generate_document_id,
+  build_collection_key,
+  parse_collection_key,
+  cleanup_database
+} from '../../../src/server/lib/query_engine.js';
+
+test.afterEach(async () => {
+  // Clean up database connections after each test
+  await cleanup_database(true); // Remove test database directory
+});
+
+test('query_engine - should throw if get_database called before initialization', (t) => {
+  const original_db_instance = global.db_instance;
+  global.db_instance = null;
+  t.throws(() => get_database(), { message: 'Database not initialized. Call initialize_database first.' });
+  global.db_instance = original_db_instance;
+});
+
+test('query_engine - should initialize database and return instance', (t) => {
+  const db = initialize_database('./test_data');
+  t.truthy(db);
+});
+
+test('query_engine - should return same instance on multiple initialize calls', (t) => {
+  const db1 = initialize_database('./test_data');
+  const db2 = initialize_database('./test_data');
+  t.is(db1, db2);
+});
+
+test('query_engine - should generate unique document ids', (t) => {
+  const id1 = generate_document_id();
+  const id2 = generate_document_id();
+  t.not(id1, id2);
+});
+
+test('query_engine - should build and parse collection keys correctly', (t) => {
+  const key = build_collection_key('default', 'users', 'abc123');
+  t.is(key, 'default:users:abc123');
+  const parsed = parse_collection_key(key);
+  t.deepEqual(parsed, { database: 'default', collection: 'users', document_id: 'abc123' });
+});