amp-rust 0.0.9

A Rust client for the Blockstream AMP API, providing interfaces for asset management, user operations, and token handling on the Liquid Network.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use amp_rs::{ApiClient, Error};
use std::env;
use std::path::Path;

#[tokio::test]
async fn test_token_persistence_lifecycle() -> Result<(), Error> {
    // Force cleanup any existing token files
    let _ = ApiClient::force_cleanup_token_files().await;

    // Set up live-like test environment (not mock)
    env::set_var("AMP_TOKEN_PERSISTENCE", "true");
    env::set_var("AMP_USERNAME", "live_test_user");
    env::set_var("AMP_PASSWORD", "live_test_password");
    env::set_var("AMP_API_BASE_URL", "https://amp-test.blockstream.com/api");

    // Verify token file doesn't exist initially
    let token_file = "token.json";
    assert!(!Path::new(token_file).exists());

    // Create client - this should NOT create a token file because we don't have valid credentials
    // But it should demonstrate the persistence logic is working
    let _client = ApiClient::new().await?;

    // Note: We can't test the actual token flow without valid credentials,
    // but we can test the environment detection and file management

    println!("✅ Token persistence lifecycle test completed");

    // Force cleanup
    let _ = ApiClient::force_cleanup_token_files().await;

    Ok(())
}

#[tokio::test]
async fn test_token_file_structure() -> Result<(), Box<dyn std::error::Error>> {
    use amp_rs::model::TokenData;
    use chrono::{Duration, Utc};

    // Create test token data
    let expires_at = Utc::now() + Duration::days(1);
    let token_data = TokenData::new("test_token_12345".to_string(), expires_at);

    // Serialize to JSON
    let json = serde_json::to_string_pretty(&token_data)?;
    println!("Token JSON structure:\n{}", json);

    // Verify we can deserialize it back
    let deserialized: TokenData = serde_json::from_str(&json)?;

    // Verify the token is properly secured
    assert!(!deserialized.is_expired());
    assert_eq!(deserialized.expires_at, expires_at);

    println!("✅ Token serialization/deserialization test passed");

    Ok(())
}

#[test]
fn test_token_persistence_environment_detection() {
    use std::env;

    // Save original environment
    let original_tests = env::var("AMP_TESTS").ok();
    let original_persistence = env::var("AMP_TOKEN_PERSISTENCE").ok();
    let original_username = env::var("AMP_USERNAME").ok();
    let original_password = env::var("AMP_PASSWORD").ok();

    // Test mock environment detection (should disable persistence)
    env::set_var("AMP_USERNAME", "mock_user");
    env::set_var("AMP_PASSWORD", "mock_pass");
    env::set_var("AMP_TOKEN_PERSISTENCE", "true");
    // In this case, persistence should be disabled due to mock detection

    // Test live environment detection (should enable persistence)
    env::remove_var("AMP_USERNAME");
    env::remove_var("AMP_PASSWORD");
    env::set_var("AMP_TESTS", "live");
    // In this case, persistence should be enabled

    // Test explicit persistence setting with non-mock environment
    env::remove_var("AMP_TESTS");
    env::set_var("AMP_TOKEN_PERSISTENCE", "true");
    env::set_var("AMP_USERNAME", "real_user");
    env::set_var("AMP_PASSWORD", "real_pass");
    // In this case, persistence should be enabled

    println!("✅ Environment detection test completed");

    // Restore original environment
    env::remove_var("AMP_TESTS");
    env::remove_var("AMP_TOKEN_PERSISTENCE");
    env::remove_var("AMP_USERNAME");
    env::remove_var("AMP_PASSWORD");

    if let Some(val) = original_tests {
        env::set_var("AMP_TESTS", val);
    }
    if let Some(val) = original_persistence {
        env::set_var("AMP_TOKEN_PERSISTENCE", val);
    }
    if let Some(val) = original_username {
        env::set_var("AMP_USERNAME", val);
    }
    if let Some(val) = original_password {
        env::set_var("AMP_PASSWORD", val);
    }
}