mooooore tests

contracts/delegation/dao-vote-delegation/src/contract.rs

@@ -35,7 +35,7 @@ use crate::state::{
 };
 use crate::ContractError;
 
-pub(crate) const CONTRACT_NAME: &str = env!("CARGO_PKG_NAME");
+pub(crate) const CONTRACT_NAME: &str = "crates.io:dao-vote-delegation";
 pub(crate) const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");
 
 pub const DEFAULT_LIMIT: u32 = 10;
@@ -149,7 +149,7 @@ fn execute_register(deps: DepsMut, env: Env, info: MessageInfo) -> Result<Respon
  // ensure delegate has no delegations
  let has_delegations = !DELEGATION_ENTRIES.prefix(&delegate).is_empty(deps.storage);
  if has_delegations {
- return Err(ContractError::UndelegateBeforeRegistering {});
+ return Err(ContractError::CannotRegisterWithDelegations {});
  }
 
  DELEGATES.save(deps.storage, delegate, &Delegate {}, env.block.height)?;
@@ -191,18 +191,13 @@ fn execute_delegate(
  }
 
  let delegator = info.sender;
+ let delegate = deps.api.addr_validate(&delegate)?;
 
  // delegates cannot delegate to others
  if is_delegate_registered(deps.as_ref(), &delegator, None)? {
  return Err(ContractError::DelegatesCannotDelegate {});
  }
 
- // prevent self delegation
- let delegate = deps.api.addr_validate(&delegate)?;
- if delegate == delegator {
- return Err(ContractError::CannotDelegateToSelf {});
- }
-
  // ensure delegate is registered
  if !is_delegate_registered(deps.as_ref(), &delegate, None)? {
  return Err(ContractError::DelegateNotRegistered {});
@@ -290,10 +285,10 @@ fn execute_delegate(
  if new_total_percent_delegated > Decimal::one() {
  return Err(ContractError::CannotDelegateMoreThan100Percent {
  current: current_percent_delegated
- .checked_mul(Decimal::new(100u128.into()))?
+ .checked_mul(Decimal::from_atomics(100u128, 0).unwrap())?
  .to_string(),
  attempt: new_total_percent_delegated
- .checked_mul(Decimal::new(100u128.into()))?
+ .checked_mul(Decimal::from_atomics(100u128, 0).unwrap())?
  .to_string(),
  });
  }

contracts/delegation/dao-vote-delegation/src/error.rs

@@ -40,15 +40,12 @@ pub enum ContractError {
  #[error("delegates cannot delegate to others")]
  DelegatesCannotDelegate {},
 
- #[error("undelegate before registering as a delegate")]
- UndelegateBeforeRegistering {},
+ #[error("cannot register as a delegate with existing delegations")]
+ CannotRegisterWithDelegations {},
 
- #[error("no voting power to delegate")]
+ #[error("no voting power")]
  NoVotingPower {},
 
- #[error("cannot delegate to self")]
- CannotDelegateToSelf {},
-
  #[error("delegation does not exist")]
  DelegationDoesNotExist {},
 
@@ -58,7 +55,7 @@ pub enum ContractError {
  #[error("invalid voting power percent")]
  InvalidVotingPowerPercent {},
 
- #[error("migration error: incorrect contract: expected {expected}, actual {actual}")]
+ #[error("migration error: incorrect contract: expected \"{expected}\", actual \"{actual}\"")]
  MigrationErrorIncorrectContract { expected: String, actual: String },
 
  #[error("migration error: invalid version: new {new}, current {current}")]

contracts/delegation/dao-vote-delegation/src/testing/suite.rs

@@ -95,7 +95,7 @@ impl DaoVoteDelegationTestingSuite {
  },
  &[],
  "delegation",
- None,
+ Some(core_addr.to_string()),
  );
 
  self.setup_delegation_module();

contracts/delegation/dao-vote-delegation/src/testing/tests.rs

@@ -1,7 +1,13 @@
-use cosmwasm_std::{to_json_binary, Addr, Decimal, Empty, Uint128};
+use cosmwasm_std::{
+ testing::{mock_dependencies, mock_env},
+ to_json_binary, Addr, Decimal, Empty, Uint128,
+};
 use cw_multi_test::{Contract, ContractWrapper};
+use dao_interface::helpers::OptionalUpdate;
 use dao_testing::{ADDR0, ADDR1, ADDR2, ADDR3, ADDR4};
 
+use crate::contract::{CONTRACT_NAME, CONTRACT_VERSION};
+
 use super::*;
 
 pub fn dao_vote_delegation_contract() -> Box<dyn Contract<Empty>> {
@@ -607,3 +613,251 @@ fn test_vote_with_override() {
  suite.members[0].weight + suite.members[2].weight,
  );
 }
+
+#[test]
+fn test_allow_register_after_unregister_same_block() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.register(ADDR0);
+ suite.unregister(ADDR0);
+ suite.register(ADDR0);
+}
+
+#[test]
+fn test_allow_register_after_unregister_next_block() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.register(ADDR0);
+ suite.advance_block();
+ suite.unregister(ADDR0);
+ suite.advance_block();
+ suite.register(ADDR0);
+}
+
+#[test]
+#[should_panic(expected = "invalid delegation validity blocks: provided 1, minimum 2")]
+fn test_validate_delegation_validity_blocks() {
+ DaoVoteDelegationTestingSuite::new()
+ .with_delegation_validity_blocks(1)
+ .build();
+}
+
+#[test]
+#[should_panic(expected = "invalid delegation validity blocks: provided 1, minimum 2")]
+fn test_validate_delegation_validity_blocks_update() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.update_delegation_validity_blocks(Some(1));
+}
+
+#[test]
+#[should_panic(expected = "delegate already registered")]
+fn test_no_double_register() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.register(ADDR0);
+ suite.register(ADDR0);
+}
+
+#[test]
+#[should_panic(expected = "no voting power")]
+fn test_no_vp_register() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.register("non_member");
+}
+
+#[test]
+#[should_panic(expected = "cannot register as a delegate with existing delegations")]
+fn test_cannot_register_with_delegations_same_block() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.register(ADDR0);
+ suite.delegate(ADDR1, ADDR0, Decimal::percent(100));
+ suite.register(ADDR1);
+}
+
+#[test]
+#[should_panic(expected = "cannot register as a delegate with existing delegations")]
+fn test_cannot_register_with_delegations_next_block() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.register(ADDR0);
+ suite.delegate(ADDR1, ADDR0, Decimal::percent(100));
+ suite.advance_block();
+ suite.register(ADDR1);
+}
+
+#[test]
+#[should_panic(expected = "delegate not registered")]
+fn test_cannot_unregister_unregistered() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.unregister(ADDR0);
+}
+
+#[test]
+#[should_panic(expected = "invalid voting power percent")]
+fn test_cannot_delegate_zero_percent() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.register(ADDR0);
+ suite.delegate(ADDR1, ADDR0, Decimal::zero());
+}
+
+#[test]
+#[should_panic(expected = "invalid voting power percent")]
+fn test_cannot_delegate_more_than_100_percent() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.register(ADDR0);
+ suite.delegate(ADDR1, ADDR0, Decimal::percent(101));
+}
+
+#[test]
+#[should_panic(expected = "delegates cannot delegate to others")]
+fn test_delegates_cannot_delegate() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.register(ADDR0);
+ suite.register(ADDR1);
+ suite.delegate(ADDR0, ADDR1, Decimal::percent(100));
+}
+
+#[test]
+#[should_panic(expected = "delegate not registered")]
+fn test_cannot_delegate_unregistered() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.delegate(ADDR0, ADDR1, Decimal::percent(100));
+}
+
+#[test]
+#[should_panic(expected = "no voting power")]
+fn test_cannot_delegate_no_vp() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.register(ADDR0);
+ suite.delegate("not_member", ADDR0, Decimal::percent(100));
+}
+
+#[test]
+#[should_panic(expected = "cannot delegate more than 100% (current: 50%, attempt: 101%)")]
+fn test_cannot_delegate_more_than_100() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.register(ADDR0);
+ suite.register(ADDR1);
+ suite.delegate(ADDR2, ADDR0, Decimal::percent(50));
+ suite.delegate(ADDR2, ADDR1, Decimal::percent(51));
+}
+
+#[test]
+#[should_panic(expected = "delegation does not exist")]
+fn test_cannot_undelegate_nonexistent() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.undelegate(ADDR0, ADDR1);
+}
+
+#[test]
+fn test_delegate_undelegate_same_block() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.register(ADDR0);
+ suite.delegate(ADDR1, ADDR0, Decimal::percent(100));
+ suite.undelegate(ADDR1, ADDR0);
+}
+
+#[test]
+#[should_panic(expected = "delegation does not exist")]
+fn test_cannot_undelegate_twice() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+
+ suite.register(ADDR0);
+ suite.delegate(ADDR1, ADDR0, Decimal::percent(100));
+ suite.undelegate(ADDR1, ADDR0);
+ suite.undelegate(ADDR1, ADDR0);
+}
+
+#[test]
+#[should_panic(expected = "unauthorized")]
+fn test_unauthorized_update_voting_power_hook_callers() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+ let delegation_addr = suite.delegation_addr.clone();
+
+ suite.execute_smart_ok(
+ "no_one",
+ &delegation_addr,
+ &crate::msg::ExecuteMsg::UpdateVotingPowerHookCallers {
+ add: None,
+ remove: None,
+ },
+ &[],
+ );
+}
+
+#[test]
+#[should_panic(expected = "unauthorized")]
+fn test_unauthorized_config_update() {
+ let mut suite = DaoVoteDelegationTestingSuite::new().build();
+ let delegation_addr = suite.delegation_addr.clone();
+
+ suite.execute_smart_ok(
+ "no_one",
+ &delegation_addr,
+ &crate::msg::ExecuteMsg::UpdateConfig {
+ vp_cap_percent: OptionalUpdate(None),
+ delegation_validity_blocks: OptionalUpdate(None),
+ },
+ &[],
+ );
+}
+
+#[test]
+fn test_migration_incorrect_contract() {
+ let mut deps = mock_dependencies();
+
+ cw2::set_contract_version(&mut deps.storage, "different_contract", "0.1.0").unwrap();
+
+ let err =
+ crate::contract::migrate(deps.as_mut(), mock_env(), crate::msg::MigrateMsg {}).unwrap_err();
+ assert_eq!(
+ err,
+ crate::ContractError::MigrationErrorIncorrectContract {
+ expected: "crates.io:dao-vote-delegation".to_string(),
+ actual: "different_contract".to_string(),
+ }
+ );
+}
+
+#[test]
+fn test_cannot_migrate_to_same_version() {
+ let mut deps = mock_dependencies();
+
+ cw2::set_contract_version(&mut deps.storage, CONTRACT_NAME, CONTRACT_VERSION).unwrap();
+
+ let err =
+ crate::contract::migrate(deps.as_mut(), mock_env(), crate::msg::MigrateMsg {}).unwrap_err();
+ assert_eq!(
+ err,
+ crate::ContractError::MigrationErrorInvalidVersion {
+ new: CONTRACT_VERSION.to_string(),
+ current: CONTRACT_VERSION.to_string()
+ }
+ );
+}
+
+#[test]
+fn test_migrate() {
+ let mut deps = mock_dependencies();
+
+ cw2::set_contract_version(&mut deps.storage, CONTRACT_NAME, "2.4.0").unwrap();
+
+ crate::contract::migrate(deps.as_mut(), mock_env(), crate::msg::MigrateMsg {}).unwrap();
+
+ let version = cw2::get_contract_version(&deps.storage).unwrap();
+
+ assert_eq!(version.contract, CONTRACT_NAME);
+ assert_eq!(version.version, CONTRACT_VERSION);
+}