1 // Copyright (c) 2025 Huawei Device Co., Ltd.
2 // Licensed under the Apache License, Version 2.0 (the "License");
3 // you may not use this file except in compliance with the License.
4 // You may obtain a copy of the License at
5 //
6 // http://www.apache.org/licenses/LICENSE-2.0
7 //
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
13
14 #![cfg(all(feature = "async", feature = "http1_1", feature = "tokio_base"))]
15 mod common;
16 use std::convert::Infallible;
17
18 // use tokio::sync::mpsc::{Receiver, Sender};
19 use ylong_http::response::status::StatusCode;
20 use ylong_http::version::Version;
21 use ylong_http_client::async_impl::{Body, Client, Request};
22
23 use crate::common::init_test_work_runtime;
24
25 #[test]
26 #[cfg(not(feature = "__tls"))]
sdv_async_http10_get()27 fn sdv_async_http10_get() {
28 define_service_handle!(HTTP;);
29
30 async fn server_fn(
31 _req: hyper::Request<hyper::Body>,
32 ) -> Result<hyper::Response<hyper::Body>, Infallible> {
33 let response = hyper::Response::builder()
34 .status(hyper::StatusCode::OK)
35 .body(hyper::Body::empty())
36 .expect("build hyper response failed");
37 Ok(response)
38 }
39
40 let rt = init_test_work_runtime(4);
41
42 let (tx, rx) = std::sync::mpsc::channel();
43
44 rt.block_on(async move {
45 let mut handle = start_http_server!(HTTP; server_fn);
46 handle
47 .server_start
48 .recv()
49 .await
50 .expect("recv server start msg failed !");
51 tx.send(handle)
52 .expect("send Handle out the server coroutine failed !");
53 });
54
55 let mut handle = rx.recv().expect("recv Handle failed !");
56
57 let client = Client::builder().build().expect("Build Client failed.");
58
59 let request = Request::builder()
60 .url(format!("{}:{}", "127.0.0.1", handle.port).as_str())
61 .version("HTTP/1.0")
62 .method("GET")
63 .body(Body::empty())
64 .expect("Client build Request failed.");
65
66 rt.block_on(async move {
67 let response = client.request(request).await.expect("get response failed");
68 assert_eq!(response.status(), StatusCode::OK);
69 assert_eq!(response.version(), &Version::HTTP1_0);
70
71 handle
72 .client_shutdown
73 .send(())
74 .await
75 .expect("send client shutdown");
76 handle
77 .server_shutdown
78 .recv()
79 .await
80 .expect("server shutdown");
81 })
82 }
83
84 #[test]
85 #[cfg(feature = "__tls")]
sdv_async_https10_get()86 fn sdv_async_https10_get() {
87 define_service_handle!(HTTPS;);
88
89 async fn server_fn(
90 _req: hyper::Request<hyper::Body>,
91 ) -> Result<hyper::Response<hyper::Body>, Infallible> {
92 let response = hyper::Response::builder()
93 .status(hyper::StatusCode::OK)
94 .body(hyper::Body::empty())
95 .expect("build hyper response failed");
96 Ok(response)
97 }
98
99 let rt = init_test_work_runtime(4);
100
101 let mut handles_vec = vec![];
102 start_server!(
103 HTTPS;
104 ServerNum: 1,
105 Runtime: rt,
106 Handles: handles_vec,
107 ServeFnName: server_fn,
108 );
109 let handle = handles_vec.pop().expect("No more handles !");
110
111 let client = Client::builder()
112 .danger_accept_invalid_certs(true)
113 .build()
114 .expect("Build Client failed.");
115
116 let request = Request::builder()
117 .url(format!("{}:{}", "127.0.0.1", handle.port).as_str())
118 .version("HTTP/1.0")
119 .method("GET")
120 .body(Body::empty())
121 .expect("Client build Request failed.");
122
123 rt.block_on(async move {
124 let response = client.request(request).await.expect("Request send failed");
125 assert_eq!(response.status(), StatusCode::OK);
126 assert_eq!(response.version(), &Version::HTTP1_0);
127 });
128 }
129
130 #[test]
131 #[cfg(not(feature = "__tls"))]
sdv_async_http10_connect()132 fn sdv_async_http10_connect() {
133 define_service_handle!(HTTP;);
134
135 async fn server_fn(
136 _req: hyper::Request<hyper::Body>,
137 ) -> Result<hyper::Response<hyper::Body>, Infallible> {
138 let response = hyper::Response::builder()
139 .status(hyper::StatusCode::OK)
140 .body(hyper::Body::empty())
141 .expect("build hyper response failed");
142 Ok(response)
143 }
144
145 let rt = init_test_work_runtime(4);
146
147 let (tx, rx) = std::sync::mpsc::channel();
148
149 rt.block_on(async move {
150 let mut handle = start_http_server!(HTTP; server_fn);
151 handle
152 .server_start
153 .recv()
154 .await
155 .expect("recv server start msg failed !");
156 tx.send(handle)
157 .expect("send Handle out the server coroutine failed !");
158 });
159
160 let mut handle = rx.recv().expect("recv Handle failed !");
161
162 let client = Client::builder().build().expect("Build Client failed.");
163
164 let request = Request::builder()
165 .url(format!("{}:{}", "127.0.0.1", handle.port).as_str())
166 .version("HTTP/1.0")
167 .method("CONNECT")
168 .body(Body::empty())
169 .expect("Client build Request failed.");
170
171 rt.block_on(async move {
172 let response = client.request(request).await;
173 assert!(response.is_err());
174
175 handle
176 .client_shutdown
177 .send(())
178 .await
179 .expect("send client shutdown");
180 handle
181 .server_shutdown
182 .recv()
183 .await
184 .expect("server shutdown");
185 })
186 }
187
188 #[test]
189 #[cfg(not(feature = "__tls"))]
sdv_async_http10_no_support()190 fn sdv_async_http10_no_support() {
191 define_service_handle!(HTTP;);
192
193 async fn server_fn(
194 req: hyper::Request<hyper::Body>,
195 ) -> Result<hyper::Response<hyper::Body>, Infallible> {
196 if req.version() == hyper::Version::HTTP_10 {
197 return Ok(hyper::Response::builder()
198 .status(hyper::StatusCode::HTTP_VERSION_NOT_SUPPORTED)
199 .body(hyper::Body::empty())
200 .unwrap());
201 }
202 let response = hyper::Response::builder()
203 .status(hyper::StatusCode::OK)
204 .body(hyper::Body::empty())
205 .expect("build hyper response failed");
206 Ok(response)
207 }
208
209 let rt = init_test_work_runtime(4);
210
211 let (tx, rx) = std::sync::mpsc::channel();
212
213 rt.block_on(async move {
214 let mut handle = start_http_server!(HTTP; server_fn);
215 handle
216 .server_start
217 .recv()
218 .await
219 .expect("recv server start msg failed !");
220 tx.send(handle)
221 .expect("send Handle out the server coroutine failed !");
222 });
223
224 let mut handle = rx.recv().expect("recv Handle failed !");
225
226 let client = Client::builder().build().expect("Build Client failed.");
227
228 let request = Request::builder()
229 .url(format!("{}:{}", "127.0.0.1", handle.port).as_str())
230 .version("HTTP/1.0")
231 .method("CONNECT")
232 .body(Body::empty())
233 .expect("Client build Request failed.");
234
235 rt.block_on(async move {
236 let response = client.request(request).await;
237 assert!(response.is_err());
238
239 handle
240 .client_shutdown
241 .send(())
242 .await
243 .expect("send client shutdown");
244 handle
245 .server_shutdown
246 .recv()
247 .await
248 .expect("server shutdown");
249 })
250 }
251