refactor(tests): delete redundant tests, add missing coverage

Author: glottologist

Cargo.lock

@@ -1694,79 +1694,35 @@ pub fn calculate_chunks_added(txs: &[DataTransactionHeader], chunk_size: u64) ->
 mod oracle_choice_tests {
     use super::choose_oracle_price;
     use irys_types::{UnixTimestamp, storage_pricing::Amount};
+    use rstest::rstest;
     use rust_decimal_macros::dec;
 
-    const MAX_AGE_SECS: u64 = 3 * 60; // 3 minutes
-
-    #[test]
-    fn chooses_parent_when_oracle_is_too_stale() {
+    const MAX_AGE_SECS: u64 = 3 * 60;
+
+    #[rstest]
+    #[case::stale_oracle(1000, 1000 - MAX_AGE_SECS - 1, true)]
+    #[case::at_tolerance_boundary(1000, 1000 - MAX_AGE_SECS, false)]
+    #[case::fresher_oracle(100, 200, false)]
+    #[case::equal_timestamps(500, 500, false)]
+    fn choose_oracle_price_scenarios(
+        #[case] parent_ts_secs: u64,
+        #[case] oracle_ts_secs: u64,
+        #[case] expect_parent: bool,
+    ) {
         let parent_price = Amount::token(dec!(2.0)).unwrap();
         let oracle_price = Amount::token(dec!(1.0)).unwrap();
 
-        // Oracle is more than 3 minutes behind parent - use parent
         let chosen = choose_oracle_price(
-            UnixTimestamp::from_secs(1000),
+            UnixTimestamp::from_secs(parent_ts_secs),
             parent_price,
             oracle_price,
-            UnixTimestamp::from_secs(1000 - MAX_AGE_SECS - 1), // 181 seconds behind
-        );
-        assert_eq!(
-            chosen, parent_price,
-            "should choose parent price when oracle is more than 3 minutes stale"
+            UnixTimestamp::from_secs(oracle_ts_secs),
         );
-    }
 
-    #[test]
-    fn chooses_oracle_when_within_tolerance() {
-        let parent_price = Amount::token(dec!(2.0)).unwrap();
-        let oracle_price = Amount::token(dec!(1.0)).unwrap();
-
-        // Oracle is exactly at the 3-minute tolerance boundary - still use oracle
-        let chosen = choose_oracle_price(
-            UnixTimestamp::from_secs(1000),
-            parent_price,
-            oracle_price,
-            UnixTimestamp::from_secs(1000 - MAX_AGE_SECS), // exactly 180 seconds behind
-        );
-        assert_eq!(
-            chosen, oracle_price,
-            "should choose oracle price when exactly at 3-minute tolerance"
-        );
-    }
-
-    #[test]
-    fn chooses_oracle_when_oracle_is_fresher() {
-        let parent_price = Amount::token(dec!(2.0)).unwrap();
-        let oracle_price = Amount::token(dec!(1.0)).unwrap();
-
-        // Oracle is fresher than parent - definitely use oracle
-        let chosen = choose_oracle_price(
-            UnixTimestamp::from_secs(100),
-            parent_price,
-            oracle_price,
-            UnixTimestamp::from_secs(200),
-        );
-        assert_eq!(
-            chosen, oracle_price,
-            "should choose oracle price when oracle is fresher"
-        );
-    }
-
-    #[test]
-    fn chooses_oracle_when_timestamps_are_equal() {
-        let parent_price = Amount::token(dec!(2.0)).unwrap();
-        let oracle_price = Amount::token(dec!(1.0)).unwrap();
-
-        // Both at same second - prefer oracle (authoritative source)
-        let chosen = choose_oracle_price(
-            UnixTimestamp::from_secs(500),
-            parent_price,
-            oracle_price,
-            UnixTimestamp::from_secs(500),
-        );
-        assert_eq!(
-            chosen, oracle_price,
-            "should choose oracle price when timestamps are equal"
-        );
+        if expect_parent {
+            assert_eq!(chosen, parent_price);
+        } else {
+            assert_eq!(chosen, oracle_price);
+        }
     }
 }

crates/actors/src/block_producer.rs

@@ -1068,26 +1068,6 @@ mod tests {
         Ok(())
     }
 
-    // ========================================================================
-    // FIFO Ordering Property Tests
-    // ========================================================================
-
-    #[cfg(test)]
-    mod fifo_properties {
-
-        use irys_types::UnixTimestamp;
-        use proptest::prelude::*;
-
-        prop_compose! {
-            fn unix_timestamps()(
-                // Realistic range: 2020-01-01 to 2030-01-01
-                secs in 1_577_836_800_u64..1_893_456_000_u64
-            ) -> UnixTimestamp {
-                UnixTimestamp::from_secs(secs)
-            }
-        }
-    }
-
     // Chunks should remain when there is an active ingress proof present for the data_root.
     #[tokio::test]
     async fn does_not_prune_chunks_with_active_proof() -> eyre::Result<()> {

crates/actors/src/cache_service.rs

@@ -922,8 +922,6 @@ mod tests {
     }
 
     proptest! {
-        /// Property: publish ledger data_size is ALWAYS preferred over submit ledger,
-        /// regardless of the relative sizes.
         #[test]
         fn publish_ledger_always_preferred_over_submit(
             publish_size in 1..u64::MAX,
@@ -939,7 +937,6 @@ mod tests {
             prop_assert!(selected.is_from_publish_ledger);
         }
 
-        /// Property: single ledger type always selects max size
         #[test]
         fn single_ledger_type_selects_max(
             sizes in prop::collection::vec(1..u64::MAX, 1..10),
@@ -961,7 +958,6 @@ mod tests {
             prop_assert_eq!(selected.is_from_publish_ledger, is_publish);
         }
 
-        /// Property: with mixed ledgers, publish ledger max is always selected
         #[test]
         fn mixed_ledgers_selects_publish_max(
             publish_sizes in prop::collection::vec(1..u64::MAX, 1..5),

crates/actors/src/chunk_ingress_service/chunks.rs

@@ -35,17 +35,6 @@ impl Drop for ActiveWorkerGuard {
 mod tests {
     use super::*;
 
-    #[test]
-    fn test_guard_increments_on_create() {
-        let counter = Arc::new(AtomicUsize::new(0));
-        let notify = Arc::new(Notify::new());
-
-        {
-            let _guard = ActiveWorkerGuard::new(counter.clone(), notify);
-            assert_eq!(counter.load(Ordering::Relaxed), 1);
-        }
-    }
-
     #[test]
     fn test_guard_decrements_on_drop() {
         let counter = Arc::new(AtomicUsize::new(0));