Skip to content

Commit 3a93b02

Browse files
cboh4cboh4
committed
refactor unit tests
1 parent 10a2fb9 commit 3a93b02

File tree

3 files changed

+190
-87
lines changed

3 files changed

+190
-87
lines changed

‎worker-manager/src/contract.rs‎

Lines changed: 190 additions & 85 deletions
Original file line numberDiff line numberDiff line change
@@ -38,12 +38,14 @@ pub fn execute(
3838
payment_wallet,
3939
attestation_report,
4040
} => try_register_worker(deps, info, ip_address, payment_wallet, attestation_report),
41-
ExecuteMsg::SetWorkerWallet { ip_address, payment_wallet } => {
42-
try_set_worker_wallet(deps, info, ip_address, payment_wallet)
43-
}
44-
ExecuteMsg::SetWorkerAddress { new_ip_address, old_ip_address } => {
45-
try_set_worker_address(deps, info, new_ip_address, old_ip_address)
46-
}
41+
ExecuteMsg::SetWorkerWallet {
42+
ip_address,
43+
payment_wallet,
44+
} => try_set_worker_wallet(deps, info, ip_address, payment_wallet),
45+
ExecuteMsg::SetWorkerAddress {
46+
new_ip_address,
47+
old_ip_address,
48+
} => try_set_worker_address(deps, info, new_ip_address, old_ip_address),
4749
ExecuteMsg::ReportLiveliness {} => try_report_liveliness(deps, info),
4850
ExecuteMsg::ReportWork {} => try_report_work(deps, info),
4951
}
@@ -56,7 +58,6 @@ pub fn try_register_worker(
5658
payment_wallet: String,
5759
attestation_report: String,
5860
) -> StdResult<Response> {
59-
6061
let worker = Worker {
6162
ip_address,
6263
payment_wallet,
@@ -77,7 +78,9 @@ pub fn try_set_worker_wallet(
7778
let worker_entry = WORKERS_MAP.get(_deps.storage, &ip_address);
7879
if let Some(worker) = worker_entry {
7980
if _info.sender != worker.payment_wallet {
80-
return Err(StdError::generic_err("Only the owner has the authority to modify the payment wallet"));
81+
return Err(StdError::generic_err(
82+
"Only the owner has the authority to modify the payment wallet",
83+
));
8184
}
8285
let worker = Worker {
8386
payment_wallet,
@@ -101,7 +104,9 @@ pub fn try_set_worker_address(
101104
let worker_entry = WORKERS_MAP.get(_deps.storage, &old_ip_address);
102105
if let Some(worker) = worker_entry {
103106
if _info.sender != worker.payment_wallet {
104-
return Err(StdError::generic_err("Only the owner has the authority to modify the IP address"));
107+
return Err(StdError::generic_err(
108+
"Only the owner has the authority to modify the IP address",
109+
));
105110
}
106111
let worker = Worker {
107112
payment_wallet: worker.payment_wallet,
@@ -149,7 +154,6 @@ fn query_workers(
149154
_signature: String,
150155
_sender_public_key: String,
151156
) -> StdResult<GetWorkersResponse> {
152-
153157
let workers: Vec<_> = WORKERS_MAP
154158
.iter(_deps.storage)?
155159
.map(|x| {
@@ -172,9 +176,14 @@ fn query_liveliness_challenge(_deps: Deps) -> StdResult<GetLivelinessChallengeRe
172176

173177
#[cfg(test)]
174178
mod tests {
179+
use crate::msg;
180+
175181
use super::*;
176-
use cosmwasm_std::{from_binary, testing::*};
182+
use cosmwasm_std::{from_binary, testing::*, OwnedDeps};
177183
use cosmwasm_std::{Coin, Uint128};
184+
const IP_ADDRESS: &str = "127.0.0.1";
185+
const PAYMENT_WALLET: &str = "secret1ap26qrlp8mcq2pg6r47w43l0y8zkqm8a450s03";
186+
const ATTESTATION_REPORT: &str = "";
178187

179188
#[test]
180189
fn proper_initialization() {
@@ -194,117 +203,210 @@ mod tests {
194203
assert_eq!(0, res.messages.len());
195204
}
196205

197-
#[test]
198-
fn register_worker_success() {
206+
fn init_contract() -> (
207+
StdResult<Response>,
208+
OwnedDeps<MockStorage, MockApi, MockQuerier>,
209+
) {
199210
let mut deps = mock_dependencies();
200211
let env = mock_env();
201212
let info = mock_info("admin", &[]);
202213
let msg = InstantiateMsg {};
203-
let _res = instantiate(deps.as_mut(), env.clone(), info.clone(), msg).unwrap();
214+
let res = instantiate(deps.as_mut(), env.clone(), info.clone(), msg);
204215

216+
(res, deps)
217+
}
218+
219+
fn register_worker(
220+
deps: &mut OwnedDeps<MockStorage, MockApi, MockQuerier>,
221+
ip_address: String,
222+
payment_wallet: String,
223+
attestation_report: String,
224+
) -> StdResult<Response> {
205225
let execute_msg = ExecuteMsg::RegisterWorker {
206-
ip_address: String::from("127.0.0.1"),
207-
payment_wallet: "secret1ap26qrlp8mcq2pg6r47w43l0y8zkqm8a450s03".to_string(),
208-
attestation_report: "".to_string(),
226+
ip_address,
227+
payment_wallet: payment_wallet.clone(),
228+
attestation_report,
209229
};
210-
let res = execute(deps.as_mut(), env, info, execute_msg).unwrap();
211-
assert_eq!(0, res.messages.len());
230+
execute(
231+
deps.as_mut(),
232+
mock_env(),
233+
mock_info(&payment_wallet, &[]),
234+
execute_msg,
235+
)
236+
}
237+
238+
#[test]
239+
fn register_worker_success() {
240+
let (res, mut deps) = init_contract();
241+
assert_eq!(res.unwrap().messages.len(), 0);
242+
243+
let res = register_worker(
244+
&mut deps,
245+
IP_ADDRESS.into(),
246+
PAYMENT_WALLET.into(),
247+
ATTESTATION_REPORT.into(),
248+
)
249+
.unwrap();
250+
212251
let worker: Worker = from_binary(&res.data.unwrap()).unwrap();
213252
assert_eq!(
214253
worker,
215254
Worker {
216-
ip_address: String::from("127.0.0.1"),
217-
payment_wallet: "secret1ap26qrlp8mcq2pg6r47w43l0y8zkqm8a450s03".to_string(),
218-
attestation_report: "".to_string(),
255+
ip_address: IP_ADDRESS.into(),
256+
payment_wallet: PAYMENT_WALLET.into(),
257+
attestation_report: ATTESTATION_REPORT.into(),
219258
}
220259
);
221260
}
222261

223262
#[test]
224263
fn set_worker_wallet() {
225-
let mut deps = mock_dependencies();
226-
let env = mock_env();
227-
let info = mock_info("secret1ap26qrlp8mcq2pg6r47w43l0y8zkqm8a450s03", &[]);
228-
let msg = InstantiateMsg {};
229-
let _res = instantiate(deps.as_mut(), env.clone(), info.clone(), msg).unwrap();
230-
231-
let ip_address = String::from("127.0.0.1");
232-
let payment_wallet = "secret1ap26qrlp8mcq2pg6r47w43l0y8zkqm8a450s03".to_string();
233-
let attestation_report = "".to_string();
234-
235-
let execute_msg = ExecuteMsg::RegisterWorker {
236-
ip_address: ip_address.clone(),
237-
payment_wallet,
238-
attestation_report: attestation_report.clone(),
239-
};
240-
let res = execute(deps.as_mut(), env.clone(), info.clone(), execute_msg).unwrap();
264+
let (res, mut deps) = init_contract();
265+
assert_eq!(res.unwrap().messages.len(), 0);
266+
267+
let res = register_worker(
268+
&mut deps,
269+
IP_ADDRESS.into(),
270+
PAYMENT_WALLET.into(),
271+
ATTESTATION_REPORT.into(),
272+
)
273+
.unwrap();
241274
assert_eq!(0, res.messages.len());
242275

243276
let new_payment_wallet = "secret1ap26qrlp8mcq2pg6r47w43l0y8zkqm8a450007".to_string();
244277
let execute_msg = ExecuteMsg::SetWorkerWallet {
245-
ip_address: ip_address.clone(),
278+
ip_address: IP_ADDRESS.into(),
246279
payment_wallet: new_payment_wallet.clone(),
247280
};
248-
let res = execute(deps.as_mut(), env, info, execute_msg).unwrap();
281+
let res = execute(
282+
deps.as_mut(),
283+
mock_env(),
284+
mock_info(PAYMENT_WALLET, &[]),
285+
execute_msg,
286+
)
287+
.unwrap();
249288
assert_eq!(0, res.messages.len());
250289

251290
let worker: Worker = from_binary(&res.data.unwrap()).unwrap();
252291
assert_eq!(
253292
worker,
254293
Worker {
255-
ip_address: ip_address.clone(),
294+
ip_address: IP_ADDRESS.into(),
256295
payment_wallet: new_payment_wallet,
257-
attestation_report,
296+
attestation_report: ATTESTATION_REPORT.into(),
258297
}
259298
);
260299
}
261300

262301
#[test]
263-
fn set_worker_address() {
264-
let mut deps = mock_dependencies();
265-
let env = mock_env();
266-
let info = mock_info("secret1ap26qrlp8mcq2pg6r47w43l0y8zkqm8a450s03", &[]);
267-
let msg = InstantiateMsg {};
268-
let _res = instantiate(deps.as_mut(), env.clone(), info.clone(), msg).unwrap();
269-
270-
let ip_address = String::from("127.0.0.1");
271-
let payment_wallet = "secret1ap26qrlp8mcq2pg6r47w43l0y8zkqm8a450s03".to_string();
272-
let attestation_report = "".to_string();
302+
fn set_worker_wallet_unauthorized() {
303+
let (res, mut deps) = init_contract();
304+
assert_eq!(res.unwrap().messages.len(), 0);
305+
306+
let res = register_worker(
307+
&mut deps,
308+
IP_ADDRESS.into(),
309+
PAYMENT_WALLET.into(),
310+
ATTESTATION_REPORT.into(),
311+
)
312+
.unwrap();
313+
assert_eq!(0, res.messages.len());
273314

274-
let execute_msg = ExecuteMsg::RegisterWorker {
275-
ip_address: ip_address.clone(),
276-
payment_wallet: payment_wallet.clone(),
277-
attestation_report: attestation_report.clone(),
315+
let new_payment_wallet = "secret1ap26qrlp8mcq2pg6r47w43l0y8zkqm8a450007".to_string();
316+
let execute_msg = ExecuteMsg::SetWorkerWallet {
317+
ip_address: IP_ADDRESS.into(),
318+
payment_wallet: new_payment_wallet.clone(),
278319
};
279-
let res = execute(deps.as_mut(), env.clone(), info.clone(), execute_msg).unwrap();
320+
321+
// set as sender foreign wallet
322+
let res = execute(
323+
deps.as_mut(),
324+
mock_env(),
325+
mock_info(&new_payment_wallet, &[]),
326+
execute_msg,
327+
);
328+
assert!(res.is_err());
329+
assert_eq!(
330+
res.unwrap_err(),
331+
StdError::generic_err("Only the owner has the authority to modify the payment wallet",)
332+
);
333+
}
334+
335+
#[test]
336+
fn set_worker_address() {
337+
let (res, mut deps) = init_contract();
338+
assert_eq!(res.unwrap().messages.len(), 0);
339+
340+
let res = register_worker(
341+
&mut deps,
342+
IP_ADDRESS.into(),
343+
PAYMENT_WALLET.into(),
344+
ATTESTATION_REPORT.into(),
345+
)
346+
.unwrap();
280347
assert_eq!(0, res.messages.len());
281348

282349
let new_ip_address = String::from("147.4.4.7");
283350
let execute_msg = ExecuteMsg::SetWorkerAddress {
284351
new_ip_address: new_ip_address.clone(),
285-
old_ip_address: ip_address.clone(),
352+
old_ip_address: IP_ADDRESS.into(),
286353
};
287-
let res = execute(deps.as_mut(), env, info, execute_msg).unwrap();
354+
let res = execute(
355+
deps.as_mut(),
356+
mock_env(),
357+
mock_info(PAYMENT_WALLET, &[]),
358+
execute_msg,
359+
)
360+
.unwrap();
288361
assert_eq!(0, res.messages.len());
289362

290363
let worker: Worker = from_binary(&res.data.unwrap()).unwrap();
291364
assert_eq!(
292365
worker,
293366
Worker {
294367
ip_address: new_ip_address,
295-
payment_wallet,
296-
attestation_report,
368+
payment_wallet: PAYMENT_WALLET.into(),
369+
attestation_report: ATTESTATION_REPORT.into(),
297370
}
298371
);
299372
}
300373

374+
#[test]
375+
fn set_worker_address_unauthorized() {
376+
let (res, mut deps) = init_contract();
377+
assert_eq!(res.unwrap().messages.len(), 0);
378+
379+
let res = register_worker(
380+
&mut deps,
381+
IP_ADDRESS.into(),
382+
PAYMENT_WALLET.into(),
383+
ATTESTATION_REPORT.into(),
384+
)
385+
.unwrap();
386+
assert_eq!(0, res.messages.len());
387+
388+
let new_ip_address = String::from("147.4.4.7");
389+
let execute_msg = ExecuteMsg::SetWorkerAddress {
390+
new_ip_address: new_ip_address.clone(),
391+
old_ip_address: IP_ADDRESS.into(),
392+
};
393+
let res = execute(
394+
deps.as_mut(),
395+
mock_env(),
396+
mock_info("fake_acc", &[]),
397+
execute_msg,
398+
);
399+
assert!(res.is_err());
400+
assert_eq!(
401+
res.unwrap_err(),
402+
StdError::generic_err("Only the owner has the authority to modify the IP address",)
403+
);
404+
}
405+
301406
#[test]
302407
fn query_workers() {
303-
let mut deps = mock_dependencies();
304-
let env = mock_env();
305-
let info = mock_info("secret1ap26qrlp8mcq2pg6r47w43l0y8zkqm8a450s03", &[]);
306-
let msg = InstantiateMsg {};
307-
let _res = instantiate(deps.as_mut(), env.clone(), info.clone(), msg).unwrap();
408+
let (res, mut deps) = init_contract();
409+
assert_eq!(res.unwrap().messages.len(), 0);
308410

309411
let ip_address_1 = String::from("127.0.0.1");
310412
let ip_address_2 = String::from("127.0.0.2");
@@ -314,36 +416,39 @@ mod tests {
314416
let payment_wallet_2 = "secret1ap26qrlp8mcq2pg6r47w43l0y8zkqm8a450s07".to_string();
315417
let attestation_report = "".to_string();
316418

317-
let execute_msg = ExecuteMsg::RegisterWorker {
318-
ip_address: ip_address_1.clone(),
319-
payment_wallet: payment_wallet_1.clone(),
320-
attestation_report: attestation_report.clone(),
321-
};
322-
let res = execute(deps.as_mut(), env.clone(), info.clone(), execute_msg).unwrap();
419+
let res = register_worker(
420+
&mut deps,
421+
ip_address_1.clone(),
422+
payment_wallet_1.clone(),
423+
ATTESTATION_REPORT.into(),
424+
)
425+
.unwrap();
323426
assert_eq!(0, res.messages.len());
324427

325-
let execute_msg = ExecuteMsg::RegisterWorker {
326-
ip_address: ip_address_2.clone(),
327-
payment_wallet: payment_wallet_1.clone(),
328-
attestation_report: attestation_report.clone(),
329-
};
330-
let res = execute(deps.as_mut(), env.clone(), info.clone(), execute_msg).unwrap();
428+
let res = register_worker(
429+
&mut deps,
430+
ip_address_2.clone(),
431+
payment_wallet_1.clone(),
432+
ATTESTATION_REPORT.into(),
433+
)
434+
.unwrap();
331435
assert_eq!(0, res.messages.len());
332436

333-
let execute_msg = ExecuteMsg::RegisterWorker {
334-
ip_address: ip_address_3.clone(),
335-
payment_wallet: payment_wallet_2.clone(),
336-
attestation_report: attestation_report.clone(),
337-
};
338-
let res = execute(deps.as_mut(), env.clone(), info.clone(), execute_msg).unwrap();
437+
let res = register_worker(
438+
&mut deps,
439+
ip_address_3.clone(),
440+
payment_wallet_2.clone(),
441+
ATTESTATION_REPORT.into(),
442+
)
443+
.unwrap();
339444
assert_eq!(0, res.messages.len());
340445

341446
let query_msg = QueryMsg::GetWorkers {
342447
address: "".to_string(),
343448
signature: "".to_string(),
344449
subscriber_public_key: "".to_string(),
345450
};
346-
let res = query(deps.as_ref(), env, query_msg).unwrap();
451+
let res = query(deps.as_ref(), mock_env(), query_msg).unwrap();
347452

348453
let workers: GetWorkersResponse = from_binary(&res).unwrap();
349454
assert_eq!(

0 commit comments

Comments
 (0)