diff --git a/.github/workflows/run-tests-on-push-to-main.yml b/.github/workflows/run-tests-on-push-to-main.yml index c04a2192..7bd62060 100644 --- a/.github/workflows/run-tests-on-push-to-main.yml +++ b/.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 \ diff --git a/common/examples/test_streaming_parser.rs b/common/examples/test_streaming_parser.rs index 35b56709..170b6f6f 100644 --- a/common/examples/test_streaming_parser.rs +++ b/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, utxo_count: u64, @@ -26,24 +27,6 @@ struct CountingCallbacks { sample_proposals: Vec, } -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) -> 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) -> Result<()> { self.proposal_count = proposals.len(); - if proposals.len() > 0 { + if !proposals.is_empty() { eprintln!("✓ Parsed {} governance proposals", proposals.len()); // Show first 10 proposals diff --git a/common/src/stake_addresses.rs b/common/src/stake_addresses.rs index b4daf076..3d762e59 100644 --- a/common/src/stake_addresses.rs +++ b/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] diff --git a/common/src/types.rs b/common/src/types.rs index 3b6267d2..edfa1774 100644 --- a/common/src/types.rs +++ b/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), }, }); diff --git a/common/tests/loc_over_bus.rs b/common/tests/loc_over_bus.rs index 559fe789..9cba1896 100644 --- a/common/tests/loc_over_bus.rs +++ b/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(®istry()).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(®istry()).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; } } - _ => {} } } }); diff --git a/modules/accounts_state/src/snapshot.rs b/modules/accounts_state/src/snapshot.rs index e1aab49c..aa4632da 100644 --- a/modules/accounts_state/src/snapshot.rs +++ b/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), } } diff --git a/modules/address_state/src/state.rs b/modules/address_state/src/state.rs index 74ff3a71..cc6e1d09 100644 --- a/modules/address_state/src/state.rs +++ b/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(()) } diff --git a/modules/assets_state/src/asset_registry.rs b/modules/assets_state/src/asset_registry.rs index eac9d38e..492d4aa6 100644 --- a/modules/assets_state/src/asset_registry.rs +++ b/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); diff --git a/modules/assets_state/src/state.rs b/modules/assets_state/src/state.rs index 364837b3..90c8b384 100644 --- a/modules/assets_state/src/state.rs +++ b/modules/assets_state/src/state.rs @@ -669,7 +669,7 @@ mod tests { seed_transactions: StoreTransactions, ) -> (State, AssetId, AssetName) { let asset_name = AssetName::new(asset_name_bytes).unwrap(); - let asset_id = registry.get_or_insert(policy_id, asset_name.clone()); + let asset_id = registry.get_or_insert(policy_id, asset_name); let mut state = State::new(AssetsStorageConfig { store_info: true, @@ -782,14 +782,8 @@ mod tests { let tx = dummy_tx_identifier(9); let deltas = vec![( - tx.clone(), - vec![( - policy, - vec![NativeAssetDelta { - name: name.clone(), - amount: 100, - }], - )], + tx, + vec![(policy, vec![NativeAssetDelta { name, amount: 100 }])], )]; let new_state = state.handle_mint_deltas(&deltas, &mut registry).unwrap(); @@ -827,24 +821,12 @@ mod tests { let tx2 = dummy_tx_identifier(2); let deltas1 = vec![( - tx1.clone(), - vec![( - policy, - vec![NativeAssetDelta { - name: name.clone(), - amount: 50, - }], - )], + tx1, + vec![(policy, vec![NativeAssetDelta { name, amount: 50 }])], )]; let deltas2 = vec![( - tx2.clone(), - vec![( - policy, - vec![NativeAssetDelta { - name: name.clone(), - amount: 25, - }], - )], + tx2, + vec![(policy, vec![NativeAssetDelta { name, amount: 25 }])], )]; let state = state.handle_mint_deltas(&deltas1, &mut registry).unwrap(); @@ -877,24 +859,12 @@ mod tests { let tx2 = dummy_tx_identifier(2); let mint = vec![( - tx1.clone(), - vec![( - policy, - vec![NativeAssetDelta { - name: name.clone(), - amount: 100, - }], - )], + tx1, + vec![(policy, vec![NativeAssetDelta { name, amount: 100 }])], )]; let burn = vec![( - tx2.clone(), - vec![( - policy, - vec![NativeAssetDelta { - name: name.clone(), - amount: -40, - }], - )], + tx2, + vec![(policy, vec![NativeAssetDelta { name, amount: -40 }])], )]; let state = state.handle_mint_deltas(&mint, &mut registry).unwrap(); @@ -927,14 +897,8 @@ mod tests { let tx = dummy_tx_identifier(1); let deltas = vec![( - tx.clone(), - vec![( - policy, - vec![NativeAssetDelta { - name: name.clone(), - amount: -50, - }], - )], + tx, + vec![(policy, vec![NativeAssetDelta { name, amount: -50 }])], )]; let result = state.handle_mint_deltas(&deltas, &mut registry); @@ -952,14 +916,8 @@ mod tests { let tx = dummy_tx_identifier(1); let deltas = vec![( - tx.clone(), - vec![( - policy, - vec![NativeAssetDelta { - name: name.clone(), - amount: -10, - }], - )], + tx, + vec![(policy, vec![NativeAssetDelta { name, amount: -10 }])], )]; let result = state.handle_mint_deltas(&deltas, &mut registry); @@ -988,7 +946,7 @@ mod tests { #[test] fn handle_cip25_metadata_updates_correct_asset() { let mut registry = AssetRegistry::new(); - let policy_id: PolicyId = [0u8; 28].into(); + let policy_id: PolicyId = [0u8; 28]; let (state, asset_id, asset_name) = setup_state_with_asset( &mut registry, @@ -1017,7 +975,7 @@ mod tests { #[test] fn handle_cip25_metadata_version_field_sets_v2() { let mut registry = AssetRegistry::new(); - let policy_id: PolicyId = [1u8; 28].into(); + let policy_id: PolicyId = [1u8; 28]; let (state, asset_id, asset_name) = setup_state_with_asset( &mut registry, @@ -1047,7 +1005,7 @@ mod tests { #[test] fn handle_cip25_metadata_unknown_asset_is_ignored() { let mut registry = AssetRegistry::new(); - let policy_id: PolicyId = [2u8; 28].into(); + let policy_id: PolicyId = [2u8; 28]; let (state, asset_id, _) = setup_state_with_asset( &mut registry, policy_id, @@ -1075,7 +1033,7 @@ mod tests { #[test] fn handle_cip25_metadata_invalid_cbor_is_skipped() { let mut registry = AssetRegistry::new(); - let policy_id: PolicyId = [3u8; 28].into(); + let policy_id: PolicyId = [3u8; 28]; let (state, asset_id, _) = setup_state_with_asset( &mut registry, policy_id, @@ -1107,7 +1065,7 @@ mod tests { #[test] fn handle_cip68_metadata_updates_onchain_metadata() { let mut registry = AssetRegistry::new(); - let policy_id: PolicyId = [9u8; 28].into(); + let policy_id: PolicyId = [9u8; 28]; let (state, reference_id, reference_name) = setup_state_with_asset( &mut registry, @@ -1119,10 +1077,10 @@ mod tests { ); let datum_blob = vec![1, 2, 3, 4]; - let output = make_output(policy_id, reference_name.clone(), Some(datum_blob.clone())); + let output = make_output(policy_id, reference_name, Some(datum_blob.clone())); let new_state = - state.handle_cip68_metadata(&[UTXODelta::Output(output)], &mut registry).unwrap(); + state.handle_cip68_metadata(&[UTXODelta::Output(output)], ®istry).unwrap(); let info = new_state.info.expect("info should be Some"); let record = info.get(&reference_id).expect("record should exist"); @@ -1133,7 +1091,7 @@ mod tests { #[test] fn handle_cip68_metadata_ignores_non_reference_assets() { let mut registry = AssetRegistry::new(); - let policy_id: PolicyId = [9u8; 28].into(); + let policy_id: PolicyId = [9u8; 28]; let (state, normal_id, normal_name) = setup_state_with_asset( &mut registry, @@ -1145,10 +1103,10 @@ mod tests { ); let datum_blob = vec![1, 2, 3, 4]; - let output = make_output(policy_id, normal_name.clone(), Some(datum_blob.clone())); + let output = make_output(policy_id, normal_name, Some(datum_blob.clone())); let delta = UTXODelta::Output(output); - let new_state = state.handle_cip68_metadata(&[delta], &mut registry).unwrap(); + let new_state = state.handle_cip68_metadata(&[delta], ®istry).unwrap(); let info = new_state.info.expect("info should be Some"); let record = info.get(&normal_id).expect("non reference asset should exist"); @@ -1160,7 +1118,7 @@ mod tests { #[test] fn handle_cip68_metadata_ignores_unknown_reference_assets() { let mut registry = AssetRegistry::new(); - let policy_id: PolicyId = [9u8; 28].into(); + let policy_id: PolicyId = [9u8; 28]; let (state, asset_id, name) = setup_state_with_asset( &mut registry, @@ -1175,7 +1133,7 @@ mod tests { let output = make_output(policy_id, name, Some(datum_blob)); let delta = UTXODelta::Output(output); - let new_state = state.handle_cip68_metadata(&[delta], &mut registry).unwrap(); + let new_state = state.handle_cip68_metadata(&[delta], ®istry).unwrap(); let info = new_state.info.expect("info should be Some"); @@ -1189,7 +1147,7 @@ mod tests { #[test] fn handle_cip68_metadata_ignores_inputs_and_outputs_without_datum() { let mut registry = AssetRegistry::new(); - let policy_id: PolicyId = [7u8; 28].into(); + let policy_id: PolicyId = [7u8; 28]; let (state, asset_id, name) = setup_state_with_asset( &mut registry, @@ -1207,7 +1165,7 @@ mod tests { let output_delta = UTXODelta::Output(output); let new_state = - state.handle_cip68_metadata(&[input_delta, output_delta], &mut registry).unwrap(); + state.handle_cip68_metadata(&[input_delta, output_delta], ®istry).unwrap(); let info = new_state.info.expect("info should be Some"); let record = info.get(&asset_id).unwrap(); @@ -1222,7 +1180,7 @@ mod tests { #[test] fn get_asset_info_reference_nft_strips_metadata() { let mut registry = AssetRegistry::new(); - let policy_id: PolicyId = [9u8; 28].into(); + let policy_id: PolicyId = [9u8; 28]; let (mut state, ref_id, _) = setup_state_with_asset( &mut registry, @@ -1256,10 +1214,10 @@ mod tests { #[test] fn resolve_cip68_metadata_overwrites_cip25_user_token_metadata() { let mut registry = AssetRegistry::new(); - let policy_id: PolicyId = [10u8; 28].into(); + let policy_id: PolicyId = [10u8; 28]; let user_name = AssetName::new(&[0x00, 0x0d, 0xe1, 0x40, 0xaa]).unwrap(); - let user_id = registry.get_or_insert(policy_id, user_name.clone()); + let user_id = registry.get_or_insert(policy_id, user_name); let mut ref_bytes = user_name.as_slice().to_vec(); ref_bytes[0..4].copy_from_slice(&[0x00, 0x06, 0x43, 0xb0]); @@ -1273,14 +1231,18 @@ mod tests { }); let mut info_map = imbl::HashMap::new(); - let mut user_record = AssetInfoRecord::default(); - user_record.onchain_metadata = Some(vec![1, 2, 3]); - user_record.metadata_standard = Some(AssetMetadataStandard::CIP25v1); + let user_record = AssetInfoRecord { + onchain_metadata: Some(vec![1, 2, 3]), + metadata_standard: Some(AssetMetadataStandard::CIP25v1), + ..Default::default() + }; info_map.insert(user_id, user_record); - let mut ref_record = AssetInfoRecord::default(); - ref_record.onchain_metadata = Some(vec![9, 9, 9]); - ref_record.metadata_standard = Some(AssetMetadataStandard::CIP68v2); + let ref_record = AssetInfoRecord { + onchain_metadata: Some(vec![9, 9, 9]), + metadata_standard: Some(AssetMetadataStandard::CIP68v2), + ..Default::default() + }; info_map.insert(ref_id, ref_record); state.info = Some(info_map); @@ -1302,7 +1264,7 @@ mod tests { #[test] fn handle_transactions_duplicate_tx_ignored() { let mut registry = AssetRegistry::new(); - let policy_id: PolicyId = [1u8; 28].into(); + let policy_id: PolicyId = [1u8; 28]; let (state, asset_id, asset_name) = setup_state_with_asset( &mut registry, @@ -1313,7 +1275,7 @@ mod tests { StoreTransactions::All, ); - let output = make_output(policy_id, asset_name.clone(), None); + let output = make_output(policy_id, asset_name, None); let delta1 = UTXODelta::Output(acropolis_common::TxOutput { utxo_identifier: UTxOIdentifier::new(0, 0, 0), @@ -1335,7 +1297,7 @@ mod tests { #[test] fn handle_transactions_updates_asset_transactions() { let mut registry = AssetRegistry::new(); - let policy_id: PolicyId = [2u8; 28].into(); + let policy_id: PolicyId = [2u8; 28]; let (state, asset_id, asset_name) = setup_state_with_asset( &mut registry, @@ -1346,8 +1308,8 @@ mod tests { StoreTransactions::All, ); - let out1 = make_output(policy_id, asset_name.clone(), None); - let out2 = make_output(policy_id, asset_name.clone(), None); + let out1 = make_output(policy_id, asset_name, None); + let out2 = make_output(policy_id, asset_name, None); let delta1 = UTXODelta::Output(acropolis_common::TxOutput { utxo_identifier: UTxOIdentifier::new(9, 0, 0), @@ -1372,7 +1334,7 @@ mod tests { #[test] fn handle_transactions_prunes_on_store_transactions_config() { let mut registry = AssetRegistry::new(); - let policy_id: PolicyId = [3u8; 28].into(); + let policy_id: PolicyId = [3u8; 28]; let (state, asset_id, asset_name) = setup_state_with_asset( &mut registry, @@ -1383,7 +1345,7 @@ mod tests { StoreTransactions::Last(2), ); - let base_output = make_output(policy_id, asset_name.clone(), None); + let base_output = make_output(policy_id, asset_name, None); let delta1 = UTXODelta::Output(acropolis_common::TxOutput { utxo_identifier: UTxOIdentifier::new(9, 0, 0), ..base_output.clone() @@ -1411,7 +1373,7 @@ mod tests { #[test] fn handle_address_deltas_accumulates_address_balance() { let mut registry = AssetRegistry::new(); - let policy_id: PolicyId = [4u8; 28].into(); + let policy_id: PolicyId = [4u8; 28]; let (state, asset_id, asset_name) = setup_state_with_asset( &mut registry, policy_id, @@ -1421,8 +1383,8 @@ mod tests { StoreTransactions::None, ); - let delta1 = make_address_delta(policy_id, asset_name.clone(), 10); - let delta2 = make_address_delta(policy_id, asset_name.clone(), 15); + let delta1 = make_address_delta(policy_id, asset_name, 10); + let delta2 = make_address_delta(policy_id, asset_name, 15); let new_state = state.handle_address_deltas(&[delta1, delta2], ®istry).unwrap(); let addr_map = new_state.addresses.unwrap(); @@ -1443,7 +1405,7 @@ mod tests { #[test] fn handle_address_deltas_removes_zero_balance_addresses() { let mut registry = AssetRegistry::new(); - let policy_id: PolicyId = [5u8; 28].into(); + let policy_id: PolicyId = [5u8; 28]; let (state, asset_id, asset_name) = setup_state_with_asset( &mut registry, @@ -1454,7 +1416,7 @@ mod tests { StoreTransactions::None, ); - let add_delta = make_address_delta(policy_id, asset_name.clone(), 10); + let add_delta = make_address_delta(policy_id, asset_name, 10); let state_after_add = state.handle_address_deltas(&[add_delta], ®istry).unwrap(); let addr_map = state_after_add.addresses.as_ref().unwrap(); let holders = addr_map.get(&asset_id).unwrap(); @@ -1470,7 +1432,7 @@ mod tests { 10 ); - let remove_delta = make_address_delta(policy_id, asset_name.clone(), -10); + let remove_delta = make_address_delta(policy_id, asset_name, -10); let state_after_remove = state_after_add.handle_address_deltas(&[remove_delta], ®istry).unwrap(); let addr_map = state_after_remove.addresses.as_ref().unwrap(); diff --git a/modules/chain_store/src/stores/fjall.rs b/modules/chain_store/src/stores/fjall.rs index b1583cce..e36e1569 100644 --- a/modules/chain_store/src/stores/fjall.rs +++ b/modules/chain_store/src/stores/fjall.rs @@ -316,7 +316,7 @@ mod tests { state.store.insert_block(&info, &bytes).unwrap(); - let new_block = state.store.get_block_by_hash(&info.hash.as_ref()).unwrap(); + let new_block = state.store.get_block_by_hash(info.hash.as_ref()).unwrap(); assert_eq!(block, new_block.unwrap()); } diff --git a/modules/drep_state/src/state.rs b/modules/drep_state/src/state.rs index 7995880f..4268624d 100644 --- a/modules/drep_state/src/state.rs +++ b/modules/drep_state/src/state.rs @@ -595,7 +595,7 @@ mod tests { cert_index: 0, }; let mut state = State::new(DRepStorageConfig::default()); - assert_eq!(state.process_one_cert(&tx_cert, 1).unwrap(), true); + assert!(state.process_one_cert(&tx_cert, 1).unwrap()); assert_eq!(state.get_count(), 1); let tx_cert_record = DRepRecord { deposit: 500000000, @@ -621,7 +621,7 @@ mod tests { }; let mut state = State::new(DRepStorageConfig::default()); - assert_eq!(state.process_one_cert(&tx_cert, 1).unwrap(), true); + assert!(state.process_one_cert(&tx_cert, 1).unwrap()); let bad_tx_cert = TxCertificateWithPos { cert: TxCertificate::DRepRegistration(DRepRegistration { @@ -658,7 +658,7 @@ mod tests { cert_index: 1, }; let mut state = State::new(DRepStorageConfig::default()); - assert_eq!(state.process_one_cert(&tx_cert, 1).unwrap(), true); + assert!(state.process_one_cert(&tx_cert, 1).unwrap()); let anchor = Anchor { url: "https://poop.bike".into(), @@ -673,10 +673,7 @@ mod tests { cert_index: 1, }; - assert_eq!( - state.process_one_cert(&update_anchor_tx_cert, 1).unwrap(), - false - ); + assert!(!state.process_one_cert(&update_anchor_tx_cert, 1).unwrap()); assert_eq!(state.get_count(), 1); let tx_cert_record = DRepRecord { @@ -702,7 +699,7 @@ mod tests { cert_index: 1, }; let mut state = State::new(DRepStorageConfig::default()); - assert_eq!(state.process_one_cert(&tx_cert, 1).unwrap(), true); + assert!(state.process_one_cert(&tx_cert, 1).unwrap()); let anchor = Anchor { url: "https://poop.bike".into(), @@ -742,7 +739,7 @@ mod tests { cert_index: 1, }; let mut state = State::new(DRepStorageConfig::default()); - assert_eq!(state.process_one_cert(&tx_cert, 1).unwrap(), true); + assert!(state.process_one_cert(&tx_cert, 1).unwrap()); let unregister_tx_cert = TxCertificateWithPos { cert: TxCertificate::DRepDeregistration(DRepDeregistration { @@ -752,10 +749,7 @@ mod tests { tx_identifier: TxIdentifier::default(), cert_index: 1, }; - assert_eq!( - state.process_one_cert(&unregister_tx_cert, 1).unwrap(), - true - ); + assert!(state.process_one_cert(&unregister_tx_cert, 1).unwrap()); assert_eq!(state.get_count(), 0); assert!(state.get_drep(&tx_cred).is_none()); } @@ -773,7 +767,7 @@ mod tests { cert_index: 1, }; let mut state = State::new(DRepStorageConfig::default()); - assert_eq!(state.process_one_cert(&tx_cert, 1).unwrap(), true); + assert!(state.process_one_cert(&tx_cert, 1).unwrap()); let unregister_tx_cert = TxCertificateWithPos { cert: TxCertificate::DRepDeregistration(DRepDeregistration { diff --git a/modules/spo_state/src/epochs_history.rs b/modules/spo_state/src/epochs_history.rs index 6ad7ed51..29213277 100644 --- a/modules/spo_state/src/epochs_history.rs +++ b/modules/spo_state/src/epochs_history.rs @@ -239,7 +239,7 @@ mod tests { epoch_activity_msg.spo_blocks = vec![(vec![11], 1)]; epoch_activity_msg.total_blocks = 1; epoch_activity_msg.total_fees = 10; - epochs_history.handle_epoch_activity(&block, &epoch_activity_msg, &vec![(vec![1], 1)]); + epochs_history.handle_epoch_activity(&block, &epoch_activity_msg, &[(vec![1], 1)]); let mut spo_rewards_msg = new_spo_rewards_message(1); spo_rewards_msg.spos = vec![( @@ -253,7 +253,7 @@ mod tests { let pool_history = epochs_history.get_pool_history(&vec![1]).unwrap(); assert_eq!(2, pool_history.len()); - let first_epoch = pool_history.get(0).unwrap(); + let first_epoch = pool_history.first().unwrap(); let third_epoch = pool_history.get(1).unwrap(); assert_eq!(1, first_epoch.epoch); assert_eq!(1, first_epoch.blocks_minted); diff --git a/modules/spo_state/src/state.rs b/modules/spo_state/src/state.rs index 84a4f566..9cccb21e 100644 --- a/modules/spo_state/src/state.rs +++ b/modules/spo_state/src/state.rs @@ -726,7 +726,7 @@ mod tests { assert!(state.handle_tx_certs(&block, &msg).is_ok()); assert_eq!(1, state.spos.len()); let spo = state.spos.get(&vec![0]); - assert!(!spo.is_none()); + assert!(spo.is_some()); } #[tokio::test] @@ -745,7 +745,7 @@ mod tests { assert!(state.handle_tx_certs(&block, &msg).is_ok()); assert_eq!(1, state.pending_deregistrations.len()); let drs = state.pending_deregistrations.get(&1); - assert!(!drs.is_none()); + assert!(drs.is_some()); if let Some(drs) = drs { assert_eq!(1, drs.len()); assert!(drs.contains(&vec![0])); @@ -781,7 +781,7 @@ mod tests { assert_eq!(1, state.pending_deregistrations.len()); let drs = state.pending_deregistrations.get(&2); - assert!(!drs.is_none()); + assert!(drs.is_some()); if let Some(drs) = drs { assert_eq!(2, drs.len()); assert!(drs.contains(&vec![0u8])); @@ -829,7 +829,7 @@ mod tests { assert!(state.handle_tx_certs(&block, &msg).is_ok()); assert_eq!(1, state.pending_deregistrations.len()); let drs = state.pending_deregistrations.get(&2); - assert!(!drs.is_none()); + assert!(drs.is_some()); if let Some(drs) = drs { assert_eq!(1, drs.len()); assert!(drs.contains(&vec![0])); @@ -850,7 +850,7 @@ mod tests { assert_eq!(1, state.spos.len()); let spo = state.spos.get(&vec![0u8]); - assert!(!spo.is_none()); + assert!(spo.is_some()); block.number = 1; let mut msg = new_certs_msg(); @@ -888,7 +888,7 @@ mod tests { assert!(state.handle_tx_certs(&block, &msg).is_ok()); assert_eq!(1, state.spos.len()); let spo = state.spos.get(&vec![0u8]); - assert!(!spo.is_none()); + assert!(spo.is_some()); history.lock().await.commit(block.number, state); let mut state = history.lock().await.get_current_state(); @@ -920,7 +920,7 @@ mod tests { assert!(state.handle_tx_certs(&block, &msg).is_ok()); assert_eq!(1, state.spos.len()); let spo = state.spos.get(&vec![0]); - assert!(!spo.is_none()); + assert!(spo.is_some()); } #[tokio::test] @@ -967,7 +967,7 @@ mod tests { #[test] fn get_total_blocks_minted_returns_zeros_when_state_is_new() { let state = State::default(); - assert_eq!(0, state.get_total_blocks_minted_by_pools(&vec![vec![0]])[0]); + assert_eq!(0, state.get_total_blocks_minted_by_pools(&[vec![0]])[0]); assert_eq!(0, state.get_total_blocks_minted_by_pool(&vec![0])); } @@ -976,7 +976,7 @@ mod tests { let mut state = State::new(&save_blocks_store_config()); let mut block = new_block(0); let mut msg = new_certs_msg(); - let spo_id = keyhash_224(&vec![1 as u8]); + let spo_id = keyhash_224(&[1_u8]); msg.certificates.push(TxCertificateWithPos { cert: TxCertificate::PoolRegistration(default_pool_registration(spo_id.clone(), None)), tx_identifier: TxIdentifier::default(), @@ -985,12 +985,12 @@ mod tests { assert!(state.handle_tx_certs(&block, &msg).is_ok()); block = new_block(2); - assert_eq!(true, state.handle_mint(&block, &vec![1])); + assert!(state.handle_mint(&block, &[1])); assert_eq!(1, state.get_total_blocks_minted_by_pool(&spo_id)); block = new_block(3); - assert_eq!(true, state.handle_mint(&block, &vec![1])); - assert_eq!(2, state.get_total_blocks_minted_by_pools(&vec![spo_id])[0]); + assert!(state.handle_mint(&block, &[1])); + assert_eq!(2, state.get_total_blocks_minted_by_pools(&[spo_id])[0]); } #[test] @@ -1003,7 +1003,7 @@ mod tests { fn handle_mint_returns_false_if_pool_not_found() { let mut state = State::new(&save_blocks_store_config()); let block = new_block(0); - assert_eq!(false, state.handle_mint(&block, &vec![0])); + assert!(!state.handle_mint(&block, &[0])); } #[test] @@ -1011,7 +1011,7 @@ mod tests { let mut state = State::new(&save_blocks_store_config()); let mut block = new_block(0); let mut msg = new_certs_msg(); - let spo_id = keyhash_224(&vec![1 as u8]); + let spo_id = keyhash_224(&[1_u8]); msg.certificates.push(TxCertificateWithPos { cert: TxCertificate::PoolRegistration(default_pool_registration(spo_id.clone(), None)), tx_identifier: TxIdentifier::default(), @@ -1019,7 +1019,7 @@ mod tests { }); assert!(state.handle_tx_certs(&block, &msg).is_ok()); block = new_block(2); - assert_eq!(true, state.handle_mint(&block, &vec![1])); // Note raw issuer_vkey + assert!(state.handle_mint(&block, &[1])); // Note raw issuer_vkey let blocks = state.get_blocks_by_pool(&spo_id).unwrap(); assert_eq!(blocks.len(), 1); assert_eq!(blocks[0], block.number); diff --git a/modules/stake_delta_filter/src/utils.rs b/modules/stake_delta_filter/src/utils.rs index 41431f1b..7855edd9 100644 --- a/modules/stake_delta_filter/src/utils.rs +++ b/modules/stake_delta_filter/src/utils.rs @@ -485,7 +485,7 @@ mod test { let (_hrp, key_vec) = bech32::decode(key).unwrap(); let hash_vec = pallas::crypto::hash::Hasher::<224>::hash(&key_vec); let prefix_hrp: Hrp = Hrp::parse(prefix).unwrap(); - bech32::encode::(prefix_hrp, &hash_vec.to_vec()).unwrap() + bech32::encode::(prefix_hrp, hash_vec.as_ref()).unwrap() } // The test is based on CIP-19 standard examples. @@ -551,7 +551,7 @@ mod test { let stake_delta = process_message(&cache, &delta, &block, None); assert_eq!( - stake_delta.deltas.get(0).unwrap().address.to_string().unwrap(), + stake_delta.deltas.first().unwrap().address.to_string().unwrap(), stake_addr ); assert_eq!( @@ -585,7 +585,7 @@ mod test { // additional check: payload conversion correctness assert_eq!( - stake_delta.deltas.get(0).unwrap().address.credential.to_string().unwrap(), + stake_delta.deltas.first().unwrap().address.credential.to_string().unwrap(), stake_key_hash ); assert_eq!( diff --git a/modules/upstream_chain_fetcher/src/upstream_cache.rs b/modules/upstream_chain_fetcher/src/upstream_cache.rs index 64838fbe..29e42f3f 100644 --- a/modules/upstream_chain_fetcher/src/upstream_cache.rs +++ b/modules/upstream_chain_fetcher/src/upstream_cache.rs @@ -224,20 +224,20 @@ mod test { cache.density = 3; let perm: [u64; 11] = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]; - for n in 0..11 { - cache.write_record(&ucr(perm[n], n, n + 100))?; + for (n, p) in perm.iter().enumerate() { + cache.write_record(&ucr(*p, n, n + 100))?; } assert_eq!(cache.storage.rec.len(), 4); for ch in 0..3 { let chunk = cache.storage.rec.get(&ch).unwrap(); - assert_eq!(chunk.get(0).unwrap().id.number, perm[ch * 3]); + assert_eq!(chunk.first().unwrap().id.number, perm[ch * 3]); assert_eq!(chunk.get(1).unwrap().id.number, perm[ch * 3 + 1]); assert_eq!(chunk.get(2).unwrap().id.number, perm[ch * 3 + 2]); assert_eq!(chunk.len(), 3); } assert_eq!( - cache.storage.rec.get(&3).unwrap().get(0).unwrap().id.number, + cache.storage.rec.get(&3).unwrap().first().unwrap().id.number, perm[9] ); assert_eq!( @@ -247,9 +247,9 @@ mod test { assert_eq!(cache.storage.rec.get(&3).unwrap().len(), 2); cache.start_reading()?; - for n in 0..11 { + for (n, p) in perm.iter().enumerate() { let record = cache.read_record()?.unwrap(); - assert_eq!(record.id.number, perm[n]); + assert_eq!(record.id.number, *p); assert_eq!(record.message.header, vec![n as u8]); assert_eq!(record.message.body, vec![(n + 100) as u8]); diff --git a/modules/utxo_state/src/state.rs b/modules/utxo_state/src/state.rs index db945cb9..48258fe4 100644 --- a/modules/utxo_state/src/state.rs +++ b/modules/utxo_state/src/state.rs @@ -791,7 +791,7 @@ mod tests { || (asset.name == AssetName::new(b"FOO").unwrap() && (asset.amount == 200 || asset.amount == -200)) ); - let key = (*policy, asset.name.clone()); + let key = (*policy, asset.name); *asset_balances.entry(key).or_insert(0) += asset.amount; } }