telltale-runtime 17.0.0

Choreographic programming for Telltale - effect-based distributed protocols
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

// Unit tests for effects code generation.
use super::*;
use crate::ast::{Annotations, MessageType, Protocol, Role};

#[test]
fn test_generate_simple_protocol() {
    let choreography = Choreography {
        name: format_ident!("SimpleProtocol"),
        namespace: None,
        roles: vec![
            Role::new(format_ident!("Client")).expect("valid role"),
            Role::new(format_ident!("Server")).expect("valid role"),
        ],
        protocol: Protocol::End,
        attrs: std::collections::HashMap::new(),
    };

    let code = generate_effects_protocol(&choreography);
    let code_str = code.to_string();

    assert!(code_str.contains("enum Role"));
    assert!(code_str.contains("Client"));
    assert!(code_str.contains("Server"));
    assert!(code_str.contains("run_client"));
    assert!(code_str.contains("run_server"));
}

#[test]
fn test_message_codegen_is_deterministic_and_sorted() {
    let alice = Role::new(format_ident!("Alice")).expect("valid role");
    let bob = Role::new(format_ident!("Bob")).expect("valid role");

    let protocol = Protocol::Send {
        from: alice.clone(),
        to: bob.clone(),
        message: MessageType {
            name: format_ident!("Zeta"),
            type_annotation: None,
            payload: None,
        },
        continuation: Box::new(Protocol::Send {
            from: alice,
            to: bob,
            message: MessageType {
                name: format_ident!("Alpha"),
                type_annotation: None,
                payload: None,
            },
            continuation: Box::new(Protocol::End),
            annotations: Annotations::new(),
            from_annotations: Annotations::new(),
            to_annotations: Annotations::new(),
        }),
        annotations: Annotations::new(),
        from_annotations: Annotations::new(),
        to_annotations: Annotations::new(),
    };

    let code = protocol_types::generate_message_types(&protocol).to_string();
    let alpha_idx = code.find("struct Alpha").expect("find Alpha type");
    let zeta_idx = code.find("struct Zeta").expect("find Zeta type");
    assert!(alpha_idx < zeta_idx);
}