Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

32.6 KB
Raw Blame
use std::sync::Arc;

use crate::lsp_log_view::LogMenuItem;

use super::*;
use futures::StreamExt;
use gpui::{AppContext as _, TestAppContext, VisualContext as _, VisualTestContext};
use language::{
    FakeLspAdapter, Language, LanguageConfig, LanguageMatcher, LanguageServerId, tree_sitter_rust,
};
use lsp::LanguageServerName;
use project::{
    Event as ProjectEvent, FakeFs, Project,
    lsp_store::log_store::{LanguageServerKind, LanguageServerLogKey, LogKind, LogStore},
};
use proto::PeerId;
use serde_json::json;
use settings::SettingsStore;
use util::path;

#[gpui::test]
async fn test_lsp_log_view_filters_servers_from_other_projects(cx: &mut TestAppContext) {
    init_test(cx);

    let fs = FakeFs::new(cx.background_executor.clone());
    fs.insert_tree(path!("/current-project"), json!({ "test.rs": "" }))
        .await;
    fs.insert_tree(path!("/other-project"), json!({ "test.rs": "" }))
        .await;

    let project = Project::test(fs.clone(), [path!("/current-project").as_ref()], cx).await;
    let other_project = Project::test(fs.clone(), [path!("/other-project").as_ref()], cx).await;
    let worktree_id = project.read_with(cx, |project, cx| {
        project.worktrees(cx).next().unwrap().read(cx).id()
    });
    let current_lsp_store = project
        .read_with(cx, |project, _| project.lsp_store())
        .downgrade();
    let other_lsp_store = other_project
        .read_with(cx, |project, _| project.lsp_store())
        .downgrade();

    let current_ssh_server_id = LanguageServerId(99);
    let current_server_id = LanguageServerId(100);
    let log_store = cx.new(|cx| LogStore::new(false, cx));
    log_store.update(cx, |store, cx| {
        store.add_language_server(
            LanguageServerKind::LocalSsh {
                lsp_store: current_lsp_store,
            },
            current_ssh_server_id,
            Some(LanguageServerName::new_static("current-ssh-server")),
            Some(worktree_id),
            None,
            cx,
        );
        store.add_language_server(
            LanguageServerKind::Local {
                project: project.downgrade(),
            },
            current_server_id,
            Some(LanguageServerName::new_static("current-server")),
            Some(worktree_id),
            None,
            cx,
        );
        store.add_language_server(
            LanguageServerKind::Remote {
                project: other_project.downgrade(),
            },
            current_server_id,
            Some(LanguageServerName::new_static("other-remote-server")),
            None,
            None,
            cx,
        );
        store.add_language_server(
            LanguageServerKind::Supplementary {
                project: other_project.downgrade(),
            },
            current_server_id,
            Some(LanguageServerName::new_static("other-supplementary-server")),
            None,
            None,
            cx,
        );
        store.add_language_server(
            LanguageServerKind::LocalSsh {
                lsp_store: other_lsp_store,
            },
            current_ssh_server_id,
            Some(LanguageServerName::new_static("other-ssh-server")),
            None,
            None,
            cx,
        );
    });
    assert_eq!(
        log_store.read_with(cx, |store, _| store.language_servers.len()),
        5
    );

    let window =
        cx.add_window(|window, cx| LspLogView::new(project.clone(), log_store, window, cx));
    let log_view = window.root(cx).unwrap();
    let mut cx = VisualTestContext::from_window(*window, cx);

    log_view.update(&mut cx, |view, cx| {
        let visible_servers = view
            .menu_items(cx)
            .unwrap()
            .into_iter()
            .map(|item| (item.server_id, item.server_name))
            .collect::<Vec<_>>();
        assert_eq!(
            visible_servers,
            [
                (
                    current_ssh_server_id,
                    LanguageServerName::new_static("current-ssh-server"),
                ),
                (
                    current_server_id,
                    LanguageServerName::new_static("current-server"),
                ),
            ]
        );
    });
}

#[gpui::test]
async fn test_lsp_log_view_labels_registered_supplementary_servers(cx: &mut TestAppContext) {
    init_test(cx);

    let fs = FakeFs::new(cx.background_executor.clone());
    fs.insert_tree(path!("/the-root"), json!({ "test.rs": "" }))
        .await;
    let project = Project::test(fs, [path!("/the-root").as_ref()], cx).await;
    let lsp_store = project.read_with(cx, |project, _| project.lsp_store());
    let log_store = cx.new(|cx| LogStore::new(false, cx));
    log_store.update(cx, |store, cx| store.add_project(&project, cx));

    let server_id = LanguageServerId(100);
    let (server, _fake_server) = lsp::FakeLanguageServer::new(
        server_id,
        lsp::LanguageServerBinary {
            path: "path/to/prettier".into(),
            arguments: Vec::new(),
            env: None,
        },
        "prettier".to_string(),
        Default::default(),
        &mut cx.to_async(),
    );
    lsp_store.update(cx, |lsp_store, cx| {
        lsp_store.register_supplementary_language_server_for_test(
            server_id,
            LanguageServerName::new_static("prettier (default)"),
            Arc::new(server),
            cx,
        );
    });

    let window =
        cx.add_window(|window, cx| LspLogView::new(project.clone(), log_store, window, cx));
    let log_view = window.root(cx).unwrap();
    let mut cx = VisualTestContext::from_window(*window, cx);

    log_view.update(&mut cx, |view, cx| {
        assert_eq!(
            view.menu_items(cx).unwrap(),
            &[LogMenuItem {
                server_id,
                server_name: LanguageServerName::new_static("prettier (default)"),
                worktree_root_name: "supplementary".to_string(),
                rpc_trace_enabled: false,
                selected_entry: LogKind::Logs,
                trace_level: lsp::TraceValue::Off,
                server_kind: LanguageServerKind::Supplementary {
                    project: project.downgrade(),
                },
            }]
        );
    });

    lsp_store.update(&mut cx, |lsp_store, cx| {
        lsp_store.unregister_supplementary_language_server_for_test(server_id, cx);
    });
    log_view.update(&mut cx, |view, cx| {
        assert!(view.menu_items(cx).unwrap().is_empty());
    });
}

#[gpui::test]
async fn test_lsp_log_view_rpc_checkbox_tracks_view_ownership(cx: &mut TestAppContext) {
    init_test(cx);

    let fs = FakeFs::new(cx.background_executor.clone());
    fs.insert_tree(path!("/rpc-ownership"), json!({ "test.rs": "" }))
        .await;
    let project = Project::test(fs, [path!("/rpc-ownership").as_ref()], cx).await;
    let log_store = cx.new(|cx| LogStore::new(false, cx));
    let server_keys = [
        LanguageServerKind::Local {
            project: project.downgrade(),
        },
        LanguageServerKind::Supplementary {
            project: project.downgrade(),
        },
    ]
    .map(|kind| LanguageServerLogKey::new(kind, LanguageServerId(100)));
    log_store.update(cx, |store, cx| {
        store.add_project(&project, cx);
        for server_key in &server_keys {
            store.add_language_server(
                server_key.kind.clone(),
                server_key.server_id,
                Some(LanguageServerName::new_static("test-server")),
                None,
                None,
                cx,
            );
            assert_eq!(
                store.set_downstream_log_stream(
                    server_key,
                    PeerId { owner_id: 1, id: 1 },
                    LogKind::Rpc,
                    true,
                    cx,
                ),
                Some(())
            );
        }
    });

    let window =
        cx.add_window(|window, cx| LspLogView::new(project.clone(), log_store, window, cx));
    let log_view = window.root(cx).expect("log view should exist");
    let mut cx = VisualTestContext::from_window(*window, cx);
    log_view.update_in(&mut cx, |view, window, cx| {
        for enabled in [false, true] {
            if enabled {
                for server_key in &server_keys {
                    view.show_entry_for_test(server_key.clone(), LogKind::Rpc, window, cx);
                }
            }
            let menu_items = view.menu_items(cx).expect("server menu should exist");
            assert_eq!(menu_items.len(), server_keys.len());
            assert!(
                menu_items
                    .iter()
                    .all(|item| item.rpc_trace_enabled == enabled)
            );
        }
    });
}

async fn rpc_registration_fixture(
    cx: &mut TestAppContext,
) -> (
    Entity<Project>,
    Entity<LogStore>,
    LanguageServerLogKey,
    VisualTestContext,
) {
    let project = Project::test(FakeFs::new(cx.background_executor.clone()), [], cx).await;
    let log_store = cx.new(|cx| LogStore::new(false, cx));
    let key = LanguageServerLogKey::new(
        LanguageServerKind::Local {
            project: project.downgrade(),
        },
        LanguageServerId(100),
    );
    log_store.update(cx, |store, cx| {
        store.add_project(&project, cx);
        store.add_language_server(key.kind.clone(), key.server_id, None, None, None, cx);
    });
    let window = cx.add_window(|_, _| gpui::Empty);
    let cx = VisualTestContext::from_window(*window, cx);
    (project, log_store, key, cx)
}

fn assert_rpc_registration(
    log_store: &Entity<LogStore>,
    key: &LanguageServerLogKey,
    enabled: bool,
    cx: &VisualTestContext,
) {
    log_store.read_with(cx, |store, _| {
        assert_eq!(
            store
                .language_servers
                .get(key)
                .map(|state| state.rpc_state.is_some()),
            Some(enabled),
        );
    });
}

#[gpui::test]
async fn test_lsp_log_view_replacement_refreshes_rpc_ownership(cx: &mut TestAppContext) {
    init_test(cx);
    for (batched, active_entry) in [
        (false, LogKind::Logs),
        (true, LogKind::Logs),
        (false, LogKind::Rpc),
        (true, LogKind::Rpc),
    ] {
        let (project, log_store, key, mut cx) = rpc_registration_fixture(cx).await;
        let log_view = cx.new_window_entity(|window, cx| {
            LspLogView::new(project.clone(), log_store.clone(), window, cx)
        });
        cx.update(|window, cx| {
            log_view.update(cx, |view, cx| {
                view.show_entry_for_test(key.clone(), LogKind::Rpc, window, cx);
                view.show_entry_for_test(key.clone(), active_entry, window, cx);
                assert!(view.stream_enabled_for_test(&key, LogKind::Rpc));
            });
        });
        if !batched {
            log_store.update(&mut cx, |store, cx| store.remove_language_server(&key, cx));
            log_view.update(&mut cx, |view, cx| {
                assert!(!view.stream_enabled_for_test(&key, LogKind::Rpc));
                assert!(view.menu_items(cx).expect("server menu").is_empty());
            });
        }
        cx.update(|_, cx| {
            log_store.update(cx, |store, cx| {
                if batched {
                    store.remove_language_server(&key, cx);
                }
                store.add_language_server(key.kind.clone(), key.server_id, None, None, None, cx);
                store.add_language_server_log(&key, lsp::MessageType::LOG, "replacement log", cx);
            });
        });
        let rpc_is_visible = active_entry == LogKind::Rpc;
        assert_rpc_registration(&log_store, &key, rpc_is_visible, &cx);
        cx.update(|window, cx| {
            log_view.update(cx, |view, cx| {
                if active_entry == LogKind::Logs {
                    assert_eq!(view.editor.read(cx).text(cx), "replacement log\n");
                }
                assert_eq!(
                    view.stream_enabled_for_test(&key, LogKind::Rpc),
                    rpc_is_visible
                );
                let menu = view.menu_items(cx).expect("server menu");
                assert_eq!(menu.len(), 1);
                assert_eq!(
                    menu.first().expect("replacement server").rpc_trace_enabled,
                    rpc_is_visible
                );
                for _ in 0..2 {
                    view.show_entry_for_test(key.clone(), LogKind::Rpc, window, cx);
                    assert!(view.stream_enabled_for_test(&key, LogKind::Rpc));
                }
            });
        });
        assert_rpc_registration(&log_store, &key, true, &cx);
        cx.update(|_, _| drop(log_view));
        assert_rpc_registration(&log_store, &key, false, &cx);
    }
}

#[gpui::test]
async fn test_lsp_log_view_release_before_observer_preserves_replacement_rpc(
    cx: &mut TestAppContext,
) {
    init_test(cx);
    for reenable_old_owner in [false, true] {
        let (project, log_store, key, mut cx) = rpc_registration_fixture(cx).await;
        let mut new_view = || {
            cx.new_window_entity(|window, cx| {
                LspLogView::new(project.clone(), log_store.clone(), window, cx)
            })
        };
        let old_owner = new_view();
        let new_owner = new_view();
        cx.update(|window, cx| {
            old_owner.update(cx, |view, cx| {
                view.show_entry_for_test(key.clone(), LogKind::Rpc, window, cx);
            });
        });
        cx.update(|window, cx| {
            log_store.update(cx, |store, cx| {
                store.remove_language_server(&key, cx);
                store.add_language_server(key.kind.clone(), key.server_id, None, None, None, cx);
            });
            old_owner.update(cx, |view, cx| {
                let menu = view.menu_items(cx).expect("server menu");
                assert!(!menu.first().expect("replacement server").rpc_trace_enabled);
                if reenable_old_owner {
                    view.show_entry_for_test(key.clone(), LogKind::Rpc, window, cx);
                }
            });
            if reenable_old_owner {
                assert!(
                    log_store
                        .read(cx)
                        .language_servers
                        .get(&key)
                        .is_some_and(|state| state.rpc_state.is_some())
                );
            }
            new_owner.update(cx, |view, cx| {
                assert!(!view.stream_enabled_for_test(&key, LogKind::Rpc));
                view.show_entry_for_test(key.clone(), LogKind::Rpc, window, cx);
            });
            // Release runs before the coalesced notification can prune the old ownership.
            drop(old_owner);
        });
        assert_rpc_registration(&log_store, &key, true, &cx);
        cx.update(|_, _| drop(new_owner));
        assert_rpc_registration(&log_store, &key, false, &cx);
    }
}

#[gpui::test]
async fn test_log_store_does_not_retain_language_servers(cx: &mut TestAppContext) {
    init_test(cx);

    let fs = FakeFs::new(cx.background_executor.clone());
    fs.insert_tree(path!("/the-root"), json!({ "test.rs": "" }))
        .await;
    let project = Project::test(fs, [path!("/the-root").as_ref()], cx).await;
    let server_id = LanguageServerId(100);
    let server_kind = LanguageServerKind::Local {
        project: project.downgrade(),
    };
    let server_key = LanguageServerLogKey::new(server_kind.clone(), server_id);
    let log_store = cx.new(|cx| LogStore::new(false, cx));

    let (first_server, _first_fake_server) = lsp::FakeLanguageServer::new(
        server_id,
        lsp::LanguageServerBinary {
            path: "path/to/first-language-server".into(),
            arguments: Vec::new(),
            env: None,
        },
        "first-language-server".to_string(),
        Default::default(),
        &mut cx.to_async(),
    );
    let first_server = Arc::new(first_server);
    let first_server_weak = Arc::downgrade(&first_server);
    log_store.update(cx, |store, cx| {
        store.add_language_server(
            server_kind.clone(),
            server_id,
            Some(LanguageServerName::new_static("first-language-server")),
            None,
            Some(first_server.clone()),
            cx,
        );
    });

    let (replacement_server, _replacement_fake_server) = lsp::FakeLanguageServer::new(
        server_id,
        lsp::LanguageServerBinary {
            path: "path/to/replacement-language-server".into(),
            arguments: Vec::new(),
            env: None,
        },
        "replacement-language-server".to_string(),
        Default::default(),
        &mut cx.to_async(),
    );
    let replacement_server = Arc::new(replacement_server);
    let replacement_server_weak = Arc::downgrade(&replacement_server);
    log_store.update(cx, |store, cx| {
        store.add_language_server(
            server_kind,
            server_id,
            Some(LanguageServerName::new_static(
                "replacement-language-server",
            )),
            None,
            Some(replacement_server.clone()),
            cx,
        );
    });

    let stored_server = log_store
        .read_with(cx, |store, _| {
            store
                .language_servers
                .get(&server_key)
                .and_then(|state| state.server())
        })
        .expect("replacement language server should be available");
    assert!(Arc::ptr_eq(&stored_server, &replacement_server));
    drop(stored_server);

    drop(first_server);
    assert!(first_server_weak.upgrade().is_none());
    drop(replacement_server);
    assert!(replacement_server_weak.upgrade().is_none());
    assert!(
        log_store
            .read_with(cx, |store, _| store
                .language_servers
                .get(&server_key)
                .and_then(|state| state.server()))
            .is_none()
    );
}

#[gpui::test]
async fn test_log_store_removes_unavailable_copilot_server(cx: &mut TestAppContext) {
    init_test(cx);

    let fs = FakeFs::new(cx.background_executor.clone());
    fs.insert_tree(path!("/the-root"), json!({ "test.rs": "" }))
        .await;
    let project = Project::test(fs, [path!("/the-root").as_ref()], cx).await;
    let server_id = LanguageServerId(100);
    let server_kind = LanguageServerKind::Supplementary {
        project: project.downgrade(),
    };
    let server_key = LanguageServerLogKey::new(server_kind, server_id);
    let log_store = cx.new(|cx| LogStore::new(false, cx));
    log_store.update(cx, |log_store, cx| log_store.add_project(&project, cx));

    let (server, _fake_server) = lsp::FakeLanguageServer::new(
        server_id,
        lsp::LanguageServerBinary {
            path: "path/to/copilot-language-server".into(),
            arguments: Vec::new(),
            env: None,
        },
        "copilot".to_string(),
        Default::default(),
        &mut cx.to_async(),
    );
    log_store.update(cx, |log_store, cx| {
        log_store.sync_copilot_for_project(&project.downgrade(), Some(Arc::new(server)), cx);
    });
    assert!(log_store.read_with(cx, |log_store, _| {
        log_store.language_servers.contains_key(&server_key)
    }));

    log_store.update(cx, |log_store, cx| {
        log_store.sync_copilot_for_project(&project.downgrade(), None, cx);
    });
    assert!(!log_store.read_with(cx, |log_store, _| {
        log_store.language_servers.contains_key(&server_key)
    }));
}

#[gpui::test]
async fn test_local_views_and_downstream_peers_own_rpc_streams_independently(
    cx: &mut TestAppContext,
) {
    init_test(cx);

    let fs = FakeFs::new(cx.background_executor.clone());
    fs.insert_tree(path!("/stream-ownership"), json!({ "test.rs": "" }))
        .await;
    let project = Project::test(fs, [path!("/stream-ownership").as_ref()], cx).await;
    let server_id = LanguageServerId(100);
    let server_key = LanguageServerLogKey::new(
        LanguageServerKind::Local {
            project: project.downgrade(),
        },
        server_id,
    );
    let first_peer_id = PeerId { owner_id: 1, id: 1 };
    let second_peer_id = PeerId { owner_id: 2, id: 2 };
    let log_store = cx.new(|cx| LogStore::new(false, cx));

    log_store.update(cx, |store, cx| {
        store.add_project(&project, cx);
        store.add_language_server(
            server_key.kind.clone(),
            server_id,
            Some(LanguageServerName::new_static("test-server")),
            None,
            None,
            cx,
        );
    });

    for peer_id in [first_peer_id, second_peer_id] {
        project.update(cx, |_, cx| {
            cx.emit(ProjectEvent::ToggleLspLogs {
                peer_id,
                server_id,
                enabled: true,
                toggled_log_kind: LogKind::Rpc,
            });
        });
    }
    project.update(cx, |_, cx| {
        cx.emit(ProjectEvent::ToggleLspLogs {
            peer_id: first_peer_id,
            server_id,
            enabled: false,
            toggled_log_kind: LogKind::Rpc,
        });
    });
    assert!(log_store.read_with(cx, |store, _| {
        store
            .language_servers
            .get(&server_key)
            .is_some_and(|state| state.rpc_state.is_some())
    }));
    project.update(cx, |_, cx| {
        cx.emit(ProjectEvent::CollaboratorLeft(second_peer_id));
    });
    assert!(log_store.read_with(cx, |store, _| {
        store
            .language_servers
            .get(&server_key)
            .is_some_and(|state| state.rpc_state.is_none())
    }));

    project.update(cx, |_, cx| {
        cx.emit(ProjectEvent::ToggleLspLogs {
            peer_id: first_peer_id,
            server_id,
            enabled: true,
            toggled_log_kind: LogKind::Rpc,
        });
    });
    log_store.update(cx, |store, cx| {
        assert_eq!(
            store.retain_view_log_stream(&server_key, LogKind::Rpc, cx),
            Some(())
        );
        assert_eq!(
            store.release_view_log_stream(&server_key, LogKind::Rpc, cx),
            Some(())
        );
    });
    assert!(
        log_store.read_with(cx, |store, _| {
            store
                .language_servers
                .get(&server_key)
                .is_some_and(|state| state.rpc_state.is_some())
        }),
        "releasing the final local view must preserve a downstream peer's RPC stream"
    );
    project.update(cx, |_, cx| {
        cx.emit(ProjectEvent::ToggleLspLogs {
            peer_id: first_peer_id,
            server_id,
            enabled: false,
            toggled_log_kind: LogKind::Rpc,
        });
    });
    assert!(log_store.read_with(cx, |store, _| {
        store
            .language_servers
            .get(&server_key)
            .is_some_and(|state| state.rpc_state.is_none())
    }));

    log_store.update(cx, |store, cx| {
        assert_eq!(
            store.retain_view_log_stream(&server_key, LogKind::Rpc, cx),
            Some(())
        );
    });
    project.update(cx, |_, cx| {
        cx.emit(ProjectEvent::ToggleLspLogs {
            peer_id: first_peer_id,
            server_id,
            enabled: true,
            toggled_log_kind: LogKind::Rpc,
        });
        cx.emit(ProjectEvent::ToggleLspLogs {
            peer_id: first_peer_id,
            server_id,
            enabled: false,
            toggled_log_kind: LogKind::Rpc,
        });
    });
    assert!(
        log_store.read_with(cx, |store, _| {
            store
                .language_servers
                .get(&server_key)
                .is_some_and(|state| state.rpc_state.is_some())
        }),
        "disabling a downstream peer's RPC stream must preserve a local view's stream"
    );
    log_store.update(cx, |store, cx| {
        assert_eq!(
            store.release_view_log_stream(&server_key, LogKind::Rpc, cx),
            Some(())
        );
    });
    assert!(log_store.read_with(cx, |store, _| {
        store
            .language_servers
            .get(&server_key)
            .is_some_and(|state| state.rpc_state.is_none())
    }));

    project.update(cx, |_, cx| {
        cx.emit(ProjectEvent::ToggleLspLogs {
            peer_id: first_peer_id,
            server_id,
            enabled: true,
            toggled_log_kind: LogKind::Rpc,
        });
        cx.emit(ProjectEvent::CollaboratorUpdated {
            old_peer_id: first_peer_id,
            new_peer_id: second_peer_id,
        });
        cx.emit(ProjectEvent::ToggleLspLogs {
            peer_id: second_peer_id,
            server_id,
            enabled: false,
            toggled_log_kind: LogKind::Rpc,
        });
    });
    assert!(log_store.read_with(cx, |store, _| {
        store
            .language_servers
            .get(&server_key)
            .is_some_and(|state| state.rpc_state.is_none())
    }));
}

#[gpui::test]
async fn test_unsharing_releases_only_project_downstream_rpc_streams(cx: &mut TestAppContext) {
    init_test(cx);

    let fs = FakeFs::new(cx.background_executor.clone());
    let project = Project::test(fs.clone(), [], cx).await;
    let other_project = Project::test(fs, [], cx).await;
    let server_keys = [
        (project.downgrade(), LanguageServerId(100)),
        (project.downgrade(), LanguageServerId(101)),
        (other_project.downgrade(), LanguageServerId(100)),
    ]
    .map(|(project, server_id)| {
        LanguageServerLogKey::new(LanguageServerKind::Local { project }, server_id)
    });
    let [_, local_view_key, _] = &server_keys;
    let log_store = cx.new(|cx| LogStore::new(false, cx));
    log_store.update(cx, |store, cx| {
        store.add_project(&project, cx);
        store.add_project(&other_project, cx);
        for server_key in &server_keys {
            store.add_language_server(
                server_key.kind.clone(),
                server_key.server_id,
                None,
                None,
                None,
                cx,
            );
            for peer_id in [PeerId { owner_id: 1, id: 1 }, PeerId { owner_id: 2, id: 2 }] {
                store.set_downstream_log_stream(server_key, peer_id, LogKind::Rpc, true, cx);
            }
        }
        store.retain_view_log_stream(local_view_key, LogKind::Rpc, cx);
    });

    project
        .update(cx, |project, cx| project.shared(1, cx))
        .expect("project should be shareable");
    project
        .update(cx, |project, cx| project.unshare(cx))
        .expect("shared project should unshare");

    log_store.update(cx, |store, cx| {
        for (server_key, rpc_enabled) in server_keys.iter().zip([false, true, true]) {
            assert_eq!(
                store
                    .language_servers
                    .get(server_key)
                    .map(|state| state.rpc_state.is_some()),
                Some(rpc_enabled),
                "unsharing must preserve local views and other projects"
            );
        }
        store.release_view_log_stream(local_view_key, LogKind::Rpc, cx);
        assert!(
            store
                .language_servers
                .get(local_view_key)
                .is_some_and(|state| state.rpc_state.is_none()),
            "unsharing must release every downstream peer even while a local view owns the stream"
        );
    });
}

#[gpui::test]
async fn test_lsp_log_view(cx: &mut TestAppContext) {
    zlog::init_test();

    init_test(cx);

    let fs = FakeFs::new(cx.background_executor.clone());
    fs.insert_tree(
        path!("/the-root"),
        json!({
            "test.rs": "",
            "package.json": "",
        }),
    )
    .await;

    let project = Project::test(fs.clone(), [path!("/the-root").as_ref()], cx).await;

    let language_registry = project.read_with(cx, |project, _| project.languages().clone());
    language_registry.add(Arc::new(Language::new(
        LanguageConfig {
            name: "Rust".into(),
            matcher: (LanguageMatcher {
                path_suffixes: vec!["rs".into()],
                ..Default::default()
            })
            .into(),
            ..Default::default()
        },
        Some(tree_sitter_rust::LANGUAGE.into()),
    )));
    let mut fake_rust_servers = language_registry.register_fake_lsp(
        "Rust",
        FakeLspAdapter {
            name: "the-rust-language-server",
            ..Default::default()
        },
    );

    let log_store = cx.new(|cx| LogStore::new(false, cx));
    log_store.update(cx, |store, cx| store.add_project(&project, cx));

    let _rust_buffer = project
        .update(cx, |project, cx| {
            project.open_local_buffer_with_lsp(path!("/the-root/test.rs"), cx)
        })
        .await
        .unwrap();

    let mut language_server = fake_rust_servers.next().await.unwrap();
    language_server
        .receive_notification::<lsp::notification::DidOpenTextDocument>()
        .await;
    let server_key = LanguageServerLogKey::new(
        LanguageServerKind::Local {
            project: project.downgrade(),
        },
        language_server.server.server_id(),
    );
    let unavailable_server_key = LanguageServerLogKey::new(
        LanguageServerKind::Local {
            project: project.downgrade(),
        },
        LanguageServerId(999),
    );

    let window =
        cx.add_window(|window, cx| LspLogView::new(project.clone(), log_store.clone(), window, cx));
    let log_view = window.root(cx).unwrap();
    let mut cx = VisualTestContext::from_window(*window, cx);

    language_server.notify::<lsp::notification::LogMessage>(lsp::LogMessageParams {
        message: "hello from the server".into(),
        typ: lsp::MessageType::INFO,
    });
    cx.executor().run_until_parked();

    log_view.update(&mut cx, |view, cx| {
        assert_eq!(
            view.menu_items(cx).unwrap(),
            &[LogMenuItem {
                server_id: language_server.server.server_id(),
                server_name: LanguageServerName("the-rust-language-server".into()),
                worktree_root_name: project
                    .read(cx)
                    .worktrees(cx)
                    .next()
                    .unwrap()
                    .read(cx)
                    .root_name_str()
                    .to_string(),
                rpc_trace_enabled: false,
                selected_entry: LogKind::Logs,
                trace_level: lsp::TraceValue::Off,
                server_kind: LanguageServerKind::Local {
                    project: project.downgrade()
                }
            }]
        );
        assert_eq!(view.editor.read(cx).text(cx), "hello from the server\n");
    });

    log_view.update_in(&mut cx, |view, window, cx| {
        assert!(view.stream_enabled_for_test(&server_key, LogKind::Logs));

        view.show_entry_for_test(server_key.clone(), LogKind::Trace, window, cx);
        assert!(!view.stream_enabled_for_test(&server_key, LogKind::Logs));
        assert!(view.stream_enabled_for_test(&server_key, LogKind::Trace));

        view.show_entry_for_test(server_key.clone(), LogKind::Rpc, window, cx);
        assert!(!view.stream_enabled_for_test(&server_key, LogKind::Logs));
        assert!(!view.stream_enabled_for_test(&server_key, LogKind::Trace));
        assert!(view.stream_enabled_for_test(&server_key, LogKind::Rpc));

        view.show_entry_for_test(server_key.clone(), LogKind::Logs, window, cx);
        assert!(view.stream_enabled_for_test(&server_key, LogKind::Logs));
        assert!(!view.stream_enabled_for_test(&server_key, LogKind::Trace));
        assert!(view.stream_enabled_for_test(&server_key, LogKind::Rpc));

        view.show_entry_for_test(server_key.clone(), LogKind::Trace, window, cx);
        assert!(!view.stream_enabled_for_test(&server_key, LogKind::Logs));
        assert!(view.stream_enabled_for_test(&server_key, LogKind::Trace));
        assert!(view.stream_enabled_for_test(&server_key, LogKind::Rpc));

        view.show_entry_for_test(server_key.clone(), LogKind::ServerInfo, window, cx);
        assert!(!view.stream_enabled_for_test(&server_key, LogKind::Logs));
        assert!(!view.stream_enabled_for_test(&server_key, LogKind::Trace));
        assert!(view.stream_enabled_for_test(&server_key, LogKind::Rpc));

        view.show_entry_for_test(server_key.clone(), LogKind::Logs, window, cx);
        view.show_entry_for_test(unavailable_server_key.clone(), LogKind::Logs, window, cx);
        assert!(view.stream_enabled_for_test(&server_key, LogKind::Logs));
        assert!(!view.stream_enabled_for_test(&unavailable_server_key, LogKind::Logs));
        assert!(view.stream_enabled_for_test(&server_key, LogKind::Rpc));

        view.show_entry_for_test(unavailable_server_key.clone(), LogKind::Rpc, window, cx);
        assert!(view.stream_enabled_for_test(&server_key, LogKind::Logs));
        assert!(!view.stream_enabled_for_test(&unavailable_server_key, LogKind::Rpc));
        assert!(view.stream_enabled_for_test(&server_key, LogKind::Rpc));
    });
}

fn init_test(cx: &mut gpui::TestAppContext) {
    cx.update(|cx| {
        let settings_store = SettingsStore::test(cx);
        cx.set_global(settings_store);
        theme_settings::init(theme::LoadThemes::JustBase, cx);
        release_channel::init(semver::Version::new(0, 0, 0), cx);
    });
}