Move setup to testing, fix tests so they compile

Scarb.toml

@@ -7,11 +7,11 @@ cairo-version = "2.6.3"
 [dependencies]
 starknet = ">=2.0.0"
 openzeppelin = { git = "https://github.com/OpenZeppelin/cairo-contracts.git", tag = "v0.10.0" }
-snforge_std = { git = "https://github.com/foundry-rs/starknet-foundry.git", tag = "v0.23.0" }
 
 
 # can be fixed by doing import super::testing from tests
-# [dev-dependencies] sadly can't use this because we have testing in src/
+[dev-dependencies]
+snforge_std = { git = "https://github.com/foundry-rs/starknet-foundry.git", tag = "v0.23.0" }
 
 [lib]
 

src/lib.cairo

@@ -13,6 +13,3 @@ mod treasury;
 mod types;
 mod upgrades;
 mod voting_token;
-mod testing {
-    mod setup;
-}

tests/basic.cairo

@@ -21,7 +21,7 @@ fn test_submit_proposal() {
     let dispatcher = IProposalsDispatcher { contract_address: gov_contract_addr };
     // corresponding govtoken: 0x05151bfdd47826df3669033ea7fb977d3b2d45c4f4d1c439a9edf4062bf34bfa
     // has one holder, with 31 CARM: 0x0583a9d956d65628f806386ab5b12dccd74236a3c6b930ded9cf3c54efc722a1
-    let admin_addr: ContractAddress =
+    let _admin_addr: ContractAddress =
         0x0583a9d956d65628f806386ab5b12dccd74236a3c6b930ded9cf3c54efc722a1
         .try_into()
         .unwrap();

tests/lib.cairo

@@ -2,3 +2,4 @@ mod basic;
 mod test_treasury;
 mod proposals_tests;
 mod airdrop_tests;
+mod setup;

tests/proposals_tests.cairo

@@ -2,12 +2,12 @@ use array::ArrayTrait;
 use core::traits::TryInto;
 use debug::PrintTrait;
 use starknet::ContractAddress;
-use openzeppelin::token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait};
+use openzeppelin::token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait, IERC20CamelOnlyDispatcher, IERC20CamelOnlyDispatcherTrait};
 use snforge_std::{
-    BlockId, declare, ContractClassTrait, ContractClass, start_prank, start_warp, CheatTarget
+    BlockId, declare, ContractClassTrait, ContractClass, start_prank, start_warp, CheatTarget, prank, CheatSpan
 };
 
-use konoha::testing::setup::{
+use super::setup::{
     admin_addr, first_address, second_address, deploy_governance, deploy_and_distribute_gov_tokens, test_vote_upgrade_root, check_if_healthy
 };
 use konoha::contract::IGovernanceDispatcher;
@@ -56,11 +56,11 @@ fn test_proposal_expiry() {
     start_warp(CheatTarget::One(gov_contract_addr), end_timestamp + 1);
 
     let status = dispatcher.get_proposal_status(prop_id);
-    assert!(dispatcher.get_proposal_status(prop_id) == constants::MINUS_ONE, "proposal not expired!");
+    assert!(status == constants::MINUS_ONE, "proposal not expired!");
 }
 
 #[test]
-#[should_panic(expected: ('Cannot vote on an expired proposal',))]
+#[should_panic(expected: ('voting concluded',))]
 fn test_vote_on_expired_proposal() {
     let token_contract = deploy_and_distribute_gov_tokens(admin_addr.try_into().unwrap());
     let gov_contract = deploy_governance(token_contract.contract_address);
@@ -76,6 +76,9 @@ fn test_vote_on_expired_proposal() {
     let end_timestamp = current_timestamp + constants::PROPOSAL_VOTING_SECONDS;
     start_warp(CheatTarget::One(gov_contract_addr), end_timestamp + 1);
 
+
+    prank(CheatTarget::One(token_contract.contract_address), admin_addr.try_into().unwrap(), CheatSpan::TargetCalls(1));
+    token_contract.transfer(first_address.try_into().unwrap(), 100000.try_into().unwrap());
     start_prank(CheatTarget::One(gov_contract_addr), first_address.try_into().unwrap());
     dispatcher.vote(prop_id, 1);
 }
@@ -88,34 +91,43 @@ fn test_vote_on_quorum_not_met() {
 
     let dispatcher = IProposalsDispatcher { contract_address: gov_contract_addr };
 
-    start_prank(CheatTarget::One(gov_contract_addr), admin_addr.try_into().unwrap());
+    prank(CheatTarget::One(gov_contract_addr), admin_addr.try_into().unwrap(), CheatSpan::TargetCalls(1));
     let prop_id = dispatcher.submit_proposal(42, 1);
 
-    start_prank(CheatTarget::One(gov_contract_addr), first_address.try_into().unwrap());
+    prank(CheatTarget::One(token_contract.contract_address), admin_addr.try_into().unwrap(), CheatSpan::TargetCalls(1));
+    token_contract.transfer(first_address.try_into().unwrap(), 100000.try_into().unwrap());
+
+    prank(CheatTarget::One(gov_contract_addr), first_address.try_into().unwrap(), CheatSpan::TargetCalls(1));
     dispatcher.vote(prop_id, 1);
 
     let (yay_votes, nay_votes) = dispatcher.get_vote_counts(prop_id);
     let total_votes = yay_votes + nay_votes;
-    let total_eligible_votes: u128 = IERC20Dispatcher {
+    let total_eligible_votes: u128 = IERC20CamelOnlyDispatcher {
         contract_address: token_contract.contract_address
     }
         .totalSupply()
         .low;
     let quorum_threshold = total_eligible_votes * constants::QUORUM / 100;
 
-    assert!(total_votes < quorum_threshold, "Total votes should be less than quorum threshold");
-    assert!(dispatcher.get_proposal_status(prop_id) == constants::MINUS_ONE, "Proposal shouldn't pass when quorum not met");
+    assert(total_votes < quorum_threshold, 'Total votes >= quorum threshold');
+    let current_timestamp = get_block_timestamp();
+    let end_timestamp = current_timestamp + constants::PROPOSAL_VOTING_SECONDS;
+    start_warp(CheatTarget::One(gov_contract_addr), end_timestamp + 1);
+    assert(dispatcher.get_proposal_status(prop_id) == constants::MINUS_ONE, 'Proposal pass & quorum not met');
 }
 
 #[test]
-#[should_panic(expected: ('not enough tokens to submit proposal',))]
-fn_test_submit_proposal_under_quorum() {
+#[should_panic(expected: ('not enough tokens to submit',))]
+fn test_submit_proposal_under_quorum() {
     let token_contract = deploy_and_distribute_gov_tokens(admin_addr.try_into().unwrap());
     let gov_contract = deploy_governance(token_contract.contract_address);
     let gov_contract_addr = gov_contract.contract_address;
 
     let dispatcher = IProposalsDispatcher { contract_address: gov_contract_addr };
 
-    start_prank(CheatTarget::One(gov_contract_addr), first_address);
+    prank(CheatTarget::One(token_contract.contract_address), admin_addr.try_into().unwrap(), CheatSpan::TargetCalls(1));
+    token_contract.transfer(first_address.try_into().unwrap(), 100000.try_into().unwrap());
+
+    prank(CheatTarget::One(gov_contract_addr), first_address.try_into().unwrap(), CheatSpan::TargetCalls(1));
     dispatcher.submit_proposal(42,1);
-}
+}

src/testing/setup.cairo → tests/setup.cairo

@@ -21,7 +21,7 @@ use openzeppelin::token::erc20::interface::IERC20;
 use starknet::get_block_timestamp;
 
 
-const GOV_TOKEN_INITIAL_SUPPLY: felt252 = 1000000000000000000;
+const GOV_TOKEN_INITIAL_SUPPLY: u256 = 1000000000000000000;
 
 const first_address: felt252 = 0x1;
 const second_address: felt252 = 0x2;
@@ -38,22 +38,15 @@ fn deploy_governance(token_address: ContractAddress) -> IGovernanceDispatcher {
 
 fn deploy_and_distribute_gov_tokens(recipient: ContractAddress) -> IERC20Dispatcher {
     let mut calldata = ArrayTrait::new();
-    calldata.append(GOV_TOKEN_INITIAL_SUPPLY);
+    calldata.append(GOV_TOKEN_INITIAL_SUPPLY.low.into());
+    calldata.append(GOV_TOKEN_INITIAL_SUPPLY.high.into());
     calldata.append(recipient.into());
 
     let gov_token_contract = declare("FloatingToken").expect('unable to declare FloatingToken');
     let (token_addr, _) = gov_token_contract
         .deploy(@calldata)
         .expect('unable to deploy FloatingToken');
-    let token: IERC20Dispatcher = IERC20Dispatcher { contract_address: token_addr };
-
-    start_prank(CheatTarget::One(token_addr), admin_addr.try_into().unwrap());
-
-    token.mint(admin_addr.try_into().unwrap(), GOV_TOKEN_INITIAL_SUPPLY);
-
-    token.transfer(first_address.try_into().unwrap(), 100000);
-    token.transfer(second_address.try_into().unwrap(), 100000);
-    token
+    IERC20Dispatcher { contract_address: token_addr }
 }