waddling-errors-macros 0.7.3

//! Test: Verify sequence_value field is populated correctly
//!
//! This example verifies that the diag! macro correctly populates
//! the sequence_value field with the numeric value from sequence! definitions.
//!
//! ## What This Tests
//!
//! - sequence! generates numeric constants (e.g., TOKEN_EXPIRED = 1)
//! - diag! populates sequence_value with the actual number (not 0)
//! - The value is accessible at runtime via the DiagnosticRuntime struct
//!
//! ## Running
//!
//! ```bash
//! cargo run --example test_sequence_value --features metadata
//! ```

// Primaries intentionally use CamelCase to match E.Component.Primary.SEQUENCE format
#![allow(non_upper_case_globals)]

#[cfg(not(feature = "metadata"))]
compile_error!(
    "\n\n\
    ❌ This example requires the 'metadata' feature!\n\
    \n\
    Run with: cargo run --example test_sequence_value --features metadata\n\
    "
);

use waddling_errors_macros::{diag, setup};

// Define sequences with specific numeric values
pub mod sequences {
    use waddling_errors_macros::sequence;

    sequence! {
        TOKEN_EXPIRED(1) {
            description: "Authentication token has expired",
            typical_severity: "Error",
        },

        INVALID_CREDENTIALS(2) {
            description: "Invalid username or password",
            typical_severity: "Error",
        },

        RATE_LIMIT(5) {
            description: "Too many requests",
            typical_severity: "Warning",
        },

        CONNECTION_FAILED(10) {
            description: "Network connection failed",
            typical_severity: "Error",
        },
    }
}

pub mod components {
    use waddling_errors_macros::component;

    component! {
        pub enum Component {
            Auth {
                docs: "Authentication component",
            },
        }
    }

    pub use Component::*;
}

pub mod primaries {
    use waddling_errors_macros::primary;

    primary! {
        pub enum Primary {
            Token {
                description: "Token-related errors",
            },
        }
    }

    pub use Primary::*;
}

setup! {
    components = crate::components,
    primaries = crate::primaries,
    sequences = crate::sequences,
}

// Define diagnostics - these should have correct sequence_value populated
diag! {
    strict(component, primary, sequence, naming, duplicates, sequence_values, string_values),
    E.Auth.Token.TOKEN_EXPIRED: {
        message: "Your session has expired",
    },

    E.Auth.Token.INVALID_CREDENTIALS: {
        message: "Invalid credentials provided",
    },

    W.Auth.Token.RATE_LIMIT: {
        message: "Too many login attempts",
    },

    E.Auth.Token.CONNECTION_FAILED: {
        message: "Cannot reach authentication server",
    },
}

fn main() {
    println!("🦆 Testing sequence_value Population\n");
    println!("=====================================\n");

    // Test 1: Verify sequence constants exist and have correct values
    println!("✅ Test 1: Sequence constants");
    println!("   TOKEN_EXPIRED = {}", sequences::TOKEN_EXPIRED);
    assert_eq!(sequences::TOKEN_EXPIRED, 1);

    println!(
        "   INVALID_CREDENTIALS = {}",
        sequences::INVALID_CREDENTIALS
    );
    assert_eq!(sequences::INVALID_CREDENTIALS, 2);

    println!("   RATE_LIMIT = {}", sequences::RATE_LIMIT);
    assert_eq!(sequences::RATE_LIMIT, 5);

    println!("   CONNECTION_FAILED = {}", sequences::CONNECTION_FAILED);
    assert_eq!(sequences::CONNECTION_FAILED, 10);
    println!();

    // Test 2: Verify DiagnosticRuntime has correct sequence_value
    println!("✅ Test 2: DiagnosticRuntime sequence_value field");

    println!(
        "   E_AUTH_TOKEN_TOKEN_EXPIRED.sequence = \"{}\"",
        E_AUTH_TOKEN_TOKEN_EXPIRED.sequence
    );
    println!(
        "   E_AUTH_TOKEN_TOKEN_EXPIRED.sequence_value = {}",
        E_AUTH_TOKEN_TOKEN_EXPIRED.sequence_value
    );
    assert_eq!(
        E_AUTH_TOKEN_TOKEN_EXPIRED.sequence_value, 1,
        "sequence_value should be 1, not 0!"
    );

    println!(
        "   E_AUTH_TOKEN_INVALID_CREDENTIALS.sequence_value = {}",
        E_AUTH_TOKEN_INVALID_CREDENTIALS.sequence_value
    );
    assert_eq!(
        E_AUTH_TOKEN_INVALID_CREDENTIALS.sequence_value, 2,
        "sequence_value should be 2, not 0!"
    );

    println!(
        "   W_AUTH_TOKEN_RATE_LIMIT.sequence_value = {}",
        W_AUTH_TOKEN_RATE_LIMIT.sequence_value
    );
    assert_eq!(
        W_AUTH_TOKEN_RATE_LIMIT.sequence_value, 5,
        "sequence_value should be 5, not 0!"
    );

    println!(
        "   E_AUTH_TOKEN_CONNECTION_FAILED.sequence_value = {}",
        E_AUTH_TOKEN_CONNECTION_FAILED.sequence_value
    );
    assert_eq!(
        E_AUTH_TOKEN_CONNECTION_FAILED.sequence_value, 10,
        "sequence_value should be 10, not 0!"
    );
    println!();

    // Test 3: Verify sequence string matches the constant name
    println!("✅ Test 3: Sequence string names match");
    assert_eq!(E_AUTH_TOKEN_TOKEN_EXPIRED.sequence, "TOKEN_EXPIRED");
    assert_eq!(
        E_AUTH_TOKEN_INVALID_CREDENTIALS.sequence,
        "INVALID_CREDENTIALS"
    );
    assert_eq!(W_AUTH_TOKEN_RATE_LIMIT.sequence, "RATE_LIMIT");
    assert_eq!(E_AUTH_TOKEN_CONNECTION_FAILED.sequence, "CONNECTION_FAILED");
    println!("   All sequence names match correctly\n");

    // Test 4: Verify full code format includes all parts
    println!("✅ Test 4: Full diagnostic codes");
    println!("   {}", E_AUTH_TOKEN_TOKEN_EXPIRED.code);
    assert_eq!(
        E_AUTH_TOKEN_TOKEN_EXPIRED.code,
        "E.Auth.Token.TOKEN_EXPIRED"
    );

    println!("   {}", E_AUTH_TOKEN_INVALID_CREDENTIALS.code);
    assert_eq!(
        E_AUTH_TOKEN_INVALID_CREDENTIALS.code,
        "E.Auth.Token.INVALID_CREDENTIALS"
    );

    println!("   {}", W_AUTH_TOKEN_RATE_LIMIT.code);
    assert_eq!(W_AUTH_TOKEN_RATE_LIMIT.code, "W.Auth.Token.RATE_LIMIT");

    println!("   {}", E_AUTH_TOKEN_CONNECTION_FAILED.code);
    assert_eq!(
        E_AUTH_TOKEN_CONNECTION_FAILED.code,
        "E.Auth.Token.CONNECTION_FAILED"
    );
    println!();

    println!("=====================================");
    println!("🎉 All tests passed!\n");
    println!("This proves:");
    println!("  • sequence! generates numeric constants (1, 2, 5, 10)");
    println!("  • diag! populates sequence_value correctly (not hardcoded to 0)");
    println!("  • The value is accessible at runtime");
    println!("  • Sequence strings and values are consistent");
    println!("\n✨ The sequence_value bug is FIXED! ✨");
}