test server with h2 over tcp

ntex/src/http/h2/dispatcher.rs

@@ -123,12 +123,7 @@ where
                         on_connect.set(&mut req.extensions_mut());
                     }
 
-                    crate::rt::spawn(ServiceResponse::<
-                        S::Future,
-                        S::Response,
-                        S::Error,
-                        B,
-                    > {
+                    crate::rt::spawn(ServiceResponse {
                         state: ServiceResponseState::ServiceCall(
                             this.config.service.call(req),
                             Some(res),

ntex/src/server/worker.rs

@@ -605,6 +605,14 @@ mod tests {
         let _ = lazy(|cx| Pin::new(&mut worker).poll(cx)).await;
         assert!(avail.available());
 
+        *st.lock().unwrap() = St::Pending;
+        let _ = lazy(|cx| Pin::new(&mut worker).poll(cx)).await;
+        assert!(!avail.available());
+
+        *st.lock().unwrap() = St::Ready;
+        let _ = lazy(|cx| Pin::new(&mut worker).poll(cx)).await;
+        assert!(avail.available());
+
         // restart
         *st.lock().unwrap() = St::Fail;
         let _ = lazy(|cx| Pin::new(&mut worker).poll(cx)).await;

ntex/src/web/test.rs

@@ -1000,7 +1000,7 @@ mod tests {
         let data = req.app_data::<web::types::Data<u64>>().unwrap();
         assert_eq!(*data.get_ref(), 20);
 
-        // let req = TestRequest::with_uri("/test").to_http_
+        assert_eq!(format!("{:?}", StreamType::Tcp), "StreamType::Tcp");
     }
 
     #[ntex_rt::test]
@@ -1216,4 +1216,30 @@ mod tests {
         let res = srv.put("").send().await.unwrap();
         assert_eq!(srv.load_body(res).await.unwrap(), Bytes::new());
     }
+
+    #[ntex_rt::test]
+    async fn test_h2_tcp() {
+        let srv = server_with(TestServerConfig::default().h2(), || {
+            App::new().service(
+                web::resource("/").route(web::get().to(|| async { HttpResponse::Ok() })),
+            )
+        });
+
+        let client = Client::build()
+            .connector(
+                Connector::default()
+                    .secure_connector(Service::map(
+                        crate::connect::Connector::default(),
+                        |stream| (stream, crate::http::Protocol::Http2),
+                    ))
+                    .finish(),
+            )
+            .timeout(time::Duration::from_millis(30000))
+            .finish();
+
+        let url = format!("https://localhost:{}/", srv.addr.port());
+        let response = client.get(url).send().await.unwrap();
+        assert_eq!(response.version(), Version::HTTP_2);
+        assert!(response.status().is_success());
+    }
 }