vidi-macros 0.1.0

The proc macros for Vidi
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

//! Handler test cases

#![allow(clippy::unused_async)]
#![allow(clippy::unnecessary_wraps)]

use vidi_core::{Error, FromRequest, Handler, IntoResponse, Request, Result, StatusCode};
use vidi_macros::handler;

#[derive(Debug)]
struct Foo;

impl FromRequest for Foo {
    type Error = Error;

    async fn extract(_: &mut Request) -> Result<Self> {
        Ok(Self)
    }
}

#[derive(Debug)]
struct Bar;

impl FromRequest for Bar {
    type Error = Error;

    async fn extract(_: &mut Request) -> Result<Self> {
        Ok(Self)
    }
}

struct MyError(String);

impl From<MyError> for Error {
    fn from(MyError(err): MyError) -> Self {
        (StatusCode::INTERNAL_SERVER_ERROR, err).into_error()
    }
}

#[handler]
async fn a() -> impl IntoResponse {}

#[handler]
async fn b(_: Foo) -> Result<impl IntoResponse> {
    Ok(())
}

#[handler]
async fn c(_: Foo, _: Bar) -> Result<impl IntoResponse> {
    Ok(())
}

#[handler]
async fn d() {}

#[handler]
async fn e() -> StatusCode {
    StatusCode::OK
}

#[handler]
async fn f() -> (StatusCode, &'static str) {
    (StatusCode::OK, "Hello, World!")
}

#[handler]
async fn g() {}

#[handler]
async fn h(_: Foo) -> Result<()> {
    Ok(())
}

#[handler]
async fn i(_: Foo) -> Result<StatusCode> {
    Ok(StatusCode::OK)
}

#[handler]
async fn j(_: Foo) -> Result<StatusCode> {
    Err(MyError("custom error".to_string()).into())
}

#[handler]
fn aa() -> impl IntoResponse {}

#[handler]
fn bb(_: Foo) -> Result<impl IntoResponse> {
    Ok(())
}

#[handler]
fn cc(_: Foo, _: Bar) -> Result<impl IntoResponse> {
    Ok(())
}

#[handler]
const fn dd() {}

#[handler]
const fn ee() -> StatusCode {
    StatusCode::OK
}

#[handler]
const fn ff() -> (StatusCode, &'static str) {
    (StatusCode::OK, "Hello, World!")
}

#[handler]
const fn gg() {}

#[handler]
const fn hh(_: Foo) -> Result<()> {
    Ok(())
}

#[handler]
const fn ii(_: Foo) -> Result<StatusCode> {
    Ok(StatusCode::OK)
}

#[tokio::test]
async fn test_handler() -> anyhow::Result<()> {
    assert!(a.call(Request::default()).await.is_ok());
    assert!(b.call(Request::default()).await.is_ok());
    assert!(c.call(Request::default()).await.is_ok());
    assert!(d.call(Request::default()).await.is_ok());
    assert!(e.call(Request::default()).await.is_ok());
    assert!(f.call(Request::default()).await.is_ok());
    assert!(g.call(Request::default()).await.is_ok());
    assert!(h.call(Request::default()).await.is_ok());
    assert!(i.call(Request::default()).await.is_ok());
    assert!(j.call(Request::default()).await.is_err());

    assert!(aa.call(Request::default()).await.is_ok());
    assert!(bb.call(Request::default()).await.is_ok());
    assert!(cc.call(Request::default()).await.is_ok());
    assert!(dd.call(Request::default()).await.is_ok());
    assert!(ee.call(Request::default()).await.is_ok());
    assert!(ff.call(Request::default()).await.is_ok());
    assert!(gg.call(Request::default()).await.is_ok());
    assert!(hh.call(Request::default()).await.is_ok());
    assert!(ii.call(Request::default()).await.is_ok());

    Ok(())
}