trustcaptcha 3.0.0

TrustCaptcha – Privacy-first CAPTCHA solution for Rust. GDPR-compliant, bot protection made in Europe.
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use std::time::Duration;
use trustcaptcha::errors::{
    ApiKeyInvalidError, ServerUnreachableError, VerificationNotFinishedError,
    VerificationNotFoundError, VerificationResultExpiredError,
    VerificationResultRetrievalLimitReachedError, VerificationTokenInvalidError,
};
use trustcaptcha::trust_captcha::TrustCaptcha;

const VALID_TOKEN: &str =
    "eyJ2ZXJpZmljYXRpb25JZCI6IjAwMDAwMDAwLTAwMDAtMDAwMC0wMDAwLTAwMDAwMDAwMDAwMCJ9";
const NOT_FOUND_TOKEN: &str =
    "eyJ2ZXJpZmljYXRpb25JZCI6IjAwMDAwMDAwLTAwMDAtMDAwMC0wMDAwLTAwMDAwMDAwMDAwMSJ9";
const LOCKED_TOKEN: &str =
    "eyJ2ZXJpZmljYXRpb25JZCI6IjAwMDAwMDAwLTAwMDAtMDAwMC0wMDAwLTAwMDAwMDAwMDAwMiJ9";
const EXPIRED_TOKEN: &str =
    "eyJ2ZXJpZmljYXRpb25JZCI6IjAwMDAwMDAwLTAwMDAtMDAwMC0wMDAwLTAwMDAwMDAwMDAwMyJ9";
const LIMIT_REACHED_TOKEN: &str =
    "eyJ2ZXJpZmljYXRpb25JZCI6IjAwMDAwMDAwLTAwMDAtMDAwMC0wMDAwLTAwMDAwMDAwMDAwNCJ9";
const TOKEN_WITH_UNKNOWN_FIELDS: &str = "eyJ2ZXJpZmljYXRpb25JZCI6IjAwMDAwMDAwLTAwMDAtMDAwMC0wMDAwLTAwMDAwMDAwMDAwMCIsInVua25vd25GaWVsZCI6ImZvbyIsImFub3RoZXJKdW5rIjo0MiwibmVzdGVkIjp7IngiOjF9fQ==";

const VALID_API_KEY: &str = "ak_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";

fn tc(api_key: &str) -> trustcaptcha::trust_captcha::TrustCaptcha {
    TrustCaptcha::builder(api_key).build().expect("builder")
}

#[tokio::test]
async fn test_successful_verification() {
    let result = tc(VALID_API_KEY).get_verification_result(VALID_TOKEN).await;
    assert!(result.is_ok());
}

#[tokio::test]
async fn test_verification_token_invalid() {
    let result = tc(VALID_API_KEY)
        .get_verification_result("invalid_token")
        .await;
    assert!(matches!(
        result
            .unwrap_err()
            .downcast_ref::<VerificationTokenInvalidError>(),
        Some(_)
    ));
}

#[tokio::test]
async fn test_verification_token_invalid_when_base64_but_not_json() {
    // base64("not-a-json")
    let result = tc(VALID_API_KEY)
        .get_verification_result("bm90LWEtanNvbg==")
        .await;
    assert!(matches!(
        result
            .unwrap_err()
            .downcast_ref::<VerificationTokenInvalidError>(),
        Some(_)
    ));
}

#[tokio::test]
async fn test_verification_token_invalid_when_json_missing_verification_id() {
    // base64('{"foo":"bar"}')
    let result = tc(VALID_API_KEY)
        .get_verification_result("eyJmb28iOiJiYXIifQ==")
        .await;
    assert!(matches!(
        result
            .unwrap_err()
            .downcast_ref::<VerificationTokenInvalidError>(),
        Some(_)
    ));
}

#[tokio::test]
async fn test_verification_not_found() {
    let result = tc(VALID_API_KEY)
        .get_verification_result(NOT_FOUND_TOKEN)
        .await;
    assert!(result.is_err());
    assert!(matches!(
        result
            .unwrap_err()
            .downcast_ref::<VerificationNotFoundError>(),
        Some(_)
    ));
}

#[tokio::test]
async fn test_api_key_invalid() {
    let result = tc("invalid-key").get_verification_result(VALID_TOKEN).await;
    assert!(result.is_err());
    assert!(matches!(
        result.unwrap_err().downcast_ref::<ApiKeyInvalidError>(),
        Some(_)
    ));
}

#[tokio::test]
async fn test_verification_not_finished() {
    let result = tc(VALID_API_KEY)
        .get_verification_result(LOCKED_TOKEN)
        .await;
    assert!(result.is_err());
    assert!(matches!(
        result
            .unwrap_err()
            .downcast_ref::<VerificationNotFinishedError>(),
        Some(_)
    ));
}

#[tokio::test]
async fn test_verification_result_expired() {
    let result = tc(VALID_API_KEY)
        .get_verification_result(EXPIRED_TOKEN)
        .await;
    assert!(result.is_err());
    assert!(matches!(
        result
            .unwrap_err()
            .downcast_ref::<VerificationResultExpiredError>(),
        Some(_)
    ));
}

#[tokio::test]
async fn test_verification_result_retrieval_limit_reached() {
    let result = tc(VALID_API_KEY)
        .get_verification_result(LIMIT_REACHED_TOKEN)
        .await;
    assert!(result.is_err());
    assert!(matches!(
        result
            .unwrap_err()
            .downcast_ref::<VerificationResultRetrievalLimitReachedError>(),
        Some(_)
    ));
}

#[tokio::test]
async fn test_tolerates_unknown_fields_in_verification_token() {
    let result = tc(VALID_API_KEY)
        .get_verification_result(TOKEN_WITH_UNKNOWN_FIELDS)
        .await;
    assert!(result.is_ok());
}

#[tokio::test]
async fn test_throws_server_unreachable_on_unreachable_host() {
    let tc = TrustCaptcha::builder(VALID_API_KEY)
        .api_host("http://localhost:1")
        .connect_timeout(Duration::from_millis(500))
        .read_timeout(Duration::from_millis(500))
        .build()
        .expect("builder");
    let result = tc.get_verification_result(VALID_TOKEN).await;
    assert!(result.is_err());
    assert!(matches!(
        result.unwrap_err().downcast_ref::<ServerUnreachableError>(),
        Some(_)
    ));
}