lsp-max 26.7.3

Law-state LSP runtime: max LSP 3.18 coverage, process-mining conformance, receipt-chain admission
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

use std::future::Future;

use crate::jsonrpc::Request;
use futures::stream::StreamExt;
use lsp_types_max::notification::{
    LogMessage, LogTrace, PublishDiagnostics, ShowMessage, TelemetryEvent,
};
use lsp_types_max::*;
use serde_json::json;

use super::*;

async fn assert_client_message<F, Fut>(f: F, expected: Request)
where
    F: FnOnce(Client) -> Fut,
    Fut: Future,
{
    let state = Arc::new(ServerState::new());
    state.set(State::Initialized);

    let (client, socket) = Client::new(state);
    f(client).await;

    let messages: Vec<_> = socket.collect().await;
    assert_eq!(messages, vec![expected]);
}

#[tokio::test(flavor = "current_thread")]
async fn log_message() {
    let (typ, msg) = (MessageType::LOG, "foo bar".to_owned());
    let expected = Request::from_notification::<LogMessage>(LogMessageParams {
        typ,
        message: msg.clone(),
    });

    assert_client_message(|p| async move { p.log_message(typ, msg).await }, expected).await;
}

#[tokio::test(flavor = "current_thread")]
async fn log_trace() {
    let params = LogTraceParams {
        message: "foo bar".to_owned(),
        verbose: Some("verbose info".to_owned()),
    };
    let expected = Request::from_notification::<LogTrace>(params.clone());

    assert_client_message(|p| async move { p.log_trace(params).await }, expected).await;
}

#[tokio::test(flavor = "current_thread")]
async fn show_message() {
    let (typ, msg) = (MessageType::LOG, "foo bar".to_owned());
    let expected = Request::from_notification::<ShowMessage>(ShowMessageParams {
        typ,
        message: msg.clone(),
    });

    assert_client_message(|p| async move { p.show_message(typ, msg).await }, expected).await;
}

#[tokio::test(flavor = "current_thread")]
async fn telemetry_event() {
    let null = json!(null);
    let expected = Request::from_notification::<TelemetryEvent>(OneOf::Right(Vec::new()));
    assert_client_message(|p| async move { p.telemetry_event(null).await }, expected).await;

    let array = json!([1, 2, 3]);
    let expected = Request::from_notification::<TelemetryEvent>(OneOf::Right(vec![
        1.into(),
        2.into(),
        3.into(),
    ]));
    assert_client_message(|p| async move { p.telemetry_event(array).await }, expected).await;

    let object = json!({});
    let expected =
        Request::from_notification::<TelemetryEvent>(OneOf::Left(serde_json::Map::new()));
    assert_client_message(|p| async move { p.telemetry_event(object).await }, expected).await;

    let other = json!("hello");
    let expected = Request::from_notification::<TelemetryEvent>(OneOf::Right(vec![other.clone()]));
    assert_client_message(|p| async move { p.telemetry_event(other).await }, expected).await;
}

#[tokio::test(flavor = "current_thread")]
async fn publish_diagnostics() {
    let uri: Uri = "file:///path/to/file".parse().unwrap();
    let diagnostics = vec![Diagnostic::new_simple(Default::default(), "example".into())];

    let params = PublishDiagnosticsParams::new(uri.clone(), diagnostics.clone(), None);
    let expected = Request::from_notification::<PublishDiagnostics>(params);

    assert_client_message(
        |p| async move { p.publish_diagnostics(uri, diagnostics, None).await },
        expected,
    )
    .await;
}