From d4d2b5ee0a2356eb35385d29c0b55d5d5e4b8b8a Mon Sep 17 00:00:00 2001 From: lilyjjo Date: Wed, 27 Mar 2024 07:50:00 -0400 Subject: [PATCH 1/2] test(sequencer): add unit tests for src/asset/state_ext --- .../astria-sequencer/src/asset/state_ext.rs | 159 ++++++++++++++++++ 1 file changed, 159 insertions(+) diff --git a/crates/astria-sequencer/src/asset/state_ext.rs b/crates/astria-sequencer/src/asset/state_ext.rs index 87e23d70d8..c05bcc2420 100644 --- a/crates/astria-sequencer/src/asset/state_ext.rs +++ b/crates/astria-sequencer/src/asset/state_ext.rs @@ -72,3 +72,162 @@ pub(crate) trait StateWriteExt: StateWrite { } impl StateWriteExt for T {} + +#[cfg(test)] +mod test { + use astria_core::sequencer::v1::asset::{ + Denom, + Id, + }; + use cnidarium::StateDelta; + + use super::{ + StateReadExt as _, + StateWriteExt as _, + }; + + #[tokio::test] + async fn get_ibc_asset_non_existent() { + let storage = cnidarium::TempStorage::new().await.unwrap(); + let snapshot = storage.latest_snapshot(); + let state = StateDelta::new(snapshot); + + let asset = Id::from_denom("asset_0"); + + // gets for non existing assets fail + state + .get_ibc_asset(asset) + .await + .expect_err("gets for non existing ibc assets should fail"); + } + + #[tokio::test] + async fn has_ibc_asset() { + let storage = cnidarium::TempStorage::new().await.unwrap(); + let snapshot = storage.latest_snapshot(); + let mut state = StateDelta::new(snapshot); + + let asset_string = "asset_0"; + let asset = Id::from_denom(asset_string); + let denom = Denom::from_base_denom(asset_string); + + // non existing calls are ok for 'has' + assert!( + !state + .has_ibc_asset(asset) + .await + .expect("'has' for non existing ibc assets should be ok"), + "query for non existing asset should return false" + ); + + state + .put_ibc_asset(asset, &denom) + .expect("putting ibc asset should not fail"); + + // existing calls are ok for 'has' + assert!( + state + .has_ibc_asset(asset) + .await + .expect("'has' for existing ibc assets should be ok"), + "query for existing asset should return true" + ); + } + + #[tokio::test] + async fn put_ibc_asset_simple() { + let storage = cnidarium::TempStorage::new().await.unwrap(); + let snapshot = storage.latest_snapshot(); + let mut state = StateDelta::new(snapshot); + + // can write new + let asset_string = "asset_0"; + let asset = Id::from_denom(asset_string); + let denom = Denom::from_base_denom(asset_string); + state + .put_ibc_asset(asset, &denom) + .expect("putting ibc asset should not fail"); + assert_eq!( + state + .get_ibc_asset(asset) + .await + .expect("an ibc asset was written and must exist inside the database"), + denom, + "stored ibc asset was not what was expected" + ); + } + + #[tokio::test] + async fn put_ibc_asset_complex() { + let storage = cnidarium::TempStorage::new().await.unwrap(); + let snapshot = storage.latest_snapshot(); + let mut state = StateDelta::new(snapshot); + + // can write new + let asset_string = "asset_0"; + let asset = Id::from_denom(asset_string); + let denom = Denom::from_base_denom(asset_string); + state + .put_ibc_asset(asset, &denom) + .expect("putting ibc asset should not fail"); + assert_eq!( + state + .get_ibc_asset(asset) + .await + .expect("an ibc asset was written and must exist inside the database"), + denom, + "stored ibc asset was not what was expected" + ); + + // can write another without affecting original + let asset_string_1 = "asset_1"; + let asset_1 = Id::from_denom(asset_string_1); + let denom_1 = Denom::from_base_denom(asset_string_1); + state + .put_ibc_asset(asset_1, &denom_1) + .expect("putting ibc asset should not fail"); + assert_eq!( + state + .get_ibc_asset(asset_1) + .await + .expect("an additional ibc asset was written and must exist inside the database"), + denom_1, + "additional ibc asset was not what was expected" + ); + assert_eq!( + state + .get_ibc_asset(asset) + .await + .expect("an ibc asset was written and must exist inside the database"), + denom, + "original ibc asset was not what was expected" + ); + } + + #[tokio::test] + async fn put_ibc_asset_can_write_unrelated_ids_to_denoms() { + let storage = cnidarium::TempStorage::new().await.unwrap(); + let snapshot = storage.latest_snapshot(); + let mut state = StateDelta::new(snapshot); + + // can write unrelated ids and denoms + let id_string = "asset_0"; + let id_key = Id::from_denom(id_string); + let denom_string = "asset_1"; + let denom = Denom::from_base_denom(denom_string); + state + .put_ibc_asset(id_key, &denom) + .expect("putting ibc asset should not fail"); + + // see that id key and denom's stored id differ + assert_ne!( + state + .get_ibc_asset(id_key) + .await + .expect("an ibc asset was written and must exist inside the database") + .id(), + id_key, + "stored ibc asset was not what was expected" + ); + } +} From d748b8c1b3e2d84584bac824f95ad88fb6187332 Mon Sep 17 00:00:00 2001 From: lilyjjo Date: Mon, 1 Apr 2024 14:31:13 -0400 Subject: [PATCH 2/2] refactor(sequencer): address comments from noot --- .../astria-sequencer/src/asset/state_ext.rs | 44 +++++++------------ 1 file changed, 17 insertions(+), 27 deletions(-) diff --git a/crates/astria-sequencer/src/asset/state_ext.rs b/crates/astria-sequencer/src/asset/state_ext.rs index c05bcc2420..edcad70cc3 100644 --- a/crates/astria-sequencer/src/asset/state_ext.rs +++ b/crates/astria-sequencer/src/asset/state_ext.rs @@ -92,7 +92,7 @@ mod test { let snapshot = storage.latest_snapshot(); let state = StateDelta::new(snapshot); - let asset = Id::from_denom("asset_0"); + let asset = Id::from_denom("asset"); // gets for non existing assets fail state @@ -107,27 +107,25 @@ mod test { let snapshot = storage.latest_snapshot(); let mut state = StateDelta::new(snapshot); - let asset_string = "asset_0"; - let asset = Id::from_denom(asset_string); - let denom = Denom::from_base_denom(asset_string); + let denom = Denom::from_base_denom("asset"); // non existing calls are ok for 'has' assert!( !state - .has_ibc_asset(asset) + .has_ibc_asset(denom.id()) .await .expect("'has' for non existing ibc assets should be ok"), "query for non existing asset should return false" ); state - .put_ibc_asset(asset, &denom) + .put_ibc_asset(denom.id(), &denom) .expect("putting ibc asset should not fail"); // existing calls are ok for 'has' assert!( state - .has_ibc_asset(asset) + .has_ibc_asset(denom.id()) .await .expect("'has' for existing ibc assets should be ok"), "query for existing asset should return true" @@ -141,15 +139,13 @@ mod test { let mut state = StateDelta::new(snapshot); // can write new - let asset_string = "asset_0"; - let asset = Id::from_denom(asset_string); - let denom = Denom::from_base_denom(asset_string); + let denom = Denom::from_base_denom("asset"); state - .put_ibc_asset(asset, &denom) + .put_ibc_asset(denom.id(), &denom) .expect("putting ibc asset should not fail"); assert_eq!( state - .get_ibc_asset(asset) + .get_ibc_asset(denom.id()) .await .expect("an ibc asset was written and must exist inside the database"), denom, @@ -164,15 +160,13 @@ mod test { let mut state = StateDelta::new(snapshot); // can write new - let asset_string = "asset_0"; - let asset = Id::from_denom(asset_string); - let denom = Denom::from_base_denom(asset_string); + let denom = Denom::from_base_denom("asset_0"); state - .put_ibc_asset(asset, &denom) + .put_ibc_asset(denom.id(), &denom) .expect("putting ibc asset should not fail"); assert_eq!( state - .get_ibc_asset(asset) + .get_ibc_asset(denom.id()) .await .expect("an ibc asset was written and must exist inside the database"), denom, @@ -180,15 +174,13 @@ mod test { ); // can write another without affecting original - let asset_string_1 = "asset_1"; - let asset_1 = Id::from_denom(asset_string_1); - let denom_1 = Denom::from_base_denom(asset_string_1); + let denom_1 = Denom::from_base_denom("asset_1"); state - .put_ibc_asset(asset_1, &denom_1) + .put_ibc_asset(denom_1.id(), &denom_1) .expect("putting ibc asset should not fail"); assert_eq!( state - .get_ibc_asset(asset_1) + .get_ibc_asset(denom_1.id()) .await .expect("an additional ibc asset was written and must exist inside the database"), denom_1, @@ -196,7 +188,7 @@ mod test { ); assert_eq!( state - .get_ibc_asset(asset) + .get_ibc_asset(denom.id()) .await .expect("an ibc asset was written and must exist inside the database"), denom, @@ -211,10 +203,8 @@ mod test { let mut state = StateDelta::new(snapshot); // can write unrelated ids and denoms - let id_string = "asset_0"; - let id_key = Id::from_denom(id_string); - let denom_string = "asset_1"; - let denom = Denom::from_base_denom(denom_string); + let id_key = Id::from_denom("asset_0"); + let denom = Denom::from_base_denom("asset_1"); state .put_ibc_asset(id_key, &denom) .expect("putting ibc asset should not fail");