@simonecoelhosfo/optimizely-mcp-server
Version:
Optimizely MCP Server for AI assistants with integrated CLI tools
223 lines • 8.64 kB
JavaScript
/**
* Phase 4C Complete Test - Field Disambiguation
*
* Tests the fully implemented field disambiguation features
* using correct entity names (singular) and proper syntax.
*/
import { IntelligentQueryEngine } from './IntelligentQueryEngine.js';
import { OptimizelyAdapter } from './adapters/OptimizelyAdapter.js';
import Database from 'better-sqlite3';
async function runTest(engine, test) {
const startTime = Date.now();
try {
const result = await engine.query(test.query);
return {
name: test.name,
success: true,
rowCount: result.data?.length || 0,
executionTime: Date.now() - startTime
};
}
catch (error) {
return {
name: test.name,
success: false,
error: error instanceof Error ? error.message : String(error),
executionTime: Date.now() - startTime
};
}
}
async function testPhase4CComplete() {
console.log('# Phase 4C Complete Test Suite\\n');
// Initialize
const db = new Database('./data/optimizely-cache.db', { readonly: true });
const engine = new IntelligentQueryEngine({
discovery: {
autoDiscover: true,
discoveryInterval: 60000,
cacheTTL: 3600000
}
});
const adapter = new OptimizelyAdapter({ database: db });
engine.registerAdapter(adapter);
// Wait for discovery
await new Promise(resolve => setTimeout(resolve, 500));
const testGroups = [
{
name: 'Automatic Disambiguation',
tests: [
{
name: 'Simple fields - automatic resolution',
query: {
find: 'flag',
select: ['name', 'key', 'archived'],
where: [{ field: 'archived', operator: '=', value: false }],
limit: 3
},
expectedBehavior: 'Fields automatically resolved for single entity'
},
{
name: 'Field with alias',
query: {
find: 'event',
select: ['name as event_name', 'event_type', 'category'],
where: [{ field: 'event_type', operator: '=', value: 'custom' }],
limit: 3
},
expectedBehavior: 'Aliased fields handled correctly'
}
]
},
{
name: 'Explicit Table Prefixes',
tests: [
{
name: 'Entity prefix in select',
query: {
find: 'flag',
select: ['flag.name', 'flag.key'],
limit: 3
},
expectedBehavior: 'Entity prefixes converted to table names in SQL'
},
{
name: 'Mixed prefixed and unprefixed',
query: {
find: 'flag',
select: ['flag.name', 'key', 'archived'],
where: [{ field: 'flag.archived', operator: '=', value: false }],
limit: 3
},
expectedBehavior: 'Mix of prefixed and unprefixed fields'
}
]
},
{
name: 'Field Aliasing',
tests: [
{
name: 'Simple alias',
query: {
find: 'flag',
select: ['name as flag_name', 'key as flag_key'],
limit: 3
},
expectedBehavior: 'AS clause creates proper aliases'
},
{
name: 'Alias with conditions',
query: {
find: 'attribute',
select: ['name as attr_name', 'key as attr_key', 'condition_type'],
where: [{ field: 'archived', operator: '=', value: false }],
limit: 3
},
expectedBehavior: 'Aliases work with WHERE conditions'
}
]
},
{
name: 'Aggregation Queries',
tests: [
{
name: 'Simple COUNT aggregation',
query: {
find: 'flag',
select: ['archived'],
groupBy: ['archived'],
aggregations: [{
field: '*',
function: 'COUNT',
alias: 'total_count'
}]
},
expectedBehavior: 'COUNT aggregation with grouping'
},
{
name: 'Multiple aggregations',
query: {
find: 'event',
select: ['event_type'],
groupBy: ['event_type'],
aggregations: [
{ field: '*', function: 'COUNT', alias: 'count' },
{ field: 'id', function: 'COUNT', alias: 'id_count' }
]
},
expectedBehavior: 'Multiple aggregations in one query'
}
]
},
{
name: 'Complex Queries',
tests: [
{
name: 'Date filtering with disambiguation',
query: {
find: 'flag',
select: ['name', 'created_time'],
where: [
{ field: 'created_time', operator: '>', value: 'LAST_7_DAYS' },
{ field: 'archived', operator: '=', value: false }
],
orderBy: [{ field: 'created_time', direction: 'DESC' }],
limit: 3
},
expectedBehavior: 'Date functions with field disambiguation'
},
{
name: 'Pattern matching with LIKE',
query: {
find: 'flag',
select: ['name', 'key'],
where: [
{ field: 'name', operator: 'LIKE', value: '%test%' },
{ field: 'key', operator: 'LIKE', value: '%mcp%' }
],
limit: 3
},
expectedBehavior: 'Multiple LIKE conditions'
}
]
}
];
const allResults = [];
// Run tests
for (const group of testGroups) {
console.log(`## ${group.name}\\n`);
for (const test of group.tests) {
const result = await runTest(engine, test);
allResults.push(result);
const status = result.success ? '✅' : '❌';
console.log(`${status} ${test.name}`);
if (result.success) {
console.log(` Rows: ${result.rowCount} | Time: ${result.executionTime}ms`);
}
else {
console.log(` Error: ${result.error}`);
console.log(` Time: ${result.executionTime}ms`);
}
console.log(` Expected: ${test.expectedBehavior}\\n`);
}
}
// Summary
const passed = allResults.filter(r => r.success).length;
const total = allResults.length;
const successRate = ((passed / total) * 100).toFixed(1);
const avgTime = (allResults.reduce((sum, r) => sum + r.executionTime, 0) / total).toFixed(1);
console.log('## Summary');
console.log(`- Total Tests: ${total}`);
console.log(`- Passed: ${passed}`);
console.log(`- Failed: ${total - passed}`);
console.log(`- Success Rate: ${successRate}%`);
console.log(`- Average Time: ${avgTime}ms\\n`);
console.log('## Phase 4C Implementation Complete');
console.log('Field disambiguation without bypass');
console.log('Entity/table name mapping');
console.log('Proper handling of field aliases');
console.log('Support for entity prefixes');
console.log('Integration with aggregations and date functions');
db.close();
}
testPhase4CComplete().catch(console.error);
//# sourceMappingURL=test-phase4c-complete.js.map