Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Normalize tests #918

Merged
merged 1 commit into from
Feb 20, 2024
Merged

Normalize tests #918

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
97 changes: 37 additions & 60 deletions src/tests/access/test_ownable_twostep.cairo
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -34,95 +34,88 @@ fn setup() -> ComponentState {
//

#[test]
#[available_gas(2000000)]
fn test_initializer_owner_pending_owner() {
let mut state = COMPONENT_STATE();
assert(state.Ownable_owner.read() == ZERO(), 'Owner should be ZERO');
assert(state.Ownable_pending_owner.read() == ZERO(), 'Pending owner should be ZERO');
assert!(state.Ownable_owner.read().is_zero());
assert!(state.Ownable_pending_owner.read().is_zero());
state.initializer(OWNER());

assert_event_ownership_transferred(ZERO(), OWNER());

assert(state.Ownable_owner.read() == OWNER(), 'Owner should be set');
assert(state.Ownable_pending_owner.read() == ZERO(), 'Pending owner should be ZERO');
assert_eq!(state.Ownable_owner.read(), OWNER());
assert!(state.Ownable_pending_owner.read().is_zero());
}

//
// _accept_ownership
//

#[test]
#[available_gas(2000000)]
fn test__accept_ownership() {
let mut state = setup();
state.Ownable_pending_owner.write(OTHER());

state._accept_ownership();

assert_event_ownership_transferred(OWNER(), OTHER());
assert(state.owner() == OTHER(), 'Owner should be OTHER');
assert(state.pending_owner() == ZERO(), 'Pending owner should be ZERO');
assert_eq!(state.owner(), OTHER());
assert!(state.pending_owner().is_zero());
}

//
// _propose_owner
//

#[test]
#[available_gas(2000000)]
fn test__propose_owner() {
let mut state = setup();

state._propose_owner(OTHER());

assert_event_ownership_transfer_started(OWNER(), OTHER());
assert(state.owner() == OWNER(), 'Owner should be OWNER');
assert(state.pending_owner() == OTHER(), 'Pending owner should be OTHER');
assert_eq!(state.owner(), OWNER());
assert_eq!(state.pending_owner(), OTHER());
}

// transfer_ownership & transferOwnership

#[test]
#[available_gas(2000000)]
fn test_transfer_ownership() {
let mut state = setup();
testing::set_caller_address(OWNER());
state.transfer_ownership(OTHER());

assert_event_ownership_transfer_started(OWNER(), OTHER());
assert(state.owner() == OWNER(), 'Owner should be OWNER');
assert(state.pending_owner() == OTHER(), 'Pending owner should be OTHER');
assert_eq!(state.owner(), OWNER());
assert_eq!(state.pending_owner(), OTHER());

// Transferring to yet another owner while pending is set should work
state.transfer_ownership(NEW_OWNER());

assert_event_ownership_transfer_started(OWNER(), NEW_OWNER());
assert(state.owner() == OWNER(), 'Owner should be OWNER');
assert(state.pending_owner() == NEW_OWNER(), 'Pending should be NEW_OWNER');
assert_eq!(state.owner(), OWNER());
assert_eq!(state.pending_owner(), NEW_OWNER());
}

#[test]
#[available_gas(2000000)]
fn test_transfer_ownership_to_zero() {
let mut state = setup();
testing::set_caller_address(OWNER());
state.transfer_ownership(ZERO());

assert_event_ownership_transfer_started(OWNER(), ZERO());
assert(state.owner() == OWNER(), 'Owner should be OWNER');
assert(state.pending_owner() == ZERO(), 'Pending owner should be ZERO');
assert_eq!(state.owner(), OWNER());
assert_eq!(state.pending_owner(), ZERO());
}

#[test]
#[available_gas(2000000)]
#[should_panic(expected: ('Caller is the zero address',))]
fn test_transfer_ownership_from_zero() {
let mut state = setup();
state.transfer_ownership(OTHER());
}

#[test]
#[available_gas(2000000)]
#[should_panic(expected: ('Caller is not the owner',))]
fn test_transfer_ownership_from_nonowner() {
let mut state = setup();
Expand All @@ -131,46 +124,42 @@ fn test_transfer_ownership_from_nonowner() {
}

#[test]
#[available_gas(2000000)]
fn test_transferOwnership() {
let mut state = setup();
testing::set_caller_address(OWNER());
state.transferOwnership(OTHER());

assert_event_ownership_transfer_started(OWNER(), OTHER());
assert(state.owner() == OWNER(), 'Owner should be OWNER');
assert(state.pendingOwner() == OTHER(), 'Pending owner should be OTHER');
assert_eq!(state.owner(), OWNER());
assert_eq!(state.pendingOwner(), OTHER());

// Transferring to yet another owner while pending is set should work
state.transferOwnership(NEW_OWNER());

assert_event_ownership_transfer_started(OWNER(), NEW_OWNER());
assert(state.owner() == OWNER(), 'Owner should be OWNER');
assert(state.pendingOwner() == NEW_OWNER(), 'Pending should be NEW_OWNER');
assert_eq!(state.owner(), OWNER());
assert_eq!(state.pendingOwner(), NEW_OWNER());
}

#[test]
#[available_gas(2000000)]
fn test_transferOwnership_to_zero() {
let mut state = setup();
testing::set_caller_address(OWNER());
state.transferOwnership(ZERO());

assert_event_ownership_transfer_started(OWNER(), ZERO());
assert(state.owner() == OWNER(), 'Owner should be OWNER');
assert(state.pendingOwner() == ZERO(), 'Pending owner should be ZERO');
assert_eq!(state.owner(), OWNER());
assert!(state.pendingOwner().is_zero());
}

#[test]
#[available_gas(2000000)]
#[should_panic(expected: ('Caller is the zero address',))]
fn test_transferOwnership_from_zero() {
let mut state = setup();
state.transferOwnership(OTHER());
}

#[test]
#[available_gas(2000000)]
#[should_panic(expected: ('Caller is not the owner',))]
fn test_transferOwnership_from_nonowner() {
let mut state = setup();
Expand All @@ -183,7 +172,6 @@ fn test_transferOwnership_from_nonowner() {
//

#[test]
#[available_gas(2000000)]
fn test_accept_ownership() {
let mut state = setup();
state.Ownable_pending_owner.write(OTHER());
Expand All @@ -192,12 +180,11 @@ fn test_accept_ownership() {
state.accept_ownership();

assert_event_ownership_transferred(OWNER(), OTHER());
assert(state.owner() == OTHER(), 'Owner should be OTHER');
assert(state.pending_owner() == ZERO(), 'Pending owner should be ZERO');
assert_eq!(state.owner(), OTHER());
assert!(state.pending_owner().is_zero());
}

#[test]
#[available_gas(2000000)]
#[should_panic(expected: ('Caller is not the pending owner',))]
fn test_accept_ownership_from_nonpending() {
let mut state = setup();
Expand All @@ -207,7 +194,6 @@ fn test_accept_ownership_from_nonpending() {
}

#[test]
#[available_gas(2000000)]
fn test_acceptOwnership() {
let mut state = setup();
state.Ownable_pending_owner.write(OTHER());
Expand All @@ -216,12 +202,11 @@ fn test_acceptOwnership() {
state.acceptOwnership();

assert_event_ownership_transferred(OWNER(), OTHER());
assert(state.owner() == OTHER(), 'Owner should be OTHER');
assert(state.pendingOwner() == ZERO(), 'Pending owner should be ZERO');
assert_eq!(state.owner(), OTHER());
assert!(state.pendingOwner().is_zero());
}

#[test]
#[available_gas(2000000)]
#[should_panic(expected: ('Caller is not the pending owner',))]
fn test_acceptOwnership_from_nonpending() {
let mut state = setup();
Expand All @@ -235,27 +220,24 @@ fn test_acceptOwnership_from_nonpending() {
//

#[test]
#[available_gas(2000000)]
fn test_renounce_ownership() {
let mut state = setup();
testing::set_caller_address(OWNER());
state.renounce_ownership();

assert_event_ownership_transferred(OWNER(), ZERO());

assert(state.owner() == ZERO(), 'Should renounce ownership');
assert!(state.owner().is_zero());
}

#[test]
#[available_gas(2000000)]
#[should_panic(expected: ('Caller is the zero address',))]
fn test_renounce_ownership_from_zero_address() {
let mut state = setup();
state.renounce_ownership();
}

#[test]
#[available_gas(2000000)]
#[should_panic(expected: ('Caller is not the owner',))]
fn test_renounce_ownership_from_nonowner() {
let mut state = setup();
Expand All @@ -264,27 +246,24 @@ fn test_renounce_ownership_from_nonowner() {
}

#[test]
#[available_gas(2000000)]
fn test_renounceOwnership() {
let mut state = setup();
testing::set_caller_address(OWNER());
state.renounceOwnership();

assert_event_ownership_transferred(OWNER(), ZERO());

assert(state.owner() == ZERO(), 'Should renounce ownership');
assert!(state.owner().is_zero());
}

#[test]
#[available_gas(2000000)]
#[should_panic(expected: ('Caller is the zero address',))]
fn test_renounceOwnership_from_zero_address() {
let mut state = setup();
state.renounceOwnership();
}

#[test]
#[available_gas(2000000)]
#[should_panic(expected: ('Caller is not the owner',))]
fn test_renounceOwnership_from_nonowner() {
let mut state = setup();
Expand All @@ -293,46 +272,44 @@ fn test_renounceOwnership_from_nonowner() {
}

#[test]
#[available_gas(2000000)]
fn test_full_two_step_transfer() {
let mut state = setup();
testing::set_caller_address(OWNER());
state.transfer_ownership(OTHER());

assert_event_ownership_transfer_started(OWNER(), OTHER());
assert(state.owner() == OWNER(), 'Owner should be OWNER');
assert(state.pending_owner() == OTHER(), 'Pending owner should be OTHER');
assert_eq!(state.owner(), OWNER());
assert_eq!(state.pending_owner(), OTHER());

testing::set_caller_address(OTHER());
state.accept_ownership();

assert_event_ownership_transferred(OWNER(), OTHER());
assert(state.owner() == OTHER(), 'Owner should be OTHER');
assert(state.pending_owner() == ZERO(), 'Pending owner should be ZERO');
assert_eq!(state.owner(), OTHER());
assert!(state.pending_owner().is_zero());
}

#[test]
#[available_gas(2000000)]
fn test_pending_accept_after_owner_renounce() {
let mut state = setup();
testing::set_caller_address(OWNER());
state.transfer_ownership(OTHER());

assert_event_ownership_transfer_started(OWNER(), OTHER());
assert(state.owner() == OWNER(), 'Owner should be OWNER');
assert(state.pending_owner() == OTHER(), 'Pending owner should be OTHER');
assert_eq!(state.owner(), OWNER());
assert_eq!(state.pending_owner(), OTHER());

state.renounce_ownership();

assert_event_ownership_transferred(OWNER(), ZERO());
assert(state.owner() == ZERO(), 'Should renounce ownership');
assert!(state.owner().is_zero());

testing::set_caller_address(OTHER());
state.accept_ownership();

assert_event_ownership_transferred(ZERO(), OTHER());
assert(state.owner() == OTHER(), 'Owner should be OTHER');
assert(state.pending_owner() == ZERO(), 'Pending owner should be ZERO');
assert_eq!(state.owner(), OTHER());
assert!(state.pending_owner().is_zero());
}

//
Expand All @@ -343,8 +320,8 @@ fn assert_event_ownership_transfer_started(
previous_owner: ContractAddress, new_owner: ContractAddress
) {
let event = utils::pop_log::<OwnershipTransferStarted>(ZERO()).unwrap();
assert(event.previous_owner == previous_owner, 'Invalid `previous_owner`');
assert(event.new_owner == new_owner, 'Invalid `new_owner`');
assert_eq!(event.previous_owner, previous_owner);
assert_eq!(event.new_owner, new_owner);
utils::assert_no_events_left(ZERO());

let mut indexed_keys = array![];
Expand Down
4 changes: 2 additions & 2 deletions src/tests/presets/test_account.cairo
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -182,10 +182,10 @@ fn test_isValidSignature_bad_sig() {
fn test_supports_interface() {
let dispatcher = setup_dispatcher();
let supports_isrc5 = dispatcher.supports_interface(ISRC5_ID);
let supports_isrc6 = dispatcher.supports_interface(ISRC6_ID);
let doesnt_support_0x123 = !dispatcher.supports_interface(0x123);
assert!(supports_isrc5);
let supports_isrc6 = dispatcher.supports_interface(ISRC6_ID);
assert!(supports_isrc6);
let doesnt_support_0x123 = !dispatcher.supports_interface(0x123);
assert!(doesnt_support_0x123);
}

Expand Down