fix(tsmdb): add comprehensive unit tests for tsmdb components: checksum, query planner, index engine, session, and WAL
This commit is contained in:
273
test/test.tsmdb.queryplanner.ts
Normal file
273
test/test.tsmdb.queryplanner.ts
Normal file
@@ -0,0 +1,273 @@
|
||||
import { expect, tap } from '@git.zone/tstest/tapbundle';
|
||||
import * as smartmongo from '../ts/index.js';
|
||||
|
||||
const { QueryPlanner, IndexEngine, MemoryStorageAdapter, ObjectId } = smartmongo.tsmdb;
|
||||
|
||||
let storage: InstanceType<typeof MemoryStorageAdapter>;
|
||||
let indexEngine: InstanceType<typeof IndexEngine>;
|
||||
let queryPlanner: InstanceType<typeof QueryPlanner>;
|
||||
|
||||
const TEST_DB = 'testdb';
|
||||
const TEST_COLL = 'testcoll';
|
||||
|
||||
// ============================================================================
|
||||
// Setup
|
||||
// ============================================================================
|
||||
|
||||
tap.test('queryplanner: should create QueryPlanner instance', async () => {
|
||||
storage = new MemoryStorageAdapter();
|
||||
await storage.initialize();
|
||||
await storage.createCollection(TEST_DB, TEST_COLL);
|
||||
|
||||
indexEngine = new IndexEngine(TEST_DB, TEST_COLL, storage);
|
||||
queryPlanner = new QueryPlanner(indexEngine);
|
||||
|
||||
expect(queryPlanner).toBeTruthy();
|
||||
});
|
||||
|
||||
tap.test('queryplanner: should insert test documents', async () => {
|
||||
// Insert test documents
|
||||
const docs = [
|
||||
{ _id: new ObjectId(), name: 'Alice', age: 25, city: 'NYC', category: 'A' },
|
||||
{ _id: new ObjectId(), name: 'Bob', age: 30, city: 'LA', category: 'B' },
|
||||
{ _id: new ObjectId(), name: 'Charlie', age: 35, city: 'NYC', category: 'A' },
|
||||
{ _id: new ObjectId(), name: 'Diana', age: 28, city: 'Chicago', category: 'C' },
|
||||
{ _id: new ObjectId(), name: 'Eve', age: 32, city: 'LA', category: 'B' },
|
||||
];
|
||||
|
||||
for (const doc of docs) {
|
||||
await storage.insertOne(TEST_DB, TEST_COLL, doc);
|
||||
}
|
||||
});
|
||||
|
||||
// ============================================================================
|
||||
// Basic Plan Tests
|
||||
// ============================================================================
|
||||
|
||||
tap.test('queryplanner: empty filter should result in COLLSCAN', async () => {
|
||||
const plan = await queryPlanner.plan({});
|
||||
|
||||
expect(plan.type).toEqual('COLLSCAN');
|
||||
expect(plan.indexCovering).toBeFalse();
|
||||
expect(plan.selectivity).toEqual(1.0);
|
||||
expect(plan.explanation).toContain('No filter');
|
||||
});
|
||||
|
||||
tap.test('queryplanner: null filter should result in COLLSCAN', async () => {
|
||||
const plan = await queryPlanner.plan(null as any);
|
||||
|
||||
expect(plan.type).toEqual('COLLSCAN');
|
||||
});
|
||||
|
||||
tap.test('queryplanner: filter with no matching index should result in COLLSCAN', async () => {
|
||||
const plan = await queryPlanner.plan({ nonExistentField: 'value' });
|
||||
|
||||
expect(plan.type).toEqual('COLLSCAN');
|
||||
expect(plan.explanation).toContain('No suitable index');
|
||||
});
|
||||
|
||||
// ============================================================================
|
||||
// Index Scan Tests (with indexes)
|
||||
// ============================================================================
|
||||
|
||||
tap.test('queryplanner: should create test indexes', async () => {
|
||||
await indexEngine.createIndex({ age: 1 }, { name: 'age_1' });
|
||||
await indexEngine.createIndex({ name: 1 }, { name: 'name_1' });
|
||||
await indexEngine.createIndex({ city: 1, category: 1 }, { name: 'city_category_1' });
|
||||
|
||||
const indexes = await indexEngine.listIndexes();
|
||||
expect(indexes.length).toBeGreaterThanOrEqual(4); // _id_ + 3 created
|
||||
});
|
||||
|
||||
tap.test('queryplanner: simple equality filter should use IXSCAN', async () => {
|
||||
const plan = await queryPlanner.plan({ age: 30 });
|
||||
|
||||
expect(plan.type).toEqual('IXSCAN');
|
||||
expect(plan.indexName).toEqual('age_1');
|
||||
expect(plan.indexFieldsUsed).toContain('age');
|
||||
expect(plan.usesRange).toBeFalse();
|
||||
});
|
||||
|
||||
tap.test('queryplanner: $eq operator should use IXSCAN', async () => {
|
||||
const plan = await queryPlanner.plan({ name: { $eq: 'Alice' } });
|
||||
|
||||
expect(plan.type).toEqual('IXSCAN');
|
||||
expect(plan.indexName).toEqual('name_1');
|
||||
expect(plan.indexFieldsUsed).toContain('name');
|
||||
});
|
||||
|
||||
tap.test('queryplanner: range filter ($gt) should use IXSCAN_RANGE', async () => {
|
||||
const plan = await queryPlanner.plan({ age: { $gt: 25 } });
|
||||
|
||||
expect(plan.type).toEqual('IXSCAN_RANGE');
|
||||
expect(plan.indexName).toEqual('age_1');
|
||||
expect(plan.usesRange).toBeTrue();
|
||||
});
|
||||
|
||||
tap.test('queryplanner: range filter ($lt) should use IXSCAN_RANGE', async () => {
|
||||
const plan = await queryPlanner.plan({ age: { $lt: 35 } });
|
||||
|
||||
expect(plan.type).toEqual('IXSCAN_RANGE');
|
||||
expect(plan.usesRange).toBeTrue();
|
||||
});
|
||||
|
||||
tap.test('queryplanner: range filter ($gte, $lte) should use IXSCAN_RANGE', async () => {
|
||||
const plan = await queryPlanner.plan({ age: { $gte: 25, $lte: 35 } });
|
||||
|
||||
expect(plan.type).toEqual('IXSCAN_RANGE');
|
||||
expect(plan.usesRange).toBeTrue();
|
||||
});
|
||||
|
||||
tap.test('queryplanner: $in operator should use IXSCAN', async () => {
|
||||
const plan = await queryPlanner.plan({ age: { $in: [25, 30, 35] } });
|
||||
|
||||
expect(plan.type).toEqual('IXSCAN');
|
||||
expect(plan.indexName).toEqual('age_1');
|
||||
});
|
||||
|
||||
// ============================================================================
|
||||
// Compound Index Tests
|
||||
// ============================================================================
|
||||
|
||||
tap.test('queryplanner: compound index - first field equality should use index', async () => {
|
||||
const plan = await queryPlanner.plan({ city: 'NYC' });
|
||||
|
||||
expect(plan.type).toEqual('IXSCAN');
|
||||
expect(plan.indexName).toEqual('city_category_1');
|
||||
expect(plan.indexFieldsUsed).toContain('city');
|
||||
});
|
||||
|
||||
tap.test('queryplanner: compound index - both fields should use full index', async () => {
|
||||
const plan = await queryPlanner.plan({ city: 'NYC', category: 'A' });
|
||||
|
||||
expect(plan.type).toEqual('IXSCAN');
|
||||
expect(plan.indexName).toEqual('city_category_1');
|
||||
expect(plan.indexFieldsUsed).toContain('city');
|
||||
expect(plan.indexFieldsUsed).toContain('category');
|
||||
expect(plan.indexFieldsUsed.length).toEqual(2);
|
||||
});
|
||||
|
||||
// ============================================================================
|
||||
// Selectivity Tests
|
||||
// ============================================================================
|
||||
|
||||
tap.test('queryplanner: equality query should have low selectivity', async () => {
|
||||
const plan = await queryPlanner.plan({ age: 30 });
|
||||
|
||||
expect(plan.selectivity).toBeLessThan(0.1);
|
||||
});
|
||||
|
||||
tap.test('queryplanner: range query should have moderate selectivity', async () => {
|
||||
const plan = await queryPlanner.plan({ age: { $gt: 25 } });
|
||||
|
||||
expect(plan.selectivity).toBeGreaterThan(0);
|
||||
expect(plan.selectivity).toBeLessThan(1);
|
||||
});
|
||||
|
||||
tap.test('queryplanner: $in query selectivity depends on array size', async () => {
|
||||
const smallInPlan = await queryPlanner.plan({ age: { $in: [25] } });
|
||||
const largeInPlan = await queryPlanner.plan({ age: { $in: [25, 26, 27, 28, 29, 30] } });
|
||||
|
||||
// Larger $in should have higher selectivity (less selective = more documents)
|
||||
expect(largeInPlan.selectivity).toBeGreaterThanOrEqual(smallInPlan.selectivity);
|
||||
});
|
||||
|
||||
// ============================================================================
|
||||
// Index Covering Tests
|
||||
// ============================================================================
|
||||
|
||||
tap.test('queryplanner: query covering all filter fields should be index covering', async () => {
|
||||
const plan = await queryPlanner.plan({ age: 30 });
|
||||
|
||||
// All filter fields are covered by the index
|
||||
expect(plan.indexCovering).toBeTrue();
|
||||
});
|
||||
|
||||
tap.test('queryplanner: query with residual filter should not be index covering', async () => {
|
||||
const plan = await queryPlanner.plan({ city: 'NYC', name: 'Alice' });
|
||||
|
||||
// 'name' is not in the compound index city_category, so it's residual
|
||||
expect(plan.indexCovering).toBeFalse();
|
||||
expect(plan.residualFilter).toBeTruthy();
|
||||
});
|
||||
|
||||
// ============================================================================
|
||||
// Explain Tests
|
||||
// ============================================================================
|
||||
|
||||
tap.test('queryplanner: explain should return detailed plan info', async () => {
|
||||
const explanation = await queryPlanner.explain({ age: 30 });
|
||||
|
||||
expect(explanation.queryPlanner).toBeTruthy();
|
||||
expect(explanation.queryPlanner.plannerVersion).toEqual(1);
|
||||
expect(explanation.queryPlanner.winningPlan).toBeTruthy();
|
||||
expect(explanation.queryPlanner.rejectedPlans).toBeArray();
|
||||
});
|
||||
|
||||
tap.test('queryplanner: explain should include winning and rejected plans', async () => {
|
||||
const explanation = await queryPlanner.explain({ age: 30 });
|
||||
|
||||
expect(explanation.queryPlanner.winningPlan.type).toBeTruthy();
|
||||
expect(explanation.queryPlanner.rejectedPlans.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
tap.test('queryplanner: explain winning plan should be the best plan', async () => {
|
||||
const explanation = await queryPlanner.explain({ age: 30 });
|
||||
|
||||
// Winning plan should use an index, not collection scan (if index exists)
|
||||
expect(explanation.queryPlanner.winningPlan.type).toEqual('IXSCAN');
|
||||
|
||||
// There should be a COLLSCAN in rejected plans
|
||||
const hasCOLLSCAN = explanation.queryPlanner.rejectedPlans.some(p => p.type === 'COLLSCAN');
|
||||
expect(hasCOLLSCAN).toBeTrue();
|
||||
});
|
||||
|
||||
// ============================================================================
|
||||
// $and Operator Tests
|
||||
// ============================================================================
|
||||
|
||||
tap.test('queryplanner: $and conditions should be analyzed', async () => {
|
||||
const plan = await queryPlanner.plan({
|
||||
$and: [
|
||||
{ age: { $gte: 25 } },
|
||||
{ age: { $lte: 35 } },
|
||||
],
|
||||
});
|
||||
|
||||
expect(plan.type).toEqual('IXSCAN_RANGE');
|
||||
expect(plan.indexName).toEqual('age_1');
|
||||
});
|
||||
|
||||
// ============================================================================
|
||||
// Edge Cases
|
||||
// ============================================================================
|
||||
|
||||
tap.test('queryplanner: should handle complex nested operators', async () => {
|
||||
const plan = await queryPlanner.plan({
|
||||
age: { $gte: 20, $lte: 40 },
|
||||
city: 'NYC',
|
||||
});
|
||||
|
||||
expect(plan).toBeTruthy();
|
||||
expect(plan.type).not.toBeUndefined();
|
||||
});
|
||||
|
||||
tap.test('queryplanner: should handle $exists operator', async () => {
|
||||
await indexEngine.createIndex({ email: 1 }, { name: 'email_1', sparse: true });
|
||||
|
||||
const plan = await queryPlanner.plan({ email: { $exists: true } });
|
||||
|
||||
// $exists can use sparse indexes
|
||||
expect(plan).toBeTruthy();
|
||||
});
|
||||
|
||||
// ============================================================================
|
||||
// Cleanup
|
||||
// ============================================================================
|
||||
|
||||
tap.test('queryplanner: cleanup', async () => {
|
||||
await storage.close();
|
||||
expect(true).toBeTrue();
|
||||
});
|
||||
|
||||
export default tap.start();
|
||||
Reference in New Issue
Block a user