openauth-core 0.0.2

Core types and primitives for OpenAuth.
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

use http::{Method, Request, StatusCode};
use openauth_core::api::{response, ApiRequest, AsyncAuthEndpoint, AuthEndpoint, AuthRouter};
use openauth_core::context::{create_auth_context, AuthContext};
use openauth_core::error::OpenAuthError;
use openauth_core::options::OpenAuthOptions;

fn sync_endpoint() -> AuthEndpoint {
    AuthEndpoint {
        path: "/sync".to_owned(),
        method: Method::GET,
        handler: |_context: &AuthContext, _request: ApiRequest| {
            response(StatusCode::OK, b"SYNC".to_vec())
        },
    }
}

fn async_endpoint(path: &str) -> AsyncAuthEndpoint {
    AsyncAuthEndpoint::new(
        path.to_owned(),
        Method::GET,
        |_context: &AuthContext, _request: ApiRequest| {
            Box::pin(async move { response(StatusCode::OK, b"ASYNC".to_vec()) })
        },
    )
}

#[tokio::test]
async fn handle_async_runs_async_endpoint() -> Result<(), Box<dyn std::error::Error>> {
    let context = create_auth_context(OpenAuthOptions {
        secret: Some("secret-a-at-least-32-chars-long!!".to_owned()),
        ..OpenAuthOptions::default()
    })?;
    let router =
        AuthRouter::with_async_endpoints(context, Vec::new(), vec![async_endpoint("/async")])?;

    let response = router
        .handle_async(
            Request::builder()
                .method(Method::GET)
                .uri("http://localhost:3000/api/auth/async")
                .body(Vec::new())?,
        )
        .await?;

    assert_eq!(response.status(), StatusCode::OK);
    assert_eq!(response.body(), b"ASYNC");
    Ok(())
}

#[tokio::test]
async fn handle_async_can_run_existing_sync_endpoints() -> Result<(), Box<dyn std::error::Error>> {
    let context = create_auth_context(OpenAuthOptions {
        secret: Some("secret-a-at-least-32-chars-long!!".to_owned()),
        ..OpenAuthOptions::default()
    })?;
    let router = AuthRouter::with_async_endpoints(context, vec![sync_endpoint()], Vec::new())?;

    let response = router
        .handle_async(
            Request::builder()
                .method(Method::GET)
                .uri("http://localhost:3000/api/auth/sync")
                .body(Vec::new())?,
        )
        .await?;

    assert_eq!(response.status(), StatusCode::OK);
    assert_eq!(response.body(), b"SYNC");
    Ok(())
}

#[test]
fn sync_handle_rejects_async_only_endpoint() -> Result<(), Box<dyn std::error::Error>> {
    let context = create_auth_context(OpenAuthOptions {
        secret: Some("secret-a-at-least-32-chars-long!!".to_owned()),
        ..OpenAuthOptions::default()
    })?;
    let router =
        AuthRouter::with_async_endpoints(context, Vec::new(), vec![async_endpoint("/async")])?;

    let error = match router.handle(
        Request::builder()
            .method(Method::GET)
            .uri("http://localhost:3000/api/auth/async")
            .body(Vec::new())?,
    ) {
        Ok(_) => return Err("sync handle unexpectedly accepted async endpoint".into()),
        Err(error) => error,
    };

    assert_eq!(
        error,
        OpenAuthError::Api("async endpoint requires AuthRouter::handle_async".to_owned())
    );
    Ok(())
}

#[test]
fn async_endpoint_conflicts_with_sync_endpoint() -> Result<(), Box<dyn std::error::Error>> {
    let context = create_auth_context(OpenAuthOptions {
        secret: Some("secret-a-at-least-32-chars-long!!".to_owned()),
        ..OpenAuthOptions::default()
    })?;

    let result = AuthRouter::with_async_endpoints(
        context,
        vec![AuthEndpoint {
            path: "/same".to_owned(),
            method: Method::GET,
            handler: |_context: &AuthContext, _request: ApiRequest| {
                response(StatusCode::OK, Vec::new())
            },
        }],
        vec![async_endpoint("/same")],
    );

    assert!(result.is_err());
    Ok(())
}