@simonecoelhosfo/optimizely-mcp-server
Version:
Optimizely MCP Server for AI assistants with integrated CLI tools
528 lines • 17.5 kB
JavaScript
/**
* Comprehensive Test Suite for Intelligent Query Engine
*
* This test suite covers all permutations of queries across:
* - Feature Experimentation (flags, rules, variations, rulesets)
* - Web Experimentation (experiments, campaigns, pages, variations)
* - All query types and operators
*/
import { IntelligentQueryEngine } from './IntelligentQueryEngine.js';
import { OptimizelyAdapter } from './adapters/OptimizelyAdapter.js';
import { getLogger } from '../../logging/Logger.js';
import Database from 'better-sqlite3';
const logger = getLogger();
const testQueries = [
// ===== FEATURE EXPERIMENTATION QUERIES =====
// Basic Flag Queries
{
name: 'All flags',
category: 'Feature Experimentation - Basic',
query: {
find: 'flags',
select: ['*']
}
},
{
name: 'Flag by key',
category: 'Feature Experimentation - Basic',
query: {
find: 'flags',
select: ['key', 'name', 'description'],
where: [{ field: 'key', operator: '=', value: 'mcp_test_flag_c2201' }]
}
},
{
name: 'Flags with limit and offset',
category: 'Feature Experimentation - Basic',
query: {
find: 'flags',
select: ['key', 'name'],
limit: 5,
offset: 2
}
},
{
name: 'Active flags only',
category: 'Feature Experimentation - Basic',
query: {
find: 'flags',
select: ['key', 'name', 'archived'],
where: [{ field: 'archived', operator: '=', value: false }]
}
},
// Flag Environment Queries
{
name: 'Flags with environments',
category: 'Feature Experimentation - Environments',
query: {
find: 'flags',
select: ['key', 'name', 'environment'],
limit: 20
}
},
{
name: 'Flags in specific environments',
category: 'Feature Experimentation - Environments',
query: {
find: 'flags',
select: ['key', 'name', 'environment'],
where: [{ field: 'environment', operator: 'IN', value: ['production', 'development'] }]
}
},
{
name: 'Count flags by environment',
category: 'Feature Experimentation - Environments',
query: {
find: 'flags',
select: ['environment'],
groupBy: ['environment'],
aggregations: [{
field: '*',
function: 'COUNT',
alias: 'flag_count'
}]
},
expectedResultType: 'aggregation'
},
// Variations Queries
{
name: 'All variations',
category: 'Feature Experimentation - Variations',
query: {
find: 'variations',
select: ['key', 'name', 'description', 'flag_key']
}
},
{
name: 'Variations for specific flag',
category: 'Feature Experimentation - Variations',
query: {
find: 'variations',
select: ['key', 'name', 'enabled'],
where: [{ field: 'flag_key', operator: '=', value: 'mcp_test_flag_c2201' }]
}
},
{
name: 'Enabled variations only',
category: 'Feature Experimentation - Variations',
query: {
find: 'variations',
select: ['key', 'name', 'flag_key'],
where: [{ field: 'enabled', operator: '=', value: true }]
}
},
// Rules and Rulesets Queries
{
name: 'All rulesets',
category: 'Feature Experimentation - Rules',
query: {
find: 'rulesets',
select: ['flag_key', 'environment_key', 'enabled', 'rules_count']
}
},
{
name: 'Rulesets by environment',
category: 'Feature Experimentation - Rules',
query: {
find: 'rulesets',
select: ['flag_key', 'environment_key', 'enabled'],
where: [{ field: 'environment_key', operator: '=', value: 'production' }]
}
},
{
name: 'Enabled rulesets count',
category: 'Feature Experimentation - Rules',
query: {
find: 'rulesets',
select: ['enabled'],
groupBy: ['enabled'],
aggregations: [{
field: '*',
function: 'COUNT',
alias: 'count'
}]
},
expectedResultType: 'aggregation'
},
{
name: 'Rules with audience conditions',
category: 'Feature Experimentation - Rules',
query: {
find: 'rules',
select: ['key', 'name', 'type', 'audience_conditions'],
where: [{ field: 'audience_conditions', operator: '!=', value: null }]
}
},
// ===== WEB EXPERIMENTATION QUERIES =====
// Basic Experiment Queries
{
name: 'All experiments',
category: 'Web Experimentation - Basic',
query: {
find: 'experiments',
select: ['id', 'name', 'status', 'type']
}
},
{
name: 'Running experiments',
category: 'Web Experimentation - Basic',
query: {
find: 'experiments',
select: ['name', 'status', 'created_time'],
where: [{ field: 'status', operator: '=', value: 'running' }]
}
},
{
name: 'Experiments by type',
category: 'Web Experimentation - Basic',
query: {
find: 'experiments',
select: ['type'],
groupBy: ['type'],
aggregations: [{
field: '*',
function: 'COUNT',
alias: 'count'
}]
},
expectedResultType: 'aggregation'
},
// Campaign Queries
{
name: 'All campaigns',
category: 'Web Experimentation - Campaigns',
query: {
find: 'campaigns',
select: ['id', 'name', 'description', 'holdback']
}
},
{
name: 'Active campaigns with holdback',
category: 'Web Experimentation - Campaigns',
query: {
find: 'campaigns',
select: ['name', 'holdback'],
where: [
{ field: 'archived', operator: '=', value: false },
{ field: 'holdback', operator: '>', value: 0 }
]
}
},
// Page Queries
{
name: 'All pages',
category: 'Web Experimentation - Pages',
query: {
find: 'pages',
select: ['id', 'name', 'edit_url', 'activation_mode']
}
},
{
name: 'Pages by activation mode',
category: 'Web Experimentation - Pages',
query: {
find: 'pages',
select: ['activation_mode'],
groupBy: ['activation_mode'],
aggregations: [{
field: '*',
function: 'COUNT',
alias: 'count'
}]
},
expectedResultType: 'aggregation'
},
// ===== CROSS-ENTITY QUERIES =====
// Audiences
{
name: 'All audiences',
category: 'Cross-Platform - Audiences',
query: {
find: 'audiences',
select: ['id', 'name', 'conditions', 'description']
}
},
{
name: 'Audiences with specific conditions',
category: 'Cross-Platform - Audiences',
query: {
find: 'audiences',
select: ['name', 'conditions', 'created_time'],
where: [{ field: 'conditions', operator: 'LIKE', value: '%browser%' }],
orderBy: [{ field: 'created_time', direction: 'DESC' }]
}
},
// Events
{
name: 'All events',
category: 'Cross-Platform - Events',
query: {
find: 'events',
select: ['id', 'key', 'name', 'event_type', 'category']
}
},
{
name: 'Events by type',
category: 'Cross-Platform - Events',
query: {
find: 'events',
select: ['event_type'],
groupBy: ['event_type'],
aggregations: [{
field: '*',
function: 'COUNT',
alias: 'count'
}]
},
expectedResultType: 'aggregation'
},
{
name: 'Custom events only',
category: 'Cross-Platform - Events',
query: {
find: 'events',
select: ['key', 'name', 'description'],
where: [{ field: 'event_type', operator: '=', value: 'custom' }]
}
},
// Attributes
{
name: 'All attributes',
category: 'Cross-Platform - Attributes',
query: {
find: 'attributes',
select: ['id', 'key', 'name', 'condition_type']
}
},
{
name: 'Custom attributes only',
category: 'Cross-Platform - Attributes',
query: {
find: 'attributes',
select: ['key', 'name'],
where: [{ field: 'condition_type', operator: '=', value: 'custom_attribute' }]
}
},
// ===== COMPLEX QUERIES =====
// Multi-condition filters
{
name: 'Flags with multiple conditions',
category: 'Complex - Multiple Conditions',
query: {
find: 'flags',
select: ['key', 'name', 'created_time'],
where: [
{ field: 'archived', operator: '=', value: false },
{ field: 'created_time', operator: '>', value: '2025-01-01' }
],
orderBy: [{ field: 'created_time', direction: 'DESC' }]
}
},
// Complex aggregations
{
name: 'Multi-field aggregation',
category: 'Complex - Aggregations',
query: {
find: 'experiments',
select: ['status', 'type'],
groupBy: ['status', 'type'],
aggregations: [
{
field: '*',
function: 'COUNT',
alias: 'count'
}
]
},
expectedResultType: 'aggregation'
},
// Pattern matching
{
name: 'Flags with pattern matching',
category: 'Complex - Pattern Matching',
query: {
find: 'flags',
select: ['key', 'name'],
where: [{ field: 'key', operator: 'LIKE', value: '%test%' }]
}
},
{
name: 'Events starting with prefix',
category: 'Complex - Pattern Matching',
query: {
find: 'events',
select: ['name', 'key'],
where: [{ field: 'name', operator: 'LIKE', value: 'test%' }]
}
},
// NULL handling
{
name: 'Entities with null descriptions',
category: 'Complex - NULL Handling',
query: {
find: 'flags',
select: ['key', 'name', 'description'],
where: [{ field: 'description', operator: '=', value: null }]
}
},
{
name: 'Entities with non-null descriptions',
category: 'Complex - NULL Handling',
query: {
find: 'flags',
select: ['key', 'name'],
where: [{ field: 'description', operator: '!=', value: null }]
}
},
// Sorting and pagination
{
name: 'Paginated results with sorting',
category: 'Complex - Pagination',
query: {
find: 'flags',
select: ['key', 'name', 'updated_time'],
orderBy: [
{ field: 'updated_time', direction: 'DESC' },
{ field: 'name', direction: 'ASC' }
],
limit: 10,
offset: 0
}
},
// JSON field queries (if supported)
{
name: 'Query JSON fields',
category: 'Complex - JSON Fields',
query: {
find: 'variations',
select: ['key', 'name', 'variables'],
where: [{ field: 'variables', operator: '!=', value: null }]
}
}
];
async function runComprehensiveTests() {
logger.info('Starting Comprehensive Query Engine Test Suite');
const results = {
total: testQueries.length,
passed: 0,
failed: 0,
categories: new Map()
};
try {
// Open database
const db = new Database('./data/optimizely-cache.db', { readonly: true });
// Initialize engine
const engine = new IntelligentQueryEngine({
discovery: {
autoDiscover: true,
discoveryInterval: 3600000,
cacheTTL: 60000
},
execution: {
defaultStrategy: 'hybrid-sql-first',
maxQueryTime: 30000,
enableParallel: false,
parallelThreshold: 1000
}
});
// Register Optimizely adapter
const optimizelyAdapter = new OptimizelyAdapter({ database: db });
engine.registerAdapter(optimizelyAdapter);
// Run each test
for (const testCase of testQueries) {
// Initialize category stats
if (!results.categories.has(testCase.category)) {
results.categories.set(testCase.category, { passed: 0, failed: 0 });
}
logger.debug(`\n${'='.repeat(80)}`);
logger.debug(`Category: ${testCase.category}`);
logger.debug(`Test: ${testCase.name}`);
logger.debug('='.repeat(80));
try {
// Execute query
const startTime = Date.now();
const result = await engine.query(testCase.query);
const duration = Date.now() - startTime;
// Validate results
let testPassed = true;
let failureReason = '';
if (!result || !result.data) {
testPassed = false;
failureReason = 'No result data returned';
}
else if (testCase.minimumRows && result.data.length < testCase.minimumRows) {
testPassed = false;
failureReason = `Expected at least ${testCase.minimumRows} rows, got ${result.data.length}`;
}
else if (testCase.expectedResultType === 'aggregation' && result.data.length === 0) {
testPassed = false;
failureReason = 'Expected aggregation results';
}
if (testPassed) {
logger.debug(`PASSED`);
results.passed++;
results.categories.get(testCase.category).passed++;
}
else {
logger.debug(`FAILED: ${failureReason}`);
results.failed++;
results.categories.get(testCase.category).failed++;
}
logger.debug(`- Execution time: ${duration}ms`);
logger.debug(`- Rows returned: ${result.data.length}`);
logger.debug(`- Strategy used: ${result.plan?.strategy || 'unknown'}`);
// Show sample data
if (result.data.length > 0) {
logger.debug('\nSample data (first row):');
logger.debug(JSON.stringify(result.data[0], null, 2));
}
}
catch (error) {
logger.debug(`ERROR: ${error.message}`);
results.failed++;
results.categories.get(testCase.category).failed++;
if (error.stack) {
logger.debug('\nStack trace:');
logger.debug(error.stack.split('\n').slice(1, 3).join('\n'));
}
}
}
// Print summary
logger.debug(`\n${'='.repeat(80)}`);
logger.debug('TEST SUITE SUMMARY');
logger.debug('='.repeat(80));
logger.debug(`Total Tests: ${results.total}`);
logger.debug(`Passed: ${results.passed} (${((results.passed / results.total) * 100).toFixed(1)}%)`);
logger.debug(`Failed: ${results.failed} (${((results.failed / results.total) * 100).toFixed(1)}%)`);
logger.debug('\nResults by Category:');
for (const [category, stats] of results.categories) {
const total = stats.passed + stats.failed;
const passRate = total > 0 ? ((stats.passed / total) * 100).toFixed(1) : '0.0';
logger.debug(`- ${category}: ${stats.passed}/${total} passed (${passRate}%)`);
}
// Shutdown
await engine.shutdown();
db.close();
// Exit with appropriate code
if (results.failed === 0) {
logger.debug('\nAll tests passed!');
process.exit(0);
}
else {
logger.debug(`\n ${results.failed} tests failed`);
process.exit(1);
}
}
catch (error) {
logger.error('Test suite failed:', error);
console.error('\nFATAL ERROR:', error.message);
process.exit(1);
}
}
// Run tests
logger.debug('Intelligent Query Engine - Comprehensive Test Suite');
logger.debug('='.repeat(80));
logger.debug('Testing all query permutations across Feature & Web Experimentation');
logger.debug('='.repeat(80));
runComprehensiveTests();
//# sourceMappingURL=comprehensive-test-suite.js.map