feat: use client encoding (but always expect JSON)

1 files changed, 38 insertions, 35 deletions

diff --git a/lambda-calcul/rust/src/web.rs b/lambda-calcul/rust/src/web.rs
index 13b888e..ad6bc03 100644
--- a/lambda-calcul/rust/src/web.rs
+++ b/lambda-calcul/rust/src/web.rs
@@ -79,6 +79,7 @@ struct Client {
     runner: TestRunner,
     results: Vec<Test>,
     delay: std::time::Duration,
+    encoding: AstEncoding,
 }
 
 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
@@ -109,6 +110,7 @@ impl Client {
             runner,
             results: Vec::new(),
             delay,
+            encoding: AstEncoding::Json,
         }
     }
 
@@ -153,24 +155,20 @@ impl Client {
         self.results.push(test.clone());
     }
 
-    fn check_result(&self, expected: &String, response: &Result<String, TestResult>) -> Test {
+    fn check_result(
+        &self,
+        expected: &Vec<Value>,
+        response: &Result<Vec<Value>, TestResult>,
+    ) -> Test {
         let result = match response {
             Ok(expr) => {
-                if let Ok(vals) = parse_total(expr) {
-                    let actual = eval_all(&vals)
-                        .iter()
-                        .map(|v| format!("{}", v))
-                        .collect::<Vec<_>>()
-                        .join("\n");
-                    if actual == *expected {
-                        TestResult::TestSucceeded
-                    } else {
-                        TestResult::TestFailed(actual)
-                    }
+                if *expr == *expected {
+                    TestResult::TestSucceeded
                 } else {
-                    TestResult::TestFailed("Could not parse response".to_string())
+                    TestResult::TestFailed(format!("{:?}", expr))
                 }
             }
+
             Err(res) => res.clone(),
         };
         Test {
@@ -361,28 +359,29 @@ async fn send_tests(client_m: Arc<Mutex<Client>>) {
 
 async fn send_one_test(client_m: &Arc<Mutex<Client>>, sleep: Duration) {
     let (input, url, expected) = get_test(client_m);
-    let response = send_test(
-        &input
-            .iter()
-            .map(|v| format!("{}", v))
-            .collect::<Vec<_>>()
-            .join("\n"),
-        &url,
-        sleep,
-    )
-    .await;
-    apply_result(
-        client_m,
-        expected
+
+    let encoding = client_m.lock().unwrap().encoding.clone();
+
+    let request = match encoding {
+        AstEncoding::Json => serde_json::to_string(&input).unwrap(),
+        _ => input
             .iter()
             .map(|v| format!("{}", v))
             .collect::<Vec<_>>()
             .join("\n"),
-        response,
-    );
+    };
+    let response: Result<Vec<Value>, TestResult> = send_test(&request, &url, sleep)
+        .await
+        .and_then(|r| serde_json::from_str(&r).map_err(|e| TestResult::TestFailed(e.to_string())));
+
+    apply_result(client_m, expected, response);
 }
 
-fn apply_result(client_m: &Mutex<Client>, expected: String, response: Result<String, TestResult>) {
+fn apply_result(
+    client_m: &Mutex<Client>,
+    expected: Vec<Value>,
+    response: Result<Vec<Value>, TestResult>,
+) {
     let mut client = client_m.lock().unwrap();
     let test = client.check_result(&expected, &response);
     client.apply(&test);
@@ -741,7 +740,7 @@ mod app_tests {
         let (input, _) = client.generate_expr();
 
         if let [Value::App(_, _)] = &input[..] {
-//            assert!(input.split(' ').count() >= 2)
+            //            assert!(input.split(' ').count() >= 2)
         } else {
             panic!("Expected application, got {:?}", input)
         }
@@ -796,8 +795,8 @@ mod app_tests {
     #[test]
     async fn client_returns_test_successful_if_result_match() {
         let client = client();
-        let expected = "1".to_string();
-        let response = Ok("1".to_string());
+        let expected = parse("1");
+        let response = Ok(parse("1"));
 
         let test = client.check_result(&expected, &response);
 
@@ -807,12 +806,16 @@ mod app_tests {
     #[test]
     async fn client_returns_test_failed_given_result_do_not_match() {
         let client = client();
-        let expected = "1".to_string();
-        let response = Ok("2".to_string());
+        let expected = parse("1");
+        let received = parse("2");
+        let response = Ok(received.clone());
 
         let test = client.check_result(&expected, &response);
 
-        assert_eq!(TestResult::TestFailed("2".to_string()), test.result);
+        assert_eq!(
+            TestResult::TestFailed(format!("{:?}", &received)),
+            test.result
+        );
     }
 
     #[test]