chore: add vendor directory

2 files changed, 323 insertions, 0 deletions

diff --git a/vendor/tonic-reflection/tests/server.rs b/vendor/tonic-reflection/tests/server.rs
new file mode 100644
index 00000000..778e887e
--- /dev/null
+++ b/vendor/tonic-reflection/tests/server.rs
@@ -0,0 +1,151 @@
+#![allow(missing_docs)]
+
+use prost::Message;
+use std::net::SocketAddr;
+use tokio::sync::oneshot;
+use tokio_stream::{wrappers::TcpListenerStream, StreamExt};
+use tonic::{transport::Server, Request};
+use tonic_reflection::{
+    pb::v1::{
+        server_reflection_client::ServerReflectionClient,
+        server_reflection_request::MessageRequest, server_reflection_response::MessageResponse,
+        ServerReflectionRequest, ServiceResponse, FILE_DESCRIPTOR_SET,
+    },
+    server::Builder,
+};
+
+pub(crate) fn get_encoded_reflection_service_fd() -> Vec<u8> {
+    let mut expected = Vec::new();
+    prost_types::FileDescriptorSet::decode(FILE_DESCRIPTOR_SET)
+        .expect("decode reflection service file descriptor set")
+        .file[0]
+        .encode(&mut expected)
+        .expect("encode reflection service file descriptor");
+    expected
+}
+
+#[tokio::test]
+async fn test_list_services() {
+    let response = make_test_reflection_request(ServerReflectionRequest {
+        host: "".to_string(),
+        message_request: Some(MessageRequest::ListServices(String::new())),
+    })
+    .await;
+
+    if let MessageResponse::ListServicesResponse(services) = response {
+        assert_eq!(
+            services.service,
+            vec![ServiceResponse {
+                name: String::from("grpc.reflection.v1.ServerReflection")
+            }]
+        );
+    } else {
+        panic!("Expected a ListServicesResponse variant");
+    }
+}
+
+#[tokio::test]
+async fn test_file_by_filename() {
+    let response = make_test_reflection_request(ServerReflectionRequest {
+        host: "".to_string(),
+        message_request: Some(MessageRequest::FileByFilename(String::from(
+            "reflection_v1.proto",
+        ))),
+    })
+    .await;
+
+    if let MessageResponse::FileDescriptorResponse(descriptor) = response {
+        let file_descriptor_proto = descriptor
+            .file_descriptor_proto
+            .first()
+            .expect("descriptor");
+        assert_eq!(
+            file_descriptor_proto.as_ref(),
+            get_encoded_reflection_service_fd()
+        );
+    } else {
+        panic!("Expected a FileDescriptorResponse variant");
+    }
+}
+
+#[tokio::test]
+async fn test_file_containing_symbol() {
+    let response = make_test_reflection_request(ServerReflectionRequest {
+        host: "".to_string(),
+        message_request: Some(MessageRequest::FileContainingSymbol(String::from(
+            "grpc.reflection.v1.ServerReflection",
+        ))),
+    })
+    .await;
+
+    if let MessageResponse::FileDescriptorResponse(descriptor) = response {
+        let file_descriptor_proto = descriptor
+            .file_descriptor_proto
+            .first()
+            .expect("descriptor");
+        assert_eq!(
+            file_descriptor_proto.as_ref(),
+            get_encoded_reflection_service_fd()
+        );
+    } else {
+        panic!("Expected a FileDescriptorResponse variant");
+    }
+}
+
+async fn make_test_reflection_request(request: ServerReflectionRequest) -> MessageResponse {
+    // Run a test server
+    let (shutdown_tx, shutdown_rx) = oneshot::channel();
+
+    let addr: SocketAddr = "127.0.0.1:0".parse().expect("SocketAddr parse");
+    let listener = tokio::net::TcpListener::bind(addr).await.expect("bind");
+    let local_addr = format!("http://{}", listener.local_addr().expect("local address"));
+    let jh = tokio::spawn(async move {
+        let service = Builder::configure()
+            .register_encoded_file_descriptor_set(FILE_DESCRIPTOR_SET)
+            .build_v1()
+            .unwrap();
+
+        Server::builder()
+            .add_service(service)
+            .serve_with_incoming_shutdown(TcpListenerStream::new(listener), async {
+                drop(shutdown_rx.await)
+            })
+            .await
+            .unwrap();
+    });
+
+    // Give the test server a few ms to become available
+    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+
+    // Construct client and send request, extract response
+    let conn = tonic::transport::Endpoint::new(local_addr)
+        .unwrap()
+        .connect()
+        .await
+        .unwrap();
+    let mut client = ServerReflectionClient::new(conn);
+
+    let request = Request::new(tokio_stream::once(request));
+    let mut inbound = client
+        .server_reflection_info(request)
+        .await
+        .expect("request")
+        .into_inner();
+
+    let response = inbound
+        .next()
+        .await
+        .expect("steamed response")
+        .expect("successful response")
+        .message_response
+        .expect("some MessageResponse");
+
+    // We only expect one response per request
+    assert!(inbound.next().await.is_none());
+
+    // Shut down test server
+    shutdown_tx.send(()).expect("send shutdown");
+    jh.await.expect("server shutdown");
+
+    response
+}
diff --git a/vendor/tonic-reflection/tests/versions.rs b/vendor/tonic-reflection/tests/versions.rs
new file mode 100644
index 00000000..9ab0858e
--- /dev/null
+++ b/vendor/tonic-reflection/tests/versions.rs
@@ -0,0 +1,172 @@
+#![allow(missing_docs)]
+
+use std::net::SocketAddr;
+
+use tokio::sync::oneshot;
+use tokio_stream::{wrappers::TcpListenerStream, StreamExt};
+use tonic::{transport::Server, Request};
+
+use tonic_reflection::pb::{v1, v1alpha};
+use tonic_reflection::server::Builder;
+
+#[tokio::test]
+async fn test_v1() {
+    let response = make_v1_request(v1::ServerReflectionRequest {
+        host: "".to_string(),
+        message_request: Some(v1::server_reflection_request::MessageRequest::ListServices(
+            String::new(),
+        )),
+    })
+    .await;
+
+    if let v1::server_reflection_response::MessageResponse::ListServicesResponse(services) =
+        response
+    {
+        assert_eq!(
+            services.service,
+            vec![v1::ServiceResponse {
+                name: String::from("grpc.reflection.v1.ServerReflection")
+            }]
+        );
+    } else {
+        panic!("Expected a ListServicesResponse variant");
+    }
+}
+
+#[tokio::test]
+async fn test_v1alpha() {
+    let response = make_v1alpha_request(v1alpha::ServerReflectionRequest {
+        host: "".to_string(),
+        message_request: Some(
+            v1alpha::server_reflection_request::MessageRequest::ListServices(String::new()),
+        ),
+    })
+    .await;
+
+    if let v1alpha::server_reflection_response::MessageResponse::ListServicesResponse(services) =
+        response
+    {
+        assert_eq!(
+            services.service,
+            vec![v1alpha::ServiceResponse {
+                name: String::from("grpc.reflection.v1alpha.ServerReflection")
+            }]
+        );
+    } else {
+        panic!("Expected a ListServicesResponse variant");
+    }
+}
+
+async fn make_v1_request(
+    request: v1::ServerReflectionRequest,
+) -> v1::server_reflection_response::MessageResponse {
+    // Run a test server
+    let (shutdown_tx, shutdown_rx) = oneshot::channel();
+
+    let addr: SocketAddr = "127.0.0.1:0".parse().expect("SocketAddr parse");
+    let listener = tokio::net::TcpListener::bind(addr).await.expect("bind");
+    let local_addr = format!("http://{}", listener.local_addr().expect("local address"));
+    let jh = tokio::spawn(async move {
+        let service = Builder::configure().build_v1().unwrap();
+
+        Server::builder()
+            .add_service(service)
+            .serve_with_incoming_shutdown(TcpListenerStream::new(listener), async {
+                drop(shutdown_rx.await)
+            })
+            .await
+            .unwrap();
+    });
+
+    // Give the test server a few ms to become available
+    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+
+    // Construct client and send request, extract response
+    let conn = tonic::transport::Endpoint::new(local_addr)
+        .unwrap()
+        .connect()
+        .await
+        .unwrap();
+    let mut client = v1::server_reflection_client::ServerReflectionClient::new(conn);
+
+    let request = Request::new(tokio_stream::once(request));
+    let mut inbound = client
+        .server_reflection_info(request)
+        .await
+        .expect("request")
+        .into_inner();
+
+    let response = inbound
+        .next()
+        .await
+        .expect("steamed response")
+        .expect("successful response")
+        .message_response
+        .expect("some MessageResponse");
+
+    // We only expect one response per request
+    assert!(inbound.next().await.is_none());
+
+    // Shut down test server
+    shutdown_tx.send(()).expect("send shutdown");
+    jh.await.expect("server shutdown");
+
+    response
+}
+
+async fn make_v1alpha_request(
+    request: v1alpha::ServerReflectionRequest,
+) -> v1alpha::server_reflection_response::MessageResponse {
+    // Run a test server
+    let (shutdown_tx, shutdown_rx) = oneshot::channel();
+
+    let addr: SocketAddr = "127.0.0.1:0".parse().expect("SocketAddr parse");
+    let listener = tokio::net::TcpListener::bind(addr).await.expect("bind");
+    let local_addr = format!("http://{}", listener.local_addr().expect("local address"));
+    let jh = tokio::spawn(async move {
+        let service = Builder::configure().build_v1alpha().unwrap();
+
+        Server::builder()
+            .add_service(service)
+            .serve_with_incoming_shutdown(TcpListenerStream::new(listener), async {
+                drop(shutdown_rx.await)
+            })
+            .await
+            .unwrap();
+    });
+
+    // Give the test server a few ms to become available
+    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+
+    // Construct client and send request, extract response
+    let conn = tonic::transport::Endpoint::new(local_addr)
+        .unwrap()
+        .connect()
+        .await
+        .unwrap();
+    let mut client = v1alpha::server_reflection_client::ServerReflectionClient::new(conn);
+
+    let request = Request::new(tokio_stream::once(request));
+    let mut inbound = client
+        .server_reflection_info(request)
+        .await
+        .expect("request")
+        .into_inner();
+
+    let response = inbound
+        .next()
+        .await
+        .expect("steamed response")
+        .expect("successful response")
+        .message_response
+        .expect("some MessageResponse");
+
+    // We only expect one response per request
+    assert!(inbound.next().await.is_none());
+
+    // Shut down test server
+    shutdown_tx.send(()).expect("send shutdown");
+    jh.await.expect("server shutdown");
+
+    response
+}