Run clippy against tests

.github/workflows/run-tests-on-push-to-main.yml

@@ -25,7 +25,7 @@ jobs:
 
       - name: Run Clippy
         run: |
-          cargo clippy \
+          cargo clippy --all-targets --all-features \
             --package acropolis_common \
             --package acropolis_codec \
             --package acropolis_module_accounts_state \

common/examples/test_streaming_parser.rs

@@ -12,6 +12,7 @@ use std::env;
 use std::time::Instant;
 
 // Simple counter callback that doesn't store data in memory
+#[derive(Default)]
 struct CountingCallbacks {
     metadata: Option<SnapshotMetadata>,
     utxo_count: u64,
@@ -26,24 +27,6 @@ struct CountingCallbacks {
     sample_proposals: Vec<GovernanceProposal>,
 }
 
-impl Default for CountingCallbacks {
-    fn default() -> Self {
-        Self {
-            metadata: None,
-            utxo_count: 0,
-            pool_count: 0,
-            account_count: 0,
-            drep_count: 0,
-            proposal_count: 0,
-            sample_utxos: Vec::new(),
-            sample_pools: Vec::new(),
-            sample_accounts: Vec::new(),
-            sample_dreps: Vec::new(),
-            sample_proposals: Vec::new(),
-        }
-    }
-}
-
 impl UtxoCallback for CountingCallbacks {
     fn on_utxo(&mut self, utxo: UtxoEntry) -> Result<()> {
         self.utxo_count += 1;
@@ -62,7 +45,7 @@ impl UtxoCallback for CountingCallbacks {
             self.sample_utxos.push(utxo);
         }
         // Progress reporting every million UTXOs
-        if self.utxo_count > 0 && self.utxo_count % 1000000 == 0 {
+        if self.utxo_count > 0 && self.utxo_count.is_multiple_of(1000000) {
             eprintln!("  Parsed {} UTXOs...", self.utxo_count);
         }
         Ok(())
@@ -95,7 +78,7 @@ impl PoolCallback for CountingCallbacks {
 impl StakeCallback for CountingCallbacks {
     fn on_accounts(&mut self, accounts: Vec<AccountState>) -> Result<()> {
         self.account_count = accounts.len();
-        if accounts.len() > 0 {
+        if !accounts.is_empty() {
             eprintln!("✓ Parsed {} stake accounts", accounts.len());
 
             // Show first 10 accounts
@@ -152,7 +135,7 @@ impl DRepCallback for CountingCallbacks {
 impl ProposalCallback for CountingCallbacks {
     fn on_proposals(&mut self, proposals: Vec<GovernanceProposal>) -> Result<()> {
         self.proposal_count = proposals.len();
-        if proposals.len() > 0 {
+        if !proposals.is_empty() {
             eprintln!("✓ Parsed {} governance proposals", proposals.len());
 
             // Show first 10 proposals

common/src/stake_addresses.rs

@@ -558,7 +558,7 @@ mod tests {
 
     fn create_stake_address(hash: &[u8]) -> StakeAddress {
         StakeAddress::new(
-            StakeCredential::AddrKeyHash(hash.to_vec().try_into().expect("Invalid hash length")),
+            StakeCredential::AddrKeyHash(hash.to_vec()),
             NetworkId::Mainnet,
         )
     }
@@ -1017,7 +1017,7 @@ mod tests {
 
             let spdd = stake_addresses.generate_spdd();
 
-            let pool_stake = spdd.get(&SPO_HASH.to_vec()).unwrap();
+            let pool_stake = spdd.get(SPO_HASH.as_slice()).unwrap();
             assert_eq!(pool_stake.active, 3000); // utxo only
             assert_eq!(pool_stake.live, 3150); // utxo + rewards
             assert_eq!(pool_stake.active_delegators_count, 2);
@@ -1047,8 +1047,8 @@ mod tests {
             let spdd = stake_addresses.generate_spdd();
 
             assert_eq!(spdd.len(), 2);
-            assert_eq!(spdd.get(&SPO_HASH.to_vec()).unwrap().active, 1000);
-            assert_eq!(spdd.get(&SPO_HASH_2.to_vec()).unwrap().active, 2000);
+            assert_eq!(spdd.get(SPO_HASH.as_slice()).unwrap().active, 1000);
+            assert_eq!(spdd.get(SPO_HASH_2.as_slice()).unwrap().active, 2000);
         }
 
         #[test]

common/src/types.rs

@@ -1928,7 +1928,7 @@ mod tests {
         assert_eq!(Era::default() as u8, 0);
         assert_eq!(Era::Byron as u8, 0);
         assert_eq!(Era::Conway as u8, 6);
-        assert!(!Era::try_from(7).is_ok());
+        assert!(Era::try_from(7).is_err());
 
         for ei in 0..=6 {
             for ej in 0..=6 {
@@ -1986,16 +1986,14 @@ mod tests {
         let gov_action = GovernanceAction::UpdateCommittee(UpdateCommitteeAction {
             previous_action_id: None,
             data: CommitteeChange {
-                removed_committee_members: HashSet::from_iter(
-                    vec![
-                        make_committee_credential(true, 48),
-                        make_committee_credential(false, 12),
-                    ]
-                    .into_iter(),
-                ),
-                new_committee_members: HashMap::from_iter(
-                    vec![(make_committee_credential(false, 87), 1234)].into_iter(),
-                ),
+                removed_committee_members: HashSet::from_iter([
+                    make_committee_credential(true, 48),
+                    make_committee_credential(false, 12),
+                ]),
+                new_committee_members: HashMap::from_iter([(
+                    make_committee_credential(false, 87),
+                    1234,
+                )]),
                 terms: RationalNumber::from(1),
             },
         });

common/tests/loc_over_bus.rs

@@ -63,46 +63,37 @@ impl Subscriber {
         let ctx = context.clone();
         ctx.run(async move {
             while let Ok((_, msg)) = sub.read().await {
-                match &*msg {
-                    BusMsg::Loc(loc) => {
-                        let res = Resolver::new(&registry()).resolve(loc);
-                        match res {
-                            Ok(view) => {
-                                // touch the bytes so we know mapping worked
-                                let slice = view.as_slice();
-                                // trivial check: non-empty
-                                if !slice.is_empty() {
-                                    context
-                                        .publish(
-                                            &ack_topic,
-                                            Arc::new(BusMsg::Ack("ok".to_string())),
-                                        )
-                                        .await
-                                        .expect("Failed to publish ACK");
-                                } else {
-                                    context
-                                        .publish(
-                                            &ack_topic,
-                                            Arc::new(BusMsg::Ack("empty".to_string())),
-                                        )
-                                        .await
-                                        .expect("Failed to publish ACK");
-                                }
-                                break; // test done
-                            }
-                            Err(_) => {
+                if let BusMsg::Loc(loc) = &*msg {
+                    let res = Resolver::new(&registry()).resolve(loc);
+                    match res {
+                        Ok(view) => {
+                            // touch the bytes so we know mapping worked
+                            let slice = view.as_slice();
+                            // trivial check: non-empty
+                            if !slice.is_empty() {
                                 context
-                                    .publish(
-                                        &ack_topic,
-                                        Arc::new(BusMsg::Ack("resolve_err".to_string())),
-                                    )
+                                    .publish(&ack_topic, Arc::new(BusMsg::Ack("ok".to_string())))
+                                    .await
+                                    .expect("Failed to publish ACK");
+                            } else {
+                                context
+                                    .publish(&ack_topic, Arc::new(BusMsg::Ack("empty".to_string())))
                                     .await
                                     .expect("Failed to publish ACK");
-                                break;
                             }
+                            break; // test done
+                        }
+                        Err(_) => {
+                            context
+                                .publish(
+                                    &ack_topic,
+                                    Arc::new(BusMsg::Ack("resolve_err".to_string())),
+                                )
+                                .await
+                                .expect("Failed to publish ACK");
+                            break;
                         }
                     }
-                    _ => {}
                 }
             }
         });

modules/accounts_state/src/snapshot.rs

@@ -196,7 +196,7 @@ mod tests {
         hash[0] = id;
         StakeAddress {
             network: Mainnet,
-            credential: StakeCredential::AddrKeyHash(hash.try_into().expect("Invalid hash length")),
+            credential: StakeCredential::AddrKeyHash(hash),
         }
     }
 

modules/address_state/src/state.rs

@@ -232,7 +232,7 @@ mod tests {
     fn delta(addr: &Address, utxo: &UTxOIdentifier, lovelace: i64) -> AddressDelta {
         AddressDelta {
             address: addr.clone(),
-            utxo: utxo.clone(),
+            utxo: *utxo,
             value: ValueDelta {
                 lovelace,
                 assets: Vec::new(),
@@ -311,21 +311,21 @@ mod tests {
 
         // Verify UTxO was removed while in volatile
         let after_spend_volatile = state.get_address_utxos(&addr).await?;
-        assert!(after_spend_volatile.as_ref().map_or(true, |u| u.is_empty()));
+        assert!(after_spend_volatile.as_ref().is_none_or(|u| u.is_empty()));
 
         // Drain volatile to immutable
         state.prune_volatile().await;
 
         // Verify UTxO was removed while in pending immutable
         let after_spend_pending = state.get_address_utxos(&addr).await?;
-        assert!(after_spend_pending.as_ref().map_or(true, |u| u.is_empty()));
+        assert!(after_spend_pending.as_ref().is_none_or(|u| u.is_empty()));
 
         // Perisist immutable to disk
         state.immutable.persist_epoch(2, &state.config).await?;
 
         // Verify UTxO was removed after persisting spend to disk
         let after_spend_disk = state.get_address_utxos(&addr).await?;
-        assert!(after_spend_disk.as_ref().map_or(true, |u| u.is_empty()));
+        assert!(after_spend_disk.as_ref().is_none_or(|u| u.is_empty()));
 
         Ok(())
     }

modules/assets_state/src/asset_registry.rs

@@ -88,8 +88,8 @@ mod tests {
         let policy = dummy_policy(1);
         let name = asset_name_from_str("tokenA");
 
-        let id1 = registry.get_or_insert(policy.clone(), name.clone());
-        let id2 = registry.get_or_insert(policy.clone(), name.clone());
+        let id1 = registry.get_or_insert(policy, name);
+        let id2 = registry.get_or_insert(policy, name);
 
         assert_eq!(id1, id2);
     }
@@ -102,8 +102,8 @@ mod tests {
         let name1 = asset_name_from_str("tokenA");
         let name2 = asset_name_from_str("tokenB");
 
-        let id1 = registry.get_or_insert(policy1.clone(), name1.clone());
-        let id2 = registry.get_or_insert(policy2.clone(), name2.clone());
+        let id1 = registry.get_or_insert(policy1, name1);
+        let id2 = registry.get_or_insert(policy2, name2);
 
         assert_ne!(id1, id2);
         assert_eq!(id1.index(), 0);
@@ -116,7 +116,7 @@ mod tests {
         let policy = dummy_policy(1);
         let name = asset_name_from_str("tokenA");
 
-        let id1 = registry.get_or_insert(policy.clone(), name.clone());
+        let id1 = registry.get_or_insert(policy, name);
         let id2 = registry.lookup_id(&policy, &name).unwrap();
 
         assert_eq!(id1, id2);
@@ -137,7 +137,7 @@ mod tests {
         let policy = dummy_policy(1);
         let name = asset_name_from_str("tokenA");
 
-        let id = registry.get_or_insert(policy.clone(), name.clone());
+        let id = registry.get_or_insert(policy, name);
         let key = registry.lookup(id).unwrap();
 
         assert_eq!(policy, *key.policy);