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

use super::*;

use crate::service_protocol::messages::{EndMessage, OutputCommandMessage, StartMessage};
use crate::PayloadOptions;
use test_log::test;

fn echo_handler(vm: &mut CoreVM) {
    assert2::assert!(let Input { input, .. } = vm.sys_input().unwrap());
    assert_eq!(input, b"my-data".to_vec());

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

#[test]
fn echo() {
    let mut output = VMTestCase::new()
        .input(StartMessage {
            id: Bytes::from_static(b"123"),
            debug_id: "123".to_string(),
            known_entries: 1,
            ..Default::default()
        })
        .input(input_entry_message(b"my-data"))
        .run(echo_handler);

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

#[test]
fn headers() {
    let mut output = VMTestCase::new()
        .input(StartMessage {
            id: Bytes::from_static(b"123"),
            debug_id: "123".to_string(),
            known_entries: 1,
            ..Default::default()
        })
        .input(InputCommandMessage {
            headers: vec![service_protocol::messages::Header {
                key: "x-my-header".to_owned(),
                value: "my-value".to_owned(),
            }],
            value: Some(Bytes::from_static(b"other-value").into()),
            ..InputCommandMessage::default()
        })
        .run(|vm| {
            assert2::assert!(let Input { headers, .. } = vm.sys_input().unwrap());

            assert_that!(
                headers,
                elements_are![eq(Header {
                    key: Cow::Borrowed("x-my-header"),
                    value: Cow::Borrowed("my-value"),
                })]
            );

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

    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 replay_output_too() {
    let mut output = VMTestCase::new()
        .input(StartMessage {
            id: Bytes::from_static(b"123"),
            debug_id: "123".to_string(),
            known_entries: 2,
            ..Default::default()
        })
        .input(input_entry_message(b"my-data"))
        .input(OutputCommandMessage {
            result: Some(output_command_message::Result::Value(
                Bytes::from_static(b"my-data").into(),
            )),
            ..OutputCommandMessage::default()
        })
        .run(echo_handler);

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