Support all experimental features

.code-samples.meilisearch.yaml

@@ -1650,7 +1650,7 @@ get_experimental_features_1: |-
 update_experimental_features_1: |-
   let client = Client::new("http://localhost:7700", Some("apiKey"));
   let features = ExperimentalFeatures::new(&client);
-  // update the feature you want here
+  features.set_metrics(true)
   let res = features
     .update()
     .await

src/features.rs

@@ -8,7 +8,13 @@ use serde::{Deserialize, Serialize};
 /// Struct representing the experimental features result from the API.
 #[derive(Clone, Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct ExperimentalFeaturesResult {}
+pub struct ExperimentalFeaturesResult {
+    pub metrics: bool,
+    pub logs_route: bool,
+    pub contains_filter: bool,
+    pub network: bool,
+    pub edit_documents_by_function: bool,
+}
 
 /// Struct representing the experimental features request.
 ///
@@ -28,12 +34,30 @@ pub struct ExperimentalFeaturesResult {}
 pub struct ExperimentalFeatures<'a, Http: HttpClient> {
     #[serde(skip_serializing)]
     client: &'a Client<Http>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metrics: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub contains_filter: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub logs_route: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub network: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub edit_documents_by_function: Option<bool>,
 }
 
 impl<'a, Http: HttpClient> ExperimentalFeatures<'a, Http> {
     #[must_use]
     pub fn new(client: &'a Client<Http>) -> Self {
-        ExperimentalFeatures { client }
+        ExperimentalFeatures {
+            client,
+            metrics: None,
+            logs_route: None,
+            network: None,
+            contains_filter: None,
+            edit_documents_by_function: None,
+        }
     }
 
     /// Get all the experimental features
@@ -88,6 +112,34 @@ impl<'a, Http: HttpClient> ExperimentalFeatures<'a, Http> {
             )
             .await
     }
+
+    pub fn set_metrics(&mut self, metrics: bool) -> &mut Self {
+        self.metrics = Some(metrics);
+        self
+    }
+
+    pub fn set_logs_route(&mut self, logs_route: bool) -> &mut Self {
+        self.logs_route = Some(logs_route);
+        self
+    }
+
+    pub fn set_contains_filter(&mut self, contains_filter: bool) -> &mut Self {
+        self.contains_filter = Some(contains_filter);
+        self
+    }
+
+    pub fn set_edit_documents_by_function(
+        &mut self,
+        edit_documents_by_function: bool,
+    ) -> &mut Self {
+        self.edit_documents_by_function = Some(edit_documents_by_function);
+        self
+    }
+
+    pub fn set_network(&mut self, network: bool) -> &mut Self {
+        self.network = Some(network);
+        self
+    }
 }
 
 #[cfg(test)]
@@ -96,12 +148,52 @@ mod tests {
     use meilisearch_test_macro::meilisearch_test;
 
     #[meilisearch_test]
-    async fn test_experimental_features_get(client: Client) {
-        let features = ExperimentalFeatures::new(&client);
-        // set feature here, once some exist again
+    async fn test_experimental_features_set_metrics(client: Client) {
+        let mut features = ExperimentalFeatures::new(&client);
+        features.set_metrics(true);
+        let _ = features.update().await.unwrap();
+
+        let res = features.get().await.unwrap();
+        assert!(res.metrics)
+    }
+
+    #[meilisearch_test]
+    async fn test_experimental_features_set_logs_route(client: Client) {
+        let mut features = ExperimentalFeatures::new(&client);
+        features.set_logs_route(true);
+        let _ = features.update().await.unwrap();
+
+        let res = features.get().await.unwrap();
+        assert!(res.logs_route)
+    }
+
+    #[meilisearch_test]
+    async fn test_experimental_features_set_contains_filter(client: Client) {
+        let mut features = ExperimentalFeatures::new(&client);
+        features.set_contains_filter(true);
+        let _ = features.update().await.unwrap();
+
+        let res = features.get().await.unwrap();
+        assert!(res.contains_filter)
+    }
+
+    #[meilisearch_test]
+    async fn test_experimental_features_set_network(client: Client) {
+        let mut features = ExperimentalFeatures::new(&client);
+        features.set_network(true);
+        let _ = features.update().await.unwrap();
+
+        let res = features.get().await.unwrap();
+        assert!(res.network)
+    }
+
+    #[meilisearch_test]
+    async fn test_experimental_features_set_edit_documents_by_function(client: Client) {
+        let mut features = ExperimentalFeatures::new(&client);
+        features.set_edit_documents_by_function(true);
         let _ = features.update().await.unwrap();
 
-        let _res = features.get().await.unwrap();
-        // assert that the feature has been set once they exist again
+        let res = features.get().await.unwrap();
+        assert!(res.edit_documents_by_function)
     }
 }