myid 0.1.10

Rust client library for MyID SDK API — user identification and verification
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::time::Duration;

use myid::client::MyIdClient;
use myid::config::Config;
use myid::error::MyIdResult;

fn fast_config(url: &str) -> MyIdResult<Config> {
    Ok(Config::new(url, "id", "secret")?
        .with_timeout(Duration::from_millis(100))?
        .with_connect_timeout(Duration::from_millis(100))?)
}

// ===== MyIdClient::new() =====

#[test]
fn new_with_valid_config() -> MyIdResult<()> {
    let config = Config::new("https://myid.uz", "id", "secret")?;
    assert!(MyIdClient::new(config).is_ok());
    Ok(())
}

#[test]
fn new_with_proxy() -> MyIdResult<()> {
    let config =
        Config::new("https://myid.uz", "id", "secret")?.with_proxy("http://proxy.local:8080")?;
    assert!(MyIdClient::new(config).is_ok());
    Ok(())
}

#[test]
fn new_with_custom_timeouts() -> MyIdResult<()> {
    let config = Config::new("https://myid.uz", "id", "secret")?
        .with_timeout(Duration::from_secs(60))?
        .with_connect_timeout(Duration::from_secs(10))?;
    assert!(MyIdClient::new(config).is_ok());
    Ok(())
}

// ===== Clone — shared cache =====

#[test]
fn clone_shares_token_cache() -> MyIdResult<()> {
    let client = MyIdClient::new(Config::new("https://myid.uz", "id", "secret")?)?;
    let cloned = client.clone();
    drop(cloned);
    drop(client);
    Ok(())
}

// ===== get_token — server yo'q =====

#[tokio::test]
async fn get_token_without_server_returns_error() -> MyIdResult<()> {
    // Mavjud bo'lmagan yoki yopiq serverga ulanish — xato kutamiz
    let config = fast_config("http://127.0.0.1:1")?;
    let client = MyIdClient::new(config)?;
    assert!(client.get_token().await.is_err());
    Ok(())
}

// ===== create_session — server yo'q =====

#[tokio::test]
async fn create_session_without_server_returns_error() -> MyIdResult<()> {
    let config = fast_config("http://127.0.0.1:1")?;
    let client = MyIdClient::new(config)?;
    let request = myid::dto::CreateSessionRequest::Empty {};
    assert!(client.create_session(&request).await.is_err());
    Ok(())
}

// ===== recover_session — server yo'q =====

#[tokio::test]
async fn recover_session_without_server_returns_error() -> MyIdResult<()> {
    let config = fast_config("http://127.0.0.1:1")?;
    let client = MyIdClient::new(config)?;
    let session_id = myid::types::SessionId::parse("550e8400-e29b-41d4-a716-446655440000")
        .expect("to'g'ri UUID");
    assert!(client.recover_session(session_id).await.is_err());
    Ok(())
}

// ===== handle_callback =====

#[tokio::test]
async fn handle_callback_empty_code_returns_validation_error() -> MyIdResult<()> {
    // Server bilan bog'lanmasdan ham validatsiya xatosi qaytishi kerak
    let config = fast_config("http://127.0.0.1:1")?;
    let client = MyIdClient::new(config)?;

    let err = client.handle_callback("").await.unwrap_err();
    assert!(matches!(err, myid::error::MyIdError::Validation { .. }));
    Ok(())
}

#[tokio::test]
async fn handle_callback_whitespace_code_returns_validation_error() -> MyIdResult<()> {
    let config = fast_config("http://127.0.0.1:1")?;
    let client = MyIdClient::new(config)?;

    let err = client.handle_callback("   ").await.unwrap_err();
    assert!(matches!(err, myid::error::MyIdError::Validation { .. }));
    Ok(())
}

#[tokio::test]
async fn handle_callback_without_server_returns_error() -> MyIdResult<()> {
    let config = fast_config("http://127.0.0.1:1")?;
    let client = MyIdClient::new(config)?;
    let code = "550e8400-e29b-41d4-a716-446655440000";
    assert!(client.handle_callback(code).await.is_err());
    Ok(())
}

// ===== Clone — parallel get_token =====

#[tokio::test]
async fn cloned_clients_share_error_path() -> MyIdResult<()> {
    let config = fast_config("http://127.0.0.1:1")?;
    let client = MyIdClient::new(config)?;
    let c1 = client.clone();
    let c2 = client.clone();

    let (r1, r2) = tokio::join!(c1.get_token(), c2.get_token());
    assert!(r1.is_err());
    assert!(r2.is_err());
    Ok(())
}