product-os-command-control 0.0.27

// Integration tests for ProductOSController

mod test_helpers;
use test_helpers::{create_test_certificates, create_test_configuration, create_test_key_value_store};

use product_os_command_control::ProductOSController;

#[test]
fn test_controller_creation() {
    let config = create_test_configuration();
    let certs = create_test_certificates();
    let kv_store = Some(create_test_key_value_store());
    
    #[cfg(feature = "relational_store")]
    let controller = ProductOSController::new(
        config,
        certs,
        kv_store,
        None,
    );
    
    #[cfg(not(feature = "relational_store"))]
    let controller = ProductOSController::new(
        config,
        certs,
        kv_store,
    );
    
    // Verify controller was created successfully
    assert!(controller.get_registry().get_me().get_identifier().len() > 0);
}

#[test]
fn test_controller_get_registry() {
    let config = create_test_configuration();
    let certs = create_test_certificates();
    let kv_store = Some(create_test_key_value_store());
    
    #[cfg(feature = "relational_store")]
    let controller = ProductOSController::new(
        config,
        certs,
        kv_store,
        None,
    );
    
    #[cfg(not(feature = "relational_store"))]
    let controller = ProductOSController::new(
        config,
        certs,
        kv_store,
    );
    
    let registry = controller.get_registry();
    let me = registry.get_me();
    
    assert!(!me.get_identifier().is_empty());
}

#[test]
fn test_controller_get_max_servers() {
    let config = create_test_configuration();
    let certs = create_test_certificates();
    
    #[cfg(feature = "relational_store")]
    let controller = ProductOSController::new(
        config,
        certs,
        None,
        None,
    );
    
    #[cfg(not(feature = "relational_store"))]
    let controller = ProductOSController::new(
        config,
        certs,
        None,
    );
    
    let max_servers = controller.get_max_servers();
    assert!(max_servers > 0);
}

#[test]
fn test_controller_get_certificates() {
    let config = create_test_configuration();
    let certs = create_test_certificates();
    let expected_cert = certs.certificates[0].clone();
    
    #[cfg(feature = "relational_store")]
    let controller = ProductOSController::new(
        config,
        certs,
        None,
        None,
    );
    
    #[cfg(not(feature = "relational_store"))]
    let controller = ProductOSController::new(
        config,
        certs,
        None,
    );
    
    let certificates = controller.get_certificates();
    assert!(!certificates.is_empty());
    assert_eq!(certificates[0], expected_cert.as_slice());
}

#[test]
fn test_controller_get_private_key() {
    let config = create_test_configuration();
    let certs = create_test_certificates();
    let expected_key = certs.private.clone();
    
    #[cfg(feature = "relational_store")]
    let controller = ProductOSController::new(
        config,
        certs,
        None,
        None,
    );
    
    #[cfg(not(feature = "relational_store"))]
    let controller = ProductOSController::new(
        config,
        certs,
        None,
    );
    
    let private_key = controller.get_private_key();
    assert_eq!(private_key, expected_key.as_slice());
}

#[test]
fn test_controller_validate_certificate() {
    let config = create_test_configuration();
    let certs = create_test_certificates();
    let cert_data = certs.certificates[0].clone();
    
    #[cfg(feature = "relational_store")]
    let controller = ProductOSController::new(
        config,
        certs,
        None,
        None,
    );
    
    #[cfg(not(feature = "relational_store"))]
    let controller = ProductOSController::new(
        config,
        certs,
        None,
    );
    
    // Should validate own certificate
    assert!(controller.validate_certificate(&cert_data));
    
    // Should not validate random certificate
    let fake_cert = vec![1, 2, 3, 4, 5];
    assert!(!controller.validate_certificate(&fake_cert));
}

#[test]
fn test_controller_get_configuration() {
    let config = create_test_configuration();
    let certs = create_test_certificates();
    
    #[cfg(feature = "relational_store")]
    let controller = ProductOSController::new(
        config.clone(),
        certs,
        None,
        None,
    );
    
    #[cfg(not(feature = "relational_store"))]
    let controller = ProductOSController::new(
        config.clone(),
        certs,
        None,
    );
    
    let retrieved_config = controller.get_configuration();
    assert_eq!(retrieved_config.environment, config.environment);
}

#[test]
fn test_controller_create_key_session() {
    let config = create_test_configuration();
    let certs = create_test_certificates();
    
    #[cfg(feature = "relational_store")]
    let mut controller = ProductOSController::new(
        config,
        certs,
        None,
        None,
    );
    
    #[cfg(not(feature = "relational_store"))]
    let mut controller = ProductOSController::new(
        config,
        certs,
        None,
    );
    
    let (session_id, public_key) = controller.create_key_session();
    
    assert!(!session_id.is_empty());
    assert_eq!(public_key.len(), 32); // Diffie-Hellman public key size
}

#[test]
fn test_controller_get_key_value_store() {
    let config = create_test_configuration();
    let certs = create_test_certificates();
    let kv_store = Some(create_test_key_value_store());
    
    #[cfg(feature = "relational_store")]
    let mut controller = ProductOSController::new(
        config,
        certs,
        kv_store,
        None,
    );
    
    #[cfg(not(feature = "relational_store"))]
    let mut controller = ProductOSController::new(
        config,
        certs,
        kv_store,
    );
    
    let store = controller.get_key_value_store();
    assert!(std::ptr::addr_of!(*store) as usize > 0);
}