teamtalk 6.0.0

TeamTalk SDK for Rust
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

#![cfg(all(feature = "bot-serde", feature = "mock"))]

use std::sync::Arc;
use teamtalk::client::backend::MockBackend;
use teamtalk::events::Event;
use teamtalk::mock::MockMessage;
use teamtalk::types::{ChannelId, UserId};
use teamtalk::{Client, Context, MemoryStateStore};
use teamtalk_sys::TextMsgType;

#[derive(Debug, Clone, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
struct JsonState {
    name: String,
    count: u32,
}

fn make_context<'a>(
    client: &'a Client,
    message: &'a teamtalk::Message,
    store: &'a mut MemoryStateStore,
) -> Context<'a> {
    Context {
        client,
        event: Event::TextMessage,
        message,
        command: None,
        state: store,
    }
}

fn text_message(text: &str) -> teamtalk::Message {
    MockMessage::text(
        TextMsgType::MSGTYPE_USER,
        UserId(7),
        UserId(1),
        ChannelId(0),
        "alice",
        text,
    )
}

#[test]
fn context_json_helpers_roundtrip_across_scopes() {
    let backend = Arc::new(MockBackend::new());
    let client = Client::with_backend(backend).expect("mock client");
    let message = text_message("hello");
    let mut store = MemoryStateStore::new();
    let mut ctx = make_context(&client, &message, &mut store);

    let state = JsonState {
        name: "alice".to_owned(),
        count: 2,
    };

    ctx.state_set_json("plain", &state).expect("plain json");
    ctx.user_state_set_json("profile", &state)
        .expect("user json");
    ctx.global_state_set_json("config", &state)
        .expect("global json");
    ctx.dialog_start("wizard", "step1");
    ctx.dialog_state_set_json("payload", &state)
        .expect("dialog json write");

    assert_eq!(
        ctx.state_get_json::<JsonState>("plain")
            .expect("plain json read"),
        Some(state.clone())
    );
    assert_eq!(
        ctx.state_get_json_or_default::<JsonState>("missing")
            .expect("plain json default"),
        JsonState::default()
    );
    assert_eq!(
        ctx.user_state_get_json::<JsonState>("profile")
            .expect("user json read"),
        Some(state.clone())
    );
    assert_eq!(
        ctx.user_state_get_json_or_default::<JsonState>("missing")
            .expect("user json default"),
        JsonState::default()
    );
    assert_eq!(
        ctx.global_state_get_json::<JsonState>("config")
            .expect("global json read"),
        Some(state.clone())
    );
    assert_eq!(
        ctx.global_state_get_json_or_default::<JsonState>("missing")
            .expect("global json default"),
        JsonState::default()
    );
    assert_eq!(
        ctx.dialog_state_get_json::<JsonState>("payload")
            .expect("dialog json read"),
        Some(state)
    );
    assert_eq!(
        ctx.dialog_state_get_json_or_default::<JsonState>("missing")
            .expect("dialog json default"),
        JsonState::default()
    );
}