lspz 0.11.0

AI-friendly LSP compression proxy
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
123
124
125
126
127
128
129
130
131
132
133
134

//! Integration tests for lspz daemon — verifies session reuse.
//!
//! These tests exercise the real daemon server and client over a Unix socket.
//! They require the `mcp` feature.

#[cfg(feature = "mcp")]
mod mcp_tests {
    use std::path::PathBuf;
    use std::time::Duration;

    use lspz::daemon::protocol::{DaemonRequest, DaemonResponse};
    use lspz::daemon::{DaemonServer, socket_path_for_workspace};
    use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
    use tokio::net::UnixStream;

    /// Two connections to the same daemon share the same LSP session.
    ///
    /// This test verifies the session reuse logic at the daemon protocol level:
    /// calling lsp/spawn twice with identical params returns the same session_key.
    #[tokio::test]
    async fn test_daemon_session_reuse() {
        let test_id = format!("lspz-test-reuse-{}", std::process::id());
        let socket_path = PathBuf::from(format!("/tmp/{test_id}.sock"));

        let server = DaemonServer::new(socket_path.clone());
        let daemon_handle = tokio::spawn(async move {
            let _ = server.start().await;
        });
        tokio::time::sleep(Duration::from_millis(300)).await;

        async fn send_spawn(
            socket: &PathBuf,
            id: u64,
            lang: &str,
            backend: &str,
        ) -> DaemonResponse {
            let mut stream = UnixStream::connect(socket).await.unwrap();
            let req = DaemonRequest {
                id,
                method: "lsp/spawn".into(),
                params: serde_json::json!({
                    "language": lang,
                    "backend": backend,
                    "root_path": "/tmp/lspz-test-workspace",
                }),
            };
            stream
                .write_all(format!("{}\n", serde_json::to_string(&req).unwrap()).as_bytes())
                .await
                .unwrap();
            stream.flush().await.unwrap();

            let mut buf_reader = BufReader::new(&mut stream);
            let mut line = String::new();
            tokio::time::timeout(Duration::from_secs(3), buf_reader.read_line(&mut line))
                .await
                .unwrap()
                .unwrap();
            serde_json::from_str(line.trim()).unwrap()
        }

        // First spawn — will fail because echo is not an LSP server,
        // but the test verifies protocol integrity.
        let resp1 = send_spawn(&socket_path, 1, "rust", "echo").await;
        // Second spawn — same params.
        let resp2 = send_spawn(&socket_path, 2, "rust", "echo").await;

        assert_eq!(resp1.error, resp2.error);
        if resp1.error.is_none() {
            assert_eq!(resp1.result["session_key"], resp2.result["session_key"]);
        }

        daemon_handle.abort();
        let _ = std::fs::remove_file(&socket_path);
    }

    /// Socket path is deterministic for a given workspace.
    #[test]
    fn test_socket_path_deterministic() {
        let a = socket_path_for_workspace("/home/user/my-project");
        let b = socket_path_for_workspace("/home/user/my-project");
        assert_eq!(a, b);
    }

    /// Different workspaces produce different socket paths.
    #[test]
    fn test_socket_path_different_workspaces() {
        let a = socket_path_for_workspace("/home/user/project-a");
        let b = socket_path_for_workspace("/home/user/project-b");
        assert_ne!(a, b);
    }

    /// Daemon responds with error for unknown method.
    #[tokio::test]
    async fn test_daemon_unknown_method() {
        let test_id = format!("lspz-test-unknown-{}", std::process::id());
        let socket_path = PathBuf::from(format!("/tmp/{test_id}.sock"));

        let server = DaemonServer::new(socket_path.clone());
        let daemon_handle = tokio::spawn(async move {
            let _ = server.start().await;
        });
        tokio::time::sleep(Duration::from_millis(300)).await;

        let mut stream = UnixStream::connect(&socket_path).await.unwrap();
        let req = DaemonRequest {
            id: 1,
            method: "nonexistent/method".into(),
            params: serde_json::Value::Null,
        };
        stream
            .write_all(format!("{}\n", serde_json::to_string(&req).unwrap()).as_bytes())
            .await
            .unwrap();
        stream.flush().await.unwrap();

        let mut buf_reader = BufReader::new(&mut stream);
        let mut line = String::new();
        tokio::time::timeout(Duration::from_secs(3), buf_reader.read_line(&mut line))
            .await
            .unwrap()
            .unwrap();

        let resp: DaemonResponse = serde_json::from_str(line.trim()).unwrap();
        assert!(
            resp.error.is_some(),
            "Expected error for unknown method, got: {resp:?}"
        );
        assert!(resp.error.unwrap().contains("Unknown method"));

        daemon_handle.abort();
        let _ = std::fs::remove_file(&socket_path);
    }
}