rpc-agent 0.1.5

A modular Rust framework for building RPC-based agents with pluggable provider integrations
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

use crate::error::{ApiError, Error};
use crate::jwt::{Claims, decode_jwt};
use crate::message::Message;
use std::env;

/// Guard to ensure JWT_SECRET is removed from the environment after test, even on panic.
struct JwtSecretGuard {
    previous: Option<String>,
}
impl JwtSecretGuard {
    fn set(secret: &str) -> Self {
        let previous = env::var("JWT_SECRET").ok();
        unsafe { env::set_var("JWT_SECRET", secret) };
        JwtSecretGuard { previous }
    }

    fn delete() -> Self {
        let previous = env::var("JWT_SECRET").ok();
        unsafe { env::remove_var("JWT_SECRET") };
        JwtSecretGuard { previous }
    }
}
impl Drop for JwtSecretGuard {
    fn drop(&mut self) {
        match &self.previous {
            Some(previous) => unsafe { env::set_var("JWT_SECRET", previous) },
            None => unsafe { env::remove_var("JWT_SECRET") },
        }
    }
}

#[test]
#[serial_test::serial]
fn decode_jwt_expired_token() {
    let secret = "mysecret";
    let claims = Claims {
        prompt: "expired prompt".to_string(),
        exp: 1, // Expired long ago (Unix epoch)
    };
    let token = jsonwebtoken::encode(
        &jsonwebtoken::Header::default(),
        &claims,
        &jsonwebtoken::EncodingKey::from_secret(secret.as_bytes()),
    )
    .unwrap();
    let result = decode_jwt(&token, secret);
    assert!(matches!(result, Err(Error::InvalidJWTCredentials(_))));
}

#[test]
#[serial_test::serial]
fn decode_jwt_valid_token() {
    let secret = "mysecret";
    let claims = Claims {
        prompt: "test prompt".to_string(),
        exp: 9999999999,
    };
    let token = jsonwebtoken::encode(
        &jsonwebtoken::Header::default(),
        &claims,
        &jsonwebtoken::EncodingKey::from_secret(secret.as_bytes()),
    )
    .unwrap();
    let decoded = decode_jwt(&token, secret).unwrap();
    assert_eq!(decoded.prompt, "test prompt");
}

#[test]
fn decode_jwt_invalid_token() {
    let secret = "mysecret";
    let token = "invalid.token.value";
    let result = decode_jwt(token, secret);
    assert!(matches!(result, Err(Error::InvalidJWTCredentials(_))));
}

#[test]
#[serial_test::serial]
fn message_encrypted_variant_decrypts() {
    let secret = "testsecret";
    let _guard = JwtSecretGuard::set(secret);
    let claims = Claims {
        prompt: "encrypted prompt".to_string(),
        exp: 9999999999,
    };
    let token = jsonwebtoken::encode(
        &jsonwebtoken::Header::default(),
        &claims,
        &jsonwebtoken::EncodingKey::from_secret(secret.as_bytes()),
    )
    .unwrap();
    let msg = Message::Encrypted(token);
    let result: String = msg.try_into().unwrap();
    assert_eq!(result, "encrypted prompt");
}

#[test]
#[serial_test::serial]
fn message_encrypted_variant_no_secret() {
    let _guard = JwtSecretGuard::delete();
    let msg = Message::Encrypted("sometoken".to_string());
    let result: Result<String, ApiError> = msg.try_into();
    assert_eq!(
        result.unwrap_err().to_string(),
        ApiError::from(Error::NoJWTSecretFound).to_string()
    );
}