refactor: remove unused dependencies and integrate strum for error serialization in ReplicateStatusCause

Author: Natchica

Cargo.lock

@@ -22,6 +22,8 @@ serde = "1.0.219"
 serde_json = "1.0.140"
 sha256 = "1.6.0"
 sha3 = "0.10.8"
+strum = "0.27.2"
+strum_macros = "0.27.2"
 thiserror = "2.0.12"
 walkdir = "2.5.0"
 zip = "4.0.0"
@@ -30,7 +32,6 @@ zip = "4.0.0"
 logtest = "2.0.0"
 mockall = "0.13.1"
 once_cell = "1.21.3"
-rstest = "0.26.1"
 serial_test = "3.2.0"
 temp-env = "0.3.6"
 tempfile = "3.20.0"

post-compute/Cargo.toml

@@ -1,8 +1,10 @@
-use serde::{Deserialize, Serialize};
+use serde::{Serializer, ser::SerializeStruct};
+use strum_macros::EnumDiscriminants;
 use thiserror::Error;
 
-#[derive(Debug, PartialEq, Clone, Error, Deserialize)]
-#[allow(clippy::enum_variant_names)]
+#[derive(Debug, PartialEq, Clone, Error, EnumDiscriminants)]
+#[strum_discriminants(derive(serde::Serialize))]
+#[strum_discriminants(serde(rename_all = "SCREAMING_SNAKE_CASE"))]
 pub enum ReplicateStatusCause {
     #[error("computed.json file missing")]
     PostComputeComputedFileNotFound,
@@ -40,153 +42,31 @@ pub enum ReplicateStatusCause {
     PostComputeWorkerAddressMissing,
 }
 
-impl ReplicateStatusCause {
-    fn to_screaming_snake_case(&self) -> String {
-        let debug_str = format!("{self:?}");
-        let mut result = String::new();
-        let mut prev_was_lowercase = false;
-
-        for c in debug_str.chars() {
-            if c.is_uppercase() && !result.is_empty() && prev_was_lowercase {
-                result.push('_');
-            }
-            result.push(c.to_ascii_uppercase());
-            prev_was_lowercase = c.is_lowercase();
-        }
-
-        result
-    }
-}
-
-#[derive(Debug, Serialize)]
-pub struct WorkflowError {
-    pub cause: String,
-    pub message: String,
-}
-
-impl From<&ReplicateStatusCause> for WorkflowError {
-    fn from(cause: &ReplicateStatusCause) -> Self {
-        WorkflowError {
-            cause: cause.to_screaming_snake_case(),
-            message: cause.to_string(),
-        }
-    }
-}
-
-impl Serialize for ReplicateStatusCause {
+impl serde::Serialize for ReplicateStatusCause {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
-        S: serde::Serializer,
+        S: Serializer,
     {
-        WorkflowError::from(self).serialize(serializer)
+        let mut state = serializer.serialize_struct("ReplicateStatusCause", 2)?;
+        state.serialize_field("cause", &ReplicateStatusCauseDiscriminants::from(self))?;
+        state.serialize_field("message", &self.to_string())?;
+        state.end()
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use rstest::rstest;
     use serde_json::{json, to_value};
 
-    #[rstest]
-    #[case(
-        ReplicateStatusCause::PostComputeComputedFileNotFound,
-        "POST_COMPUTE_COMPUTED_FILE_NOT_FOUND",
-        "computed.json file missing"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeDropboxUploadFailed,
-        "POST_COMPUTE_DROPBOX_UPLOAD_FAILED",
-        "Failed to upload to Dropbox"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeEncryptionFailed,
-        "POST_COMPUTE_ENCRYPTION_FAILED",
-        "Encryption stage failed"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeEncryptionPublicKeyMissing,
-        "POST_COMPUTE_ENCRYPTION_PUBLIC_KEY_MISSING",
-        "Encryption public key related environment variable is missing"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeFailedUnknownIssue,
-        "POST_COMPUTE_FAILED_UNKNOWN_ISSUE",
-        "Unexpected error occurred"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeInvalidTeeSignature,
-        "POST_COMPUTE_INVALID_TEE_SIGNATURE",
-        "Invalid TEE signature"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeIpfsUploadFailed,
-        "POST_COMPUTE_IPFS_UPLOAD_FAILED",
-        "Failed to upload to IPFS"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeMalformedEncryptionPublicKey,
-        "POST_COMPUTE_MALFORMED_ENCRYPTION_PUBLIC_KEY",
-        "Encryption public key is malformed"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeOutFolderZipFailed,
-        "POST_COMPUTE_OUT_FOLDER_ZIP_FAILED",
-        "Failed to zip result folder"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeResultDigestComputationFailed,
-        "POST_COMPUTE_RESULT_DIGEST_COMPUTATION_FAILED",
-        "Empty resultDigest"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeResultFileNotFound,
-        "POST_COMPUTE_RESULT_FILE_NOT_FOUND",
-        "Result file not found"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeSendComputedFileFailed,
-        "POST_COMPUTE_SEND_COMPUTED_FILE_FAILED",
-        "Failed to send computed file"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeStorageTokenMissing,
-        "POST_COMPUTE_STORAGE_TOKEN_MISSING",
-        "Storage token related environment variable is missing"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeTaskIdMissing,
-        "POST_COMPUTE_TASK_ID_MISSING",
-        "Task ID related environment variable is missing"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeTeeChallengePrivateKeyMissing,
-        "POST_COMPUTE_TEE_CHALLENGE_PRIVATE_KEY_MISSING",
-        "Tee challenge private key related environment variable is missing"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeTooLongResultFileName,
-        "POST_COMPUTE_TOO_LONG_RESULT_FILE_NAME",
-        "Result file name too long"
-    )]
-    #[case(
-        ReplicateStatusCause::PostComputeWorkerAddressMissing,
-        "POST_COMPUTE_WORKER_ADDRESS_MISSING",
-        "Worker address related environment variable is missing"
-    )]
-    fn error_variant_serializes_with_correct_cause_and_message(
-        #[case] error: ReplicateStatusCause,
-        #[case] expected_cause: &str,
-        #[case] expected_message: &str,
-    ) {
-        let serialized = to_value(&error).unwrap();
-        assert_eq!(
-            serialized,
-            json!({
-                "cause": expected_cause,
-                "message": expected_message
-            })
-        );
+    #[test]
+    fn error_variant_serialize_correctly() {
+        let expected = json!({
+            "cause": "POST_COMPUTE_TooLongResultFileName",
+            "message": "Result file name too long"
+        });
+        let error_variant = ReplicateStatusCause::PostComputeTooLongResultFileName;
+        assert_eq!(to_value(&error_variant).unwrap(), expected);
     }
 
     #[test]