leeca_proxmox 0.3.0

A modern, safe, and async-first SDK for interacting with Proxmox Virtual Environment servers
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

use crate::{ProxmoxClient, ProxmoxResult};
use dotenvy::dotenv;
use std::env;
use tempfile::NamedTempFile;

fn setup() {
    dotenv().ok();
}

#[tokio::test]
#[ignore = "requires running Proxmox instance and environment variables"]
async fn test_integration_login_success() -> ProxmoxResult<()> {
    setup();
    let host = env::var("PROXMOX_HOST").expect("PROXMOX_HOST not set");
    let port: u16 = env::var("PROXMOX_PORT")
        .expect("PROXMOX_PORT not set")
        .parse()
        .expect("invalid port");
    let username = env::var("PROXMOX_USERNAME").expect("PROXMOX_USERNAME not set");
    let password = env::var("PROXMOX_PASSWORD").expect("PROXMOX_PASSWORD not set");
    let realm = env::var("PROXMOX_REALM").expect("PROXMOX_REALM not set");

    let mut client = ProxmoxClient::builder()
        .host(host)
        .port(port)
        .credentials(username, password, realm)
        .secure(true)
        .accept_invalid_certs(true) // allow self-signed certs for testing
        .build()
        .await?;

    client.login().await?;
    assert!(client.is_authenticated().await);
    assert!(client.auth_token().await.is_some());
    assert!(client.csrf_token().await.is_some());

    Ok(())
}

#[tokio::test]
#[ignore = "requires running Proxmox instance and environment variables"]
async fn test_integration_login_invalid_credentials() -> ProxmoxResult<()> {
    setup();
    let host = env::var("PROXMOX_HOST").expect("PROXMOX_HOST not set");
    let port: u16 = env::var("PROXMOX_PORT")
        .expect("PROXMOX_PORT not set")
        .parse()
        .expect("invalid port");
    let realm = env::var("PROXMOX_REALM").expect("PROXMOX_REALM not set");

    let mut client = ProxmoxClient::builder()
        .host(host)
        .port(port)
        .credentials("invalid_user", "invalid_pass", realm)
        .secure(true)
        .accept_invalid_certs(true)
        .build()
        .await?;

    let result = client.login().await;
    assert!(result.is_err());
    // Optionally check error type
    // assert!(matches!(result.unwrap_err(), ProxmoxError::Authentication(_)));
    Ok(())
}

#[tokio::test]
#[ignore = "requires running Proxmox instance and environment variables"]
async fn test_integration_session_persistence() -> ProxmoxResult<()> {
    setup();
    let host = env::var("PROXMOX_HOST").expect("PROXMOX_HOST not set");
    let port: u16 = env::var("PROXMOX_PORT")
        .expect("PROXMOX_PORT not set")
        .parse()
        .expect("invalid port");
    let username = env::var("PROXMOX_USERNAME").expect("PROXMOX_USERNAME not set");
    let password = env::var("PROXMOX_PASSWORD").expect("PROXMOX_PASSWORD not set");
    let realm = env::var("PROXMOX_REALM").expect("PROXMOX_REALM not set");

    // Create client and login
    let mut client = ProxmoxClient::builder()
        .host(&host)
        .port(port)
        .credentials(username.clone(), password.clone(), realm.clone())
        .secure(true)
        .accept_invalid_certs(true)
        .build()
        .await?;

    client.login().await?;
    assert!(client.is_authenticated().await);

    // Save session to a temporary file
    let temp_file = NamedTempFile::new().unwrap();
    let path = temp_file.path().to_path_buf();
    client.save_session_to_file(&path).await?;

    // Create a new client with the same connection settings and load the session
    let new_client = ProxmoxClient::builder()
        .host(host)
        .port(port)
        .credentials(username, password, realm)
        .secure(true)
        .accept_invalid_certs(true)
        .with_session(std::fs::File::open(&path)?)
        .await?
        .build()
        .await?;

    // Should be authenticated without calling login
    assert!(new_client.is_authenticated().await);
    assert_eq!(
        client.auth_token().await.unwrap().as_str(),
        new_client.auth_token().await.unwrap().as_str()
    );

    Ok(())
}