restate-sdk-shared-core 0.10.0

SDK Shared core
Documentation 
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

use super::*;

use crate::service_protocol::messages::*;

use crate::{PayloadOptions, Value};
use test_log::test;

fn sleep_handler(vm: &mut CoreVM) {
    vm.sys_input().unwrap();

    let h1 = vm
        .sys_sleep(String::default(), Duration::from_secs(1), None)
        .unwrap();

    if vm
        .do_progress(vec![h1])
        .is_err_and(|e| e.is_suspended_error())
    {
        assert_that!(vm.take_notification(h1), err(is_closed()));
        return;
    }
    assert2::assert!(let Some(Value::Void) = vm.take_notification(h1).unwrap());

    vm.sys_write_output(
        NonEmptyValue::Success(Bytes::default()),
        PayloadOptions::default(),
    )
    .unwrap();
    vm.sys_end().unwrap();
}

#[test]
fn sleep_suspends() {
    let mut output = VMTestCase::new()
        .input(StartMessage {
            id: Bytes::from_static(b"abc"),
            debug_id: "abc".to_owned(),
            known_entries: 1,
            partial_state: true,
            ..Default::default()
        })
        .input(input_entry_message(b"Till"))
        .run(sleep_handler);

    assert_that!(
        output.next_decoded::<SleepCommandMessage>().unwrap(),
        pat!(SleepCommandMessage {
            result_completion_id: eq(1)
        })
    );
    assert_that!(
        output.next_decoded::<SuspensionMessage>().unwrap(),
        suspended_waiting_completion(1)
    );
    assert_eq!(output.next(), None);
}

#[test]
fn sleep_completed() {
    let mut output = VMTestCase::new()
        .input(StartMessage {
            id: Bytes::from_static(b"abc"),
            debug_id: "abc".to_owned(),
            known_entries: 3,
            partial_state: true,
            ..Default::default()
        })
        .input(input_entry_message(b"Till"))
        .input(SleepCommandMessage {
            wake_up_time: 1721123699086,
            result_completion_id: 1,
            ..Default::default()
        })
        .input(SleepCompletionNotificationMessage {
            completion_id: 1,
            void: Some(Default::default()),
        })
        .run(sleep_handler);

    assert_that!(
        output.next_decoded::<OutputCommandMessage>().unwrap(),
        is_output_with_success("")
    );
    assert_eq!(
        output.next_decoded::<EndMessage>().unwrap(),
        EndMessage::default()
    );
    assert_eq!(output.next(), None);
}

#[test]
fn sleep_still_sleeping() {
    let mut output = VMTestCase::new()
        .input(StartMessage {
            id: Bytes::from_static(b"abc"),
            debug_id: "abc".to_owned(),
            known_entries: 2,
            partial_state: true,
            ..Default::default()
        })
        .input(input_entry_message(b"Till"))
        .input(SleepCommandMessage {
            wake_up_time: 1721123699086,
            result_completion_id: 1,
            ..Default::default()
        })
        .run(sleep_handler);

    assert_that!(
        output.next_decoded::<SuspensionMessage>().unwrap(),
        suspended_waiting_completion(1)
    );
    assert_eq!(output.next(), None);
}