Skip to content

Commit 080449a

Browse files
rustopianrustopian
committed
nice little helper
1 parent edf1713 commit 080449a

1 file changed

Lines changed: 64 additions & 169 deletions

File tree

‎program/tests/initialize.rs‎

Lines changed: 64 additions & 169 deletions
Original file line numberDiff line numberDiff line change
@@ -6,12 +6,13 @@ use {
66
helpers::{context::StakeTestContext, lifecycle::StakeLifecycle},
77
mollusk_svm::result::Check,
88
solana_account::{AccountSharedData, ReadableAccount},
9+
solana_instruction::Instruction,
910
solana_program_error::ProgramError,
1011
solana_pubkey::Pubkey,
1112
solana_rent::Rent,
1213
solana_sdk_ids::{stake::id, system_program::id as system_program_id},
1314
solana_stake_client::instructions::{InitializeBuilder, InitializeCheckedBuilder},
14-
solana_stake_interface::state::StakeStateV2,
15+
solana_stake_interface::state::{Lockup, StakeStateV2},
1516
test_case::test_case,
1617
};
1718

@@ -21,17 +22,39 @@ enum InitializeVariant {
2122
InitializeChecked,
2223
}
2324

24-
fn lockup_for(
25-
variant: InitializeVariant,
26-
custodian: Pubkey,
27-
) -> solana_stake_interface::state::Lockup {
25+
fn lockup_for(variant: InitializeVariant, custodian: Pubkey) -> Lockup {
2826
match variant {
29-
InitializeVariant::Initialize => solana_stake_interface::state::Lockup {
27+
InitializeVariant::Initialize => Lockup {
3028
epoch: 1,
3129
unix_timestamp: 0,
3230
custodian,
3331
},
34-
InitializeVariant::InitializeChecked => solana_stake_interface::state::Lockup::default(),
32+
InitializeVariant::InitializeChecked => Lockup::default(),
33+
}
34+
}
35+
36+
fn build_initialize_instruction(
37+
variant: InitializeVariant,
38+
stake: Pubkey,
39+
staker: Pubkey,
40+
withdrawer: Pubkey,
41+
lockup: Lockup,
42+
) -> Instruction {
43+
match variant {
44+
InitializeVariant::Initialize => InitializeBuilder::new()
45+
.stake(stake)
46+
.arg0(solana_stake_client::types::Authorized { staker, withdrawer })
47+
.arg1(solana_stake_client::types::Lockup {
48+
unix_timestamp: lockup.unix_timestamp,
49+
epoch: lockup.epoch,
50+
custodian: lockup.custodian,
51+
})
52+
.instruction(),
53+
InitializeVariant::InitializeChecked => InitializeCheckedBuilder::new()
54+
.stake(stake)
55+
.stake_authority(staker)
56+
.withdraw_authority(withdrawer)
57+
.instruction(),
3558
}
3659
}
3760

@@ -58,28 +81,10 @@ fn test_initialize(variant: InitializeVariant) {
5881
.build(),
5982
];
6083

61-
match variant {
62-
InitializeVariant::Initialize => ctx.checks(&checks).execute(
63-
InitializeBuilder::new()
64-
.stake(stake)
65-
.arg0(solana_stake_client::types::Authorized { staker, withdrawer })
66-
.arg1(solana_stake_client::types::Lockup {
67-
unix_timestamp: lockup.unix_timestamp,
68-
epoch: lockup.epoch,
69-
custodian: lockup.custodian,
70-
})
71-
.instruction(),
72-
&[(&stake, &stake_account)],
73-
),
74-
InitializeVariant::InitializeChecked => ctx.checks(&checks).execute(
75-
InitializeCheckedBuilder::new()
76-
.stake(stake)
77-
.stake_authority(staker)
78-
.withdraw_authority(withdrawer)
79-
.instruction(),
80-
&[(&stake, &stake_account)],
81-
),
82-
}
84+
ctx.checks(&checks).execute(
85+
build_initialize_instruction(variant, stake, staker, withdrawer, lockup),
86+
&[(&stake, &stake_account)],
87+
)
8388
};
8489

8590
let resulting_account: AccountSharedData = result.resulting_accounts[0].1.clone().into();
@@ -94,34 +99,12 @@ fn test_initialize(variant: InitializeVariant) {
9499
);
95100

96101
// Re-initialize should fail
97-
match variant {
98-
InitializeVariant::Initialize => ctx
99-
.checks(&[Check::err(ProgramError::InvalidAccountData)])
100-
.test_missing_signers(false)
101-
.execute(
102-
InitializeBuilder::new()
103-
.stake(stake)
104-
.arg0(solana_stake_client::types::Authorized { staker, withdrawer })
105-
.arg1(solana_stake_client::types::Lockup {
106-
unix_timestamp: lockup.unix_timestamp,
107-
epoch: lockup.epoch,
108-
custodian: lockup.custodian,
109-
})
110-
.instruction(),
111-
&[(&stake, &resulting_account)],
112-
),
113-
InitializeVariant::InitializeChecked => ctx
114-
.checks(&[Check::err(ProgramError::InvalidAccountData)])
115-
.test_missing_signers(false)
116-
.execute(
117-
InitializeCheckedBuilder::new()
118-
.stake(stake)
119-
.stake_authority(staker)
120-
.withdraw_authority(withdrawer)
121-
.instruction(),
122-
&[(&stake, &resulting_account)],
123-
),
124-
};
102+
ctx.checks(&[Check::err(ProgramError::InvalidAccountData)])
103+
.test_missing_signers(false)
104+
.execute(
105+
build_initialize_instruction(variant, stake, staker, withdrawer, lockup),
106+
&[(&stake, &resulting_account)],
107+
);
125108
}
126109

127110
#[test_case(InitializeVariant::Initialize; "initialize")]
@@ -143,34 +126,12 @@ fn test_initialize_insufficient_funds(variant: InitializeVariant) {
143126
)
144127
.unwrap();
145128

146-
match variant {
147-
InitializeVariant::Initialize => ctx
148-
.checks(&[Check::err(ProgramError::InsufficientFunds)])
149-
.test_missing_signers(false)
150-
.execute(
151-
InitializeBuilder::new()
152-
.stake(stake)
153-
.arg0(solana_stake_client::types::Authorized { staker, withdrawer })
154-
.arg1(solana_stake_client::types::Lockup {
155-
unix_timestamp: lockup.unix_timestamp,
156-
epoch: lockup.epoch,
157-
custodian: lockup.custodian,
158-
})
159-
.instruction(),
160-
&[(&stake, &stake_account)],
161-
),
162-
InitializeVariant::InitializeChecked => ctx
163-
.checks(&[Check::err(ProgramError::InsufficientFunds)])
164-
.test_missing_signers(false)
165-
.execute(
166-
InitializeCheckedBuilder::new()
167-
.stake(stake)
168-
.stake_authority(staker)
169-
.withdraw_authority(withdrawer)
170-
.instruction(),
171-
&[(&stake, &stake_account)],
172-
),
173-
};
129+
ctx.checks(&[Check::err(ProgramError::InsufficientFunds)])
130+
.test_missing_signers(false)
131+
.execute(
132+
build_initialize_instruction(variant, stake, staker, withdrawer, lockup),
133+
&[(&stake, &stake_account)],
134+
);
174135
}
175136

176137
#[test_case(InitializeVariant::Initialize; "initialize")]
@@ -194,34 +155,12 @@ fn test_initialize_incorrect_size_larger(variant: InitializeVariant) {
194155
)
195156
.unwrap();
196157

197-
match variant {
198-
InitializeVariant::Initialize => ctx
199-
.checks(&[Check::err(ProgramError::InvalidAccountData)])
200-
.test_missing_signers(false)
201-
.execute(
202-
InitializeBuilder::new()
203-
.stake(stake)
204-
.arg0(solana_stake_client::types::Authorized { staker, withdrawer })
205-
.arg1(solana_stake_client::types::Lockup {
206-
unix_timestamp: lockup.unix_timestamp,
207-
epoch: lockup.epoch,
208-
custodian: lockup.custodian,
209-
})
210-
.instruction(),
211-
&[(&stake, &stake_account)],
212-
),
213-
InitializeVariant::InitializeChecked => ctx
214-
.checks(&[Check::err(ProgramError::InvalidAccountData)])
215-
.test_missing_signers(false)
216-
.execute(
217-
InitializeCheckedBuilder::new()
218-
.stake(stake)
219-
.stake_authority(staker)
220-
.withdraw_authority(withdrawer)
221-
.instruction(),
222-
&[(&stake, &stake_account)],
223-
),
224-
};
158+
ctx.checks(&[Check::err(ProgramError::InvalidAccountData)])
159+
.test_missing_signers(false)
160+
.execute(
161+
build_initialize_instruction(variant, stake, staker, withdrawer, lockup),
162+
&[(&stake, &stake_account)],
163+
);
225164
}
226165

227166
#[test_case(InitializeVariant::Initialize; "initialize")]
@@ -245,34 +184,12 @@ fn test_initialize_incorrect_size_smaller(variant: InitializeVariant) {
245184
)
246185
.unwrap();
247186

248-
match variant {
249-
InitializeVariant::Initialize => ctx
250-
.checks(&[Check::err(ProgramError::InvalidAccountData)])
251-
.test_missing_signers(false)
252-
.execute(
253-
InitializeBuilder::new()
254-
.stake(stake)
255-
.arg0(solana_stake_client::types::Authorized { staker, withdrawer })
256-
.arg1(solana_stake_client::types::Lockup {
257-
unix_timestamp: lockup.unix_timestamp,
258-
epoch: lockup.epoch,
259-
custodian: lockup.custodian,
260-
})
261-
.instruction(),
262-
&[(&stake, &stake_account)],
263-
),
264-
InitializeVariant::InitializeChecked => ctx
265-
.checks(&[Check::err(ProgramError::InvalidAccountData)])
266-
.test_missing_signers(false)
267-
.execute(
268-
InitializeCheckedBuilder::new()
269-
.stake(stake)
270-
.stake_authority(staker)
271-
.withdraw_authority(withdrawer)
272-
.instruction(),
273-
&[(&stake, &stake_account)],
274-
),
275-
};
187+
ctx.checks(&[Check::err(ProgramError::InvalidAccountData)])
188+
.test_missing_signers(false)
189+
.execute(
190+
build_initialize_instruction(variant, stake, staker, withdrawer, lockup),
191+
&[(&stake, &stake_account)],
192+
);
276193
}
277194

278195
#[test_case(InitializeVariant::Initialize; "initialize")]
@@ -294,32 +211,10 @@ fn test_initialize_wrong_owner(variant: InitializeVariant) {
294211
)
295212
.unwrap();
296213

297-
match variant {
298-
InitializeVariant::Initialize => ctx
299-
.checks(&[Check::err(ProgramError::InvalidAccountOwner)])
300-
.test_missing_signers(false)
301-
.execute(
302-
InitializeBuilder::new()
303-
.stake(stake)
304-
.arg0(solana_stake_client::types::Authorized { staker, withdrawer })
305-
.arg1(solana_stake_client::types::Lockup {
306-
unix_timestamp: lockup.unix_timestamp,
307-
epoch: lockup.epoch,
308-
custodian: lockup.custodian,
309-
})
310-
.instruction(),
311-
&[(&stake, &stake_account)],
312-
),
313-
InitializeVariant::InitializeChecked => ctx
314-
.checks(&[Check::err(ProgramError::InvalidAccountOwner)])
315-
.test_missing_signers(false)
316-
.execute(
317-
InitializeCheckedBuilder::new()
318-
.stake(stake)
319-
.stake_authority(staker)
320-
.withdraw_authority(withdrawer)
321-
.instruction(),
322-
&[(&stake, &stake_account)],
323-
),
324-
};
214+
ctx.checks(&[Check::err(ProgramError::InvalidAccountOwner)])
215+
.test_missing_signers(false)
216+
.execute(
217+
build_initialize_instruction(variant, stake, staker, withdrawer, lockup),
218+
&[(&stake, &stake_account)],
219+
);
325220
}

0 commit comments

Comments
 (0)