builtin-actors/actors/cron/tests/cron_actor_test.rs at 0093286083cfb4d01b8cfb9e70b580da484ee9ba · filecoin-project/builtin-actors · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
// Copyright 2019-2022 ChainSafe Systems
// SPDX-License-Identifier: Apache-2.0, MIT

use fil_actor_cron::{Actor as CronActor, ConstructorParams, Entry, State};
use fil_actors_runtime::test_utils::*;
use fil_actors_runtime::SYSTEM_ACTOR_ADDR;
use fvm_ipld_encoding::RawBytes;
use fvm_shared::address::Address;
use fvm_shared::error::ExitCode;

fn construct_runtime() -> MockRuntime {
    MockRuntime {
        receiver: Address::new_id(100),
        caller: *SYSTEM_ACTOR_ADDR,
        caller_type: *SYSTEM_ACTOR_CODE_ID,
        ..Default::default()
    }
}
#[test]
fn construct_with_empty_entries() {
    let mut rt = construct_runtime();

    construct_and_verify(&mut rt, &ConstructorParams { entries: vec![] });
    let state: State = rt.get_state().unwrap();

    assert_eq!(state.entries, vec![]);
}

#[test]
fn construct_with_entries() {
    let mut rt = construct_runtime();

    let entry1 = Entry { receiver: Address::new_id(1001), method_num: 1001 };
    let entry2 = Entry { receiver: Address::new_id(1002), method_num: 1002 };
    let entry3 = Entry { receiver: Address::new_id(1003), method_num: 1003 };
    let entry4 = Entry { receiver: Address::new_id(1004), method_num: 1004 };

    let params = ConstructorParams { entries: vec![entry1, entry2, entry3, entry4] };

    construct_and_verify(&mut rt, &params);

    let state: State = rt.get_state().unwrap();

    assert_eq!(state.entries, params.entries);
}

#[test]
fn epoch_tick_with_empty_entries() {
    let mut rt = construct_runtime();

    construct_and_verify(&mut rt, &ConstructorParams { entries: vec![] });
    epoch_tick_and_verify(&mut rt);
}
#[test]
fn epoch_tick_with_entries() {
    let mut rt = construct_runtime();

    let entry1 = Entry { receiver: Address::new_id(1001), method_num: 1001 };
    let entry2 = Entry { receiver: Address::new_id(1002), method_num: 1002 };
    let entry3 = Entry { receiver: Address::new_id(1003), method_num: 1003 };
    let entry4 = Entry { receiver: Address::new_id(1004), method_num: 1004 };

    let params = ConstructorParams {
        entries: vec![entry1.clone(), entry2.clone(), entry3.clone(), entry4.clone()],
    };

    construct_and_verify(&mut rt, &params);

    // ExitCodes dont matter here
    rt.expect_send(
        entry1.receiver,
        entry1.method_num,
        RawBytes::default(),
        0u8.into(),
        RawBytes::default(),
        ExitCode::OK,
    );
    rt.expect_send(
        entry2.receiver,
        entry2.method_num,
        RawBytes::default(),
        0u8.into(),
        RawBytes::default(),
        ExitCode::USR_ILLEGAL_ARGUMENT,
    );
    rt.expect_send(
        entry3.receiver,
        entry3.method_num,
        RawBytes::default(),
        0u8.into(),
        RawBytes::default(),
        ExitCode::OK,
    );
    rt.expect_send(
        entry4.receiver,
        entry4.method_num,
        RawBytes::default(),
        0u8.into(),
        RawBytes::default(),
        ExitCode::OK,
    );

    epoch_tick_and_verify(&mut rt);
}

fn construct_and_verify(rt: &mut MockRuntime, params: &ConstructorParams) {
    rt.expect_validate_caller_addr(vec![*SYSTEM_ACTOR_ADDR]);
    let ret = rt.call::<CronActor>(1, &RawBytes::serialize(&params).unwrap()).unwrap();
    assert_eq!(RawBytes::default(), ret);
    rt.verify();
}

fn epoch_tick_and_verify(rt: &mut MockRuntime) {
    rt.expect_validate_caller_addr(vec![*SYSTEM_ACTOR_ADDR]);
    let ret = rt.call::<CronActor>(2, &RawBytes::default()).unwrap();
    assert_eq!(RawBytes::default(), ret);
    rt.verify();
}