carapax 0.36.0

A Telegram Bot Framework
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
115
116
117
118
119

use std::{convert::Infallible, sync::Arc};

use seance::Session;
use serde::{Deserialize, Serialize};
use tempfile::tempdir;

use crate::{
    core::{Chain, Context, Handler, HandlerInput, PredicateOutput, TryFromInput},
    session::{SessionManager, backend::fs::FilesystemBackend},
    types::Text,
};

use super::*;

#[derive(Clone, Copy, Default, Deserialize, Serialize)]
enum State {
    #[default]
    Start,
    Step,
}

impl DialogueState for State {
    fn dialogue_name() -> &'static str {
        "test"
    }
}

type InputMock = DialogueInput<State, FilesystemBackend>;

async fn dialogue_predicate(text: Text) -> bool {
    text.data == "start"
}

async fn dialogue_handler(input: InputMock) -> Result<DialogueResult<State>, Infallible> {
    Ok(match input.state {
        State::Start => State::Step.into(),
        State::Step => DialogueResult::Exit,
    })
}

fn create_input(context: Arc<Context>, text: &str) -> HandlerInput {
    let update = serde_json::from_value(serde_json::json!({
        "update_id": 1,
        "message": {
            "message_id": 1111,
            "date": 0,
            "from": {"id": 1, "is_bot": false, "first_name": "test"},
            "chat": {"id": 1, "type": "private", "first_name": "test"},
            "text": text
        }
    }))
    .unwrap();
    HandlerInput { context, update }
}

fn create_context() -> Arc<Context> {
    let tmpdir = tempdir().expect("Failed to create temp directory");
    let backend = FilesystemBackend::new(tmpdir.path());
    let mut context = Context::default();
    let session_manager = SessionManager::new(backend);
    context.insert(session_manager);
    Arc::new(context)
}

async fn get_session(input: HandlerInput) -> Session<FilesystemBackend> {
    <Session<FilesystemBackend>>::try_from_input(input.clone())
        .await
        .expect("Failed to get session")
        .expect("Session is None")
}

#[tokio::test]
async fn dialogue() {
    let context = create_context();
    let handler = dialogue_handler.with_dialogue::<FilesystemBackend>(dialogue_predicate);

    let input = create_input(context.clone(), "start");

    let session = &mut get_session(input.clone()).await;
    let session_key = State::session_key();

    assert!(matches!(
        handler.handle((input.clone(), input)).await,
        PredicateOutput::True(Ok(()))
    ));
    let state: Option<State> = session.get(&session_key).await.expect("Failed to get state");
    assert!(matches!(state, Some(State::Step)));

    let input = create_input(context.clone(), "step");
    assert!(matches!(
        handler.handle((input.clone(), input)).await,
        PredicateOutput::True(Ok(()))
    ));
    let state: Option<State> = session.get(&session_key).await.expect("Failed to get state");
    assert!(state.is_none());
}

async fn skip_handler(mut session: Session<FilesystemBackend>) {
    session
        .set("is_skipped", &true)
        .await
        .expect("Failed to set is_skipped key")
}

#[tokio::test]
async fn dialogue_in_chain_skipped() {
    let context = create_context();
    let handler = dialogue_handler.with_dialogue::<FilesystemBackend>(dialogue_predicate);
    let chain = Chain::once().with(handler).with(skip_handler);
    let input = create_input(context.clone(), "skipped");
    let mut session = get_session(input.clone()).await;
    chain.handle(input).await.expect("Failed to run chain handler");
    let is_skipped: bool = session
        .get("is_skipped")
        .await
        .expect("Failed to get is_skipped key")
        .expect("is_skipped key is not set");
    assert!(is_skipped);
}