codex-memory 3.0.15

//! Configuration Alignment Tests
//!
//! Tests for CODEX-CONFIG-001, CODEX-VERSION-001, and CODEX-DB-002
//! Validates configuration documentation, version consistency, and migration system alignment

use std::fs;
use std::process::Command;

/// Test for CODEX-CONFIG-001: Configuration Documentation Gap
/// Validates that .env.example matches actual system capabilities
#[tokio::test]
async fn test_config_documentation_alignment() -> anyhow::Result<()> {
    // Read .env.example
    let env_example = fs::read_to_string("/Users/ladvien/codex/.env.example")?;

    // Verify simplified configuration
    assert!(env_example.contains("Simple Text Storage Service Configuration"));
    assert!(env_example.contains(
        "5 core tools: store_memory, get_memory, delete_memory, get_statistics, store_file"
    ));

    // Verify removed feature documentation
    assert!(env_example.contains("REMOVED FEATURES (for reference):"));
    assert!(env_example.contains("Embedding providers"));
    assert!(env_example.contains("Memory tier system"));
    assert!(env_example.contains("Ollama integration"));

    // Verify only essential configuration remains
    let non_comment_lines: Vec<&str> = env_example
        .lines()
        .filter(|line| !line.trim().starts_with('#') && !line.trim().is_empty())
        .collect();

    // Should have exactly 4 non-comment configuration lines
    assert_eq!(
        non_comment_lines.len(),
        4,
        "Should have 4 essential config lines, found: {:?}",
        non_comment_lines
    );

    // Verify essential configurations are present
    assert!(env_example.contains("DATABASE_URL="));
    assert!(env_example.contains("TEST_DATABASE_URL="));
    assert!(env_example.contains("LOG_LEVEL="));
    assert!(env_example.contains("MCP_PORT="));

    // Verify configuration evolution is documented
    assert!(env_example.contains("85 advanced config lines → 12 essential lines"));

    Ok(())
}

/// Test for CODEX-VERSION-001: Version Consistency
/// Validates that all version references use CARGO_PKG_VERSION
#[tokio::test]
async fn test_version_consistency() -> anyhow::Result<()> {
    // Read Cargo.toml to get source of truth version
    let cargo_toml = fs::read_to_string("/Users/ladvien/codex/Cargo.toml")?;
    let cargo_version = cargo_toml
        .lines()
        .find(|line| line.contains("version = "))
        .and_then(|line| line.split('"').nth(1))
        .expect("Version should be found in Cargo.toml");

    // Verify main.rs uses env!("CARGO_PKG_VERSION")
    let main_rs = fs::read_to_string("/Users/ladvien/codex/src/main.rs")?;
    assert!(main_rs.contains("version = env!(\"CARGO_PKG_VERSION\")"));
    assert!(!main_rs.contains("version = \"2.0.0\""));

    // Verify MCP server uses env!("CARGO_PKG_VERSION")
    let mcp_mod = fs::read_to_string("/Users/ladvien/codex/src/mcp_server/mod.rs")?;
    assert!(mcp_mod.contains("version\": env!(\"CARGO_PKG_VERSION\")"));
    assert!(!mcp_mod.contains("version\": \"2.0.0\""));

    // Test that CLI shows correct version
    let output = Command::new("cargo")
        .args(["run", "--bin", "codex-memory", "--", "--version"])
        .current_dir("/Users/ladvien/codex")
        .output()?;

    let version_output = String::from_utf8(output.stdout)?;
    assert!(
        version_output.contains(cargo_version),
        "CLI version output should contain {}, got: {}",
        cargo_version,
        version_output
    );

    Ok(())
}

/// Test for CODEX-DB-002: Migration System Conflicts  
/// Validates that database.rs doesn't create tier enum that migration 004 removes
#[tokio::test]
async fn test_migration_system_alignment() -> anyhow::Result<()> {
    // Read database core.rs file
    let database_code = fs::read_to_string("/Users/ladvien/codex/src/database/core.rs")?;

    // Verify memory_tier enum creation is removed
    assert!(
        !database_code.contains("CREATE TYPE memory_tier AS ENUM"),
        "database.rs should not create memory_tier enum that migration 004 removes"
    );

    // Verify tier references are removed from table creation
    assert!(
        !database_code.contains("tier memory_tier"),
        "table creation should not reference tier column"
    );

    // Read migration 004 to verify it drops tier system
    let migration_004 =
        fs::read_to_string("/Users/ladvien/codex/migrations/004_remove_tier_system.sql")?;
    assert!(migration_004.contains("DROP TYPE IF EXISTS memory_tier"));
    assert!(migration_004.contains("DROP COLUMN IF EXISTS tier"));

    // Verify the database code comment acknowledges tier system removal
    assert!(
        database_code.contains("tier system removed as of migration 004")
            || database_code.contains("Migration 004")
            || !database_code.contains("tier"),
        "database.rs should acknowledge tier system removal"
    );

    Ok(())
}

/// Test setup.sh script alignment with actual capabilities
#[tokio::test]
async fn test_setup_script_alignment() -> anyhow::Result<()> {
    let setup_script = fs::read_to_string("/Users/ladvien/codex/scripts/setup/setup.sh")?;

    // Verify updated banner and descriptions
    assert!(setup_script.contains("Simple Text Storage Service Setup"));
    assert!(setup_script.contains("Basic MCP Text Storage System"));
    assert!(!setup_script.contains("Agentic Memory System"));
    assert!(!setup_script.contains("Advanced AI Memory Management"));

    // Verify Ollama references are removed
    assert!(!setup_script.contains("OLLAMA_HOST"));
    assert!(!setup_script.contains("ollama pull"));
    assert!(!setup_script.contains("Ollama is running"));

    // Verify correct CLI commands are used (setup script still uses 'codex')
    assert!(setup_script.contains("cargo run --bin codex setup"));
    assert!(setup_script.contains("cargo run --bin codex mcp"));
    assert!(setup_script.contains("cargo run --bin codex stats"));

    // Verify invalid commands are removed
    assert!(!setup_script.contains("database setup"));
    assert!(!setup_script.contains("models"));
    assert!(!setup_script.contains("health --detailed"));
    assert!(!setup_script.contains("init-config"));

    // Verify capability notes are added
    assert!(setup_script.contains("no Ollama/embedding requirements"));
    assert!(setup_script.contains("simplified from advanced system"));

    Ok(())
}

/// Comprehensive configuration alignment validation
#[tokio::test]
async fn test_complete_configuration_alignment() -> anyhow::Result<()> {
    // Test that the system can be built and run with current configuration
    let build_output = Command::new("cargo")
        .args(["check", "--bin", "codex-memory"])
        .current_dir("/Users/ladvien/codex")
        .output()?;

    assert!(
        build_output.status.success(),
        "Build should succeed: {}",
        String::from_utf8_lossy(&build_output.stderr)
    );

    // Test that CLI help shows consistent information
    let help_output = Command::new("cargo")
        .args(["run", "--bin", "codex-memory", "--", "--help"])
        .current_dir("/Users/ladvien/codex")
        .output()?;

    let help_text = String::from_utf8(help_output.stdout)?;
    assert!(help_text.contains("Simple text storage service with MCP interface"));
    assert!(help_text.contains("codex-memory"));

    // Verify MCP tools list matches documentation
    // This requires database setup but validates the complete system alignment

    Ok(())
}

/// Test that .env.example can be used as a template
#[tokio::test]
async fn test_env_example_usability() -> anyhow::Result<()> {
    let env_example = fs::read_to_string("/Users/ladvien/codex/.env.example")?;

    // Verify all required configs have example values
    assert!(env_example.contains("DATABASE_URL=postgresql://"));
    assert!(env_example.contains("TEST_DATABASE_URL=postgresql://"));

    // Verify optional configs have reasonable defaults
    assert!(env_example.contains("LOG_LEVEL=info"));
    assert!(env_example.contains("MCP_PORT=3333"));

    // Verify no references to removed features in active config lines
    let active_lines: Vec<&str> = env_example
        .lines()
        .filter(|line| !line.trim().starts_with('#') && !line.trim().is_empty())
        .collect();

    for line in &active_lines {
        assert!(
            !line.contains("OLLAMA"),
            "Active config should not reference Ollama: {}",
            line
        );
        assert!(
            !line.contains("EMBEDDING"),
            "Active config should not reference embeddings: {}",
            line
        );
        assert!(
            !line.contains("TIER"),
            "Active config should not reference tiers: {}",
            line
        );
    }

    Ok(())
}