Renames meilisearch-http to meilisearch

meilisearch/tests/common/encoder.rs

@@ -0,0 +1,78 @@
+use std::io::{Read, Write};
+
+use actix_http::header::TryIntoHeaderPair;
+use bytes::Bytes;
+use flate2::read::{GzDecoder, ZlibDecoder};
+use flate2::write::{GzEncoder, ZlibEncoder};
+use flate2::Compression;
+
+#[derive(Clone, Copy)]
+pub enum Encoder {
+    Plain,
+    Gzip,
+    Deflate,
+    Brotli,
+}
+
+impl Encoder {
+    pub fn encode(self: &Encoder, body: impl Into<Bytes>) -> impl Into<Bytes> {
+        match self {
+            Self::Gzip => {
+                let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
+                encoder.write_all(&body.into()).expect("Failed to encode request body");
+                encoder.finish().expect("Failed to encode request body")
+            }
+            Self::Deflate => {
+                let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
+                encoder.write_all(&body.into()).expect("Failed to encode request body");
+                encoder.finish().unwrap()
+            }
+            Self::Plain => Vec::from(body.into()),
+            Self::Brotli => {
+                let mut encoder = brotli::CompressorWriter::new(Vec::new(), 32 * 1024, 3, 22);
+                encoder.write_all(&body.into()).expect("Failed to encode request body");
+                encoder.flush().expect("Failed to encode request body");
+                encoder.into_inner()
+            }
+        }
+    }
+
+    pub fn decode(self: &Encoder, bytes: impl Into<Bytes>) -> impl Into<Bytes> {
+        let mut buffer = Vec::new();
+        let input = bytes.into();
+        match self {
+            Self::Gzip => {
+                GzDecoder::new(input.as_ref())
+                    .read_to_end(&mut buffer)
+                    .expect("Invalid gzip stream");
+            }
+            Self::Deflate => {
+                ZlibDecoder::new(input.as_ref())
+                    .read_to_end(&mut buffer)
+                    .expect("Invalid zlib stream");
+            }
+            Self::Plain => {
+                buffer.write_all(input.as_ref()).expect("Unexpected memory copying issue");
+            }
+            Self::Brotli => {
+                brotli::Decompressor::new(input.as_ref(), 4096)
+                    .read_to_end(&mut buffer)
+                    .expect("Invalid brotli stream");
+            }
+        };
+        buffer
+    }
+
+    pub fn header(self: &Encoder) -> Option<impl TryIntoHeaderPair> {
+        match self {
+            Self::Plain => None,
+            Self::Gzip => Some(("Content-Encoding", "gzip")),
+            Self::Deflate => Some(("Content-Encoding", "deflate")),
+            Self::Brotli => Some(("Content-Encoding", "br")),
+        }
+    }
+
+    pub fn iterator() -> impl Iterator<Item = Self> {
+        [Self::Plain, Self::Gzip, Self::Deflate, Self::Brotli].iter().copied()
+    }
+}

meilisearch/tests/common/index.rs

@@ -0,0 +1,241 @@
+use std::fmt::Write;
+use std::panic::{catch_unwind, resume_unwind, UnwindSafe};
+use std::time::Duration;
+
+use actix_web::http::StatusCode;
+use serde_json::{json, Value};
+use tokio::time::sleep;
+use urlencoding::encode as urlencode;
+
+use super::encoder::Encoder;
+use super::service::Service;
+
+pub struct Index<'a> {
+    pub uid: String,
+    pub service: &'a Service,
+    pub encoder: Encoder,
+}
+
+#[allow(dead_code)]
+impl Index<'_> {
+    pub async fn get(&self) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}", urlencode(self.uid.as_ref()));
+        self.service.get(url).await
+    }
+
+    pub async fn load_test_set(&self) -> u64 {
+        let url = format!("/indexes/{}/documents", urlencode(self.uid.as_ref()));
+        let (response, code) =
+            self.service.post_str(url, include_str!("../assets/test_set.json")).await;
+        assert_eq!(code, 202);
+        let update_id = response["taskUid"].as_i64().unwrap();
+        self.wait_task(update_id as u64).await;
+        update_id as u64
+    }
+
+    pub async fn create(&self, primary_key: Option<&str>) -> (Value, StatusCode) {
+        let body = json!({
+            "uid": self.uid,
+            "primaryKey": primary_key,
+        });
+        self.service.post_encoded("/indexes", body, self.encoder).await
+    }
+
+    pub async fn update(&self, primary_key: Option<&str>) -> (Value, StatusCode) {
+        let body = json!({
+            "primaryKey": primary_key,
+        });
+        let url = format!("/indexes/{}", urlencode(self.uid.as_ref()));
+
+        self.service.patch_encoded(url, body, self.encoder).await
+    }
+
+    pub async fn delete(&self) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}", urlencode(self.uid.as_ref()));
+        self.service.delete(url).await
+    }
+
+    pub async fn add_documents(
+        &self,
+        documents: Value,
+        primary_key: Option<&str>,
+    ) -> (Value, StatusCode) {
+        let url = match primary_key {
+            Some(key) => {
+                format!("/indexes/{}/documents?primaryKey={}", urlencode(self.uid.as_ref()), key)
+            }
+            None => format!("/indexes/{}/documents", urlencode(self.uid.as_ref())),
+        };
+        self.service.post_encoded(url, documents, self.encoder).await
+    }
+
+    pub async fn update_documents(
+        &self,
+        documents: Value,
+        primary_key: Option<&str>,
+    ) -> (Value, StatusCode) {
+        let url = match primary_key {
+            Some(key) => {
+                format!("/indexes/{}/documents?primaryKey={}", urlencode(self.uid.as_ref()), key)
+            }
+            None => format!("/indexes/{}/documents", urlencode(self.uid.as_ref())),
+        };
+        self.service.put_encoded(url, documents, self.encoder).await
+    }
+
+    pub async fn wait_task(&self, update_id: u64) -> Value {
+        // try several times to get status, or panic to not wait forever
+        let url = format!("/tasks/{}", update_id);
+        for _ in 0..100 {
+            let (response, status_code) = self.service.get(&url).await;
+            assert_eq!(200, status_code, "response: {}", response);
+
+            if response["status"] == "succeeded" || response["status"] == "failed" {
+                return response;
+            }
+
+            // wait 0.5 second.
+            sleep(Duration::from_millis(500)).await;
+        }
+        panic!("Timeout waiting for update id");
+    }
+
+    pub async fn get_task(&self, update_id: u64) -> (Value, StatusCode) {
+        let url = format!("/tasks/{}", update_id);
+        self.service.get(url).await
+    }
+
+    pub async fn list_tasks(&self) -> (Value, StatusCode) {
+        let url = format!("/tasks?indexUids={}", self.uid);
+        self.service.get(url).await
+    }
+
+    pub async fn filtered_tasks(&self, types: &[&str], statuses: &[&str]) -> (Value, StatusCode) {
+        let mut url = format!("/tasks?indexUids={}", self.uid);
+        if !types.is_empty() {
+            let _ = write!(url, "&types={}", types.join(","));
+        }
+        if !statuses.is_empty() {
+            let _ = write!(url, "&statuses={}", statuses.join(","));
+        }
+        self.service.get(url).await
+    }
+
+    pub async fn get_document(
+        &self,
+        id: u64,
+        options: Option<GetDocumentOptions>,
+    ) -> (Value, StatusCode) {
+        let mut url = format!("/indexes/{}/documents/{}", urlencode(self.uid.as_ref()), id);
+        if let Some(fields) = options.and_then(|o| o.fields) {
+            let _ = write!(url, "?fields={}", fields.join(","));
+        }
+        self.service.get(url).await
+    }
+
+    pub async fn get_all_documents(&self, options: GetAllDocumentsOptions) -> (Value, StatusCode) {
+        let mut url = format!("/indexes/{}/documents?", urlencode(self.uid.as_ref()));
+        if let Some(limit) = options.limit {
+            let _ = write!(url, "limit={}&", limit);
+        }
+
+        if let Some(offset) = options.offset {
+            let _ = write!(url, "offset={}&", offset);
+        }
+
+        if let Some(attributes_to_retrieve) = options.attributes_to_retrieve {
+            let _ = write!(url, "fields={}&", attributes_to_retrieve.join(","));
+        }
+
+        self.service.get(url).await
+    }
+
+    pub async fn delete_document(&self, id: u64) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/documents/{}", urlencode(self.uid.as_ref()), id);
+        self.service.delete(url).await
+    }
+
+    pub async fn clear_all_documents(&self) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/documents", urlencode(self.uid.as_ref()));
+        self.service.delete(url).await
+    }
+
+    pub async fn delete_batch(&self, ids: Vec<u64>) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/documents/delete-batch", urlencode(self.uid.as_ref()));
+        self.service.post_encoded(url, serde_json::to_value(&ids).unwrap(), self.encoder).await
+    }
+
+    pub async fn settings(&self) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/settings", urlencode(self.uid.as_ref()));
+        self.service.get(url).await
+    }
+
+    pub async fn update_settings(&self, settings: Value) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/settings", urlencode(self.uid.as_ref()));
+        self.service.patch_encoded(url, settings, self.encoder).await
+    }
+
+    pub async fn delete_settings(&self) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/settings", urlencode(self.uid.as_ref()));
+        self.service.delete(url).await
+    }
+
+    pub async fn stats(&self) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/stats", urlencode(self.uid.as_ref()));
+        self.service.get(url).await
+    }
+
+    /// Performs both GET and POST search queries
+    pub async fn search(
+        &self,
+        query: Value,
+        test: impl Fn(Value, StatusCode) + UnwindSafe + Clone,
+    ) {
+        let (response, code) = self.search_post(query.clone()).await;
+        let t = test.clone();
+        if let Err(e) = catch_unwind(move || t(response, code)) {
+            eprintln!("Error with post search");
+            resume_unwind(e);
+        }
+
+        let (response, code) = self.search_get(query).await;
+        if let Err(e) = catch_unwind(move || test(response, code)) {
+            eprintln!("Error with get search");
+            resume_unwind(e);
+        }
+    }
+
+    pub async fn search_post(&self, query: Value) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/search", urlencode(self.uid.as_ref()));
+        self.service.post_encoded(url, query, self.encoder).await
+    }
+
+    pub async fn search_get(&self, query: Value) -> (Value, StatusCode) {
+        let params = yaup::to_string(&query).unwrap();
+        let url = format!("/indexes/{}/search?{}", urlencode(self.uid.as_ref()), params);
+        self.service.get(url).await
+    }
+
+    pub async fn update_distinct_attribute(&self, value: Value) -> (Value, StatusCode) {
+        let url =
+            format!("/indexes/{}/settings/{}", urlencode(self.uid.as_ref()), "distinct-attribute");
+        self.service.put_encoded(url, value, self.encoder).await
+    }
+
+    pub async fn get_distinct_attribute(&self) -> (Value, StatusCode) {
+        let url =
+            format!("/indexes/{}/settings/{}", urlencode(self.uid.as_ref()), "distinct-attribute");
+        self.service.get(url).await
+    }
+}
+
+pub struct GetDocumentOptions {
+    pub fields: Option<Vec<&'static str>>,
+}
+
+#[derive(Debug, Default)]
+pub struct GetAllDocumentsOptions {
+    pub limit: Option<usize>,
+    pub offset: Option<usize>,
+    pub attributes_to_retrieve: Option<Vec<&'static str>>,
+}

meilisearch/tests/common/mod.rs

@@ -0,0 +1,24 @@
+pub mod encoder;
+pub mod index;
+pub mod server;
+pub mod service;
+
+pub use index::{GetAllDocumentsOptions, GetDocumentOptions};
+pub use server::{default_settings, Server};
+
+/// Performs a search test on both post and get routes
+#[macro_export]
+macro_rules! test_post_get_search {
+    ($server:expr, $query:expr, |$response:ident, $status_code:ident | $block:expr) => {
+        let post_query: meilisearch::routes::search::SearchQueryPost =
+            serde_json::from_str(&$query.clone().to_string()).unwrap();
+        let get_query: meilisearch::routes::search::SearchQuery = post_query.into();
+        let get_query = ::serde_url_params::to_string(&get_query).unwrap();
+        let ($response, $status_code) = $server.search_get(&get_query).await;
+        let _ = ::std::panic::catch_unwind(|| $block)
+            .map_err(|e| panic!("panic in get route: {:?}", e.downcast_ref::<&str>().unwrap()));
+        let ($response, $status_code) = $server.search_post($query).await;
+        let _ = ::std::panic::catch_unwind(|| $block)
+            .map_err(|e| panic!("panic in post route: {:?}", e.downcast_ref::<&str>().unwrap()));
+    };
+}

meilisearch/tests/common/server.rs

@@ -0,0 +1,204 @@
+#![allow(dead_code)]
+
+use std::path::Path;
+use std::time::Duration;
+
+use actix_http::body::MessageBody;
+use actix_web::dev::ServiceResponse;
+use actix_web::http::StatusCode;
+use byte_unit::{Byte, ByteUnit};
+use clap::Parser;
+use meilisearch::option::{IndexerOpts, MaxMemory, Opt};
+use meilisearch::{analytics, create_app, setup_meilisearch};
+use once_cell::sync::Lazy;
+use serde_json::{json, Value};
+use tempfile::TempDir;
+use tokio::time::sleep;
+
+use super::index::Index;
+use super::service::Service;
+use crate::common::encoder::Encoder;
+
+pub struct Server {
+    pub service: Service,
+    // hold ownership to the tempdir while we use the server instance.
+    _dir: Option<TempDir>,
+}
+
+pub static TEST_TEMP_DIR: Lazy<TempDir> = Lazy::new(|| TempDir::new().unwrap());
+
+impl Server {
+    pub async fn new() -> Self {
+        let dir = TempDir::new().unwrap();
+
+        if cfg!(windows) {
+            std::env::set_var("TMP", TEST_TEMP_DIR.path());
+        } else {
+            std::env::set_var("TMPDIR", TEST_TEMP_DIR.path());
+        }
+
+        let options = default_settings(dir.path());
+
+        let (index_scheduler, auth) = setup_meilisearch(&options).unwrap();
+        let service = Service { index_scheduler, auth, options, api_key: None };
+
+        Server { service, _dir: Some(dir) }
+    }
+
+    pub async fn new_auth_with_options(mut options: Opt, dir: TempDir) -> Self {
+        if cfg!(windows) {
+            std::env::set_var("TMP", TEST_TEMP_DIR.path());
+        } else {
+            std::env::set_var("TMPDIR", TEST_TEMP_DIR.path());
+        }
+
+        options.master_key = Some("MASTER_KEY".to_string());
+
+        let (index_scheduler, auth) = setup_meilisearch(&options).unwrap();
+        let service = Service { index_scheduler, auth, options, api_key: None };
+
+        Server { service, _dir: Some(dir) }
+    }
+
+    pub async fn new_auth() -> Self {
+        let dir = TempDir::new().unwrap();
+        let options = default_settings(dir.path());
+        Self::new_auth_with_options(options, dir).await
+    }
+
+    pub async fn new_with_options(options: Opt) -> Result<Self, anyhow::Error> {
+        let (index_scheduler, auth) = setup_meilisearch(&options)?;
+        let service = Service { index_scheduler, auth, options, api_key: None };
+
+        Ok(Server { service, _dir: None })
+    }
+
+    pub async fn init_web_app(
+        &self,
+    ) -> impl actix_web::dev::Service<
+        actix_http::Request,
+        Response = ServiceResponse<impl MessageBody>,
+        Error = actix_web::Error,
+    > {
+        actix_web::test::init_service(create_app(
+            self.service.index_scheduler.clone().into(),
+            self.service.auth.clone(),
+            self.service.options.clone(),
+            analytics::MockAnalytics::new(&self.service.options),
+            true,
+        ))
+        .await
+    }
+
+    /// Returns a view to an index. There is no guarantee that the index exists.
+    pub fn index(&self, uid: impl AsRef<str>) -> Index<'_> {
+        self.index_with_encoder(uid, Encoder::Plain)
+    }
+
+    pub fn index_with_encoder(&self, uid: impl AsRef<str>, encoder: Encoder) -> Index<'_> {
+        Index { uid: uid.as_ref().to_string(), service: &self.service, encoder }
+    }
+
+    pub async fn list_indexes(
+        &self,
+        offset: Option<usize>,
+        limit: Option<usize>,
+    ) -> (Value, StatusCode) {
+        let (offset, limit) = (
+            offset.map(|offset| format!("offset={offset}")),
+            limit.map(|limit| format!("limit={limit}")),
+        );
+        let query_parameter = offset
+            .as_ref()
+            .zip(limit.as_ref())
+            .map(|(offset, limit)| format!("{offset}&{limit}"))
+            .or_else(|| offset.xor(limit));
+        if let Some(query_parameter) = query_parameter {
+            self.service.get(format!("/indexes?{query_parameter}")).await
+        } else {
+            self.service.get("/indexes").await
+        }
+    }
+
+    pub async fn version(&self) -> (Value, StatusCode) {
+        self.service.get("/version").await
+    }
+
+    pub async fn stats(&self) -> (Value, StatusCode) {
+        self.service.get("/stats").await
+    }
+
+    pub async fn tasks(&self) -> (Value, StatusCode) {
+        self.service.get("/tasks").await
+    }
+
+    pub async fn tasks_filter(&self, filter: Value) -> (Value, StatusCode) {
+        self.service.get(format!("/tasks?{}", yaup::to_string(&filter).unwrap())).await
+    }
+
+    pub async fn get_dump_status(&self, uid: &str) -> (Value, StatusCode) {
+        self.service.get(format!("/dumps/{}/status", uid)).await
+    }
+
+    pub async fn create_dump(&self) -> (Value, StatusCode) {
+        self.service.post("/dumps", json!(null)).await
+    }
+
+    pub async fn index_swap(&self, value: Value) -> (Value, StatusCode) {
+        self.service.post("/swap-indexes", value).await
+    }
+
+    pub async fn cancel_tasks(&self, value: Value) -> (Value, StatusCode) {
+        self.service
+            .post(format!("/tasks/cancel?{}", yaup::to_string(&value).unwrap()), json!(null))
+            .await
+    }
+
+    pub async fn delete_tasks(&self, value: Value) -> (Value, StatusCode) {
+        self.service.delete(format!("/tasks?{}", yaup::to_string(&value).unwrap())).await
+    }
+
+    pub async fn wait_task(&self, update_id: u64) -> Value {
+        // try several times to get status, or panic to not wait forever
+        let url = format!("/tasks/{}", update_id);
+        for _ in 0..100 {
+            let (response, status_code) = self.service.get(&url).await;
+            assert_eq!(200, status_code, "response: {}", response);
+
+            if response["status"] == "succeeded" || response["status"] == "failed" {
+                return response;
+            }
+
+            // wait 0.5 second.
+            sleep(Duration::from_millis(500)).await;
+        }
+        panic!("Timeout waiting for update id");
+    }
+
+    pub async fn get_task(&self, update_id: u64) -> (Value, StatusCode) {
+        let url = format!("/tasks/{}", update_id);
+        self.service.get(url).await
+    }
+}
+
+pub fn default_settings(dir: impl AsRef<Path>) -> Opt {
+    Opt {
+        db_path: dir.as_ref().join("db"),
+        dump_dir: dir.as_ref().join("dumps"),
+        env: "development".to_owned(),
+        #[cfg(all(not(debug_assertions), feature = "analytics"))]
+        no_analytics: true,
+        max_index_size: Byte::from_unit(100.0, ByteUnit::MiB).unwrap(),
+        max_task_db_size: Byte::from_unit(1.0, ByteUnit::GiB).unwrap(),
+        http_payload_size_limit: Byte::from_unit(10.0, ByteUnit::MiB).unwrap(),
+        snapshot_dir: ".".into(),
+        indexer_options: IndexerOpts {
+            // memory has to be unlimited because several meilisearch are running in test context.
+            max_indexing_memory: MaxMemory::unlimited(),
+            ..Parser::parse_from(None as Option<&str>)
+        },
+        #[cfg(feature = "metrics")]
+        enable_metrics_route: true,
+        ..Parser::parse_from(None as Option<&str>)
+    }
+}

meilisearch/tests/common/service.rs

@@ -0,0 +1,123 @@
+use std::sync::Arc;
+
+use actix_web::http::header::ContentType;
+use actix_web::http::StatusCode;
+use actix_web::test;
+use actix_web::test::TestRequest;
+use index_scheduler::IndexScheduler;
+use meilisearch_auth::AuthController;
+use meilisearch::{analytics, create_app, Opt};
+use serde_json::Value;
+
+use crate::common::encoder::Encoder;
+
+pub struct Service {
+    pub index_scheduler: Arc<IndexScheduler>,
+    pub auth: AuthController,
+    pub options: Opt,
+    pub api_key: Option<String>,
+}
+
+impl Service {
+    pub async fn post(&self, url: impl AsRef<str>, body: Value) -> (Value, StatusCode) {
+        self.post_encoded(url, body, Encoder::Plain).await
+    }
+
+    pub async fn post_encoded(
+        &self,
+        url: impl AsRef<str>,
+        body: Value,
+        encoder: Encoder,
+    ) -> (Value, StatusCode) {
+        let mut req = test::TestRequest::post().uri(url.as_ref());
+        req = self.encode(req, body, encoder);
+        self.request(req).await
+    }
+
+    /// Send a test post request from a text body, with a `content-type:application/json` header.
+    pub async fn post_str(
+        &self,
+        url: impl AsRef<str>,
+        body: impl AsRef<str>,
+    ) -> (Value, StatusCode) {
+        let req = test::TestRequest::post()
+            .uri(url.as_ref())
+            .set_payload(body.as_ref().to_string())
+            .insert_header(("content-type", "application/json"));
+        self.request(req).await
+    }
+
+    pub async fn get(&self, url: impl AsRef<str>) -> (Value, StatusCode) {
+        let req = test::TestRequest::get().uri(url.as_ref());
+        self.request(req).await
+    }
+
+    pub async fn put(&self, url: impl AsRef<str>, body: Value) -> (Value, StatusCode) {
+        self.put_encoded(url, body, Encoder::Plain).await
+    }
+
+    pub async fn put_encoded(
+        &self,
+        url: impl AsRef<str>,
+        body: Value,
+        encoder: Encoder,
+    ) -> (Value, StatusCode) {
+        let mut req = test::TestRequest::put().uri(url.as_ref());
+        req = self.encode(req, body, encoder);
+        self.request(req).await
+    }
+
+    pub async fn patch(&self, url: impl AsRef<str>, body: Value) -> (Value, StatusCode) {
+        self.patch_encoded(url, body, Encoder::Plain).await
+    }
+
+    pub async fn patch_encoded(
+        &self,
+        url: impl AsRef<str>,
+        body: Value,
+        encoder: Encoder,
+    ) -> (Value, StatusCode) {
+        let mut req = test::TestRequest::patch().uri(url.as_ref());
+        req = self.encode(req, body, encoder);
+        self.request(req).await
+    }
+
+    pub async fn delete(&self, url: impl AsRef<str>) -> (Value, StatusCode) {
+        let req = test::TestRequest::delete().uri(url.as_ref());
+        self.request(req).await
+    }
+
+    pub async fn request(&self, mut req: test::TestRequest) -> (Value, StatusCode) {
+        let app = test::init_service(create_app(
+            self.index_scheduler.clone().into(),
+            self.auth.clone(),
+            self.options.clone(),
+            analytics::MockAnalytics::new(&self.options),
+            true,
+        ))
+        .await;
+
+        if let Some(api_key) = &self.api_key {
+            req = req.insert_header(("Authorization", ["Bearer ", api_key].concat()));
+        }
+        let req = req.to_request();
+        let res = test::call_service(&app, req).await;
+        let status_code = res.status();
+
+        let body = test::read_body(res).await;
+        let response = serde_json::from_slice(&body).unwrap_or_default();
+        (response, status_code)
+    }
+
+    fn encode(&self, req: TestRequest, body: Value, encoder: Encoder) -> TestRequest {
+        let bytes = serde_json::to_string(&body).expect("Failed to serialize test data to json");
+        let encoded_body = encoder.encode(bytes);
+        let header = encoder.header();
+        match header {
+            Some(header) => req.insert_header(header),
+            None => req,
+        }
+        .set_payload(encoded_body)
+        .insert_header(ContentType::json())
+    }
+}