feat: Sign computed.json and send it to worker (#13)

Author: Natchica

src/api/worker_api.rs

@@ -1,4 +1,5 @@
 use crate::compute::{
+    computed_file::ComputedFile,
     errors::ReplicateStatusCause,
     utils::env_utils::{TeeSessionEnvironmentVariable, get_env_var_or_error},
 };
@@ -151,6 +152,67 @@ impl WorkerApiClient {
             Err(response.error_for_status().unwrap_err())
         }
     }
+
+    /// Sends the completed computed.json file to the worker host.
+    ///
+    /// This method transmits the computed file containing task results, signatures,
+    /// and metadata to the worker API. The computed file is sent as JSON in the
+    /// request body, allowing the worker to verify and process the computation results.
+    ///
+    /// # Arguments
+    ///
+    /// * `authorization` - The authorization token/challenge to validate the request on the worker side
+    /// * `chain_task_id` - The blockchain task identifier associated with this computation
+    /// * `computed_file` - The computed file containing results and signatures to be sent
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(())` - If the computed file was successfully sent (HTTP 2xx response)
+    /// * `Err(Error)` - If the request failed due to an HTTP error
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use crate::api::worker_api::WorkerApiClient;
+    /// use crate::compute::computed_file::ComputedFile;
+    ///
+    /// let client = WorkerApiClient::new("http://worker:13100");
+    /// let computed_file = ComputedFile {
+    ///     task_id: Some("0x123456789abcdef".to_string()),
+    ///     result_digest: Some("0xdigest".to_string()),
+    ///     enclave_signature: Some("0xsignature".to_string()),
+    ///     ..Default::default()
+    /// };
+    ///
+    /// match client.send_computed_file_to_host(
+    ///     "Bearer auth_token",
+    ///     "0x123456789abcdef",
+    ///     &computed_file,
+    /// ) {
+    ///     Ok(()) => println!("Computed file sent successfully"),
+    ///     Err(error) => eprintln!("Failed to send computed file: {}", error),
+    /// }
+    /// ```
+    pub fn send_computed_file_to_host(
+        &self,
+        authorization: &str,
+        chain_task_id: &str,
+        computed_file: &ComputedFile,
+    ) -> Result<(), Error> {
+        let url = format!("{}/compute/post/{}/computed", self.base_url, chain_task_id);
+        let response = self
+            .client
+            .post(&url)
+            .header(AUTHORIZATION, authorization)
+            .json(computed_file)
+            .send()?;
+
+        if response.status().is_success() {
+            Ok(())
+        } else {
+            Err(response.error_for_status().unwrap_err())
+        }
+    }
 }
 
 #[cfg(test)]
@@ -164,6 +226,9 @@ mod tests {
         matchers::{body_json, header, method, path},
     };
 
+    const CHALLENGE: &str = "challenge";
+    const CHAIN_TASK_ID: &str = "0x123456789abcdef";
+
     // region ExitMessage()
     #[test]
     fn should_serialize_exit_message() {
@@ -213,9 +278,6 @@ mod tests {
     // endregion
 
     // region send_exit_cause_for_post_compute_stage()
-    const CHALLENGE: &str = "challenge";
-    const CHAIN_TASK_ID: &str = "0x123456789abcdef";
-
     #[tokio::test]
     async fn should_send_exit_cause() {
         let mock_server = MockServer::start().await;
@@ -282,4 +344,132 @@ mod tests {
         }
     }
     // endregion
+
+    // region send_computed_file_to_host()
+    #[tokio::test]
+    async fn should_send_computed_file_successfully() {
+        let mock_server = MockServer::start().await;
+        let server_uri = mock_server.uri();
+
+        let computed_file = ComputedFile {
+            task_id: Some(CHAIN_TASK_ID.to_string()),
+            result_digest: Some("0xdigest".to_string()),
+            enclave_signature: Some("0xsignature".to_string()),
+            ..Default::default()
+        };
+
+        let expected_path = format!("/compute/post/{}/computed", CHAIN_TASK_ID);
+        let expected_body = json!(computed_file);
+
+        Mock::given(method("POST"))
+            .and(path(expected_path.as_str()))
+            .and(header("Authorization", CHALLENGE))
+            .and(body_json(&expected_body))
+            .respond_with(ResponseTemplate::new(200))
+            .expect(1)
+            .mount(&mock_server)
+            .await;
+
+        let result = tokio::task::spawn_blocking(move || {
+            let client = WorkerApiClient::new(&server_uri);
+            client.send_computed_file_to_host(CHALLENGE, CHAIN_TASK_ID, &computed_file)
+        })
+        .await
+        .expect("Task panicked");
+
+        assert!(result.is_ok());
+    }
+
+    #[tokio::test]
+    async fn should_fail_send_computed_file_on_server_error() {
+        let mock_server = MockServer::start().await;
+        let server_uri = mock_server.uri();
+
+        let computed_file = ComputedFile {
+            task_id: Some(CHAIN_TASK_ID.to_string()),
+            result_digest: Some("0xdigest".to_string()),
+            enclave_signature: Some("0xsignature".to_string()),
+            ..Default::default()
+        };
+        let expected_path = format!("/compute/post/{}/computed", CHAIN_TASK_ID);
+        let expected_body = json!(computed_file);
+
+        Mock::given(method("POST"))
+            .and(path(expected_path.as_str()))
+            .and(header("Authorization", CHALLENGE))
+            .and(body_json(&expected_body))
+            .respond_with(ResponseTemplate::new(500))
+            .expect(1)
+            .mount(&mock_server)
+            .await;
+
+        let result = tokio::task::spawn_blocking(move || {
+            let client = WorkerApiClient::new(&server_uri);
+            client.send_computed_file_to_host(CHALLENGE, CHAIN_TASK_ID, &computed_file)
+        })
+        .await
+        .expect("Task panicked");
+
+        assert!(result.is_err());
+        if let Err(error) = result {
+            assert_eq!(error.status().unwrap(), 500);
+        }
+    }
+
+    #[tokio::test]
+    async fn should_handle_invalid_chain_task_id_in_url() {
+        let mock_server = MockServer::start().await;
+        let server_uri = mock_server.uri();
+
+        let invalid_chain_task_id = "invalidTaskId";
+        let computed_file = ComputedFile {
+            task_id: Some(invalid_chain_task_id.to_string()),
+            ..Default::default()
+        };
+
+        let result = tokio::task::spawn_blocking(move || {
+            let client = WorkerApiClient::new(&server_uri);
+            client.send_computed_file_to_host(CHALLENGE, invalid_chain_task_id, &computed_file)
+        })
+        .await
+        .expect("Task panicked");
+
+        assert!(result.is_err(), "Should fail with invalid chain task ID");
+        if let Err(error) = result {
+            assert_eq!(error.status().unwrap(), 404);
+        }
+    }
+
+    #[tokio::test]
+    async fn should_send_computed_file_with_minimal_data() {
+        let mock_server = MockServer::start().await;
+        let server_uri = mock_server.uri();
+
+        let computed_file = ComputedFile {
+            task_id: Some(CHAIN_TASK_ID.to_string()),
+            ..Default::default()
+        };
+
+        let expected_path = format!("/compute/post/{}/computed", CHAIN_TASK_ID);
+        let expected_body = json!(computed_file);
+
+        Mock::given(method("POST"))
+            .and(path(expected_path.as_str()))
+            .and(header("Authorization", CHALLENGE))
+            .and(body_json(&expected_body))
+            .respond_with(ResponseTemplate::new(200))
+            .expect(1)
+            .mount(&mock_server)
+            .await;
+
+        let result = tokio::task::spawn_blocking(move || {
+            let client = WorkerApiClient::new(&server_uri);
+            client.send_computed_file_to_host(CHALLENGE, CHAIN_TASK_ID, &computed_file)
+        })
+        .await
+        .expect("Task panicked");
+
+        assert!(result.is_ok());
+    }
+    // endregion
 }