chore: PR suggestions and unit tests

Author: zeljkoX

src/config/server_config.rs

@@ -2063,4 +2063,104 @@ mod tests {
             env::remove_var("API_KEY");
         }
     }
+
+    mod get_sqs_wait_time_tests {
+        use super::*;
+        use serial_test::serial;
+
+        #[test]
+        #[serial]
+        fn test_returns_default_when_env_not_set() {
+            env::remove_var("SQS_TEST_QUEUE_WAIT_TIME_SECONDS");
+            let result = ServerConfig::get_sqs_wait_time("TEST_QUEUE", 5);
+            assert_eq!(result, 5, "Should return default when env var is not set");
+        }
+
+        #[test]
+        #[serial]
+        fn test_returns_parsed_value() {
+            env::set_var("SQS_TEST_QUEUE_WAIT_TIME_SECONDS", "10");
+            let result = ServerConfig::get_sqs_wait_time("TEST_QUEUE", 5);
+            assert_eq!(result, 10, "Should return parsed value");
+            env::remove_var("SQS_TEST_QUEUE_WAIT_TIME_SECONDS");
+        }
+
+        #[test]
+        #[serial]
+        fn test_returns_default_when_invalid() {
+            env::set_var("SQS_TEST_QUEUE_WAIT_TIME_SECONDS", "not_a_number");
+            let result = ServerConfig::get_sqs_wait_time("TEST_QUEUE", 5);
+            assert_eq!(result, 5, "Should return default for non-numeric input");
+            env::remove_var("SQS_TEST_QUEUE_WAIT_TIME_SECONDS");
+        }
+
+        #[test]
+        #[serial]
+        fn test_clamps_to_sqs_maximum_of_20() {
+            env::set_var("SQS_TEST_QUEUE_WAIT_TIME_SECONDS", "30");
+            let result = ServerConfig::get_sqs_wait_time("TEST_QUEUE", 5);
+            assert_eq!(result, 20, "Should clamp to SQS maximum of 20 seconds");
+            env::remove_var("SQS_TEST_QUEUE_WAIT_TIME_SECONDS");
+        }
+
+        #[test]
+        #[serial]
+        fn test_allows_zero() {
+            env::set_var("SQS_TEST_QUEUE_WAIT_TIME_SECONDS", "0");
+            let result = ServerConfig::get_sqs_wait_time("TEST_QUEUE", 5);
+            assert_eq!(result, 0, "Should allow zero (short polling)");
+            env::remove_var("SQS_TEST_QUEUE_WAIT_TIME_SECONDS");
+        }
+    }
+
+    mod get_sqs_poller_count_tests {
+        use super::*;
+        use serial_test::serial;
+
+        #[test]
+        #[serial]
+        fn test_returns_default_when_env_not_set() {
+            env::remove_var("SQS_TEST_QUEUE_POLLER_COUNT");
+            let result = ServerConfig::get_sqs_poller_count("TEST_QUEUE", 2);
+            assert_eq!(result, 2, "Should return default when env var is not set");
+        }
+
+        #[test]
+        #[serial]
+        fn test_returns_parsed_value() {
+            env::set_var("SQS_TEST_QUEUE_POLLER_COUNT", "4");
+            let result = ServerConfig::get_sqs_poller_count("TEST_QUEUE", 2);
+            assert_eq!(result, 4, "Should return parsed value");
+            env::remove_var("SQS_TEST_QUEUE_POLLER_COUNT");
+        }
+
+        #[test]
+        #[serial]
+        fn test_returns_default_when_invalid() {
+            env::set_var("SQS_TEST_QUEUE_POLLER_COUNT", "not_a_number");
+            let result = ServerConfig::get_sqs_poller_count("TEST_QUEUE", 2);
+            assert_eq!(result, 2, "Should return default for non-numeric input");
+            env::remove_var("SQS_TEST_QUEUE_POLLER_COUNT");
+        }
+
+        #[test]
+        #[serial]
+        fn test_clamps_zero_to_minimum_of_1() {
+            env::set_var("SQS_TEST_QUEUE_POLLER_COUNT", "0");
+            let result = ServerConfig::get_sqs_poller_count("TEST_QUEUE", 2);
+            assert_eq!(result, 1, "Should clamp zero to minimum of 1");
+            env::remove_var("SQS_TEST_QUEUE_POLLER_COUNT");
+        }
+
+        #[test]
+        #[serial]
+        fn test_default_also_clamped_to_minimum_of_1() {
+            env::remove_var("SQS_TEST_QUEUE_POLLER_COUNT");
+            let result = ServerConfig::get_sqs_poller_count("TEST_QUEUE", 0);
+            assert_eq!(
+                result, 1,
+                "Default of 0 should also be clamped to minimum of 1"
+            );
+        }
+    }
 }

src/metrics/mod.rs

@@ -734,3 +734,56 @@ mod property_tests {
         }
     }
 }
+
+#[cfg(test)]
+mod processing_time_tests {
+    use super::*;
+
+    #[test]
+    fn test_observe_processing_time_records_to_histogram() {
+        let before = TRANSACTION_PROCESSING_TIME
+            .with_label_values(&["test-relayer", "evm", "request_queue_dwell"])
+            .get_sample_count();
+
+        observe_processing_time("test-relayer", "evm", "request_queue_dwell", 1.5);
+
+        let after = TRANSACTION_PROCESSING_TIME
+            .with_label_values(&["test-relayer", "evm", "request_queue_dwell"])
+            .get_sample_count();
+
+        assert_eq!(after, before + 1, "sample count should increase by 1");
+    }
+
+    #[test]
+    fn test_observe_processing_time_accumulates_sum() {
+        let label = "test_sum_stage";
+        let before_sum = TRANSACTION_PROCESSING_TIME
+            .with_label_values(&["test-relayer-sum", "stellar", label])
+            .get_sample_sum();
+
+        observe_processing_time("test-relayer-sum", "stellar", label, 2.0);
+        observe_processing_time("test-relayer-sum", "stellar", label, 3.0);
+
+        let after_sum = TRANSACTION_PROCESSING_TIME
+            .with_label_values(&["test-relayer-sum", "stellar", label])
+            .get_sample_sum();
+
+        let delta = after_sum - before_sum;
+        assert!(
+            (delta - 5.0).abs() < 0.001,
+            "sum should increase by 5.0, got delta {delta}"
+        );
+    }
+
+    #[test]
+    fn test_stage_constants_are_distinct() {
+        let stages = [
+            STAGE_REQUEST_QUEUE_DWELL,
+            STAGE_PREPARE_DURATION,
+            STAGE_SUBMISSION_QUEUE_DWELL,
+            STAGE_SUBMIT_DURATION,
+        ];
+        let unique: std::collections::HashSet<&str> = stages.iter().copied().collect();
+        assert_eq!(stages.len(), unique.len(), "stage constants must be unique");
+    }
+}

src/queues/queue_type.rs

@@ -313,4 +313,90 @@ mod tests {
             assert!(qt.default_concurrency() > 0, "{qt:?} has zero concurrency");
         }
     }
+
+    #[test]
+    fn test_sqs_env_key_nonempty_and_uppercase() {
+        let all = [
+            QueueType::TransactionRequest,
+            QueueType::TransactionSubmission,
+            QueueType::StatusCheck,
+            QueueType::StatusCheckEvm,
+            QueueType::StatusCheckStellar,
+            QueueType::Notification,
+            QueueType::TokenSwapRequest,
+            QueueType::RelayerHealthCheck,
+        ];
+        for qt in &all {
+            let key = qt.sqs_env_key();
+            assert!(!key.is_empty(), "{qt:?} has empty sqs_env_key");
+            assert_eq!(
+                key,
+                key.to_uppercase(),
+                "{qt:?} sqs_env_key should be uppercase"
+            );
+        }
+    }
+
+    #[test]
+    fn test_sqs_env_key_unique_per_variant() {
+        let all = [
+            QueueType::TransactionRequest,
+            QueueType::TransactionSubmission,
+            QueueType::StatusCheck,
+            QueueType::StatusCheckEvm,
+            QueueType::StatusCheckStellar,
+            QueueType::Notification,
+            QueueType::TokenSwapRequest,
+            QueueType::RelayerHealthCheck,
+        ];
+        let keys: Vec<&str> = all.iter().map(|qt| qt.sqs_env_key()).collect();
+        let unique: std::collections::HashSet<&str> = keys.iter().copied().collect();
+        assert_eq!(
+            keys.len(),
+            unique.len(),
+            "sqs_env_key must be unique per QueueType variant"
+        );
+    }
+
+    #[test]
+    fn test_default_poller_count_at_least_one() {
+        let all = [
+            QueueType::TransactionRequest,
+            QueueType::TransactionSubmission,
+            QueueType::StatusCheck,
+            QueueType::StatusCheckEvm,
+            QueueType::StatusCheckStellar,
+            QueueType::Notification,
+            QueueType::TokenSwapRequest,
+            QueueType::RelayerHealthCheck,
+        ];
+        for qt in &all {
+            assert!(
+                qt.default_poller_count() >= 1,
+                "{qt:?} default_poller_count should be >= 1"
+            );
+        }
+    }
+
+    #[test]
+    fn test_default_wait_time_all_variants_covered() {
+        // Ensure every variant returns a value within SQS bounds [0, 20]
+        let all = [
+            QueueType::TransactionRequest,
+            QueueType::TransactionSubmission,
+            QueueType::StatusCheck,
+            QueueType::StatusCheckEvm,
+            QueueType::StatusCheckStellar,
+            QueueType::Notification,
+            QueueType::TokenSwapRequest,
+            QueueType::RelayerHealthCheck,
+        ];
+        for qt in &all {
+            let wt = qt.default_wait_time_secs();
+            assert!(
+                wt <= 20,
+                "{qt:?} default_wait_time_secs {wt} exceeds SQS max 20"
+            );
+        }
+    }
 }

src/queues/sqs/worker.rs

@@ -1683,4 +1683,146 @@ mod tests {
         assert!(!is_fifo_queue_url(standard));
         assert!(is_fifo_queue_url(fifo));
     }
+
+    // ── get_wait_time_for_queue ──────────────────────────────────────────
+
+    #[test]
+    fn test_get_wait_time_for_queue_returns_positive() {
+        let all = [
+            QueueType::TransactionRequest,
+            QueueType::TransactionSubmission,
+            QueueType::StatusCheck,
+            QueueType::StatusCheckEvm,
+            QueueType::StatusCheckStellar,
+            QueueType::Notification,
+            QueueType::TokenSwapRequest,
+            QueueType::RelayerHealthCheck,
+        ];
+        for qt in all {
+            let wt = get_wait_time_for_queue(qt);
+            assert!(
+                wt <= 20,
+                "{qt:?}: wait time {wt} exceeds SQS maximum of 20s"
+            );
+        }
+    }
+
+    #[test]
+    fn test_get_wait_time_for_queue_matches_defaults() {
+        // Without env overrides the helper should return the queue's default
+        assert_eq!(
+            get_wait_time_for_queue(QueueType::TransactionRequest),
+            QueueType::TransactionRequest.default_wait_time_secs()
+        );
+        assert_eq!(
+            get_wait_time_for_queue(QueueType::StatusCheck),
+            QueueType::StatusCheck.default_wait_time_secs()
+        );
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn test_get_wait_time_for_queue_respects_env_override() {
+        // StatusCheck default is 5; override to 12 via the real env var path
+        let env_var = format!(
+            "SQS_{}_WAIT_TIME_SECONDS",
+            QueueType::StatusCheck.sqs_env_key()
+        );
+        std::env::set_var(&env_var, "12");
+        assert_eq!(get_wait_time_for_queue(QueueType::StatusCheck), 12);
+        std::env::remove_var(&env_var);
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn test_get_wait_time_for_queue_env_override_clamped_to_20() {
+        let env_var = format!(
+            "SQS_{}_WAIT_TIME_SECONDS",
+            QueueType::Notification.sqs_env_key()
+        );
+        std::env::set_var(&env_var, "99");
+        assert_eq!(
+            get_wait_time_for_queue(QueueType::Notification),
+            20,
+            "Should clamp to SQS maximum of 20"
+        );
+        std::env::remove_var(&env_var);
+    }
+
+    // ── get_poller_count_for_queue ───────────────────────────────────────
+
+    #[test]
+    fn test_get_poller_count_for_queue_all_types_positive() {
+        let all = [
+            QueueType::TransactionRequest,
+            QueueType::TransactionSubmission,
+            QueueType::StatusCheck,
+            QueueType::StatusCheckEvm,
+            QueueType::StatusCheckStellar,
+            QueueType::Notification,
+            QueueType::TokenSwapRequest,
+            QueueType::RelayerHealthCheck,
+        ];
+        for qt in all {
+            assert!(
+                get_poller_count_for_queue(qt) >= 1,
+                "{qt:?}: poller count must be at least 1"
+            );
+        }
+    }
+
+    #[test]
+    fn test_get_poller_count_for_queue_matches_defaults() {
+        // Without env overrides the helper should return the queue's default (clamped to >= 1)
+        assert_eq!(
+            get_poller_count_for_queue(QueueType::TransactionRequest),
+            QueueType::TransactionRequest.default_poller_count().max(1)
+        );
+        assert_eq!(
+            get_poller_count_for_queue(QueueType::Notification),
+            QueueType::Notification.default_poller_count().max(1)
+        );
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn test_get_poller_count_for_queue_respects_env_override() {
+        let env_var = format!("SQS_{}_POLLER_COUNT", QueueType::Notification.sqs_env_key());
+        std::env::set_var(&env_var, "5");
+        assert_eq!(get_poller_count_for_queue(QueueType::Notification), 5);
+        std::env::remove_var(&env_var);
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn test_get_poller_count_for_queue_env_zero_clamped_to_1() {
+        let env_var = format!("SQS_{}_POLLER_COUNT", QueueType::StatusCheck.sqs_env_key());
+        std::env::set_var(&env_var, "0");
+        assert_eq!(
+            get_poller_count_for_queue(QueueType::StatusCheck),
+            1,
+            "Zero poller count from env should be clamped to 1"
+        );
+        std::env::remove_var(&env_var);
+    }
+
+    // ── PollLoopConfig ──────────────────────────────────────────────────
+
+    #[test]
+    fn test_poll_loop_config_clone() {
+        let config = PollLoopConfig {
+            queue_type: QueueType::TransactionRequest,
+            polling_interval: 15,
+            visibility_timeout: 120,
+            handler_timeout: Duration::from_secs(120),
+            max_retries: 3,
+            poller_id: 0,
+            poller_count: 2,
+        };
+        let cloned = config.clone();
+        assert_eq!(cloned.polling_interval, 15);
+        assert_eq!(cloned.poller_id, 0);
+        assert_eq!(cloned.poller_count, 2);
+        assert_eq!(cloned.max_retries, 3);
+    }
 }