axum-enum-response 0.2.0

Easily create axum::http::Response's from Enums!
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

use std::string::FromUtf8Error;

use axum::{
	body::Body,
	http::{Response, StatusCode},
	response::IntoResponse,
};
use axum_enum_response::EnumIntoResponse;
use futures::StreamExt;

#[derive(serde::Serialize)]
struct UnauthorizedStruct {
	a: String,
	b: i32,
}

#[derive(EnumIntoResponse)]
enum TestResponse {
	#[status_code(OK)]
	Ok(#[key("aga")] &'static str),
	#[status_code(UNAUTHORIZED)]
	Unauthorized(UnauthorizedStruct),
	#[status_code(INTERNAL_SERVER_ERROR)]
	InternalServerError,
	#[status_code(INTERNAL_SERVER_ERROR)]
	FromUtf8Error(#[from] FromUtf8Error),
}

async fn get_body(res: Response<Body>) -> String {
	let stream = res.into_body().into_data_stream();
	String::from_utf8(
		stream
			.collect::<Vec<_>>()
			.await
			.into_iter()
			.map(|v| v.unwrap())
			.collect::<Vec<_>>()
			.concat(),
	)
	.unwrap()
}

#[tokio::test]
async fn compiles() {
	{
		let res = TestResponse::Ok("Hello World").into_response();
		assert_eq!(res.status(), StatusCode::OK);

		let body = get_body(res).await;
		assert_eq!(body, "{\"aga\":\"Hello World\"}");
	}

	{
		let res = TestResponse::Unauthorized(UnauthorizedStruct {
			a: "Hi".into(),
			b: 1337,
		})
		.into_response();
		assert_eq!(res.status(), StatusCode::UNAUTHORIZED);

		let body = get_body(res).await;
		assert_eq!(body, "{\"a\":\"Hi\",\"b\":1337}");
	}

	{
		let res = TestResponse::InternalServerError.into_response();
		assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);

		let body = get_body(res).await;
		assert_eq!(body, "");
	}
}