apollo-router 2.13.1

A configurable, high-performance routing runtime for Apollo Federation 🚀
Documentation 
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

//! Mock connector implementation

#![allow(missing_docs)] // FIXME

use std::collections::HashMap;
use std::sync::Arc;
use std::task::Poll;

use apollo_federation::connectors::runtime::http_json_transport::TransportRequest;
use futures::future;
use http::HeaderMap;
use http::HeaderName;
use http::HeaderValue;
use serde_json_bytes::json;
use tower::BoxError;
use tower::Service;

use crate::json_ext::Object;
use crate::services::connector::request_service::Request as ConnectorRequest;
use crate::services::connector::request_service::Response as ConnectorResponse;

type MockResponses = HashMap<String, String>;

#[derive(Default, Clone)]
pub struct MockConnector {
    // using an arc to improve efficiency when service is cloned
    mocks: Arc<MockResponses>,
    extensions: Option<Object>,
    map_request_fn:
        Option<Arc<dyn (Fn(ConnectorRequest) -> ConnectorRequest) + Send + Sync + 'static>>,
    headers: HeaderMap,
}

impl MockConnector {
    pub fn new(mocks: MockResponses) -> Self {
        Self {
            mocks: Arc::new(mocks.into_iter().collect()),
            extensions: None,
            map_request_fn: None,
            headers: HeaderMap::new(),
        }
    }

    pub fn builder() -> MockConnectorBuilder {
        MockConnectorBuilder::default()
    }

    pub fn with_extensions(mut self, extensions: Object) -> Self {
        self.extensions = Some(extensions);
        self
    }
}

/// Builder for `MockConnector`
#[derive(Default, Clone)]
pub struct MockConnectorBuilder {
    mocks: MockResponses,
    extensions: Option<Object>,
    headers: HeaderMap,
}
impl MockConnectorBuilder {
    pub fn with_extensions(mut self, extensions: Object) -> Self {
        self.extensions = Some(extensions);
        self
    }

    /// adds a mocked response for a request
    ///
    /// the arguments must deserialize to `crate::graphql::Request` and `crate::graphql::Response`
    pub fn with_json(mut self, request: serde_json::Value, response: serde_json::Value) -> Self {
        let request = serde_json::from_value(request).unwrap();
        self.mocks
            .insert(request, serde_json::from_value(response).unwrap());
        self
    }

    pub fn with_header(mut self, name: HeaderName, value: HeaderValue) -> Self {
        self.headers.insert(name, value);
        self
    }

    pub fn build(self) -> MockConnector {
        MockConnector {
            mocks: Arc::new(self.mocks),
            extensions: self.extensions,
            map_request_fn: None,
            headers: self.headers,
        }
    }
}

impl Service<ConnectorRequest> for MockConnector {
    type Response = ConnectorResponse;

    type Error = BoxError;

    type Future = future::Ready<Result<Self::Response, Self::Error>>;

    fn poll_ready(&mut self, _cx: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, mut req: ConnectorRequest) -> Self::Future {
        if let Some(map_request_fn) = &self.map_request_fn {
            req = map_request_fn.clone()(req);
        }
        let TransportRequest::Http(http) = req.transport_request;
        let body = http.inner.body();

        let response = if let Some(response) = self.mocks.get(body) {
            let response_key = req.key;
            let data = json!(response);
            let headers = self.headers.clone();

            ConnectorResponse::test_new(
                req.context.clone(),
                response_key,
                vec![],
                data,
                Some(headers),
            )
        } else {
            let error_message = format!(
                "couldn't find mock for query {}",
                serde_json::to_string(&body).unwrap()
            );
            let response_key = req.key;
            let data = json!(error_message);
            let headers = self.headers.clone();

            ConnectorResponse::test_new(
                req.context.clone(),
                response_key,
                vec![],
                data,
                Some(headers),
            )
        };
        future::ok(response)
    }
}