pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-05-01 17:07:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

BREAKING: Rename Origin (#12258)

Browse Source 
* BREAKING: Rename Origin

* more renaming

* a bit more renaming

* fix

* more fixing

* fix in frame_support

* even more fixes

* fix

* small fix

* ...

* update .stderr

* docs

* update docs

* update docs

* docs
This commit is contained in:
Sergej Sakac
2022-09-21 00:13:09 +02:00
committed by GitHub
parent 986d20b352
commit e4b6f4a66d
221 changed files with 5233 additions and 4200 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/frame/lottery/src/tests.rs
+55 -55
View File
@@ -20,8 +20,8 @@
use super::*;
use frame_support::{assert_noop, assert_ok, assert_storage_noop};
use mock::{
new_test_ext, run_to_block, Balances, BalancesCall, Lottery, Origin, RuntimeCall, SystemCall,
Test,
new_test_ext, run_to_block, Balances, BalancesCall, Lottery, RuntimeCall, RuntimeOrigin,
SystemCall, Test,
};
use pallet_balances::Error as BalancesError;
use sp_runtime::traits::BadOrigin;
@@ -49,15 +49,15 @@ fn basic_end_to_end_works() {
];
// Set calls for the lottery
assert_ok!(Lottery::set_calls(Origin::root(), calls));
assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls));
// Start lottery, it repeats
assert_ok!(Lottery::start_lottery(Origin::root(), price, length, delay, true));
assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), price, length, delay, true));
assert!(crate::Lottery::<Test>::get().is_some());
assert_eq!(Balances::free_balance(&1), 100);
let call = Box::new(RuntimeCall::Balances(BalancesCall::transfer { dest: 2, value: 20 }));
assert_ok!(Lottery::buy_ticket(Origin::signed(1), call.clone()));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call.clone()));
// 20 from the transfer, 10 from buying a ticket
assert_eq!(Balances::free_balance(&1), 100 - 20 - 10);
assert_eq!(Participants::<Test>::get(&1).1.len(), 1);
@@ -66,14 +66,14 @@ fn basic_end_to_end_works() {
assert_eq!(Tickets::<Test>::get(0), Some(1));
// More ticket purchases
assert_ok!(Lottery::buy_ticket(Origin::signed(2), call.clone()));
assert_ok!(Lottery::buy_ticket(Origin::signed(3), call.clone()));
assert_ok!(Lottery::buy_ticket(Origin::signed(4), call.clone()));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(2), call.clone()));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(3), call.clone()));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(4), call.clone()));
assert_eq!(TicketsCount::<Test>::get(), 4);
// Go to end
run_to_block(20);
assert_ok!(Lottery::buy_ticket(Origin::signed(5), call.clone()));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(5), call.clone()));
// Ticket isn't bought
assert_eq!(TicketsCount::<Test>::get(), 4);
@@ -100,15 +100,15 @@ fn stop_repeat_works() {
let delay = 5;
// Set no calls for the lottery.
assert_ok!(Lottery::set_calls(Origin::root(), vec![]));
assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), vec![]));
// Start lottery, it repeats.
assert_ok!(Lottery::start_lottery(Origin::root(), price, length, delay, true));
assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), price, length, delay, true));
// Non-manager fails to `stop_repeat`.
assert_noop!(Lottery::stop_repeat(Origin::signed(1)), DispatchError::BadOrigin);
assert_noop!(Lottery::stop_repeat(RuntimeOrigin::signed(1)), DispatchError::BadOrigin);
// Manager can `stop_repeat`, even twice.
assert_ok!(Lottery::stop_repeat(Origin::root()));
assert_ok!(Lottery::stop_repeat(Origin::root()));
assert_ok!(Lottery::stop_repeat(RuntimeOrigin::root()));
assert_ok!(Lottery::stop_repeat(RuntimeOrigin::root()));
// Lottery still exists.
assert!(crate::Lottery::<Test>::get().is_some());
@@ -132,7 +132,7 @@ fn set_calls_works() {
RuntimeCall::Balances(BalancesCall::transfer { dest: 0, value: 0 }),
];
assert_ok!(Lottery::set_calls(Origin::root(), calls));
assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls));
assert!(CallIndices::<Test>::exists());
let too_many_calls = vec![
@@ -142,12 +142,12 @@ fn set_calls_works() {
];
assert_noop!(
Lottery::set_calls(Origin::root(), too_many_calls),
Lottery::set_calls(RuntimeOrigin::root(), too_many_calls),
Error::<Test>::TooManyCalls,
);
// Clear calls
assert_ok!(Lottery::set_calls(Origin::root(), vec![]));
assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), vec![]));
assert!(CallIndices::<Test>::get().is_empty());
});
}
@@ -182,16 +182,16 @@ fn start_lottery_works() {
// Setup ignores bad origin
assert_noop!(
Lottery::start_lottery(Origin::signed(1), price, length, delay, false),
Lottery::start_lottery(RuntimeOrigin::signed(1), price, length, delay, false),
BadOrigin,
);
// All good
assert_ok!(Lottery::start_lottery(Origin::root(), price, length, delay, false));
assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), price, length, delay, false));
// Can't open another one if lottery is already present
assert_noop!(
Lottery::start_lottery(Origin::root(), price, length, delay, false),
Lottery::start_lottery(RuntimeOrigin::root(), price, length, delay, false),
Error::<Test>::InProgress,
);
});
@@ -205,7 +205,7 @@ fn buy_ticket_works_as_simple_passthrough() {
// No lottery set up
let call = Box::new(RuntimeCall::Balances(BalancesCall::transfer { dest: 2, value: 20 }));
// This is just a basic transfer then
assert_ok!(Lottery::buy_ticket(Origin::signed(1), call.clone()));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call.clone()));
assert_eq!(Balances::free_balance(&1), 100 - 20);
assert_eq!(TicketsCount::<Test>::get(), 0);
@@ -214,11 +214,11 @@ fn buy_ticket_works_as_simple_passthrough() {
RuntimeCall::Balances(BalancesCall::force_transfer { source: 0, dest: 0, value: 0 }),
RuntimeCall::Balances(BalancesCall::transfer { dest: 0, value: 0 }),
];
assert_ok!(Lottery::set_calls(Origin::root(), calls));
assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls));
// Ticket price of 60 would kill the user's account
assert_ok!(Lottery::start_lottery(Origin::root(), 60, 10, 5, false));
assert_ok!(Lottery::buy_ticket(Origin::signed(1), call.clone()));
assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 60, 10, 5, false));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call.clone()));
assert_eq!(Balances::free_balance(&1), 100 - 20 - 20);
assert_eq!(TicketsCount::<Test>::get(), 0);
@@ -226,7 +226,7 @@ fn buy_ticket_works_as_simple_passthrough() {
let fail_call =
Box::new(RuntimeCall::Balances(BalancesCall::transfer { dest: 2, value: 1000 }));
assert_noop!(
Lottery::buy_ticket(Origin::signed(1), fail_call),
Lottery::buy_ticket(RuntimeOrigin::signed(1), fail_call),
BalancesError::<Test, _>::InsufficientBalance,
);
@@ -235,17 +235,17 @@ fn buy_ticket_works_as_simple_passthrough() {
dest: 0,
value: 0,
}));
assert_noop!(Lottery::buy_ticket(Origin::signed(1), bad_origin_call), BadOrigin,);
assert_noop!(Lottery::buy_ticket(RuntimeOrigin::signed(1), bad_origin_call), BadOrigin,);
// User can call other txs, but doesn't get a ticket
let remark_call =
Box::new(RuntimeCall::System(SystemCall::remark { remark: b"hello, world!".to_vec() }));
assert_ok!(Lottery::buy_ticket(Origin::signed(2), remark_call));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(2), remark_call));
assert_eq!(TicketsCount::<Test>::get(), 0);
let successful_call =
Box::new(RuntimeCall::Balances(BalancesCall::transfer { dest: 2, value: 1 }));
assert_ok!(Lottery::buy_ticket(Origin::signed(2), successful_call));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(2), successful_call));
assert_eq!(TicketsCount::<Test>::get(), 1);
});
}
@@ -258,40 +258,40 @@ fn buy_ticket_works() {
RuntimeCall::System(SystemCall::remark { remark: vec![] }),
RuntimeCall::Balances(BalancesCall::transfer { dest: 0, value: 0 }),
];
assert_ok!(Lottery::set_calls(Origin::root(), calls));
assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls));
// Can't buy ticket before start
let call = Box::new(RuntimeCall::Balances(BalancesCall::transfer { dest: 2, value: 1 }));
assert_ok!(Lottery::buy_ticket(Origin::signed(1), call.clone()));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call.clone()));
assert_eq!(TicketsCount::<Test>::get(), 0);
// Start lottery
assert_ok!(Lottery::start_lottery(Origin::root(), 1, 20, 5, false));
assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 1, 20, 5, false));
// Go to start, buy ticket for transfer
run_to_block(5);
assert_ok!(Lottery::buy_ticket(Origin::signed(1), call));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call));
assert_eq!(TicketsCount::<Test>::get(), 1);
// Can't buy another of the same ticket (even if call is slightly changed)
let call = Box::new(RuntimeCall::Balances(BalancesCall::transfer { dest: 3, value: 30 }));
assert_ok!(Lottery::buy_ticket(Origin::signed(1), call));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call));
assert_eq!(TicketsCount::<Test>::get(), 1);
// Buy ticket for remark
let call =
Box::new(RuntimeCall::System(SystemCall::remark { remark: b"hello, world!".to_vec() }));
assert_ok!(Lottery::buy_ticket(Origin::signed(1), call.clone()));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call.clone()));
assert_eq!(TicketsCount::<Test>::get(), 2);
// Go to end, can't buy tickets anymore
run_to_block(20);
assert_ok!(Lottery::buy_ticket(Origin::signed(2), call.clone()));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(2), call.clone()));
assert_eq!(TicketsCount::<Test>::get(), 2);
// Go to payout, can't buy tickets when there is no lottery open
run_to_block(25);
assert_ok!(Lottery::buy_ticket(Origin::signed(2), call.clone()));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(2), call.clone()));
assert_eq!(TicketsCount::<Test>::get(), 0);
assert_eq!(LotteryIndex::<Test>::get(), 1);
});
@@ -303,8 +303,8 @@ fn buy_ticket_works() {
fn do_buy_ticket_already_participating() {
new_test_ext().execute_with(|| {
let calls = vec![RuntimeCall::Balances(BalancesCall::transfer { dest: 0, value: 0 })];
assert_ok!(Lottery::set_calls(Origin::root(), calls.clone()));
assert_ok!(Lottery::start_lottery(Origin::root(), 1, 10, 10, false));
assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls.clone()));
assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 1, 10, 10, false));
// Buying once works.
assert_ok!(Lottery::do_buy_ticket(&1, &calls[0]));
@@ -318,15 +318,15 @@ fn do_buy_ticket_already_participating() {
fn buy_ticket_already_participating() {
new_test_ext().execute_with(|| {
let calls = vec![RuntimeCall::Balances(BalancesCall::transfer { dest: 0, value: 0 })];
assert_ok!(Lottery::set_calls(Origin::root(), calls.clone()));
assert_ok!(Lottery::start_lottery(Origin::root(), 1, 10, 10, false));
assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls.clone()));
assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 1, 10, 10, false));
// Buying once works.
let call = Box::new(calls[0].clone());
assert_ok!(Lottery::buy_ticket(Origin::signed(1), call.clone()));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call.clone()));
// Buying the same ticket again returns Ok, but changes nothing.
assert_storage_noop!(Lottery::buy_ticket(Origin::signed(1), call).unwrap());
assert_storage_noop!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call).unwrap());
// Exactly one ticket exists.
assert_eq!(TicketsCount::<Test>::get(), 1);
@@ -338,13 +338,13 @@ fn buy_ticket_already_participating() {
fn buy_ticket_insufficient_balance() {
new_test_ext().execute_with(|| {
let calls = vec![RuntimeCall::Balances(BalancesCall::transfer { dest: 0, value: 0 })];
assert_ok!(Lottery::set_calls(Origin::root(), calls.clone()));
assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls.clone()));
// Price set to 100.
assert_ok!(Lottery::start_lottery(Origin::root(), 100, 10, 10, false));
assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 100, 10, 10, false));
let call = Box::new(calls[0].clone());
// Buying a ticket returns Ok, but changes nothing.
assert_storage_noop!(Lottery::buy_ticket(Origin::signed(1), call).unwrap());
assert_storage_noop!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call).unwrap());
assert!(TicketsCount::<Test>::get().is_zero());
});
}
@@ -353,9 +353,9 @@ fn buy_ticket_insufficient_balance() {
fn do_buy_ticket_insufficient_balance() {
new_test_ext().execute_with(|| {
let calls = vec![RuntimeCall::Balances(BalancesCall::transfer { dest: 0, value: 0 })];
assert_ok!(Lottery::set_calls(Origin::root(), calls.clone()));
assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls.clone()));
// Price set to 101.
assert_ok!(Lottery::start_lottery(Origin::root(), 101, 10, 10, false));
assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 101, 10, 10, false));
// Buying fails with InsufficientBalance.
assert_noop!(
@@ -370,9 +370,9 @@ fn do_buy_ticket_insufficient_balance() {
fn do_buy_ticket_keep_alive() {
new_test_ext().execute_with(|| {
let calls = vec![RuntimeCall::Balances(BalancesCall::transfer { dest: 0, value: 0 })];
assert_ok!(Lottery::set_calls(Origin::root(), calls.clone()));
assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls.clone()));
// Price set to 100.
assert_ok!(Lottery::start_lottery(Origin::root(), 100, 10, 10, false));
assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 100, 10, 10, false));
// Buying fails with KeepAlive.
assert_noop!(Lottery::do_buy_ticket(&1, &calls[0]), BalancesError::<Test, _>::KeepAlive);
@@ -388,9 +388,9 @@ fn no_participants_works() {
let delay = 5;
// Set no calls for the lottery.
assert_ok!(Lottery::set_calls(Origin::root(), vec![]));
assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), vec![]));
// Start lottery.
assert_ok!(Lottery::start_lottery(Origin::root(), 10, length, delay, false));
assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 10, length, delay, false));
// End the lottery, no one wins.
run_to_block(length + delay);
@@ -405,7 +405,7 @@ fn start_lottery_will_create_account() {
let delay = 5;
assert_eq!(Balances::total_balance(&Lottery::account_id()), 0);
assert_ok!(Lottery::start_lottery(Origin::root(), price, length, delay, false));
assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), price, length, delay, false));
assert_eq!(Balances::total_balance(&Lottery::account_id()), 1);
});
}
@@ -422,12 +422,12 @@ fn choose_ticket_trivial_cases() {
fn choose_account_one_participant() {
new_test_ext().execute_with(|| {
let calls = vec![RuntimeCall::Balances(BalancesCall::transfer { dest: 0, value: 0 })];
assert_ok!(Lottery::set_calls(Origin::root(), calls.clone()));
assert_ok!(Lottery::start_lottery(Origin::root(), 10, 10, 10, false));
assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls.clone()));
assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 10, 10, 10, false));
let call = Box::new(calls[0].clone());
// Buy one ticket with account 1.
assert_ok!(Lottery::buy_ticket(Origin::signed(1), call));
assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call));
// Account 1 is always the winner.
assert_eq!(Lottery::choose_account().unwrap(), 1);
});