Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
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);
});
}