vane 0.8.15

A flow-based reverse proxy with multi-layer routing and programmable pipelines.
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

/* src/api/response.rs */

use axum::{
	http::StatusCode,
	response::{IntoResponse, Json},
};
use serde::Serialize;

// A generic structure for all API responses.
#[derive(Serialize)]
struct ApiResponse<T: Serialize> {
	status: &'static str,
	#[serde(skip_serializing_if = "Option::is_none")]
	data: Option<T>,
	#[serde(skip_serializing_if = "Option::is_none")]
	message: Option<String>,
}

/// Creates a successful (200 OK) API response.
///
/// # Arguments
///
/// * `data` - Any data that implements `serde::Serialize`.
///
pub fn success<T: Serialize>(data: T) -> impl IntoResponse {
	let response = ApiResponse {
		status: "success",
		data: Some(data),
		message: None,
	};
	(StatusCode::OK, Json(response))
}

/// Creates an error API response.
///
/// # Arguments
///
/// * `status_code` - The HTTP status code for the response.
/// * `message` - A descriptive error message.
///
#[must_use]
pub fn error(status_code: StatusCode, message: String) -> impl IntoResponse {
	let response = ApiResponse::<()> {
		// No data is sent on error
		status: "error",
		data: None,
		message: Some(message),
	};
	(status_code, Json(response))
}

#[cfg(test)]
mod tests {
	use super::*;
	use axum::body::to_bytes;
	use axum::response::Response;
	use serde::Serialize;
	use serde_json::{Value, json};

	/// A simple struct for testing success responses with data.
	#[derive(Serialize, Debug, PartialEq)]
	struct TestData {
		id: u32,
		name: String,
	}

	/// Helper function to get the JSON body from a response.
	async fn get_body_as_json(response: Response) -> Value {
		let body_bytes = to_bytes(response.into_body(), usize::MAX).await.unwrap();
		serde_json::from_slice(&body_bytes).unwrap()
	}

	/// Tests that the success response is formatted correctly.
	#[tokio::test]
	async fn test_success_response_format() {
		let test_data = TestData {
			id: 123,
			name: "test-item".to_string(),
		};

		let response = success(test_data).into_response();

		assert_eq!(response.status(), StatusCode::OK);

		let body = get_body_as_json(response).await;

		assert_eq!(body["status"], "success");
		assert_eq!(body["data"]["id"], 123);
		assert_eq!(body["data"]["name"], "test-item");
		assert_eq!(body["message"], json!(null));
	}

	/// Tests that the error response is formatted correctly.
	#[tokio::test]
	async fn test_error_response_format() {
		let error_message = "Resource not found".to_string();
		let status_code = StatusCode::NOT_FOUND;

		let response = error(status_code, error_message.clone()).into_response();

		assert_eq!(response.status(), status_code);

		let body = get_body_as_json(response).await;

		assert_eq!(body["status"], "error");
		assert_eq!(body["message"], error_message);
		assert_eq!(body["data"], json!(null));
	}
}