1#![warn(clippy::pedantic)]
2#![allow(clippy::module_name_repetitions)]
3#![cfg_attr(
4 not(any(
5 feature = "json",
6 feature = "msgpack",
7 feature = "bincode",
8 feature = "bitcode",
9 feature = "cbor",
10 feature = "yaml",
11 feature = "toml"
12 )),
13 allow(unreachable_code, unused_variables)
14)]
15#![cfg_attr(not(miri), doc = include_str!("../README.md"))]
16
17mod content;
18mod decode;
19mod encode;
20pub mod extract;
21pub mod handler;
22pub mod rejection;
23pub mod response;
24pub mod routing;
25
26pub use content::{Accept, ContentType};
27pub use decode::CodecDecode;
28pub use encode::CodecEncode;
29pub use extract::{BorrowCodec, Codec};
30pub use handler::CodecHandler;
31pub use rejection::CodecRejection;
32pub use response::IntoCodecResponse;
33
34#[doc(hidden)]
35pub mod __private {
36 #[cfg(feature = "bincode")]
37 pub use bincode;
38 #[cfg(feature = "bitcode")]
39 pub use bitcode;
40 #[cfg(feature = "aide")]
41 pub use schemars;
42 #[cfg(feature = "serde")]
43 pub use serde;
44 #[cfg(feature = "validator")]
45 pub use validator;
46}
47
48pub use axum_codec_macros as macros;
49#[cfg(feature = "macros")]
50pub use macros::apply;
51#[cfg(feature = "macros")]
52pub use macros::debug_handler;
53#[cfg(feature = "macros")]
54pub use macros::debug_middleware;
55
56#[cfg(test)]
57mod test {
58 use std::borrow::Cow;
59
60 use super::*;
61
62 #[apply(decode, encode)]
63 #[derive(Debug, PartialEq)]
64 struct Data {
65 string: String,
66 integer: i32,
67 boolean: bool,
68 }
69
70 #[apply(decode, encode)]
71 #[derive(Debug, PartialEq)]
72 struct BorrowedData<'a> {
73 string: Cow<'a, str>,
74 integer: i32,
75 boolean: bool,
76 }
77
78 fn data() -> Data {
79 Data {
80 string: "hello".into(),
81 integer: 42,
82 boolean: true,
83 }
84 }
85
86 fn borrowed_data<'a>() -> BorrowedData<'a> {
87 BorrowedData {
88 string: Cow::Borrowed("hello"),
89 integer: 42,
90 boolean: true,
91 }
92 }
93
94 #[test]
95 fn test_msgpack_roundtrip() {
96 let data = data();
97 let encoded = Codec(&data).to_msgpack().unwrap();
98
99 let Codec(decoded) = Codec::<Data>::from_msgpack(&encoded).unwrap();
100
101 assert_eq!(decoded, data);
102 }
103
104 #[test]
105 fn test_borrowed_msgpack_roundtrip() {
106 let data = borrowed_data();
107 let encoded = Codec(&data).to_msgpack().unwrap();
108
109 let Codec(decoded) = Codec::<BorrowedData>::from_msgpack(&encoded).unwrap();
110
111 assert_eq!(decoded, data);
112 }
113
114 #[test]
115 fn test_json_roundtrip() {
116 let data = data();
117 let encoded = Codec(&data).to_json().unwrap();
118
119 let Codec(decoded) = Codec::<Data>::from_json(&encoded).unwrap();
120
121 assert_eq!(decoded, data);
122 }
123
124 #[test]
125 fn test_borrowed_json_roundtrip() {
126 let data = borrowed_data();
127 let encoded = Codec(&data).to_json().unwrap();
128
129 let Codec(decoded) = Codec::<BorrowedData>::from_json(&encoded).unwrap();
130
131 assert_eq!(decoded, data);
132 }
133
134 #[test]
135 fn test_form_roundtrip() {
136 let data = data();
137 let encoded = Codec(&data).to_form().unwrap();
138
139 let Codec(decoded) = Codec::<Data>::from_form(&encoded).unwrap();
140
141 assert_eq!(decoded, data);
142 }
143
144 #[test]
145 fn test_borrowed_form_roundtrip() {
146 let data = borrowed_data();
147 let encoded = Codec(&data).to_form().unwrap();
148
149 let Codec(decoded) = Codec::<BorrowedData>::from_form(&encoded).unwrap();
150
151 assert_eq!(decoded, data);
152 }
153
154 #[test]
155 #[cfg(feature = "cbor")]
156 fn test_cbor_roundtrip() {
157 let data = data();
158 let encoded = Codec(&data).to_cbor().unwrap();
159
160 let Codec(decoded) = Codec::<Data>::from_cbor(&encoded).unwrap();
161
162 assert_eq!(decoded, data);
163 }
164
165 #[test]
166 #[cfg(feature = "cbor")]
167 fn test_borrowed_cbor_roundtrip() {
168 let data = borrowed_data();
169 let encoded = Codec(&data).to_cbor().unwrap();
170
171 let Codec(decoded) = Codec::<BorrowedData>::from_cbor(&encoded).unwrap();
172
173 assert_eq!(decoded, data);
174 }
175
176 #[test]
177 fn test_yaml_roundtrip() {
178 let data = data();
179 let encoded = Codec(&data).to_yaml().unwrap();
180
181 let Codec(decoded) = Codec::<Data>::from_yaml(&encoded).unwrap();
182
183 assert_eq!(decoded, data);
184 }
185
186 #[test]
187 fn test_borrowed_yaml_roundtrip() {
188 let data = borrowed_data();
189 let encoded = Codec(&data).to_yaml().unwrap();
190
191 let Codec(decoded) = Codec::<BorrowedData>::from_yaml(&encoded).unwrap();
192
193 assert_eq!(decoded, data);
194 }
195
196 #[test]
197 fn test_toml_roundtrip() {
198 let data = data();
199 let encoded = Codec(&data).to_toml().unwrap();
200
201 let Codec(decoded) = Codec::<Data>::from_toml(&encoded).unwrap();
202
203 assert_eq!(decoded, data);
204 }
205
206 #[test]
207 fn test_borrowed_toml_roundtrip() {
208 let data = borrowed_data();
209 let encoded = Codec(&data).to_toml().unwrap();
210
211 let Codec(decoded) = Codec::<BorrowedData>::from_toml(&encoded).unwrap();
212
213 assert_eq!(decoded, data);
214 }
215
216 #[test]
217 fn test_bincode_roundtrip() {
218 let data = data();
219 let encoded = Codec(&data).to_bincode().unwrap();
220
221 let Codec(decoded) = Codec::<Data>::from_bincode(&encoded).unwrap();
222
223 assert_eq!(decoded, data);
224 }
225
226 #[test]
227 fn test_borrowed_bincode_roundtrip() {
228 let data = borrowed_data();
229 let encoded = Codec(&data).to_bincode().unwrap();
230
231 let Codec(decoded) = Codec::<BorrowedData>::from_bincode(&encoded).unwrap();
232
233 assert_eq!(decoded, data);
234 }
235
236 #[test]
237 #[cfg(feature = "bitcode")]
238 fn test_bitcode_roundtrip() {
239 let encoded = Codec(data()).to_bitcode();
240
241 let Codec(decoded) = Codec::<Data>::from_bitcode(&encoded).unwrap();
242
243 assert_eq!(decoded, data());
244 }
245
246 #[test]
247 #[cfg(feature = "bitcode")]
248 fn test_borrowed_bitcode_roundtrip() {
249 let encoded = Codec(borrowed_data()).to_bitcode();
250
251 let Codec(decoded) = Codec::<BorrowedData>::from_bitcode(&encoded).unwrap();
252
253 assert_eq!(decoded, borrowed_data());
254 }
255}