db/heromodels/examples/test_signature_functionality.rs

use heromodels::models::legal::{ContractSigner, SignerStatus};

fn main() {
    println!("Testing ContractSigner Signature Functionality");
    println!("==============================================\n");

    // Test 1: Create a new signer (should have no signature data)
    println!("Test 1: New signer creation");
    let mut signer = ContractSigner::new(
        "test-signer-001".to_string(),
        "Test User".to_string(),
        "test@example.com".to_string(),
    );
    
    println!("  Signer created: {}", signer.name);
    println!("  Status: {:?}", signer.status);
    println!("  Signature data: {:?}", signer.signature_data);
    assert_eq!(signer.signature_data, None);
    assert_eq!(signer.status, SignerStatus::Pending);
    println!("  ✓ New signer has no signature data and is pending\n");

    // Test 2: Sign with signature data
    println!("Test 2: Sign with signature data");
    let signature_data = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==".to_string();
    let comments = "I agree to all terms and conditions.".to_string();
    
    signer.sign(Some(signature_data.clone()), Some(comments.clone()));
    
    println!("  Status after signing: {:?}", signer.status);
    println!("  Signed at: {:?}", signer.signed_at);
    println!("  Comments: {:?}", signer.comments);
    println!("  Signature data length: {}", signer.signature_data.as_ref().unwrap().len());
    
    assert_eq!(signer.status, SignerStatus::Signed);
    assert!(signer.signed_at.is_some());
    assert_eq!(signer.signature_data, Some(signature_data));
    assert_eq!(signer.comments, Some(comments));
    println!("  ✓ Signing with signature data works correctly\n");

    // Test 3: Sign without signature data
    println!("Test 3: Sign without signature data");
    let mut signer2 = ContractSigner::new(
        "test-signer-002".to_string(),
        "Test User 2".to_string(),
        "test2@example.com".to_string(),
    );
    
    signer2.sign(None, Some("Electronic signature without visual data".to_string()));
    
    println!("  Status: {:?}", signer2.status);
    println!("  Signature data: {:?}", signer2.signature_data);
    println!("  Comments: {:?}", signer2.comments);
    
    assert_eq!(signer2.status, SignerStatus::Signed);
    assert_eq!(signer2.signature_data, None);
    assert!(signer2.comments.is_some());
    println!("  ✓ Signing without signature data works correctly\n");

    // Test 4: Sign with no comments or signature
    println!("Test 4: Simple signing (no signature, no comments)");
    let mut signer3 = ContractSigner::new(
        "test-signer-003".to_string(),
        "Test User 3".to_string(),
        "test3@example.com".to_string(),
    );
    
    signer3.sign(None, None);
    
    println!("  Status: {:?}", signer3.status);
    println!("  Signature data: {:?}", signer3.signature_data);
    println!("  Comments: {:?}", signer3.comments);
    
    assert_eq!(signer3.status, SignerStatus::Signed);
    assert_eq!(signer3.signature_data, None);
    assert_eq!(signer3.comments, None);
    println!("  ✓ Simple signing works correctly\n");

    // Test 5: Builder pattern with signature data
    println!("Test 5: Builder pattern with signature data");
    let signer_with_signature = ContractSigner::new(
        "test-signer-004".to_string(),
        "Builder User".to_string(),
        "builder@example.com".to_string(),
    )
    .status(SignerStatus::Pending)
    .signature_data("data:image/png;base64,example")
    .comments("Pre-signed with builder pattern");

    println!("  Signer: {}", signer_with_signature.name);
    println!("  Status: {:?}", signer_with_signature.status);
    println!("  Signature data: {:?}", signer_with_signature.signature_data);
    println!("  Comments: {:?}", signer_with_signature.comments);
    
    assert_eq!(signer_with_signature.signature_data, Some("data:image/png;base64,example".to_string()));
    println!("  ✓ Builder pattern with signature data works correctly\n");

    // Test 6: Clear signature data
    println!("Test 6: Clear signature data");
    let cleared_signer = signer_with_signature.clear_signature_data();
    println!("  Signature data after clear: {:?}", cleared_signer.signature_data);
    assert_eq!(cleared_signer.signature_data, None);
    println!("  ✓ Clear signature data works correctly\n");

    // Test 7: Serialization/Deserialization test
    println!("Test 7: Serialization/Deserialization");
    let original_signer = ContractSigner::new(
        "serialize-test".to_string(),
        "Serialize User".to_string(),
        "serialize@example.com".to_string(),
    )
    .signature_data("test-signature-data")
    .comments("Test serialization");

    // Serialize to JSON
    let json = serde_json::to_string(&original_signer).expect("Failed to serialize");
    println!("  Serialized JSON length: {} characters", json.len());
    
    // Deserialize from JSON
    let deserialized_signer: ContractSigner = serde_json::from_str(&json).expect("Failed to deserialize");
    
    println!("  Original signature data: {:?}", original_signer.signature_data);
    println!("  Deserialized signature data: {:?}", deserialized_signer.signature_data);
    
    assert_eq!(original_signer.signature_data, deserialized_signer.signature_data);
    assert_eq!(original_signer.name, deserialized_signer.name);
    assert_eq!(original_signer.email, deserialized_signer.email);
    println!("  ✓ Serialization/Deserialization works correctly\n");

    // Test 8: Backward compatibility test
    println!("Test 8: Backward compatibility");
    // Simulate old JSON without signature_data field
    let old_json = r#"{
        "id": "old-signer",
        "name": "Old User",
        "email": "old@example.com",
        "status": "Pending",
        "signed_at": null,
        "comments": null,
        "last_reminder_mail_sent_at": null
    }"#;
    
    let old_signer: ContractSigner = serde_json::from_str(old_json).expect("Failed to deserialize old format");
    println!("  Old signer name: {}", old_signer.name);
    println!("  Old signer signature data: {:?}", old_signer.signature_data);
    
    assert_eq!(old_signer.signature_data, None);
    println!("  ✓ Backward compatibility works correctly\n");

    println!("All tests passed! ✅");
    println!("ContractSigner signature functionality is working correctly.");
    
    // Summary
    println!("\n📋 Summary of Features Tested:");
    println!("  ✅ New signer creation (signature_data: None)");
    println!("  ✅ Signing with signature data");
    println!("  ✅ Signing without signature data");
    println!("  ✅ Simple signing (no data, no comments)");
    println!("  ✅ Builder pattern with signature data");
    println!("  ✅ Clear signature data functionality");
    println!("  ✅ JSON serialization/deserialization");
    println!("  ✅ Backward compatibility with old data");
    println!("\n🎯 Ready for production use!");
}