claude-flow-novice 2.3.4 → 2.3.6

package/dist/scripts/performance/test-enhanced-backend.sh

@@ -1,504 +0,0 @@
-#!/bin/bash
-
-# Test Enhanced SQLite Backend in Isolated Environment
-# Safe testing without affecting production database
-
-set -euo pipefail
-
-# Configuration
-TEST_DIR=".test-enhanced-$(date +%Y%m%d-%H%M%S)"
-CURRENT_DB=".swarm/memory.db"
-TEST_DB="${TEST_DIR}/memory-test.db"
-CONFIG_FILE="config/performance/sqlite-enhanced-config.json"
-LOG_FILE="${TEST_DIR}/test-results.log"
-
-# Colors
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m'
-
-log() {
-    echo -e "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "${LOG_FILE}"
-}
-
-error() {
-    echo -e "${RED}[ERROR]${NC} $1" | tee -a "${LOG_FILE}"
-}
-
-success() {
-    echo -e "${GREEN}[SUCCESS]${NC} $1" | tee -a "${LOG_FILE}"
-}
-
-info() {
-    echo -e "${BLUE}[INFO]${NC} $1" | tee -a "${LOG_FILE}"
-}
-
-# Setup isolated test environment
-setup_test_environment() {
-    info "Setting up isolated test environment..."
-
-    mkdir -p "${TEST_DIR}"
-
-    # Copy current database for testing
-    cp "${CURRENT_DB}" "${TEST_DB}"
-
-    # Copy config if it exists
-    if [[ -f "${CONFIG_FILE}" ]]; then
-        cp "${CONFIG_FILE}" "${TEST_DIR}/config.json"
-    fi
-
-    success "Test environment created: ${TEST_DIR}"
-}
-
-# Test basic SQLite optimizations
-test_basic_optimizations() {
-    info "Testing basic SQLite optimizations..."
-
-    local test_results="${TEST_DIR}/basic_test.json"
-
-    # Benchmark current performance
-    local before_time
-    before_time=$(time sqlite3 "${TEST_DB}" "SELECT COUNT(*) FROM memory_entries;" 2>&1 | grep real | awk '{print $2}')
-
-    # Apply basic optimizations
-    sqlite3 "${TEST_DB}" << 'EOF'
-PRAGMA cache_size = -2048000;  -- 2GB cache
-PRAGMA mmap_size = 8589934592; -- 8GB memory mapping
-PRAGMA temp_store = memory;
-PRAGMA journal_mode = WAL;
-PRAGMA synchronous = NORMAL;
-PRAGMA wal_autocheckpoint = 1000;
-PRAGMA optimize;
-EOF
-
-    # Benchmark after optimization
-    local after_time
-    after_time=$(time sqlite3 "${TEST_DB}" "SELECT COUNT(*) FROM memory_entries;" 2>&1 | grep real | awk '{print $2}')
-
-    # Run comprehensive benchmarks
-    local complex_query_time
-    complex_query_time=$(time sqlite3 "${TEST_DB}" "
-        SELECT
-            namespace,
-            COUNT(*) as entries,
-            AVG(LENGTH(value)) as avg_size,
-            SUM(LENGTH(value)) as total_size,
-            MAX(access_count) as max_access
-        FROM memory_entries
-        GROUP BY namespace
-        HAVING entries > 5
-        ORDER BY total_size DESC;
-    " 2>&1 | grep real | awk '{print $2}')
-
-    cat > "${test_results}" << EOF
-{
-    "test_type": "basic_optimizations",
-    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
-    "database_size": $(stat -f%z "${TEST_DB}" 2>/dev/null || stat -c%s "${TEST_DB}"),
-    "entry_count": $(sqlite3 "${TEST_DB}" "SELECT COUNT(*) FROM memory_entries;"),
-    "performance": {
-        "simple_count_before": "${before_time}",
-        "simple_count_after": "${after_time}",
-        "complex_query": "${complex_query_time}"
-    },
-    "settings_applied": {
-        "cache_size": "$(sqlite3 "${TEST_DB}" "PRAGMA cache_size;")",
-        "mmap_size": "$(sqlite3 "${TEST_DB}" "PRAGMA mmap_size;")",
-        "journal_mode": "$(sqlite3 "${TEST_DB}" "PRAGMA journal_mode;")"
-    }
-}
-EOF
-
-    success "Basic optimization test completed: ${test_results}"
-}
-
-# Test Enhanced Backend schema
-test_enhanced_schema() {
-    info "Testing Enhanced Backend schema modifications..."
-
-    local schema_test="${TEST_DIR}/schema_test.json"
-
-    # Add enhanced columns
-    sqlite3 "${TEST_DB}" << 'EOF'
--- Add enhanced columns if they don't exist
-ALTER TABLE memory_entries ADD COLUMN checksum TEXT DEFAULT '';
-ALTER TABLE memory_entries ADD COLUMN compressed INTEGER DEFAULT 0;
-ALTER TABLE memory_entries ADD COLUMN size INTEGER DEFAULT 0;
-ALTER TABLE memory_entries ADD COLUMN owner TEXT DEFAULT 'system';
-ALTER TABLE memory_entries ADD COLUMN access_level TEXT DEFAULT 'private';
-ALTER TABLE memory_entries ADD COLUMN version INTEGER DEFAULT 1;
-
--- Update size column for existing entries
-UPDATE memory_entries SET size = length(value) WHERE size = 0;
-UPDATE memory_entries SET checksum = hex(randomblob(16)) WHERE checksum = '';
-
--- Create enhanced indexes
-CREATE INDEX IF NOT EXISTS idx_memory_owner ON memory_entries(owner);
-CREATE INDEX IF NOT EXISTS idx_memory_access_level ON memory_entries(access_level);
-CREATE INDEX IF NOT EXISTS idx_memory_size ON memory_entries(size);
-CREATE INDEX IF NOT EXISTS idx_memory_compressed ON memory_entries(compressed) WHERE compressed = 1;
-CREATE INDEX IF NOT EXISTS idx_memory_large_values ON memory_entries(namespace, size) WHERE size > 10000;
-
--- Analyze for optimization
-ANALYZE;
-EOF
-
-    # Test enhanced queries
-    local enhanced_query_time
-    enhanced_query_time=$(time sqlite3 "${TEST_DB}" "
-        SELECT
-            owner,
-            access_level,
-            COUNT(*) as entries,
-            AVG(size) as avg_size,
-            SUM(CASE WHEN compressed = 1 THEN 1 ELSE 0 END) as compressed_count
-        FROM memory_entries
-        GROUP BY owner, access_level
-        ORDER BY entries DESC;
-    " 2>&1 | grep real | awk '{print $2}')
-
-    # Check schema integrity
-    local integrity_result
-    integrity_result=$(sqlite3 "${TEST_DB}" "PRAGMA integrity_check;")
-
-    cat > "${schema_test}" << EOF
-{
-    "test_type": "enhanced_schema",
-    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
-    "schema_integrity": "${integrity_result}",
-    "enhanced_columns_added": $(sqlite3 "${TEST_DB}" "PRAGMA table_info(memory_entries);" | grep -c "checksum\|compressed\|size\|owner\|access_level\|version"),
-    "indexes_created": $(sqlite3 "${TEST_DB}" "SELECT COUNT(*) FROM sqlite_master WHERE type='index' AND name LIKE 'idx_memory_%';"),
-    "enhanced_query_time": "${enhanced_query_time}",
-    "sample_data": {
-        "total_entries": $(sqlite3 "${TEST_DB}" "SELECT COUNT(*) FROM memory_entries;"),
-        "entries_with_checksums": $(sqlite3 "${TEST_DB}" "SELECT COUNT(*) FROM memory_entries WHERE checksum != '';"),
-        "large_entries": $(sqlite3 "${TEST_DB}" "SELECT COUNT(*) FROM memory_entries WHERE size > 1000;")
-    }
-}
-EOF
-
-    success "Enhanced schema test completed: ${schema_test}"
-}
-
-# Test cross-agent memory sharing simulation
-test_cross_agent_sharing() {
-    info "Testing cross-agent memory sharing simulation..."
-
-    local sharing_test="${TEST_DIR}/sharing_test.json"
-
-    # Simulate cross-agent sharing by creating shared entries
-    sqlite3 "${TEST_DB}" << 'EOF'
--- Create shared memory entries
-INSERT OR REPLACE INTO memory_entries (
-    id, key, value, namespace, metadata, owner, access_level, created_at, updated_at, accessed_at
-) VALUES
-    ('shared_001', 'agent_coordination', '{"topology": "mesh", "agents": ["agent1", "agent2", "agent3"]}', 'coordination', '{"shared": true, "type": "coordination"}', 'agent1', 'shared', strftime('%s', 'now'), strftime('%s', 'now'), strftime('%s', 'now')),
-    ('shared_002', 'task_results', '{"task_id": "task_123", "status": "completed", "result": "success"}', 'tasks', '{"shared": true, "type": "results"}', 'agent2', 'shared', strftime('%s', 'now'), strftime('%s', 'now'), strftime('%s', 'now')),
-    ('shared_003', 'performance_metrics', '{"cpu": 45, "memory": 62, "latency": 15}', 'performance', '{"shared": true, "type": "metrics"}', 'agent3', 'public', strftime('%s', 'now'), strftime('%s', 'now'), strftime('%s', 'now'));
-
--- Test cross-agent queries
-EOF
-
-    # Test shared memory queries
-    local shared_query_time
-    shared_query_time=$(time sqlite3 "${TEST_DB}" "
-        SELECT
-            namespace,
-            access_level,
-            COUNT(*) as shared_entries,
-            GROUP_CONCAT(DISTINCT owner) as owners
-        FROM memory_entries
-        WHERE access_level IN ('shared', 'public')
-        GROUP BY namespace, access_level
-        ORDER BY shared_entries DESC;
-    " 2>&1 | grep real | awk '{print $2}')
-
-    cat > "${sharing_test}" << EOF
-{
-    "test_type": "cross_agent_sharing",
-    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
-    "shared_entries_created": $(sqlite3 "${TEST_DB}" "SELECT COUNT(*) FROM memory_entries WHERE access_level IN ('shared', 'public');"),
-    "unique_owners": $(sqlite3 "${TEST_DB}" "SELECT COUNT(DISTINCT owner) FROM memory_entries;"),
-    "shared_query_time": "${shared_query_time}",
-    "sharing_distribution": "$(sqlite3 "${TEST_DB}" "SELECT access_level, COUNT(*) FROM memory_entries GROUP BY access_level;" | tr '\n' '; ')"
-}
-EOF
-
-    success "Cross-agent sharing test completed: ${sharing_test}"
-}
-
-# Test performance under load
-test_performance_load() {
-    info "Testing performance under simulated load..."
-
-    local load_test="${TEST_DIR}/load_test.json"
-
-    # Create test data for load testing
-    sqlite3 "${TEST_DB}" << 'EOF'
-BEGIN TRANSACTION;
-
--- Insert load test data
-WITH RECURSIVE load_test(i) AS (
-    SELECT 1
-    UNION ALL
-    SELECT i + 1 FROM load_test WHERE i < 1000
-)
-INSERT INTO memory_entries (
-    id, key, value, namespace, metadata, owner, access_level, created_at, updated_at, accessed_at, size
-)
-SELECT
-    'load_test_' || i,
-    'test_key_' || i,
-    '{"test_data": "' || hex(randomblob(100)) || '", "iteration": ' || i || ', "timestamp": "' || datetime('now') || '"}',
-    'load_test',
-    '{"test": true, "iteration": ' || i || '}',
-    'load_tester',
-    CASE WHEN i % 3 = 0 THEN 'public' WHEN i % 3 = 1 THEN 'shared' ELSE 'private' END,
-    strftime('%s', 'now'),
-    strftime('%s', 'now'),
-    strftime('%s', 'now'),
-    200 + (i % 1000)
-FROM load_test;
-
-COMMIT;
-EOF
-
-    # Test concurrent-like operations
-    local batch_insert_time
-    batch_insert_time=$(time sqlite3 "${TEST_DB}" "
-        BEGIN TRANSACTION;
-        INSERT INTO memory_entries (id, key, value, namespace, metadata, owner, created_at, updated_at, accessed_at)
-        SELECT
-            'batch_' || abs(random() % 10000),
-            'batch_key_' || abs(random() % 1000),
-            '{\"batch_data\": \"' || hex(randomblob(50)) || '\"}',
-            'batch_test',
-            '{\"batch\": true}',
-            'batch_agent',
-            strftime('%s', 'now'),
-            strftime('%s', 'now'),
-            strftime('%s', 'now')
-        FROM (SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4 UNION SELECT 5);
-        COMMIT;
-    " 2>&1 | grep real | awk '{print $2}')
-
-    # Test complex aggregations
-    local aggregation_time
-    aggregation_time=$(time sqlite3 "${TEST_DB}" "
-        SELECT
-            namespace,
-            access_level,
-            COUNT(*) as entries,
-            AVG(size) as avg_size,
-            MIN(size) as min_size,
-            MAX(size) as max_size,
-            SUM(size) as total_size,
-            COUNT(DISTINCT owner) as unique_owners
-        FROM memory_entries
-        GROUP BY namespace, access_level
-        HAVING entries > 1
-        ORDER BY total_size DESC;
-    " 2>&1 | grep real | awk '{print $2}')
-
-    cat > "${load_test}" << EOF
-{
-    "test_type": "performance_load",
-    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
-    "total_entries_after_load": $(sqlite3 "${TEST_DB}" "SELECT COUNT(*) FROM memory_entries;"),
-    "load_test_entries": $(sqlite3 "${TEST_DB}" "SELECT COUNT(*) FROM memory_entries WHERE namespace = 'load_test';"),
-    "performance_metrics": {
-        "batch_insert_time": "${batch_insert_time}",
-        "aggregation_time": "${aggregation_time}",
-        "database_size_mb": $(($(stat -f%z "${TEST_DB}" 2>/dev/null || stat -c%s "${TEST_DB}") / 1024 / 1024))
-    },
-    "memory_distribution": "$(sqlite3 "${TEST_DB}" "SELECT namespace, COUNT(*) FROM memory_entries GROUP BY namespace ORDER BY COUNT(*) DESC LIMIT 10;" | tr '\n' '; ')"
-}
-EOF
-
-    success "Performance load test completed: ${load_test}"
-}
-
-# Test reliability features
-test_reliability_features() {
-    info "Testing reliability and transaction safety..."
-
-    local reliability_test="${TEST_DIR}/reliability_test.json"
-
-    # Test transaction rollback
-    sqlite3 "${TEST_DB}" << 'EOF'
-BEGIN TRANSACTION;
-INSERT INTO memory_entries (id, key, value, namespace, created_at, updated_at, accessed_at)
-VALUES ('rollback_test', 'test_key', 'test_value', 'test', strftime('%s', 'now'), strftime('%s', 'now'), strftime('%s', 'now'));
-ROLLBACK;
-EOF
-
-    local rollback_success
-    rollback_success=$(sqlite3 "${TEST_DB}" "SELECT COUNT(*) FROM memory_entries WHERE id = 'rollback_test';")
-
-    # Test WAL mode benefits
-    local wal_checkpoint
-    wal_checkpoint=$(sqlite3 "${TEST_DB}" "PRAGMA wal_checkpoint(FULL);" | awk '{print $1}')
-
-    # Test integrity
-    local integrity_check
-    integrity_check=$(sqlite3 "${TEST_DB}" "PRAGMA integrity_check;")
-
-    cat > "${reliability_test}" << EOF
-{
-    "test_type": "reliability_features",
-    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
-    "transaction_rollback_test": {
-        "rollback_entries_found": ${rollback_success},
-        "success": $([ ${rollback_success} -eq 0 ] && echo "true" || echo "false")
-    },
-    "wal_checkpoint": {
-        "result": "${wal_checkpoint}",
-        "success": $([ "${wal_checkpoint}" = "0" ] && echo "true" || echo "false")
-    },
-    "integrity_check": {
-        "result": "${integrity_check}",
-        "success": $([ "${integrity_check}" = "ok" ] && echo "true" || echo "false")
-    },
-    "database_info": {
-        "journal_mode": "$(sqlite3 "${TEST_DB}" "PRAGMA journal_mode;")",
-        "foreign_keys": "$(sqlite3 "${TEST_DB}" "PRAGMA foreign_keys;")",
-        "synchronous": "$(sqlite3 "${TEST_DB}" "PRAGMA synchronous;")"
-    }
-}
-EOF
-
-    success "Reliability test completed: ${reliability_test}"
-}
-
-# Generate comprehensive test report
-generate_test_report() {
-    info "Generating comprehensive test report..."
-
-    local report_file="${TEST_DIR}/enhanced_backend_test_report.md"
-
-    cat > "${report_file}" << EOF
-# Enhanced SQLite Backend Test Report
-
-## Test Summary
-- **Test Environment**: ${TEST_DIR}
-- **Test Date**: $(date)
-- **Source Database**: ${CURRENT_DB}
-- **Test Database**: ${TEST_DB}
-
-## Test Results Overview
-
-### 1. Basic Optimizations Test
-$(cat "${TEST_DIR}/basic_test.json" | jq -r '"- Cache Size: " + .settings_applied.cache_size + " pages"')
-$(cat "${TEST_DIR}/basic_test.json" | jq -r '"- Memory Mapping: " + (.settings_applied.mmap_size | tonumber / 1024 / 1024 / 1024 | floor | tostring) + "GB"')
-$(cat "${TEST_DIR}/basic_test.json" | jq -r '"- Performance Improvement: " + .performance.simple_count_before + " → " + .performance.simple_count_after')
-
-### 2. Enhanced Schema Test
-$(cat "${TEST_DIR}/schema_test.json" | jq -r '"- Enhanced Columns Added: " + (.enhanced_columns_added | tostring)')
-$(cat "${TEST_DIR}/schema_test.json" | jq -r '"- Indexes Created: " + (.indexes_created | tostring)')
-$(cat "${TEST_DIR}/schema_test.json" | jq -r '"- Schema Integrity: " + .schema_integrity')
-
-### 3. Cross-Agent Sharing Test
-$(cat "${TEST_DIR}/sharing_test.json" | jq -r '"- Shared Entries: " + (.shared_entries_created | tostring)')
-$(cat "${TEST_DIR}/sharing_test.json" | jq -r '"- Unique Owners: " + (.unique_owners | tostring)')
-
-### 4. Performance Load Test
-$(cat "${TEST_DIR}/load_test.json" | jq -r '"- Total Entries: " + (.total_entries_after_load | tostring)')
-$(cat "${TEST_DIR}/load_test.json" | jq -r '"- Database Size: " + (.performance_metrics.database_size_mb | tostring) + "MB"')
-
-### 5. Reliability Test
-$(cat "${TEST_DIR}/reliability_test.json" | jq -r '"- Transaction Rollback: " + (.transaction_rollback_test.success | tostring)')
-$(cat "${TEST_DIR}/reliability_test.json" | jq -r '"- WAL Checkpoint: " + (.wal_checkpoint.success | tostring)')
-$(cat "${TEST_DIR}/reliability_test.json" | jq -r '"- Integrity Check: " + (.integrity_check.success | tostring)')
-
-## Recommendations
-
-Based on test results:
-- ✅ Enhanced Backend is ready for activation
-- ✅ Performance optimizations are effective
-- ✅ Reliability features are working correctly
-- ✅ Cross-agent sharing capability validated
-
-## Next Steps
-1. Run activation script with --dry-run first
-2. Monitor system resources during activation
-3. Validate production performance after activation
-4. Enable advanced features gradually
-
-## Test Files Generated
-- Basic Test: ${TEST_DIR}/basic_test.json
-- Schema Test: ${TEST_DIR}/schema_test.json
-- Sharing Test: ${TEST_DIR}/sharing_test.json
-- Load Test: ${TEST_DIR}/load_test.json
-- Reliability Test: ${TEST_DIR}/reliability_test.json
-- Full Log: ${LOG_FILE}
-EOF
-
-    success "Test report generated: ${report_file}"
-    info "📊 Review all test results in: ${TEST_DIR}/"
-}
-
-# Cleanup test environment (optional)
-cleanup_test_environment() {
-    local keep_results=${1:-true}
-
-    if [[ "${keep_results}" == "false" ]]; then
-        info "Cleaning up test environment..."
-        rm -rf "${TEST_DIR}"
-        success "Test environment cleaned up"
-    else
-        info "Test environment preserved: ${TEST_DIR}"
-        info "Run with --cleanup to remove test files"
-    fi
-}
-
-# Main execution
-main() {
-    local cleanup=false
-
-    # Parse arguments
-    while [[ $# -gt 0 ]]; do
-        case $1 in
-            --cleanup)
-                cleanup=true
-                shift
-                ;;
-            --help)
-                echo "Enhanced SQLite Backend Test Script"
-                echo ""
-                echo "Usage: $0 [OPTIONS]"
-                echo ""
-                echo "Options:"
-                echo "  --cleanup    Remove test environment after completion"
-                echo "  --help       Show this help message"
-                echo ""
-                echo "This script tests Enhanced Backend features in isolation."
-                exit 0
-                ;;
-            *)
-                error "Unknown option: $1"
-                exit 1
-                ;;
-        esac
-    done
-
-    info "Starting Enhanced SQLite Backend testing..."
-
-    # Execute all tests
-    setup_test_environment
-    test_basic_optimizations
-    test_enhanced_schema
-    test_cross_agent_sharing
-    test_performance_load
-    test_reliability_features
-    generate_test_report
-
-    success "🧪 All tests completed successfully!"
-    success "📊 Test report: ${TEST_DIR}/enhanced_backend_test_report.md"
-
-    cleanup_test_environment "$([ "${cleanup}" == "true" ] && echo "false" || echo "true")"
-}
-
-# Execute main function
-main "$@"