anytype 0.3.2

An ergonomic Anytype API client in 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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#![cfg(feature = "grpc")]

use std::net::SocketAddr;

use anytype::prelude::*;
use chrono::Utc;
use tokio::{
    net::TcpStream,
    time::{Duration, sleep},
};

#[tokio::test]
async fn test_chat_message_crud() -> anyhow::Result<()> {
    let temp_path = std::env::temp_dir().join(format!(
        "anytype_chat_test_{}.db",
        Utc::now().timestamp_nanos_opt().unwrap_or_default()
    ));
    let listener = std::net::TcpListener::bind("127.0.0.1:0")?;
    let addr = listener.local_addr()?;
    drop(listener);

    let handle = anytype::mock::MockChatServer::start(addr)?;
    wait_for_server(addr).await?;

    let mut config = ClientConfig::default().app_name("anytype-chat-test");
    config.keystore = Some(format!("file:path={}", temp_path.display()));
    config.keystore_service = Some("anytype-chat-test".to_string());
    config.grpc_endpoint = Some(format!("http://{}", addr));

    let client = AnytypeClient::with_config(config)?;
    let keystore = client.get_key_store();
    keystore.update_grpc_credentials(&GrpcCredentials::from_token("token-alice"))?;

    let chat_id = "chat-default";
    let message_id = client
        .chats()
        .add_message(chat_id)
        .content(MessageContent {
            text: "hello".to_string(),
            style: MessageTextStyle::Paragraph,
            marks: Vec::new(),
        })
        .send()
        .await?;

    let page = client.chats().list_messages(chat_id).list_page().await?;
    assert!(page.messages.iter().any(|msg| msg.id == message_id));

    client
        .chats()
        .edit_message(chat_id, &message_id)
        .content(MessageContent {
            text: "updated".to_string(),
            style: MessageTextStyle::Paragraph,
            marks: Vec::new(),
        })
        .send()
        .await?;

    let messages = client
        .chats()
        .get_messages(chat_id, [&message_id])
        .get()
        .await?;
    assert_eq!(messages[0].content.text, "updated");

    client
        .chats()
        .read_messages(chat_id)
        .read_type(ChatReadType::Messages)
        .mark_read()
        .await?;

    let page = client
        .chats()
        .list_messages(chat_id)
        .unread_only(ChatReadType::Messages)
        .list_page()
        .await?;
    assert!(
        page.messages.is_empty(),
        "expected no unread messages after mark_read"
    );

    client
        .chats()
        .unread_messages(chat_id)
        .read_type(ChatReadType::Messages)
        .after("0000000000000000")
        .mark_unread()
        .await?;

    let page = client
        .chats()
        .list_messages(chat_id)
        .unread_only(ChatReadType::Messages)
        .list_page()
        .await?;
    assert!(
        page.messages.iter().any(|msg| msg.id == message_id),
        "expected message to be marked unread"
    );

    client
        .chats()
        .delete_message(chat_id, &message_id)
        .delete()
        .await?;

    handle.shutdown().await;
    Ok(())
}

async fn wait_for_server(addr: SocketAddr) -> anyhow::Result<()> {
    for _ in 0..20 {
        if TcpStream::connect(addr).await.is_ok() {
            return Ok(());
        }
        sleep(Duration::from_millis(50)).await;
    }
    anyhow::bail!("mock server failed to start on {addr}");
}