Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
use crate::{
Event, ExtensionIndex, ExtensionIndexEntry, ExtensionIndexLanguageEntry,
ExtensionIndexThemeEntry, ExtensionManifest, ExtensionStore, GrammarManifestEntry,
MAX_REMOTE_SYNC_ATTEMPTS, MAX_REMOTE_SYNC_RETRY_DELAY, RELOAD_DEBOUNCE_DURATION,
REMOTE_SYNC_TIMEOUT, SchemaVersion,
headless_host::{
ExtensionVersion, HeadlessExtensionStore, LoadedExtension, STALE_UPLOAD_TTL,
hash_directory_contents, remove_stale_uploads,
},
load_plugin_queries, remote_sync_retry_delay,
};
use async_compression::futures::bufread::GzipEncoder;
use async_trait::async_trait;
use client::{AnyProtoClient, TypedEnvelope, proto};
use collections::{BTreeMap, HashMap, HashSet};
use extension::{
BuildTaskTemplate, CodeLabel, Command, Completion, ContextServerConfiguration,
DebugAdapterBinary, DebugRequest, DebugScenario, DebugTaskDefinition, Extension,
ExtensionHostProxy, KeyValueStoreDelegate, LibManifestEntry, ProjectDelegate, SlashCommand,
SlashCommandArgumentCompletion, SlashCommandOutput, StartDebuggingRequestArgumentsRequest,
Symbol, WorktreeDelegate,
};
use fs::{FakeFs, Fs, RealFs, RemoveOptions};
use futures::{AsyncReadExt, FutureExt, StreamExt, io::BufReader};
use gpui::{
AppContext as _, BackgroundExecutor, BorrowAppContext as _, Entity, EntityId, TaskExt,
TestAppContext,
};
use http_client::{FakeHttpClient, Response};
use language::{
BinaryStatus, LanguageConfig, LanguageMatcher, LanguageName, LanguageRegistry, QueryFiles,
};
use language_extension::LspAccess;
use lsp::LanguageServerName;
use node_runtime::NodeRuntime;
use parking_lot::Mutex;
use project::{DEFAULT_COMPLETION_CONTEXT, Project};
use release_channel::AppVersion;
use remote::{ConnectionState, RemoteClient, RemoteClientEvent, RemoteConnectionOptions};
use reqwest_client::ReqwestClient;
use serde_json::json;
use settings::SettingsStore;
use std::{
ffi::OsString,
path::{Path, PathBuf},
sync::{
Arc,
atomic::{AtomicUsize, Ordering},
},
time::{Duration, SystemTime},
};
use task::{SpawnInTerminal, ZedDebugConfig};
use theme::ThemeRegistry;
use util::{rel_path::rel_path_buf, test::TempTree};
#[cfg(test)]
#[ctor::ctor(unsafe)]
fn init_logger() {
zlog::init_test();
}
#[gpui::test]
async fn test_load_plugin_queries(executor: BackgroundExecutor) {
let fs = FakeFs::new(executor);
fs.insert_tree(
"/queries",
json!({
"highlights.scm": "highlight query",
"outline.scm": "outline query",
"highlights_extra.scm": "ignored query",
"locals.scm": "unrelated query",
}),
)
.await;
let queries = load_plugin_queries(
fs.clone(),
Path::new("/queries"),
Some(QueryFiles::HIGHLIGHTS),
)
.await;
assert_eq!(queries.highlights.as_deref(), Some("highlight query"));
assert!(queries.outline.is_none());
assert!(queries.brackets.is_none());
let queries = load_plugin_queries(fs, Path::new("/queries"), None).await;
assert_eq!(queries.highlights.as_deref(), Some("highlight query"));
assert_eq!(queries.outline.as_deref(), Some("outline query"));
assert!(queries.brackets.is_none());
}
fn remote_sync_entry(id: &str, manifest_body: &str) -> ExtensionIndexEntry {
let manifest = format!(
r#"
id = "{id}"
name = "{id}"
version = "1.0.0"
schema_version = 0
{manifest_body}
"#
);
ExtensionIndexEntry {
manifest: Arc::new(toml::from_str(&manifest).unwrap()),
dev: false,
}
}
fn remote_sync_language_entry(extension: &str, path: &str) -> ExtensionIndexLanguageEntry {
ExtensionIndexLanguageEntry {
extension: extension.into(),
path: path.into(),
matcher: LanguageMatcher::default().into(),
hidden: false,
grammar: None,
query_files: None,
}
}
fn remote_sync_extension_ids(index: &ExtensionIndex) -> Vec<String> {
let mut extensions = index
.extensions_to_sync_to_remote()
.into_entries()
.map(|(id, _)| id.to_string())
.collect::<Vec<_>>();
extensions.sort();
extensions
}
#[test]
fn remote_sync_includes_language_dependencies() {
let index = ExtensionIndex {
extensions: [
(
"bar-language".into(),
remote_sync_entry("bar-language", r#"languages = ["languages/bar"]"#),
),
(
"foo-lsp".into(),
remote_sync_entry(
"foo-lsp",
r#"
[language_servers.foo]
language = "Foo"
"#,
),
),
(
"foo-language".into(),
remote_sync_entry("foo-language", r#"languages = ["languages/foo"]"#),
),
]
.into_iter()
.collect(),
languages: [
(
"Bar".into(),
remote_sync_language_entry("bar-language", "languages/bar"),
),
(
"Foo".into(),
remote_sync_language_entry("foo-language", "languages/foo"),
),
]
.into_iter()
.collect(),
themes: BTreeMap::default(),
icon_themes: BTreeMap::default(),
};
assert_eq!(
remote_sync_extension_ids(&index),
["foo-language", "foo-lsp"]
);
}
#[test]
fn remote_sync_keeps_shared_language_dependency_once() {
let index = ExtensionIndex {
extensions: [
(
"aaa-lsp".into(),
remote_sync_entry(
"aaa-lsp",
r#"
[language_servers.aaa]
language = "Foo"
"#,
),
),
(
"bbb-lsp".into(),
remote_sync_entry(
"bbb-lsp",
r#"
[language_servers.bbb]
language = "Foo"
"#,
),
),
(
"zzz-language".into(),
remote_sync_entry("zzz-language", r#"languages = ["languages/foo"]"#),
),
]
.into_iter()
.collect(),
languages: [(
"Foo".into(),
remote_sync_language_entry("zzz-language", "languages/foo"),
)]
.into_iter()
.collect(),
themes: BTreeMap::default(),
icon_themes: BTreeMap::default(),
};
assert_eq!(
remote_sync_extension_ids(&index),
["aaa-lsp", "bbb-lsp", "zzz-language"]
);
}
#[test]
fn remote_sync_keeps_remote_loadable_extensions_without_language_dependency() {
let index = ExtensionIndex {
extensions: [(
"foo".into(),
remote_sync_entry(
"foo",
r#"
[language_servers.foo]
language = "Foo"
"#,
),
)]
.into_iter()
.collect(),
languages: BTreeMap::default(),
themes: BTreeMap::default(),
icon_themes: BTreeMap::default(),
};
assert_eq!(remote_sync_extension_ids(&index), ["foo"]);
}
#[test]
fn remote_sync_keeps_debug_adapters() {
let index = ExtensionIndex {
extensions: [(
"foo".into(),
remote_sync_entry(
"foo",
r#"
[debug_adapters.foo]
"#,
),
)]
.into_iter()
.collect(),
languages: BTreeMap::default(),
themes: BTreeMap::default(),
icon_themes: BTreeMap::default(),
};
assert_eq!(remote_sync_extension_ids(&index), ["foo"]);
}
#[gpui::test]
async fn test_extension_store(cx: &mut TestAppContext) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
let http_client = FakeHttpClient::with_200_response();
fs.insert_tree(
"/the-extension-dir",
json!({
"installed": {
"zed-monokai": {
"extension.json": r#"{
"id": "zed-monokai",
"name": "Zed Monokai",
"version": "2.0.0",
"themes": {
"Monokai Dark": "themes/monokai.json",
"Monokai Light": "themes/monokai.json",
"Monokai Pro Dark": "themes/monokai-pro.json",
"Monokai Pro Light": "themes/monokai-pro.json"
}
}"#,
"themes": {
"monokai.json": r#"{
"name": "Monokai",
"author": "Someone",
"themes": [
{
"name": "Monokai Dark",
"appearance": "dark",
"style": {}
},
{
"name": "Monokai Light",
"appearance": "light",
"style": {}
}
]
}"#,
"monokai-pro.json": r#"{
"name": "Monokai Pro",
"author": "Someone",
"themes": [
{
"name": "Monokai Pro Dark",
"appearance": "dark",
"style": {}
},
{
"name": "Monokai Pro Light",
"appearance": "light",
"style": {}
}
]
}"#,
}
},
"zed-ruby": {
"extension.json": r#"{
"id": "zed-ruby",
"name": "Zed Ruby",
"version": "1.0.0",
"grammars": {
"ruby": "grammars/ruby.wasm",
"embedded_template": "grammars/embedded_template.wasm"
},
"languages": {
"ruby": "languages/ruby",
"erb": "languages/erb"
}
}"#,
"grammars": {
"ruby.wasm": "",
"embedded_template.wasm": "",
},
"languages": {
"ruby": {
"config.toml": r#"
name = "Ruby"
grammar = "ruby"
path_suffixes = ["rb"]
"#,
"highlights.scm": "",
"outline.scm": "",
},
"erb": {
"config.toml": r#"
name = "ERB"
grammar = "embedded_template"
path_suffixes = ["erb"]
"#,
"highlights.scm": "",
}
},
}
}
}),
)
.await;
let mut expected_index = ExtensionIndex {
extensions: [
(
"zed-ruby".into(),
ExtensionIndexEntry {
manifest: Arc::new(ExtensionManifest {
id: "zed-ruby".into(),
name: "Zed Ruby".into(),
version: "1.0.0".into(),
schema_version: SchemaVersion::ZERO,
description: None,
authors: Vec::new(),
repository: None,
themes: Default::default(),
icon_themes: Vec::new(),
lib: Default::default(),
languages: vec![
rel_path_buf("languages/erb"),
rel_path_buf("languages/ruby"),
],
grammars: [
("embedded_template".into(), GrammarManifestEntry::default()),
("ruby".into(), GrammarManifestEntry::default()),
]
.into_iter()
.collect(),
language_servers: BTreeMap::default(),
context_servers: BTreeMap::default(),
slash_commands: BTreeMap::default(),
snippets: None,
capabilities: Vec::new(),
debug_adapters: Default::default(),
debug_locators: Default::default(),
language_model_providers: BTreeMap::default(),
}),
dev: false,
},
),
(
"zed-monokai".into(),
ExtensionIndexEntry {
manifest: Arc::new(ExtensionManifest {
id: "zed-monokai".into(),
name: "Zed Monokai".into(),
version: "2.0.0".into(),
schema_version: SchemaVersion::ZERO,
description: None,
authors: vec![],
repository: None,
themes: vec![
rel_path_buf("themes/monokai-pro.json"),
rel_path_buf("themes/monokai.json"),
],
icon_themes: Vec::new(),
lib: Default::default(),
languages: Default::default(),
grammars: BTreeMap::default(),
language_servers: BTreeMap::default(),
context_servers: BTreeMap::default(),
slash_commands: BTreeMap::default(),
snippets: None,
capabilities: Vec::new(),
debug_adapters: Default::default(),
debug_locators: Default::default(),
language_model_providers: BTreeMap::default(),
}),
dev: false,
},
),
]
.into_iter()
.collect(),
languages: [
(
"ERB".into(),
ExtensionIndexLanguageEntry {
extension: "zed-ruby".into(),
path: "languages/erb".into(),
grammar: Some("embedded_template".into()),
hidden: false,
matcher: (LanguageMatcher {
path_suffixes: vec!["erb".into()],
first_line_pattern: None,
..LanguageMatcher::default()
})
.into(),
query_files: Some(QueryFiles::HIGHLIGHTS),
},
),
(
"Ruby".into(),
ExtensionIndexLanguageEntry {
extension: "zed-ruby".into(),
path: "languages/ruby".into(),
grammar: Some("ruby".into()),
hidden: false,
matcher: (LanguageMatcher {
path_suffixes: vec!["rb".into()],
first_line_pattern: None,
..LanguageMatcher::default()
})
.into(),
query_files: Some(QueryFiles::HIGHLIGHTS | QueryFiles::OUTLINE),
},
),
]
.into_iter()
.collect(),
themes: [
(
"Monokai Dark".into(),
ExtensionIndexThemeEntry {
extension: "zed-monokai".into(),
path: "themes/monokai.json".into(),
},
),
(
"Monokai Light".into(),
ExtensionIndexThemeEntry {
extension: "zed-monokai".into(),
path: "themes/monokai.json".into(),
},
),
(
"Monokai Pro Dark".into(),
ExtensionIndexThemeEntry {
extension: "zed-monokai".into(),
path: "themes/monokai-pro.json".into(),
},
),
(
"Monokai Pro Light".into(),
ExtensionIndexThemeEntry {
extension: "zed-monokai".into(),
path: "themes/monokai-pro.json".into(),
},
),
]
.into_iter()
.collect(),
icon_themes: BTreeMap::default(),
};
let proxy = Arc::new(ExtensionHostProxy::new());
let theme_registry = Arc::new(ThemeRegistry::new(Box::new(())));
theme_extension::init(proxy.clone(), theme_registry.clone(), cx.executor());
let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
language_extension::init(LspAccess::Noop, proxy.clone(), language_registry.clone());
let node_runtime = NodeRuntime::unavailable();
let store = cx.new(|cx| {
ExtensionStore::new(
PathBuf::from("/the-extension-dir"),
None,
proxy.clone(),
fs.clone(),
http_client.clone(),
http_client.clone(),
None,
node_runtime.clone(),
cx,
)
});
cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION);
store.read_with(cx, |store, _| {
let index = &store.extension_index;
assert_eq!(index.extensions, expected_index.extensions);
for ((actual_key, actual_language), (expected_key, expected_language)) in
index.languages.iter().zip(expected_index.languages.iter())
{
assert_eq!(actual_key, expected_key);
assert_eq!(actual_language.grammar, expected_language.grammar);
assert_eq!(actual_language.matcher, expected_language.matcher);
assert_eq!(actual_language.hidden, expected_language.hidden);
}
assert_eq!(index.themes, expected_index.themes);
assert_eq!(
language_registry.language_names(),
[
LanguageName::new_static("ERB"),
LanguageName::new_static("Plain Text"),
LanguageName::new_static("Ruby"),
]
);
assert_eq!(
theme_registry.list_names(),
[
"Monokai Dark",
"Monokai Light",
"Monokai Pro Dark",
"Monokai Pro Light",
"One Dark",
]
);
});
fs.insert_tree(
"/the-extension-dir/installed/zed-gruvbox",
json!({
"extension.json": r#"{
"id": "zed-gruvbox",
"name": "Zed Gruvbox",
"version": "1.0.0",
"themes": {
"Gruvbox": "themes/gruvbox.json"
}
}"#,
"themes": {
"gruvbox.json": r#"{
"name": "Gruvbox",
"author": "Someone Else",
"themes": [
{
"name": "Gruvbox",
"appearance": "dark",
"style": {}
}
]
}"#,
}
}),
)
.await;
expected_index.extensions.insert(
"zed-gruvbox".into(),
ExtensionIndexEntry {
manifest: Arc::new(ExtensionManifest {
id: "zed-gruvbox".into(),
name: "Zed Gruvbox".into(),
version: "1.0.0".into(),
schema_version: SchemaVersion::ZERO,
description: None,
authors: vec![],
repository: None,
themes: vec![rel_path_buf("themes/gruvbox.json")],
icon_themes: Vec::new(),
lib: Default::default(),
languages: Default::default(),
grammars: BTreeMap::default(),
language_servers: BTreeMap::default(),
context_servers: BTreeMap::default(),
slash_commands: BTreeMap::default(),
snippets: None,
capabilities: Vec::new(),
debug_adapters: Default::default(),
debug_locators: Default::default(),
language_model_providers: BTreeMap::default(),
}),
dev: false,
},
);
expected_index.themes.insert(
"Gruvbox".into(),
ExtensionIndexThemeEntry {
extension: "zed-gruvbox".into(),
path: "themes/gruvbox.json".into(),
},
);
#[allow(clippy::let_underscore_future)]
let _ = store.update(cx, |store, cx| store.reload(None, cx));
cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION);
store.read_with(cx, |store, _| {
let index = &store.extension_index;
for ((actual_key, actual_language), (expected_key, expected_language)) in
index.languages.iter().zip(expected_index.languages.iter())
{
assert_eq!(actual_key, expected_key);
assert_eq!(actual_language.grammar, expected_language.grammar);
assert_eq!(actual_language.matcher, expected_language.matcher);
assert_eq!(actual_language.hidden, expected_language.hidden);
}
assert_eq!(index.extensions, expected_index.extensions);
assert_eq!(index.themes, expected_index.themes);
assert_eq!(
theme_registry.list_names(),
[
"Gruvbox",
"Monokai Dark",
"Monokai Light",
"Monokai Pro Dark",
"Monokai Pro Light",
"One Dark",
]
);
});
let prev_fs_metadata_call_count = fs.metadata_call_count();
let prev_fs_read_dir_call_count = fs.read_dir_call_count();
// Create new extension store, as if Zed were restarting.
drop(store);
let store = cx.new(|cx| {
ExtensionStore::new(
PathBuf::from("/the-extension-dir"),
None,
proxy,
fs.clone(),
http_client.clone(),
http_client.clone(),
None,
node_runtime.clone(),
cx,
)
});
cx.executor().run_until_parked();
store.read_with(cx, |store, _| {
assert_eq!(store.extension_index.extensions, expected_index.extensions);
assert_eq!(store.extension_index.themes, expected_index.themes);
assert_eq!(
store.extension_index.icon_themes,
expected_index.icon_themes
);
for ((actual_key, actual_language), (expected_key, expected_language)) in store
.extension_index
.languages
.iter()
.zip(expected_index.languages.iter())
{
assert_eq!(actual_key, expected_key);
assert_eq!(actual_language.grammar, expected_language.grammar);
assert_eq!(actual_language.matcher, expected_language.matcher);
assert_eq!(actual_language.hidden, expected_language.hidden);
}
assert_eq!(
language_registry.language_names(),
[
LanguageName::new_static("ERB"),
LanguageName::new_static("Plain Text"),
LanguageName::new_static("Ruby"),
]
);
assert_eq!(
language_registry.grammar_names(),
["embedded_template".into(), "ruby".into()]
);
assert_eq!(
theme_registry.list_names(),
[
"Gruvbox",
"Monokai Dark",
"Monokai Light",
"Monokai Pro Dark",
"Monokai Pro Light",
"One Dark",
]
);
// The on-disk manifest limits the number of FS calls that need to be made
// on startup.
assert_eq!(fs.read_dir_call_count(), prev_fs_read_dir_call_count);
assert_eq!(fs.metadata_call_count(), prev_fs_metadata_call_count + 2);
});
store.update(cx, |store, cx| {
store
.uninstall_extension("zed-ruby".into(), cx)
.detach_and_log_err(cx);
});
cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION);
expected_index.extensions.remove("zed-ruby");
expected_index.languages.remove("Ruby");
expected_index.languages.remove("ERB");
store.read_with(cx, |store, _| {
assert_eq!(store.extension_index.extensions, expected_index.extensions);
assert_eq!(store.extension_index.themes, expected_index.themes);
assert_eq!(
store.extension_index.icon_themes,
expected_index.icon_themes
);
for ((actual_key, actual_language), (expected_key, expected_language)) in store
.extension_index
.languages
.iter()
.zip(expected_index.languages.iter())
{
assert_eq!(actual_key, expected_key);
assert_eq!(actual_language.grammar, expected_language.grammar);
assert_eq!(actual_language.matcher, expected_language.matcher);
assert_eq!(actual_language.hidden, expected_language.hidden);
}
assert_eq!(
language_registry.language_names(),
[LanguageName::new_static("Plain Text")]
);
assert_eq!(language_registry.grammar_names(), []);
});
}
#[gpui::test]
async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
init_test(cx);
cx.executor().allow_parking();
let executor = cx.executor();
async fn await_or_timeout<T>(
executor: &BackgroundExecutor,
what: &'static str,
seconds: u64,
future: impl std::future::Future<Output = T>,
) -> T {
let timeout = executor.timer(std::time::Duration::from_secs(seconds));
futures::select! {
output = future.fuse() => output,
_ = futures::FutureExt::fuse(timeout) => panic!(
"[test_extension_store_with_test_extension] timed out after {seconds}s while {what}"
)
}
}
let root_dir = util::dev_repo_root().expect("test extension requires a repository checkout");
let cache_dir = root_dir.join("target");
let test_extension_id = "test-extension";
let test_extension_dir = root_dir.join("extensions").join(test_extension_id);
let fs = RealFs::new(None, cx.executor());
let extensions_tree = TempTree::new(json!({
"installed": {},
"work": {}
}));
let project_dir = TempTree::new(json!({
"test.gleam": ""
}));
let extensions_dir = extensions_tree.path().canonicalize().unwrap();
let project_dir = project_dir.path().canonicalize().unwrap();
let project = await_or_timeout(
&executor,
"awaiting Project::test",
5,
Project::test(fs.clone(), [project_dir.as_path()], cx),
)
.await;
let proxy = Arc::new(ExtensionHostProxy::new());
let theme_registry = Arc::new(ThemeRegistry::new(Box::new(())));
theme_extension::init(proxy.clone(), theme_registry.clone(), cx.executor());
let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
let lsp_store_id = project.read_with(cx, |project, _| project.lsp_store().entity_id());
language_extension::init(
LspAccess::ViaLspStore(
project
.update(cx, |project, _| project.lsp_store())
.downgrade(),
),
proxy.clone(),
language_registry.clone(),
);
let node_runtime = NodeRuntime::unavailable();
let (mut status_updates, _status_updates_subscription) =
language_registry.language_server_binary_statuses();
struct FakeLanguageServerVersion {
version: String,
binary_contents: String,
http_request_count: usize,
}
let language_server_version = Arc::new(Mutex::new(FakeLanguageServerVersion {
version: "v1.2.3".into(),
binary_contents: "the-binary-contents".into(),
http_request_count: 0,
}));
let extension_client = FakeHttpClient::create({
let language_server_version = language_server_version.clone();
move |request| {
let language_server_version = language_server_version.clone();
async move {
let version = language_server_version.lock().version.clone();
let binary_contents = language_server_version.lock().binary_contents.clone();
let github_releases_uri = "https://api.github.com/repos/gleam-lang/gleam/releases";
let asset_download_uri =
format!("https://fake-download.example.com/gleam-{version}");
let uri = request.uri().to_string();
if uri == github_releases_uri {
language_server_version.lock().http_request_count += 1;
Ok(Response::new(
json!([
{
"tag_name": version,
"prerelease": false,
"tarball_url": "",
"zipball_url": "",
"assets": [
{
"name": format!("gleam-{version}-aarch64-apple-darwin.tar.gz"),
"browser_download_url": asset_download_uri
},
{
"name": format!("gleam-{version}-x86_64-unknown-linux-musl.tar.gz"),
"browser_download_url": asset_download_uri
},
{
"name": format!("gleam-{version}-aarch64-unknown-linux-musl.tar.gz"),
"browser_download_url": asset_download_uri
},
{
"name": format!("gleam-{version}-x86_64-pc-windows-msvc.tar.gz"),
"browser_download_url": asset_download_uri
}
]
}
])
.to_string()
.into(),
))
} else if uri == asset_download_uri {
language_server_version.lock().http_request_count += 1;
let mut bytes = Vec::<u8>::new();
let mut archive = async_tar::Builder::new(&mut bytes);
let mut header = async_tar::Header::new_gnu();
header.set_size(binary_contents.len() as u64);
archive
.append_data(&mut header, "gleam", binary_contents.as_bytes())
.await
.unwrap();
archive.into_inner().await.unwrap();
let mut gzipped_bytes = Vec::new();
let mut encoder = GzipEncoder::new(BufReader::new(bytes.as_slice()));
encoder.read_to_end(&mut gzipped_bytes).await.unwrap();
Ok(Response::new(gzipped_bytes.into()))
} else {
Ok(Response::builder().status(404).body("not found".into())?)
}
}
}
});
let user_agent = cx.update(|cx| {
format!(
"Zed/{} ({}; {})",
AppVersion::global(cx),
std::env::consts::OS,
std::env::consts::ARCH
)
});
let builder_client =
Arc::new(ReqwestClient::user_agent(&user_agent).expect("Could not create HTTP client"));
let extension_store = cx.new(|cx| {
ExtensionStore::new(
extensions_dir.clone(),
Some(cache_dir),
proxy,
fs.clone(),
extension_client.clone(),
builder_client,
None,
node_runtime,
cx,
)
});
// Ensure that debounces fire.
let mut events = cx.events(&extension_store);
let executor = cx.executor();
let _task = cx.executor().spawn(async move {
while let Some(event) = events.next().await {
if let Event::StartedReloading = event {
executor.advance_clock(RELOAD_DEBOUNCE_DURATION);
}
}
});
extension_store.update(cx, |_, cx| {
cx.subscribe(&extension_store, |_, _, event, _| {
if matches!(event, Event::ExtensionFailedToLoad(_)) {
panic!("extension failed to load");
}
})
.detach();
});
let mut extension_events = cx.events(&cx.update(|cx| {
extension::ExtensionEvents::try_global(cx)
.expect("ExtensionEvents should be initialized in tests")
}));
let executor = cx.executor();
await_or_timeout(
&executor,
"awaiting install_dev_extension",
60,
extension_store.update(cx, |store, cx| {
store.install_dev_extension(test_extension_dir.clone(), cx)
}),
)
.await
.unwrap();
await_or_timeout(
&executor,
"awaiting ExtensionsInstalledChanged",
10,
async {
while let Some(event) = extension_events.next().await {
if matches!(event, extension::Event::ExtensionsInstalledChanged) {
return;
}
}
panic!(
"[test_extension_store_with_test_extension] extension event stream ended before ExtensionsInstalledChanged"
);
},
)
.await;
let mut fake_servers = language_registry.register_fake_lsp_server(
LanguageServerName("gleam".into()),
lsp::ServerCapabilities {
completion_provider: Some(Default::default()),
..Default::default()
},
None,
);
cx.executor().run_until_parked();
let mut project_events = cx.events(&project);
let buffer_path = project_dir.join("test.gleam");
let (buffer, _handle) = await_or_timeout(
&executor,
"awaiting open_local_buffer_with_lsp",
5,
project.update(cx, |project, cx| {
project.open_local_buffer_with_lsp(buffer_path.clone(), cx)
}),
)
.await
.unwrap();
cx.executor().run_until_parked();
let buffer_remote_id = buffer.read_with(cx, |buffer, _cx| buffer.remote_id());
let fake_server = await_or_timeout(
&executor,
"awaiting first fake server spawn",
10,
fake_servers.next(),
)
.await
.unwrap();
let work_dir = extensions_dir.join(format!("work/{test_extension_id}"));
let expected_server_path = work_dir.join("gleam-v1.2.3/gleam");
let expected_binary_contents = language_server_version.lock().binary_contents.clone();
// check that IO operations in extension work correctly
assert!(work_dir.join("dir-created-with-rel-path").exists());
assert!(work_dir.join("dir-created-with-abs-path").exists());
assert!(work_dir.join("file-created-with-abs-path").exists());
assert!(work_dir.join("file-created-with-rel-path").exists());
assert_eq!(fake_server.binary.path, expected_server_path);
assert_eq!(fake_server.binary.arguments, [OsString::from("lsp")]);
assert_eq!(
await_or_timeout(
&executor,
"awaiting fs.load(expected_server_path)",
5,
fs.load(&expected_server_path)
)
.await
.unwrap(),
expected_binary_contents
);
assert_eq!(language_server_version.lock().http_request_count, 2);
assert_eq!(
[
await_or_timeout(
&executor,
"awaiting status_updates #1",
5,
status_updates.next()
)
.await
.unwrap(),
await_or_timeout(
&executor,
"awaiting status_updates #2",
5,
status_updates.next()
)
.await
.unwrap(),
await_or_timeout(
&executor,
"awaiting status_updates #3",
5,
status_updates.next()
)
.await
.unwrap(),
await_or_timeout(
&executor,
"awaiting status_updates #4",
5,
status_updates.next()
)
.await
.unwrap(),
],
[
(
Some(lsp_store_id),
LanguageServerName::new_static("gleam"),
BinaryStatus::Starting
),
(
Some(lsp_store_id),
LanguageServerName::new_static("gleam"),
BinaryStatus::CheckingForUpdate
),
(
Some(lsp_store_id),
LanguageServerName::new_static("gleam"),
BinaryStatus::Downloading
),
(
Some(lsp_store_id),
LanguageServerName::new_static("gleam"),
BinaryStatus::None
)
]
);
// The extension creates custom labels for completion items.
fake_server.set_request_handler::<lsp::request::Completion, _, _>(|_, _| async move {
Ok(Some(lsp::CompletionResponse::Array(vec![
lsp::CompletionItem {
label: "foo".into(),
kind: Some(lsp::CompletionItemKind::FUNCTION),
detail: Some("fn() -> Result(Nil, Error)".into()),
..Default::default()
},
lsp::CompletionItem {
label: "bar.baz".into(),
kind: Some(lsp::CompletionItemKind::FUNCTION),
detail: Some("fn(List(a)) -> a".into()),
..Default::default()
},
lsp::CompletionItem {
label: "Quux".into(),
kind: Some(lsp::CompletionItemKind::CONSTRUCTOR),
detail: Some("fn(String) -> T".into()),
..Default::default()
},
lsp::CompletionItem {
label: "my_string".into(),
kind: Some(lsp::CompletionItemKind::CONSTANT),
detail: Some("String".into()),
..Default::default()
},
])))
});
// `register_fake_lsp_server` can yield a server instance before the client has fully registered
// the buffer with the project LSP plumbing. Wait for the project to observe that registration
// before issuing requests like completion.
await_or_timeout(
&executor,
"awaiting LanguageServerBufferRegistered",
5,
async {
while let Some(event) = project_events.next().await {
if let project::Event::LanguageServerBufferRegistered { buffer_id, .. } = event {
if buffer_id == buffer_remote_id {
return;
}
}
}
panic!(
"[test_extension_store_with_test_extension] project event stream ended before buffer registration for {}",
buffer_path.display()
);
},
)
.await;
let completion_labels = await_or_timeout(
&executor,
"awaiting completions",
5,
project.update(cx, |project, cx| {
project.completions(&buffer, 0, DEFAULT_COMPLETION_CONTEXT, cx)
}),
)
.await
.unwrap()
.into_iter()
.flat_map(|response| response.completions)
.map(|c| c.label.text)
.collect::<Vec<_>>();
assert_eq!(
completion_labels,
[
"foo: fn() -> Result(Nil, Error)".to_string(),
"bar.baz: fn(List(a)) -> a".to_string(),
"Quux: fn(String) -> T".to_string(),
"my_string: String".to_string(),
]
);
// Simulate a new version of the language server being released
language_server_version.lock().version = "v2.0.0".into();
language_server_version.lock().binary_contents = "the-new-binary-contents".into();
language_server_version.lock().http_request_count = 0;
// Start a new instance of the language server.
project.update(cx, |project, cx| {
project.restart_language_servers_for_buffers(vec![buffer.clone()], HashSet::default(), cx)
});
cx.executor().run_until_parked();
// The extension has cached the binary path, and does not attempt
// to reinstall it.
let fake_server = await_or_timeout(
&executor,
"awaiting second fake server spawn",
5,
fake_servers.next(),
)
.await
.unwrap();
assert_eq!(fake_server.binary.path, expected_server_path);
assert_eq!(
await_or_timeout(
&executor,
"awaiting fs.load(expected_server_path) after restart",
5,
fs.load(&expected_server_path)
)
.await
.unwrap(),
expected_binary_contents
);
assert_eq!(language_server_version.lock().http_request_count, 0);
// Reload the extension, clearing its cache.
// Start a new instance of the language server.
await_or_timeout(
&executor,
"awaiting extension_store.reload(test-extension)",
5,
extension_store.update(cx, |store, cx| {
store.reload(Some("test-extension".into()), cx)
}),
)
.await;
cx.executor().run_until_parked();
project.update(cx, |project, cx| {
project.restart_language_servers_for_buffers(vec![buffer.clone()], HashSet::default(), cx)
});
// The extension re-fetches the latest version of the language server.
let fake_server = await_or_timeout(
&executor,
"awaiting third fake server spawn",
5,
fake_servers.next(),
)
.await
.unwrap();
let new_expected_server_path =
extensions_dir.join(format!("work/{test_extension_id}/gleam-v2.0.0/gleam"));
let expected_binary_contents = language_server_version.lock().binary_contents.clone();
assert_eq!(fake_server.binary.path, new_expected_server_path);
assert_eq!(fake_server.binary.arguments, [OsString::from("lsp")]);
assert_eq!(
await_or_timeout(
&executor,
"awaiting fs.load(new_expected_server_path)",
5,
fs.load(&new_expected_server_path)
)
.await
.unwrap(),
expected_binary_contents
);
// The old language server directory has been cleaned up.
assert!(
await_or_timeout(
&executor,
"awaiting fs.metadata(expected_server_path)",
5,
fs.metadata(&expected_server_path)
)
.await
.unwrap()
.is_none()
);
}
fn init_test(cx: &mut TestAppContext) {
cx.update(|cx| {
let store = SettingsStore::test(cx);
cx.set_global(store);
release_channel::init(semver::Version::new(0, 0, 0), cx);
extension::init(cx);
theme_settings::init(theme::LoadThemes::JustBase, cx);
gpui_tokio::init(cx);
});
}
#[gpui::test]
async fn test_register_remote_client_syncs_only_the_new_client(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, _fs) = create_extension_store(cx);
insert_remote_sync_index_entry(&store, cx);
let (opts_a, _counter_a, sync_count_a) = setup_mock_remote(cx, server_cx);
let (opts_b, _counter_b, sync_count_b) = setup_mock_remote(cx, server_cx);
let client_a = RemoteClient::connect_mock(opts_a, cx).await;
let client_b = RemoteClient::connect_mock(opts_b, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client_a.clone(), cx)
});
cx.run_until_parked();
assert_eq!(
sync_count_a.load(Ordering::SeqCst),
1,
"registering a client should sync extensions to it once"
);
assert_eq!(sync_count_b.load(Ordering::SeqCst), 0);
store.update(cx, |store, cx| {
store.register_remote_client(client_b.clone(), cx)
});
cx.run_until_parked();
assert_eq!(
sync_count_a.load(Ordering::SeqCst),
1,
"registering a new client should not re-sync already-registered clients"
);
assert_eq!(
sync_count_b.load(Ordering::SeqCst),
1,
"registering a client should sync extensions to it once"
);
store.update(cx, |store, cx| {
store.register_remote_client(client_a.clone(), cx)
});
cx.run_until_parked();
assert_eq!(
sync_count_a.load(Ordering::SeqCst),
1,
"re-registering an already-registered client should be a no-op"
);
}
#[gpui::test]
async fn test_register_remote_client_resyncs_extensions_on_reconnect(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, _fs) = create_extension_store(cx);
insert_remote_sync_index_entry(&store, cx);
let (opts, _counter, sync_count) = setup_mock_remote(cx, server_cx);
let (other_opts, _other_counter, other_sync_count) = setup_mock_remote(cx, server_cx);
let client = RemoteClient::connect_mock(opts, cx).await;
let other_client = RemoteClient::connect_mock(other_opts, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client.clone(), cx);
store.register_remote_client(other_client.clone(), cx);
});
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
1,
"registering a remote client should sync extensions to it once"
);
assert_eq!(other_sync_count.load(Ordering::SeqCst), 1);
client.update(cx, |_client, cx| {
cx.emit(RemoteClientEvent::Reconnected);
});
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
2,
"reconnecting should re-sync extensions to the remote client"
);
assert_eq!(
other_sync_count.load(Ordering::SeqCst),
1,
"reconnecting one client should not re-sync other clients"
);
}
#[gpui::test]
async fn test_register_remote_client_retries_failed_sync(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, _fs) = create_extension_store(cx);
insert_remote_sync_index_entry(&store, cx);
let (opts, _counter, sync_count) = setup_mock_remote_with_failures(cx, server_cx, 1);
let client = RemoteClient::connect_mock(opts, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client.clone(), cx)
});
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
1,
"registering a client should attempt an initial sync"
);
cx.executor().advance_clock(remote_sync_retry_delay(0));
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
2,
"a failed sync should be retried after the retry delay"
);
cx.executor().advance_clock(remote_sync_retry_delay(1));
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
2,
"a successful sync should not be retried"
);
}
#[gpui::test]
async fn test_persistent_sync_failure_retries_with_capped_backoff(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, _fs) = create_extension_store(cx);
insert_remote_sync_index_entry(&store, cx);
let (opts, _counter, sync_count) = setup_mock_remote_with_failures(cx, server_cx, usize::MAX);
let client = RemoteClient::connect_mock(opts, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client.clone(), cx)
});
cx.run_until_parked();
assert_eq!(sync_count.load(Ordering::SeqCst), 1);
advance_through_sync_backoff(cx);
assert_eq!(
sync_count.load(Ordering::SeqCst),
9,
"every backoff period should trigger exactly one retry"
);
assert_eq!(remote_sync_retry_delay(8), MAX_REMOTE_SYNC_RETRY_DELAY);
cx.executor().advance_clock(MAX_REMOTE_SYNC_RETRY_DELAY);
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
MAX_REMOTE_SYNC_ATTEMPTS,
"a persistently failing sync should keep retrying once per capped backoff period until the attempt limit"
);
cx.executor().advance_clock(MAX_REMOTE_SYNC_RETRY_DELAY);
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
MAX_REMOTE_SYNC_ATTEMPTS,
"after the attempt limit is reached, retries should pause until the next change"
);
client.update(cx, |_client, cx| {
cx.emit(RemoteClientEvent::Reconnected);
});
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
MAX_REMOTE_SYNC_ATTEMPTS + 1,
"a connection change should resume syncing after retries were exhausted"
);
}
#[gpui::test]
async fn test_register_remote_client_drops_stale_retry_after_successful_sync(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, _fs) = create_extension_store(cx);
let (opts, _counter, sync_count) = setup_mock_remote_with_failures(cx, server_cx, 1);
let client = RemoteClient::connect_mock(opts, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client.clone(), cx)
});
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
1,
"registering a client should attempt an initial sync"
);
client.update(cx, |_client, cx| {
cx.emit(RemoteClientEvent::Reconnected);
});
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
2,
"reconnecting should trigger a sync"
);
cx.executor().advance_clock(remote_sync_retry_delay(0));
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
2,
"a pending retry should be dropped once a later sync succeeded"
);
}
#[gpui::test]
async fn test_register_remote_client_keeps_subscription_across_disconnect(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, _fs) = create_extension_store(cx);
let (opts, _counter, sync_count) = setup_mock_remote_with_failures(cx, server_cx, 1);
let client = RemoteClient::connect_mock(opts, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client.clone(), cx)
});
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
1,
"registering a client should attempt an initial sync"
);
client.update(cx, |_client, cx| {
cx.emit(RemoteClientEvent::Disconnected {
server_not_running: false,
});
});
cx.run_until_parked();
store.read_with(cx, |store, _cx| {
assert_eq!(
store.remote_clients.len(),
1,
"a disconnected client should stay registered so a later reconnect can resync"
);
});
client.update(cx, |_client, cx| {
cx.emit(RemoteClientEvent::Reconnected);
});
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
2,
"reconnecting after a disconnect should resync the client"
);
}
#[gpui::test]
async fn test_register_remote_client_release_evicts_client(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, _fs) = create_extension_store(cx);
let (opts, _counter, _sync_count) = setup_mock_remote(cx, server_cx);
let client = RemoteClient::connect_mock(opts, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client.clone(), cx)
});
cx.run_until_parked();
assert_eq!(
store.read_with(cx, |store, _cx| store.remote_clients.len()),
1
);
cx.update(move |_cx| drop(client));
cx.run_until_parked();
store.read_with(cx, |store, _cx| {
assert_eq!(
store.remote_clients.len(),
0,
"a released client should be evicted along with its subscriptions and reconciler"
);
});
}
#[gpui::test]
async fn test_register_remote_client_resyncs_after_simulated_reconnect(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, _fs) = create_extension_store(cx);
let (opts, _counter, sync_count) = setup_mock_remote(cx, server_cx);
let client = RemoteClient::connect_mock(opts, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client.clone(), cx)
});
cx.run_until_parked();
assert_eq!(sync_count.load(Ordering::SeqCst), 1);
client
.update(cx, |client, cx| client.simulate_disconnect(cx))
.detach();
cx.run_until_parked();
let mut reconnected_and_resynced = false;
for _ in 0..30 {
cx.executor().advance_clock(Duration::from_secs(10));
cx.run_until_parked();
let connected = client.read_with(cx, |client, _cx| {
client.connection_state() == ConnectionState::Connected
});
if connected && sync_count.load(Ordering::SeqCst) >= 2 {
reconnected_and_resynced = true;
break;
}
}
assert!(
reconnected_and_resynced,
"a simulated disconnect should reconnect and resync without deadlocking the reconciler"
);
assert_eq!(
sync_count.load(Ordering::SeqCst),
2,
"a real reconnect should trigger exactly one resync"
);
}
#[gpui::test]
async fn test_headless_sync_extensions_notifications(cx: &mut TestAppContext) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
fs.insert_tree(
"/extensions/foo-dev",
json!({
"extension.toml": r#"
id = "foo-dev"
name = "foo-dev"
version = "1.0.0"
schema_version = 1
languages = ["languages/foo"]
"#,
"languages": {
"foo": {
"config.toml": r#"
name = "Foo"
grammar = "foo"
path_suffixes = ["foo"]
"#
}
}
}),
)
.await;
let store = cx.update(|cx| {
HeadlessExtensionStore::new(
fs.clone(),
FakeHttpClient::with_200_response(),
PathBuf::from("/extensions"),
Arc::new(ExtensionHostProxy::new()),
NodeRuntime::unavailable(),
cx,
)
});
let installed_changed_count = Arc::new(AtomicUsize::new(0));
cx.update(|cx| {
let extension_events = extension::ExtensionEvents::try_global(cx)
.expect("ExtensionEvents should be initialized in tests");
let installed_changed_count = installed_changed_count.clone();
cx.subscribe(&extension_events, move |_, event, _cx| {
if matches!(event, extension::Event::ExtensionsInstalledChanged) {
installed_changed_count.fetch_add(1, Ordering::SeqCst);
}
})
.detach();
});
let dev_extension = || {
vec![ExtensionVersion {
id: "foo-dev".to_string(),
version: "1.0.0".to_string(),
dev: true,
content_fingerprint: None,
}]
};
let missing = store
.update(cx, |store, cx| store.sync_extensions(dev_extension(), cx))
.await
.unwrap();
cx.run_until_parked();
assert_eq!(missing.len(), 1, "dev extensions should always be re-sent");
assert_eq!(
installed_changed_count.load(Ordering::SeqCst),
1,
"loading a not-yet-loaded extension should notify"
);
let missing = store
.update(cx, |store, cx| store.sync_extensions(dev_extension(), cx))
.await
.unwrap();
cx.run_until_parked();
assert_eq!(missing.len(), 1, "dev extensions should always be re-sent");
assert_eq!(
installed_changed_count.load(Ordering::SeqCst),
1,
"re-syncing an unchanged dev extension should not reload it or notify"
);
fs.insert_file(
"/extensions/foo-dev/languages/foo/config.toml",
br#"
name = "Foo"
grammar = "foo"
path_suffixes = ["foo", "foo2"]
"#
.to_vec(),
)
.await;
let missing = store
.update(cx, |store, cx| store.sync_extensions(dev_extension(), cx))
.await
.unwrap();
cx.run_until_parked();
assert_eq!(missing.len(), 1, "dev extensions should always be re-sent");
assert_eq!(
installed_changed_count.load(Ordering::SeqCst),
2,
"reloading a dev extension whose content changed should notify"
);
store
.update(cx, |store, cx| store.sync_extensions(Vec::new(), cx))
.await
.unwrap();
cx.run_until_parked();
assert_eq!(
installed_changed_count.load(Ordering::SeqCst),
3,
"unloading an extension should notify"
);
}
#[gpui::test]
async fn test_headless_sync_skips_dev_extension_with_matching_fingerprint(cx: &mut TestAppContext) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
fs.insert_tree(
"/extensions/foo-dev",
json!({
"extension.toml": r#"
id = "foo-dev"
name = "foo-dev"
version = "1.0.0"
schema_version = 1
languages = ["languages/foo"]
"#,
"languages": {
"foo": {
"config.toml": "name = \"Foo\"\ngrammar = \"foo\"\npath_suffixes = [\"foo\"]\n"
}
}
}),
)
.await;
let store = cx.update(|cx| {
HeadlessExtensionStore::new(
fs.clone(),
FakeHttpClient::with_200_response(),
PathBuf::from("/extensions"),
Arc::new(ExtensionHostProxy::new()),
NodeRuntime::unavailable(),
cx,
)
});
let dev_extension = |content_fingerprint: Option<u64>| {
vec![ExtensionVersion {
id: "foo-dev".to_string(),
version: "1.0.0".to_string(),
dev: true,
content_fingerprint,
}]
};
let missing = store
.update(cx, |store, cx| {
store.sync_extensions(dev_extension(None), cx)
})
.await
.unwrap();
assert_eq!(
missing.len(),
1,
"a dev extension without a client fingerprint should be re-requested"
);
let fingerprint = store
.read_with(cx, |store, _cx| {
store
.loaded_extensions
.get("foo-dev")
.and_then(|loaded| loaded.content_fingerprint)
})
.expect("loading a dev extension should record its content fingerprint");
let missing = store
.update(cx, |store, cx| {
store.sync_extensions(dev_extension(Some(fingerprint)), cx)
})
.await
.unwrap();
assert_eq!(
missing.len(),
0,
"a dev extension whose fingerprint matches the loaded content should not be re-requested"
);
let missing = store
.update(cx, |store, cx| {
store.sync_extensions(dev_extension(Some(fingerprint.wrapping_add(1))), cx)
})
.await
.unwrap();
assert_eq!(
missing.len(),
1,
"a dev extension whose fingerprint differs from the loaded content should be re-requested"
);
}
#[gpui::test]
async fn test_headless_sync_extensions_reports_failed_load_as_missing_again(
cx: &mut TestAppContext,
) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
fs.insert_tree("/extensions", json!({})).await;
let store = cx.update(|cx| {
HeadlessExtensionStore::new(
fs.clone(),
FakeHttpClient::with_200_response(),
PathBuf::from("/extensions"),
Arc::new(ExtensionHostProxy::new()),
NodeRuntime::unavailable(),
cx,
)
});
let broken_extension = || {
vec![ExtensionVersion {
id: "broken".to_string(),
version: "1.0.0".to_string(),
dev: false,
content_fingerprint: None,
}]
};
let missing = store
.update(cx, |store, cx| {
store.sync_extensions(broken_extension(), cx)
})
.await
.unwrap();
assert_eq!(
missing.len(),
1,
"a failed load should be reported as missing"
);
let loaded_count = store.read_with(cx, |store, _cx| store.loaded_extensions.len());
assert_eq!(
loaded_count, 0,
"a failed load should not mark the extension as loaded"
);
let missing = store
.update(cx, |store, cx| {
store.sync_extensions(broken_extension(), cx)
})
.await
.unwrap();
assert_eq!(
missing.len(),
1,
"an extension that failed to load should be reported as missing on the next sync too"
);
}
#[gpui::test]
async fn test_headless_sync_uninstall_failure_does_not_block_other_extensions(
cx: &mut TestAppContext,
) {
init_test(cx);
let extension_files = |id: &str| {
json!({
"extension.toml": format!(
"id = \"{id}\"\nname = \"{id}\"\nversion = \"1.0.0\"\nschema_version = 1\nlanguages = [\"languages/lang\"]\n"
),
"languages": {
"lang": {
"config.toml": format!(
"name = \"{id}-lang\"\ngrammar = \"{id}\"\npath_suffixes = [\"{id}\"]\n"
)
}
}
})
};
let fs = FakeFs::new(cx.executor());
fs.insert_tree(
"/extensions",
json!({
"ext-a": extension_files("ext-a"),
"ext-b": extension_files("ext-b"),
"ext-c": extension_files("ext-c"),
}),
)
.await;
let store = cx.update(|cx| {
HeadlessExtensionStore::new(
fs.clone(),
FakeHttpClient::with_200_response(),
PathBuf::from("/extensions"),
Arc::new(ExtensionHostProxy::new()),
NodeRuntime::unavailable(),
cx,
)
});
let extension = |id: &str| ExtensionVersion {
id: id.to_string(),
version: "1.0.0".to_string(),
dev: false,
content_fingerprint: None,
};
store
.update(cx, |store, cx| {
store.sync_extensions(vec![extension("ext-a"), extension("ext-b")], cx)
})
.await
.unwrap();
fs.set_remove_dir_error("/extensions/ext-a", "simulated removal failure".to_string());
let missing = store
.update(cx, |store, cx| {
store.sync_extensions(vec![extension("ext-b"), extension("ext-c")], cx)
})
.await
.unwrap();
assert_eq!(
missing.len(),
0,
"a failed removal should not fail the sync or block loading new extensions"
);
store.read_with(cx, |store, _cx| {
let mut ids = store.loaded_extensions.keys().cloned().collect::<Vec<_>>();
ids.sort();
assert_eq!(
ids,
vec![Arc::<str>::from("ext-b"), Arc::<str>::from("ext-c")],
"the extension whose files failed to be removed should still be evicted, and the new extension loaded"
);
});
}
#[gpui::test]
async fn test_extension_index_change_sync_failure_is_retried(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, fs) = create_extension_store(cx);
let (opts, counter, sync_count) = setup_mock_remote(cx, server_cx);
let client = RemoteClient::connect_mock(opts, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client.clone(), cx)
});
cx.run_until_parked();
assert_eq!(sync_count.load(Ordering::SeqCst), 1);
counter.update(server_cx, |counter, _cx| counter.failures_remaining = 1);
insert_remote_relevant_extension(&fs, "sync-ext").await;
store.update(cx, |store, cx| drop(store.reload(None, cx)));
cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION);
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
2,
"an extension index change should sync extensions to registered clients"
);
cx.executor().advance_clock(remote_sync_retry_delay(0));
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
3,
"a failed index-change sync should be retried after the retry delay"
);
cx.executor().advance_clock(remote_sync_retry_delay(1));
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
3,
"a successful retry should not be retried again"
);
}
#[gpui::test]
async fn test_register_remote_client_reconnect_does_not_start_parallel_retry_chain(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, _fs) = create_extension_store(cx);
let (opts, _counter, sync_count) = setup_mock_remote_with_failures(cx, server_cx, usize::MAX);
let client = RemoteClient::connect_mock(opts, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client.clone(), cx)
});
cx.run_until_parked();
assert_eq!(sync_count.load(Ordering::SeqCst), 1);
client.update(cx, |_client, cx| {
cx.emit(RemoteClientEvent::Reconnected);
});
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
2,
"reconnecting should attempt a sync even while a retry is pending"
);
cx.executor().advance_clock(remote_sync_retry_delay(0));
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
3,
"after a reconnect, each backoff period should trigger exactly one retry, not one per chain"
);
cx.executor().advance_clock(remote_sync_retry_delay(1));
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
4,
"retries should stay serialized in a single chain"
);
}
#[gpui::test]
async fn test_index_change_during_backoff_neither_preempts_nor_resets_it(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, fs) = create_extension_store(cx);
let (opts, _counter, sync_count) = setup_mock_remote_with_failures(cx, server_cx, usize::MAX);
let client = RemoteClient::connect_mock(opts, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client.clone(), cx)
});
cx.run_until_parked();
assert_eq!(sync_count.load(Ordering::SeqCst), 1);
insert_remote_relevant_extension(&fs, "sync-ext").await;
store.update(cx, |store, cx| drop(store.reload(None, cx)));
cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION);
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
1,
"an index change should not preempt the pending backoff timer"
);
cx.executor().advance_clock(remote_sync_retry_delay(0));
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
2,
"the pending retry should fire on schedule and pick up the index change"
);
cx.executor().advance_clock(remote_sync_retry_delay(0));
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
2,
"an index change should not reset the backoff chain to the initial delay"
);
cx.executor().advance_clock(remote_sync_retry_delay(1));
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
3,
"the backoff chain should continue growing across index changes"
);
}
#[gpui::test]
async fn test_index_change_after_exhaustion_triggers_single_attempt(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, fs) = create_extension_store(cx);
let (opts, _counter, sync_count) = setup_mock_remote_with_failures(cx, server_cx, usize::MAX);
let client = RemoteClient::connect_mock(opts, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client.clone(), cx)
});
cx.run_until_parked();
advance_through_sync_backoff(cx);
cx.executor().advance_clock(MAX_REMOTE_SYNC_RETRY_DELAY);
cx.run_until_parked();
assert_eq!(sync_count.load(Ordering::SeqCst), MAX_REMOTE_SYNC_ATTEMPTS);
insert_remote_relevant_extension(&fs, "sync-ext").await;
store.update(cx, |store, cx| drop(store.reload(None, cx)));
cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION);
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
MAX_REMOTE_SYNC_ATTEMPTS + 1,
"after exhaustion, an index change should trigger exactly one attempt"
);
cx.executor().advance_clock(MAX_REMOTE_SYNC_RETRY_DELAY);
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
MAX_REMOTE_SYNC_ATTEMPTS + 1,
"a failed post-exhaustion attempt should park again instead of restarting the chain"
);
client.update(cx, |_client, cx| {
cx.emit(RemoteClientEvent::Reconnected);
});
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
MAX_REMOTE_SYNC_ATTEMPTS + 2,
"a reconnect should restart the retry chain after exhaustion"
);
cx.executor().advance_clock(remote_sync_retry_delay(0));
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
MAX_REMOTE_SYNC_ATTEMPTS + 3,
"the restarted chain should retry with the initial delay"
);
}
#[gpui::test]
async fn test_remote_sync_failed_install_is_retried(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, _fs) = create_extension_store(cx);
store.update(cx, |store, _cx| {
for id in ["bar-lsp", "foo-lsp"] {
let mut entry = remote_sync_entry(
id,
r#"
[language_servers.foo]
language = "Foo"
"#,
);
entry.dev = true;
store
.extension_index
.extensions
.insert(Arc::from(id), entry);
}
});
let (opts, _counter, sync_count, install_count) =
setup_mock_remote_with_install_failures(cx, server_cx, 1);
let client = RemoteClient::connect_mock(opts, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client.clone(), cx)
});
cx.run_until_parked();
assert_eq!(sync_count.load(Ordering::SeqCst), 1);
assert_eq!(
install_count.load(Ordering::SeqCst),
2,
"one failed install should not prevent installing the remaining extensions"
);
cx.executor().advance_clock(remote_sync_retry_delay(0));
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
2,
"a sync with a failed extension install should be retried"
);
assert_eq!(
install_count.load(Ordering::SeqCst),
4,
"the retried sync should reattempt all missing installs"
);
cx.executor().advance_clock(remote_sync_retry_delay(1));
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
2,
"a sync whose installs all succeeded should not be retried"
);
}
#[gpui::test]
async fn test_unchanged_dev_extension_is_not_reuploaded_on_resync(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, _fs) = create_extension_store(cx);
let insert_dev_entry = |store: &Entity<ExtensionStore>, cx: &mut TestAppContext, body: &str| {
let mut entry = remote_sync_entry("foo-lsp", body);
entry.dev = true;
store.update(cx, |store, _cx| {
store
.extension_index
.extensions
.insert(Arc::from("foo-lsp"), entry);
});
};
insert_dev_entry(&store, cx, "[language_servers.foo]\nlanguage = \"Foo\"");
let (opts, _counter, sync_count, install_count) =
setup_mock_remote_tracking_fingerprints(cx, server_cx);
let client = RemoteClient::connect_mock(opts, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client.clone(), cx)
});
cx.run_until_parked();
assert_eq!(sync_count.load(Ordering::SeqCst), 1);
assert_eq!(
install_count.load(Ordering::SeqCst),
1,
"the initial sync should upload the dev extension"
);
client.update(cx, |_client, cx| {
cx.emit(RemoteClientEvent::Reconnected);
});
cx.run_until_parked();
assert_eq!(sync_count.load(Ordering::SeqCst), 2);
assert_eq!(
install_count.load(Ordering::SeqCst),
1,
"a resync with unchanged dev extension content should not re-upload it"
);
insert_dev_entry(
&store,
cx,
"[language_servers.foo]\nlanguage = \"Foo\"\n\n[language_servers.bar]\nlanguage = \"Bar\"",
);
client.update(cx, |_client, cx| {
cx.emit(RemoteClientEvent::Reconnected);
});
cx.run_until_parked();
assert_eq!(sync_count.load(Ordering::SeqCst), 3);
assert_eq!(
install_count.load(Ordering::SeqCst),
2,
"changed dev extension content should be re-uploaded"
);
}
#[gpui::test]
async fn test_remote_sync_hang_times_out_and_is_retried(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, _fs) = create_extension_store(cx);
let (opts, _counter, sync_count) = setup_mock_remote_hanging(cx, server_cx);
let client = RemoteClient::connect_mock(opts, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client.clone(), cx)
});
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
1,
"registering a client should attempt an initial sync"
);
cx.executor().advance_clock(REMOTE_SYNC_TIMEOUT);
cx.run_until_parked();
cx.executor().advance_clock(remote_sync_retry_delay(0));
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
2,
"a hung sync should time out and be retried"
);
}
#[gpui::test]
async fn test_headless_failed_reload_keeps_other_extensions_languages(cx: &mut TestAppContext) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
fs.insert_tree(
"/extensions",
json!({
"ext-a": {
"extension.toml": r#"
id = "ext-a"
name = "ext-a"
version = "1.0.0"
schema_version = 1
languages = ["languages/shared"]
"#,
"languages": {
"shared": {
"config.toml": "name = \"Shared\"\ngrammar = \"shared\"\npath_suffixes = [\"shared\"]\n"
}
}
},
"ext-b": {
"extension.toml": r#"
id = "ext-b"
name = "ext-b"
version = "1.0.0"
schema_version = 1
languages = ["languages/foo"]
"#,
"languages": {
"foo": {
"config.toml": "name = \"Foo\"\ngrammar = \"foo\"\npath_suffixes = [\"foo\"]\n"
}
}
}
}),
)
.await;
let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
let proxy = Arc::new(ExtensionHostProxy::new());
language_extension::init(LspAccess::Noop, proxy.clone(), language_registry.clone());
let store = cx.update(|cx| {
HeadlessExtensionStore::new(
fs.clone(),
FakeHttpClient::with_200_response(),
PathBuf::from("/extensions"),
proxy,
NodeRuntime::unavailable(),
cx,
)
});
let extensions = || {
vec![
ExtensionVersion {
id: "ext-a".to_string(),
version: "1.0.0".to_string(),
dev: false,
content_fingerprint: None,
},
ExtensionVersion {
id: "ext-b".to_string(),
version: "1.0.0".to_string(),
dev: true,
content_fingerprint: None,
},
]
};
store
.update(cx, |store, cx| store.sync_extensions(extensions(), cx))
.await
.unwrap();
assert_eq!(
language_registry.language_names(),
vec![
LanguageName::new("Foo"),
LanguageName::new("Plain Text"),
LanguageName::new("Shared"),
],
);
fs.insert_tree(
"/extensions/ext-b/languages",
json!({
"shared": {
"config.toml": "name = \"Shared\"\ngrammar = \"shared\"\npath_suffixes = [\"shared\"]\n"
},
"broken": {
"config.toml": "not valid toml ["
}
}),
)
.await;
fs.insert_file(
"/extensions/ext-b/extension.toml",
br#"
id = "ext-b"
name = "ext-b"
version = "1.0.0"
schema_version = 1
languages = ["languages/foo", "languages/shared", "languages/broken"]
"#
.to_vec(),
)
.await;
let missing = store
.update(cx, |store, cx| store.sync_extensions(extensions(), cx))
.await
.unwrap();
assert_eq!(
missing.len(),
1,
"a failed dev extension reload should be reported as missing"
);
assert_eq!(
language_registry.language_names(),
vec![
LanguageName::new("Foo"),
LanguageName::new("Plain Text"),
LanguageName::new("Shared"),
],
"a failed reload of one extension should not deregister languages owned by other extensions"
);
}
#[gpui::test]
async fn test_headless_dev_reload_deregisters_dropped_languages(cx: &mut TestAppContext) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
fs.insert_tree(
"/extensions/foo-dev",
json!({
"extension.toml": r#"
id = "foo-dev"
name = "foo-dev"
version = "1.0.0"
schema_version = 1
languages = ["languages/foo", "languages/bar"]
"#,
"languages": {
"foo": {
"config.toml": "name = \"Foo\"\ngrammar = \"foo\"\npath_suffixes = [\"foo\"]\n"
},
"bar": {
"config.toml": "name = \"Bar\"\ngrammar = \"bar\"\npath_suffixes = [\"bar\"]\n"
}
}
}),
)
.await;
let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
let proxy = Arc::new(ExtensionHostProxy::new());
language_extension::init(LspAccess::Noop, proxy.clone(), language_registry.clone());
let store = cx.update(|cx| {
HeadlessExtensionStore::new(
fs.clone(),
FakeHttpClient::with_200_response(),
PathBuf::from("/extensions"),
proxy,
NodeRuntime::unavailable(),
cx,
)
});
let dev_extension = || {
vec![ExtensionVersion {
id: "foo-dev".to_string(),
version: "1.0.0".to_string(),
dev: true,
content_fingerprint: None,
}]
};
store
.update(cx, |store, cx| store.sync_extensions(dev_extension(), cx))
.await
.unwrap();
assert_eq!(
language_registry.language_names(),
vec![
LanguageName::new("Bar"),
LanguageName::new("Foo"),
LanguageName::new("Plain Text"),
],
);
fs.insert_file(
"/extensions/foo-dev/extension.toml",
br#"
id = "foo-dev"
name = "foo-dev"
version = "1.0.0"
schema_version = 1
languages = ["languages/foo"]
"#
.to_vec(),
)
.await;
store
.update(cx, |store, cx| store.sync_extensions(dev_extension(), cx))
.await
.unwrap();
assert_eq!(
language_registry.language_names(),
vec![LanguageName::new("Foo"), LanguageName::new("Plain Text")],
"a dev reload that drops a language should deregister it"
);
store.read_with(cx, |store, _cx| {
assert_eq!(
store
.loaded_extensions
.get("foo-dev")
.map(|extension| extension.languages.len()),
Some(1)
);
});
}
#[gpui::test]
async fn test_headless_uninstall_restores_surviving_extensions_language_config(
cx: &mut TestAppContext,
) {
init_test(cx);
let shared_language_extension = |id: &str, suffix: &str| {
json!({
"extension.toml": format!(
"id = \"{id}\"\nname = \"{id}\"\nversion = \"1.0.0\"\nschema_version = 1\nlanguages = [\"languages/shared\"]\n"
),
"languages": {
"shared": {
"config.toml": format!(
"name = \"Shared\"\ngrammar = \"shared\"\npath_suffixes = [\"{suffix}\"]\n"
)
}
}
})
};
let fs = FakeFs::new(cx.executor());
fs.insert_tree(
"/extensions",
json!({
"ext-a": shared_language_extension("ext-a", "shared-a"),
"ext-c": shared_language_extension("ext-c", "shared-c"),
}),
)
.await;
let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
let proxy = Arc::new(ExtensionHostProxy::new());
language_extension::init(LspAccess::Noop, proxy.clone(), language_registry.clone());
let store = cx.update(|cx| {
HeadlessExtensionStore::new(
fs.clone(),
FakeHttpClient::with_200_response(),
PathBuf::from("/extensions"),
proxy,
NodeRuntime::unavailable(),
cx,
)
});
let extension = |id: &str| ExtensionVersion {
id: id.to_string(),
version: "1.0.0".to_string(),
dev: false,
content_fingerprint: None,
};
store
.update(cx, |store, cx| {
store.sync_extensions(vec![extension("ext-a"), extension("ext-c")], cx)
})
.await
.unwrap();
store
.update(cx, |store, cx| {
store.sync_extensions(vec![extension("ext-a")], cx)
})
.await
.unwrap();
assert_eq!(
language_registry.language_name_for_extension("shared-a"),
Some(LanguageName::new("Shared")),
"uninstalling an extension should restore the surviving extension's config for a shared language"
);
assert_eq!(
language_registry.language_name_for_extension("shared-c"),
None,
"the uninstalled extension's config should no longer be registered"
);
}
#[gpui::test]
async fn test_headless_failed_reload_restores_previous_language_config(cx: &mut TestAppContext) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
fs.insert_tree(
"/extensions/foo-dev",
json!({
"extension.toml": r#"
id = "foo-dev"
name = "foo-dev"
version = "1.0.0"
schema_version = 1
languages = ["languages/foo"]
"#,
"languages": {
"foo": {
"config.toml": "name = \"Foo\"\ngrammar = \"foo\"\npath_suffixes = [\"foo\"]\n"
}
}
}),
)
.await;
let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
let proxy = Arc::new(ExtensionHostProxy::new());
language_extension::init(LspAccess::Noop, proxy.clone(), language_registry.clone());
let store = cx.update(|cx| {
HeadlessExtensionStore::new(
fs.clone(),
FakeHttpClient::with_200_response(),
PathBuf::from("/extensions"),
proxy,
NodeRuntime::unavailable(),
cx,
)
});
let dev_extension = || {
vec![ExtensionVersion {
id: "foo-dev".to_string(),
version: "1.0.0".to_string(),
dev: true,
content_fingerprint: None,
}]
};
store
.update(cx, |store, cx| store.sync_extensions(dev_extension(), cx))
.await
.unwrap();
assert_eq!(
language_registry.language_name_for_extension("foo"),
Some(LanguageName::new("Foo")),
);
fs.insert_tree(
"/extensions/foo-dev/languages",
json!({
"foo": {
"config.toml": "name = \"Foo\"\ngrammar = \"foo\"\npath_suffixes = [\"foo2\"]\n"
},
"broken": {
"config.toml": "not valid toml ["
}
}),
)
.await;
fs.insert_file(
"/extensions/foo-dev/extension.toml",
br#"
id = "foo-dev"
name = "foo-dev"
version = "1.0.0"
schema_version = 1
languages = ["languages/foo", "languages/broken"]
"#
.to_vec(),
)
.await;
let missing = store
.update(cx, |store, cx| store.sync_extensions(dev_extension(), cx))
.await
.unwrap();
assert_eq!(
missing.len(),
1,
"a failed dev extension reload should be reported as missing"
);
assert_eq!(
language_registry.language_name_for_extension("foo"),
Some(LanguageName::new("Foo")),
"a failed reload should restore the previously registered language config"
);
assert_eq!(
language_registry.language_name_for_extension("foo2"),
None,
"the failed reload's partially applied language config should be rolled back"
);
store.read_with(cx, |store, _cx| {
let loaded = store
.loaded_extensions
.get("foo-dev")
.expect("a failed reload should keep the extension loaded");
assert_eq!(
loaded.version.as_ref(),
"1.0.0",
"a failed reload should keep the previously loaded version"
);
assert_eq!(
loaded.languages.len(),
1,
"a failed reload should not duplicate or drop language registrations"
);
});
}
#[gpui::test]
async fn test_headless_failed_reinstall_restores_previous_registrations(cx: &mut TestAppContext) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
fs.insert_tree(
"/extensions/foo-dev",
json!({
"extension.toml": r#"
id = "foo-dev"
name = "foo-dev"
version = "1.0.0"
schema_version = 1
languages = ["languages/foo"]
"#,
"languages": {
"foo": {
"config.toml": "name = \"Foo\"\ngrammar = \"foo\"\npath_suffixes = [\"foo\"]\n"
}
}
}),
)
.await;
fs.insert_tree(
"/staged/foo-dev",
json!({
"extension.toml": r#"
id = "foo-dev"
name = "foo-dev"
version = "1.0.0"
schema_version = 1
languages = ["languages/foo"]
"#,
"languages": {
"foo": {
"config.toml": "not valid toml ["
}
}
}),
)
.await;
let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
let proxy = Arc::new(ExtensionHostProxy::new());
language_extension::init(LspAccess::Noop, proxy.clone(), language_registry.clone());
let store = cx.update(|cx| {
HeadlessExtensionStore::new(
fs.clone(),
FakeHttpClient::with_200_response(),
PathBuf::from("/extensions"),
proxy,
NodeRuntime::unavailable(),
cx,
)
});
let dev_extension = ExtensionVersion {
id: "foo-dev".to_string(),
version: "1.0.0".to_string(),
dev: true,
content_fingerprint: None,
};
store
.update(cx, |store, cx| {
store.sync_extensions(vec![dev_extension.clone()], cx)
})
.await
.unwrap();
assert_eq!(
language_registry.language_name_for_extension("foo"),
Some(LanguageName::new("Foo")),
);
let install_result = store
.update(cx, |store, cx| {
store.install_extension(dev_extension, PathBuf::from("/staged/foo-dev"), cx)
})
.await;
assert!(
install_result.is_err(),
"installing a broken extension should fail"
);
assert_eq!(
language_registry.language_name_for_extension("foo"),
Some(LanguageName::new("Foo")),
"a failed reinstall should leave the previous registrations untouched"
);
store.read_with(cx, |store, _cx| {
assert_eq!(
store
.loaded_extensions
.get("foo-dev")
.map(|extension| extension.languages.len()),
Some(1),
"a failed reinstall should keep the previously loaded languages"
);
assert_eq!(
store
.loaded_extensions
.get("foo-dev")
.map(|extension| extension.version.as_ref()),
Some("1.0.0"),
"a failed reinstall should keep the previous version loaded"
);
});
assert!(
fs.is_dir(Path::new("/extensions/foo-dev")).await,
"a failed reinstall should not touch the installed files"
);
assert!(
!fs.is_dir(Path::new("/staged/foo-dev")).await,
"a failed reinstall should clean up the staged upload"
);
}
#[gpui::test]
async fn test_remove_stale_uploads_removes_only_stale_entries(cx: &mut TestAppContext) {
let fs = FakeFs::new(cx.executor());
fs.insert_tree(
"/uploads/stale-upload",
json!({
"extension.toml": "id = \"stale\""
}),
)
.await;
fs.set_next_mtime(SystemTime::now() + STALE_UPLOAD_TTL * 2);
fs.insert_tree(
"/uploads/far-future-upload",
json!({
"extension.toml": "id = \"future\""
}),
)
.await;
fs.set_next_mtime(SystemTime::now());
fs.insert_tree(
"/uploads/fresh-upload",
json!({
"extension.toml": "id = \"fresh\""
}),
)
.await;
let fs_trait_object = fs.clone() as Arc<dyn Fs>;
remove_stale_uploads(&fs_trait_object, Path::new("/uploads")).await;
assert!(
!fs.is_dir(Path::new("/uploads/stale-upload")).await,
"an upload directory older than the TTL should be removed"
);
assert!(
!fs.is_dir(Path::new("/uploads/far-future-upload")).await,
"an upload directory with an mtime far in the future should be treated as stale"
);
assert!(
fs.is_dir(Path::new("/uploads/fresh-upload")).await,
"a recently modified upload directory should be kept"
);
}
#[gpui::test]
async fn test_headless_dev_reload_replaces_registrations(cx: &mut TestAppContext) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
fs.insert_tree("/extensions", json!({})).await;
let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
let proxy = Arc::new(ExtensionHostProxy::new());
language_extension::init(LspAccess::Noop, proxy.clone(), language_registry.clone());
let store = cx.update(|cx| {
HeadlessExtensionStore::new(
fs.clone(),
FakeHttpClient::with_200_response(),
PathBuf::from("/extensions"),
proxy,
NodeRuntime::unavailable(),
cx,
)
});
let loaded_extension = || LoadedExtension {
version: "1.0.0".into(),
languages: vec![(
LanguageName::new("Foo"),
LanguageConfig {
name: LanguageName::new("Foo"),
..LanguageConfig::default()
},
)],
language_servers: vec![(
LanguageServerName("foo-lsp".into()),
LanguageName::new("Foo"),
)],
debug_adapters: Vec::new(),
debug_locators: Vec::new(),
wasm_extension: Some(Arc::new(FakeExtension)),
content_fingerprint: None,
};
let foo = LanguageName::new("Foo");
let removal_tasks = store.update(cx, |store, cx| {
store.commit_extension("foo-ext".into(), Some(loaded_extension()), cx)
});
assert_eq!(
removal_tasks.len(),
0,
"the first load should not stop any language servers"
);
assert_eq!(language_registry.lsp_adapters(&foo).len(), 1);
assert_eq!(
language_registry.language_names(),
vec![LanguageName::new("Foo"), LanguageName::new("Plain Text")],
);
for _ in 0..2 {
let removal_tasks = store.update(cx, |store, cx| {
store.commit_extension("foo-ext".into(), Some(loaded_extension()), cx)
});
assert_eq!(
removal_tasks.len(),
1,
"a reload should stop the previously running language server"
);
for removal in removal_tasks {
removal.await.unwrap();
}
assert_eq!(
language_registry.lsp_adapters(&foo).len(),
1,
"a reload should not accumulate duplicate language server registrations"
);
assert_eq!(
language_registry.language_names(),
vec![LanguageName::new("Foo"), LanguageName::new("Plain Text")],
"a reload should not accumulate duplicate language registrations"
);
}
let removal_tasks = store.update(cx, |store, cx| {
store.commit_extension("foo-ext".into(), None, cx)
});
assert_eq!(removal_tasks.len(), 1);
for removal in removal_tasks {
removal.await.unwrap();
}
assert_eq!(
language_registry.lsp_adapters(&foo).len(),
0,
"an uninstall should deregister the language server"
);
assert_eq!(
language_registry.language_names(),
vec![LanguageName::new("Plain Text")],
"an uninstall should deregister the language"
);
}
#[gpui::test]
async fn test_headless_install_failure_after_removing_old_files_evicts_extension(
cx: &mut TestAppContext,
) {
init_test(cx);
let extension_files = |suffix: &str| {
json!({
"extension.toml": r#"
id = "foo"
name = "foo"
version = "1.0.0"
schema_version = 1
languages = ["languages/foo"]
"#,
"languages": {
"foo": {
"config.toml": format!(
"name = \"Foo\"\ngrammar = \"foo\"\npath_suffixes = [\"{suffix}\"]\n"
)
}
}
})
};
let fs = FakeFs::new(cx.executor());
fs.insert_tree("/extensions/foo", extension_files("foo"))
.await;
fs.insert_tree("/staged/foo", extension_files("foo2")).await;
let store = cx.update(|cx| {
HeadlessExtensionStore::new(
fs.clone(),
FakeHttpClient::with_200_response(),
PathBuf::from("/extensions"),
Arc::new(ExtensionHostProxy::new()),
NodeRuntime::unavailable(),
cx,
)
});
let extension = || ExtensionVersion {
id: "foo".to_string(),
version: "1.0.0".to_string(),
dev: false,
content_fingerprint: None,
};
store
.update(cx, |store, cx| store.sync_extensions(vec![extension()], cx))
.await
.unwrap();
store.read_with(cx, |store, _cx| {
assert_eq!(
store
.loaded_extensions
.get("foo")
.map(|extension| extension.version.as_ref()),
Some("1.0.0")
);
});
fs.set_remove_dir_error("/extensions/foo", "simulated removal failure".to_string());
let install_result = store
.update(cx, |store, cx| {
store.install_extension(extension(), PathBuf::from("/staged/foo"), cx)
})
.await;
assert!(
install_result.is_err(),
"an install whose removal step failed should report the error"
);
store.read_with(cx, |store, _cx| {
assert_eq!(
store
.loaded_extensions
.get("foo")
.map(|extension| extension.version.as_ref()),
None,
"a failed install after destructive operations started should evict the extension"
);
});
let missing = store
.update(cx, |store, cx| store.sync_extensions(vec![extension()], cx))
.await
.unwrap();
assert_eq!(
missing.len(),
0,
"a later sync should reload the evicted extension from the intact installed files"
);
store.read_with(cx, |store, _cx| {
assert_eq!(
store
.loaded_extensions
.get("foo")
.map(|extension| extension.version.as_ref()),
Some("1.0.0"),
"a later sync should repair the evicted extension"
);
});
}
#[gpui::test]
async fn test_headless_failed_install_cleanup_is_retried_on_later_syncs(cx: &mut TestAppContext) {
init_test(cx);
let extension_files = |suffix: &str| {
json!({
"extension.toml": r#"
id = "foo"
name = "foo"
version = "1.0.0"
schema_version = 1
languages = ["languages/foo"]
"#,
"languages": {
"foo": {
"config.toml": format!(
"name = \"Foo\"\ngrammar = \"foo\"\npath_suffixes = [\"{suffix}\"]\n"
)
}
}
})
};
let fs = FakeFs::new(cx.executor());
fs.insert_tree("/extensions/foo", extension_files("foo"))
.await;
fs.insert_tree("/staged/foo", extension_files("foo2")).await;
let store = cx.update(|cx| {
HeadlessExtensionStore::new(
fs.clone(),
FakeHttpClient::with_200_response(),
PathBuf::from("/extensions"),
Arc::new(ExtensionHostProxy::new()),
NodeRuntime::unavailable(),
cx,
)
});
let extension = || ExtensionVersion {
id: "foo".to_string(),
version: "1.0.0".to_string(),
dev: false,
content_fingerprint: None,
};
store
.update(cx, |store, cx| store.sync_extensions(vec![extension()], cx))
.await
.unwrap();
fs.set_remove_dir_error("/extensions/foo", "simulated removal failure".to_string());
let install_result = store
.update(cx, |store, cx| {
store.install_extension(extension(), PathBuf::from("/staged/foo"), cx)
})
.await;
assert!(
install_result.is_err(),
"an install whose removal step failed should report the error"
);
store
.update(cx, |store, cx| store.sync_extensions(Vec::new(), cx))
.await
.unwrap();
assert!(
fs.is_dir(Path::new("/extensions/foo")).await,
"the cleanup retry should leave the files while removal keeps failing"
);
fs.clear_remove_dir_error("/extensions/foo");
store
.update(cx, |store, cx| store.sync_extensions(Vec::new(), cx))
.await
.unwrap();
assert!(
!fs.is_dir(Path::new("/extensions/foo")).await,
"a later sync should retry and complete the cleanup of a failed install"
);
}
#[gpui::test]
async fn test_headless_unchanged_reinstall_skips_reload(cx: &mut TestAppContext) {
init_test(cx);
let extension_files = |suffix: &str| {
json!({
"extension.toml": r#"
id = "foo-dev"
name = "foo-dev"
version = "1.0.0"
schema_version = 1
languages = ["languages/foo"]
"#,
"languages": {
"foo": {
"config.toml": format!(
"name = \"Foo\"\ngrammar = \"foo\"\npath_suffixes = [\"{suffix}\"]\n"
)
}
}
})
};
let fs = FakeFs::new(cx.executor());
fs.insert_tree("/extensions/foo-dev", extension_files("foo"))
.await;
fs.insert_tree("/staged/foo-dev", extension_files("foo"))
.await;
let store = cx.update(|cx| {
HeadlessExtensionStore::new(
fs.clone(),
FakeHttpClient::with_200_response(),
PathBuf::from("/extensions"),
Arc::new(ExtensionHostProxy::new()),
NodeRuntime::unavailable(),
cx,
)
});
let installed_changed_count = Arc::new(AtomicUsize::new(0));
cx.update(|cx| {
let extension_events = extension::ExtensionEvents::try_global(cx)
.expect("ExtensionEvents should be initialized in tests");
let installed_changed_count = installed_changed_count.clone();
cx.subscribe(&extension_events, move |_, event, _cx| {
if matches!(event, extension::Event::ExtensionsInstalledChanged) {
installed_changed_count.fetch_add(1, Ordering::SeqCst);
}
})
.detach();
});
let dev_extension = || ExtensionVersion {
id: "foo-dev".to_string(),
version: "1.0.0".to_string(),
dev: true,
content_fingerprint: None,
};
store
.update(cx, |store, cx| {
store.sync_extensions(vec![dev_extension()], cx)
})
.await
.unwrap();
cx.run_until_parked();
assert_eq!(installed_changed_count.load(Ordering::SeqCst), 1);
store
.update(cx, |store, cx| {
store.install_extension(dev_extension(), PathBuf::from("/staged/foo-dev"), cx)
})
.await
.unwrap();
cx.run_until_parked();
assert_eq!(
installed_changed_count.load(Ordering::SeqCst),
1,
"reinstalling identical content should not reload the extension or notify"
);
assert!(
!fs.is_dir(Path::new("/staged/foo-dev")).await,
"a skipped install should clean up the staged upload"
);
assert!(
fs.is_dir(Path::new("/extensions/foo-dev")).await,
"a skipped install should leave the installed files untouched"
);
store.read_with(cx, |store, _cx| {
assert_eq!(
store
.loaded_extensions
.get("foo-dev")
.map(|extension| extension.version.as_ref()),
Some("1.0.0"),
"a skipped install should keep the extension loaded"
);
});
fs.insert_tree("/staged/foo-dev", extension_files("foo2"))
.await;
store
.update(cx, |store, cx| {
store.install_extension(dev_extension(), PathBuf::from("/staged/foo-dev"), cx)
})
.await
.unwrap();
cx.run_until_parked();
assert_eq!(
installed_changed_count.load(Ordering::SeqCst),
2,
"reinstalling changed content should reload the extension and notify"
);
}
#[gpui::test]
async fn test_headless_failed_uninstall_is_retried_on_later_syncs(cx: &mut TestAppContext) {
init_test(cx);
let extension_files = |id: &str| {
json!({
"extension.toml": format!(
"id = \"{id}\"\nname = \"{id}\"\nversion = \"1.0.0\"\nschema_version = 1\nlanguages = [\"languages/lang\"]\n"
),
"languages": {
"lang": {
"config.toml": format!(
"name = \"{id}-lang\"\ngrammar = \"{id}\"\npath_suffixes = [\"{id}\"]\n"
)
}
}
})
};
let fs = FakeFs::new(cx.executor());
fs.insert_tree(
"/extensions",
json!({
"ext-a": extension_files("ext-a"),
"ext-b": extension_files("ext-b"),
"ext-c": extension_files("ext-c"),
}),
)
.await;
let store = cx.update(|cx| {
HeadlessExtensionStore::new(
fs.clone(),
FakeHttpClient::with_200_response(),
PathBuf::from("/extensions"),
Arc::new(ExtensionHostProxy::new()),
NodeRuntime::unavailable(),
cx,
)
});
let extension = |id: &str| ExtensionVersion {
id: id.to_string(),
version: "1.0.0".to_string(),
dev: false,
content_fingerprint: None,
};
store
.update(cx, |store, cx| {
store.sync_extensions(
vec![extension("ext-a"), extension("ext-b"), extension("ext-c")],
cx,
)
})
.await
.unwrap();
fs.set_remove_dir_error("/extensions/ext-a", "simulated removal failure".to_string());
fs.set_remove_dir_error("/extensions/ext-c", "simulated removal failure".to_string());
store
.update(cx, |store, cx| {
store.sync_extensions(vec![extension("ext-b")], cx)
})
.await
.unwrap();
store.read_with(cx, |store, _cx| {
assert_eq!(
store.loaded_extensions.keys().cloned().collect::<Vec<_>>(),
vec![Arc::<str>::from("ext-b")],
"failed removals should still evict the extensions"
);
});
assert!(
fs.is_dir(Path::new("/extensions/ext-a")).await,
"a failed removal should leave the files on disk"
);
let missing = store
.update(cx, |store, cx| {
store.sync_extensions(vec![extension("ext-b"), extension("ext-c")], cx)
})
.await
.unwrap();
assert_eq!(
missing.len(),
0,
"an extension pending removal that the client re-requests should be reloaded from the intact files instead"
);
store.read_with(cx, |store, _cx| {
let mut ids = store.loaded_extensions.keys().cloned().collect::<Vec<_>>();
ids.sort();
assert_eq!(
ids,
vec![Arc::<str>::from("ext-b"), Arc::<str>::from("ext-c")]
);
});
assert!(
fs.is_dir(Path::new("/extensions/ext-a")).await,
"a removal that keeps failing should keep the files on disk"
);
fs.clear_remove_dir_error("/extensions/ext-a");
store
.update(cx, |store, cx| {
store.sync_extensions(vec![extension("ext-b"), extension("ext-c")], cx)
})
.await
.unwrap();
assert!(
!fs.is_dir(Path::new("/extensions/ext-a")).await,
"a later sync should retry and complete the failed removal"
);
}
#[gpui::test]
async fn test_index_change_without_remote_relevant_extensions_does_not_sync(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) {
init_test(cx);
let (store, fs) = create_extension_store(cx);
let (opts, _counter, sync_count) = setup_mock_remote(cx, server_cx);
let client = RemoteClient::connect_mock(opts, cx).await;
store.update(cx, |store, cx| {
store.register_remote_client(client.clone(), cx)
});
cx.run_until_parked();
assert_eq!(sync_count.load(Ordering::SeqCst), 1);
fs.insert_tree(
"/extensions/installed/plain-ext",
json!({
"extension.toml": "id = \"plain-ext\"\nname = \"plain-ext\"\nversion = \"1.0.0\"\nschema_version = 1\n",
}),
)
.await;
store.update(cx, |store, cx| drop(store.reload(None, cx)));
cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION);
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
1,
"an index change that does not affect remote-synced extensions should not trigger a sync"
);
insert_remote_relevant_extension(&fs, "sync-ext").await;
store.update(cx, |store, cx| drop(store.reload(None, cx)));
cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION);
cx.run_until_parked();
assert_eq!(
sync_count.load(Ordering::SeqCst),
2,
"an index change that affects remote-synced extensions should trigger a sync"
);
}
#[gpui::test]
async fn test_uninstalling_extension_restores_surviving_extensions_language(
cx: &mut TestAppContext,
) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
let proxy = Arc::new(ExtensionHostProxy::new());
language_extension::init(LspAccess::Noop, proxy.clone(), language_registry.clone());
insert_language_extension(&fs, "ext-a", "Shared", "shared-a").await;
insert_language_extension(&fs, "ext-b", "Shared", "shared-b").await;
let store = create_extension_store_with(fs.clone(), proxy, cx);
assert_eq!(
language_registry.language_name_for_extension("shared-b"),
Some(LanguageName::new("Shared")),
"the extension scanned last should own the language in the index"
);
fs.remove_dir(
Path::new("/extensions/installed/ext-b"),
RemoveOptions {
recursive: true,
ignore_if_not_exists: false,
},
)
.await
.unwrap();
store.update(cx, |store, cx| drop(store.reload(None, cx)));
cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION);
cx.run_until_parked();
assert_eq!(
language_registry.language_name_for_extension("shared-a"),
Some(LanguageName::new("Shared")),
"uninstalling the owning extension should re-register the language from the surviving extension"
);
assert_eq!(
language_registry.language_name_for_extension("shared-b"),
None,
"the uninstalled extension's language config should be gone"
);
}
#[gpui::test]
async fn test_extension_reload_removes_dropped_semantic_token_rules(cx: &mut TestAppContext) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
let proxy = Arc::new(ExtensionHostProxy::new());
language_extension::init(LspAccess::Noop, proxy.clone(), language_registry.clone());
insert_language_extension(&fs, "ext-a", "Shared", "shared").await;
fs.insert_tree(
"/extensions/installed/ext-a/languages/lang",
json!({ "semantic_token_rules.json": "[]" }),
)
.await;
let store = create_extension_store_with(fs.clone(), proxy, cx);
cx.update(|cx| {
assert!(
cx.global::<SettingsStore>()
.language_semantic_token_rules("Shared")
.is_some()
);
});
fs.remove_file(
Path::new("/extensions/installed/ext-a/languages/lang/semantic_token_rules.json"),
RemoveOptions {
recursive: false,
ignore_if_not_exists: false,
},
)
.await
.unwrap();
store.update(cx, |store, cx| drop(store.reload(Some("ext-a".into()), cx)));
cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION);
cx.run_until_parked();
assert_eq!(
language_registry.language_name_for_extension("shared"),
Some(LanguageName::new("Shared")),
);
cx.update(|cx| {
assert!(
cx.global::<SettingsStore>()
.language_semantic_token_rules("Shared")
.is_none()
);
});
}
#[gpui::test]
async fn test_rejected_readded_language_keeps_native_semantic_token_rules(cx: &mut TestAppContext) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
let proxy = Arc::new(ExtensionHostProxy::new());
language_extension::init(LspAccess::Noop, proxy.clone(), language_registry.clone());
language_registry.register_test_language(LanguageConfig {
name: LanguageName::new("Shared"),
matcher: Arc::new(LanguageMatcher {
path_suffixes: vec!["builtin".into()],
..LanguageMatcher::default()
}),
..LanguageConfig::default()
});
cx.update(|cx| {
cx.update_global::<SettingsStore, _>(|store, _cx| {
store.set_language_semantic_token_rules(
"Shared".into(),
settings::SemanticTokenRules::default(),
);
});
});
insert_language_extension(&fs, "ext-a", "Shared", "shadowed-a").await;
insert_language_extension(&fs, "ext-b", "Shared", "shadowed-b").await;
let store = create_extension_store_with(fs.clone(), proxy, cx);
fs.remove_dir(
Path::new("/extensions/installed/ext-b"),
RemoveOptions {
recursive: true,
ignore_if_not_exists: false,
},
)
.await
.unwrap();
store.update(cx, |store, cx| drop(store.reload(None, cx)));
cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION);
cx.run_until_parked();
assert_eq!(
language_registry.language_name_for_extension("builtin"),
Some(LanguageName::new("Shared")),
);
cx.update(|cx| {
assert!(
cx.global::<SettingsStore>()
.language_semantic_token_rules("Shared")
.is_some(),
"re-adding a language that a native language shadows must keep the native rules"
);
});
}
#[gpui::test]
async fn test_extension_cannot_shadow_language_registered_outside_extensions(
cx: &mut TestAppContext,
) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
let proxy = Arc::new(ExtensionHostProxy::new());
language_extension::init(LspAccess::Noop, proxy.clone(), language_registry.clone());
language_registry.register_test_language(LanguageConfig {
name: LanguageName::new("Shared"),
matcher: Arc::new(LanguageMatcher {
path_suffixes: vec!["builtin".into()],
..LanguageMatcher::default()
}),
..LanguageConfig::default()
});
let store = create_extension_store_with(fs.clone(), proxy, cx);
insert_language_extension(&fs, "ext-a", "Shared", "shadowed").await;
store.update(cx, |store, cx| drop(store.reload(None, cx)));
cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION);
cx.run_until_parked();
assert_eq!(
language_registry.language_name_for_extension("builtin"),
Some(LanguageName::new("Shared")),
"an extension must not replace a language registered outside of extensions"
);
assert_eq!(
language_registry.language_name_for_extension("shadowed"),
None,
"the shadowing extension's language config should not be registered"
);
fs.remove_dir(
Path::new("/extensions/installed/ext-a"),
RemoveOptions {
recursive: true,
ignore_if_not_exists: false,
},
)
.await
.unwrap();
store.update(cx, |store, cx| drop(store.reload(None, cx)));
cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION);
cx.run_until_parked();
assert_eq!(
language_registry.language_name_for_extension("builtin"),
Some(LanguageName::new("Shared")),
"uninstalling the shadowing extension must not remove the language it never registered"
);
}
#[gpui::test]
async fn test_headless_extension_cannot_shadow_language_registered_outside_extensions(
cx: &mut TestAppContext,
) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
fs.insert_tree(
"/extensions/ext-a",
json!({
"extension.toml": r#"
id = "ext-a"
name = "ext-a"
version = "1.0.0"
schema_version = 1
languages = ["languages/shared"]
"#,
"languages": {
"shared": {
"config.toml": "name = \"Shared\"\npath_suffixes = [\"shadowed\"]\n"
}
}
}),
)
.await;
let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
let proxy = Arc::new(ExtensionHostProxy::new());
language_extension::init(LspAccess::Noop, proxy.clone(), language_registry.clone());
language_registry.register_test_language(LanguageConfig {
name: LanguageName::new("Shared"),
matcher: Arc::new(LanguageMatcher {
path_suffixes: vec!["builtin".into()],
..LanguageMatcher::default()
}),
..LanguageConfig::default()
});
let store = cx.update(|cx| {
HeadlessExtensionStore::new(
fs.clone(),
FakeHttpClient::with_200_response(),
PathBuf::from("/extensions"),
proxy,
NodeRuntime::unavailable(),
cx,
)
});
let extension = || {
vec![ExtensionVersion {
id: "ext-a".to_string(),
version: "1.0.0".to_string(),
dev: false,
content_fingerprint: None,
}]
};
store
.update(cx, |store, cx| store.sync_extensions(extension(), cx))
.await
.unwrap();
assert_eq!(
language_registry.language_name_for_extension("builtin"),
Some(LanguageName::new("Shared")),
"an extension must not replace a language registered outside of extensions"
);
assert_eq!(
language_registry.language_name_for_extension("shadowed"),
None,
"the shadowing extension's language config should not be registered"
);
store
.update(cx, |store, cx| store.sync_extensions(Vec::new(), cx))
.await
.unwrap();
assert_eq!(
language_registry.language_name_for_extension("builtin"),
Some(LanguageName::new("Shared")),
"unloading the shadowing extension must not remove the language it never registered"
);
}
#[gpui::test]
async fn test_hash_directory_contents_hashes_symlinks_by_target(cx: &mut TestAppContext) {
let fs = FakeFs::new(cx.executor());
fs.insert_tree(
"/targets",
json!({
"target-1": "one",
"target-2": "two",
}),
)
.await;
fs.insert_tree(
"/dir",
json!({
"file.txt": "contents",
}),
)
.await;
fs.insert_symlink("/dir/link", PathBuf::from("/targets/target-1"))
.await;
let fs_trait_object = fs.clone() as Arc<dyn Fs>;
let first = hash_directory_contents(&fs_trait_object, Path::new("/dir"))
.await
.unwrap();
let second = hash_directory_contents(&fs_trait_object, Path::new("/dir"))
.await
.unwrap();
assert_eq!(
first, second,
"fingerprinting a directory containing a symlink should be deterministic"
);
fs.insert_symlink("/dir/link", PathBuf::from("/targets/target-2"))
.await;
let third = hash_directory_contents(&fs_trait_object, Path::new("/dir"))
.await
.unwrap();
assert_ne!(
first, third,
"changing a symlink's target should change the fingerprint"
);
}
struct SyncRequestCounter {
sync_count: Arc<AtomicUsize>,
failures_remaining: usize,
installed_fingerprints: HashMap<String, Option<u64>>,
}
fn setup_mock_remote(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) -> (
RemoteConnectionOptions,
Entity<SyncRequestCounter>,
Arc<AtomicUsize>,
) {
setup_mock_remote_with_failures(cx, server_cx, 0)
}
fn setup_mock_remote_with_failures(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
failures: usize,
) -> (
RemoteConnectionOptions,
Entity<SyncRequestCounter>,
Arc<AtomicUsize>,
) {
let sync_count = Arc::new(AtomicUsize::new(0));
let counter = server_cx.new(|_| SyncRequestCounter {
sync_count: sync_count.clone(),
failures_remaining: failures,
installed_fingerprints: HashMap::default(),
});
let (opts, server_client, _) = RemoteClient::fake_server(cx, server_cx);
register_server_handlers(&server_client, counter.clone());
(opts, counter, sync_count)
}
fn setup_mock_remote_with_install_failures(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
failures: usize,
) -> (
RemoteConnectionOptions,
Entity<SyncRequestCounter>,
Arc<AtomicUsize>,
Arc<AtomicUsize>,
) {
let sync_count = Arc::new(AtomicUsize::new(0));
let install_count = Arc::new(AtomicUsize::new(0));
let counter = server_cx.new(|_| SyncRequestCounter {
sync_count: sync_count.clone(),
failures_remaining: failures,
installed_fingerprints: HashMap::default(),
});
let (opts, server_client, _) = RemoteClient::fake_server(cx, server_cx);
register_ping_handler(&server_client, &counter);
register_sync_handler(
&server_client,
&counter,
SyncHandlerBehavior {
fail_from_counter: false,
echo_missing_extensions: true,
},
);
server_client.add_request_handler::<proto::InstallExtension, SyncRequestCounter, _, _>(
counter.downgrade(),
{
let install_count = install_count.clone();
move |counter, _envelope: TypedEnvelope<proto::InstallExtension>, mut cx| {
let install_count = install_count.clone();
async move {
install_count.fetch_add(1, Ordering::SeqCst);
let should_fail = counter.update(&mut cx, |counter, _cx| {
if counter.failures_remaining > 0 {
counter.failures_remaining -= 1;
true
} else {
false
}
});
anyhow::ensure!(!should_fail, "simulated install failure");
Ok(proto::Ack {})
}
}
},
);
(opts, counter, sync_count, install_count)
}
fn setup_mock_remote_tracking_fingerprints(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) -> (
RemoteConnectionOptions,
Entity<SyncRequestCounter>,
Arc<AtomicUsize>,
Arc<AtomicUsize>,
) {
let sync_count = Arc::new(AtomicUsize::new(0));
let install_count = Arc::new(AtomicUsize::new(0));
let counter = server_cx.new(|_| SyncRequestCounter {
sync_count: sync_count.clone(),
failures_remaining: 0,
installed_fingerprints: HashMap::default(),
});
let (opts, server_client, _) = RemoteClient::fake_server(cx, server_cx);
register_ping_handler(&server_client, &counter);
server_client.add_request_handler::<proto::SyncExtensions, SyncRequestCounter, _, _>(
counter.downgrade(),
|counter, envelope: TypedEnvelope<proto::SyncExtensions>, mut cx| async move {
let missing_extensions = counter.update(&mut cx, |counter, _cx| {
counter.sync_count.fetch_add(1, Ordering::SeqCst);
envelope
.payload
.extensions
.into_iter()
.filter(|extension| {
let installed = counter
.installed_fingerprints
.get(&extension.id)
.copied()
.flatten();
extension.content_fingerprint.is_none()
|| installed != extension.content_fingerprint
})
.collect()
});
Ok(proto::SyncExtensionsResponse {
missing_extensions,
tmp_dir: "/remote-tmp".to_string(),
})
},
);
server_client.add_request_handler::<proto::InstallExtension, SyncRequestCounter, _, _>(
counter.downgrade(),
{
let install_count = install_count.clone();
move |counter, envelope: TypedEnvelope<proto::InstallExtension>, mut cx| {
let install_count = install_count.clone();
async move {
install_count.fetch_add(1, Ordering::SeqCst);
if let Some(extension) = envelope.payload.extension {
counter.update(&mut cx, |counter, _cx| {
counter
.installed_fingerprints
.insert(extension.id, extension.content_fingerprint);
});
}
Ok(proto::Ack {})
}
}
},
);
(opts, counter, sync_count, install_count)
}
fn setup_mock_remote_hanging(
cx: &mut TestAppContext,
server_cx: &mut TestAppContext,
) -> (
RemoteConnectionOptions,
Entity<SyncRequestCounter>,
Arc<AtomicUsize>,
) {
let sync_count = Arc::new(AtomicUsize::new(0));
let counter = server_cx.new(|_| SyncRequestCounter {
sync_count: sync_count.clone(),
failures_remaining: 0,
installed_fingerprints: HashMap::default(),
});
let (opts, server_client, _) = RemoteClient::fake_server(cx, server_cx);
register_ping_handler(&server_client, &counter);
server_client.add_request_handler::<proto::SyncExtensions, SyncRequestCounter, _, _>(
counter.downgrade(),
|counter, _envelope: TypedEnvelope<proto::SyncExtensions>, mut cx| async move {
counter.update(&mut cx, |counter, _cx| {
counter.sync_count.fetch_add(1, Ordering::SeqCst)
});
drop(counter);
futures::future::pending::<()>().await;
Ok(proto::SyncExtensionsResponse {
missing_extensions: Vec::new(),
tmp_dir: String::new(),
})
},
);
(opts, counter, sync_count)
}
fn register_ping_handler(server_client: &AnyProtoClient, counter: &Entity<SyncRequestCounter>) {
server_client.add_request_handler::<proto::Ping, SyncRequestCounter, _, _>(
counter.downgrade(),
|_counter, _envelope: TypedEnvelope<proto::Ping>, _cx| async move { Ok(proto::Ack {}) },
);
}
fn register_server_handlers(server_client: &AnyProtoClient, counter: Entity<SyncRequestCounter>) {
register_ping_handler(server_client, &counter);
register_sync_handler(
server_client,
&counter,
SyncHandlerBehavior {
fail_from_counter: true,
echo_missing_extensions: false,
},
);
}
#[derive(Clone, Copy)]
struct SyncHandlerBehavior {
fail_from_counter: bool,
echo_missing_extensions: bool,
}
fn register_sync_handler(
server_client: &AnyProtoClient,
counter: &Entity<SyncRequestCounter>,
behavior: SyncHandlerBehavior,
) {
server_client.add_request_handler::<proto::SyncExtensions, SyncRequestCounter, _, _>(
counter.downgrade(),
move |counter, envelope: TypedEnvelope<proto::SyncExtensions>, mut cx| async move {
let should_fail = counter.update(&mut cx, |counter, _cx| {
counter.sync_count.fetch_add(1, Ordering::SeqCst);
if behavior.fail_from_counter && counter.failures_remaining > 0 {
counter.failures_remaining -= 1;
true
} else {
false
}
});
anyhow::ensure!(!should_fail, "simulated sync failure");
Ok(proto::SyncExtensionsResponse {
missing_extensions: if behavior.echo_missing_extensions {
envelope.payload.extensions
} else {
Vec::new()
},
tmp_dir: "/remote-tmp".to_string(),
})
},
);
}
fn create_extension_store(cx: &mut TestAppContext) -> (Entity<ExtensionStore>, Arc<FakeFs>) {
let fs = FakeFs::new(cx.executor());
let store = create_extension_store_with(fs.clone(), Arc::new(ExtensionHostProxy::new()), cx);
(store, fs)
}
fn insert_remote_sync_index_entry(store: &Entity<ExtensionStore>, cx: &mut TestAppContext) {
store.update(cx, |store, _cx| {
store.extension_index.extensions.insert(
Arc::from("foo-lsp"),
remote_sync_entry(
"foo-lsp",
r#"
[language_servers.foo]
language = "Foo"
"#,
),
);
});
}
fn advance_through_sync_backoff(cx: &mut TestAppContext) {
for attempts in 0..8 {
cx.executor()
.advance_clock(remote_sync_retry_delay(attempts));
cx.run_until_parked();
}
}
fn create_extension_store_with(
fs: Arc<FakeFs>,
proxy: Arc<ExtensionHostProxy>,
cx: &mut TestAppContext,
) -> Entity<ExtensionStore> {
let http_client = FakeHttpClient::with_200_response();
let node_runtime = NodeRuntime::unavailable();
let store = cx.new(|cx| {
ExtensionStore::new(
PathBuf::from("/extensions"),
None,
proxy,
fs,
http_client.clone(),
http_client,
None,
node_runtime,
cx,
)
});
cx.run_until_parked();
cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION);
cx.run_until_parked();
store
}
async fn insert_remote_relevant_extension(fs: &Arc<FakeFs>, id: &str) {
fs.insert_tree(
format!("/extensions/installed/{id}"),
json!({
"extension.toml": format!(
"id = \"{id}\"\nname = \"{id}\"\nversion = \"1.0.0\"\nschema_version = 1\n\n[language_servers.{id}-lsp]\nlanguage = \"{id}-lang\"\n"
),
}),
)
.await;
}
async fn insert_language_extension(fs: &Arc<FakeFs>, id: &str, language: &str, suffix: &str) {
fs.insert_tree(
format!("/extensions/installed/{id}"),
json!({
"extension.toml": format!(
"id = \"{id}\"\nname = \"{id}\"\nversion = \"1.0.0\"\nschema_version = 1\nlanguages = [\"languages/lang\"]\n"
),
"languages": {
"lang": {
"config.toml": format!(
"name = \"{language}\"\npath_suffixes = [\"{suffix}\"]\n"
)
}
}
}),
)
.await;
}
struct FakeExtension;
#[async_trait]
impl Extension for FakeExtension {
fn manifest(&self) -> Arc<ExtensionManifest> {
Arc::new(ExtensionManifest {
id: "fake-extension".into(),
name: "Fake Extension".to_string(),
version: "1.0.0".into(),
schema_version: SchemaVersion(1),
description: None,
repository: None,
authors: Vec::new(),
lib: LibManifestEntry::default(),
themes: Vec::new(),
icon_themes: Vec::new(),
languages: Vec::new(),
grammars: BTreeMap::default(),
language_servers: BTreeMap::default(),
context_servers: BTreeMap::default(),
slash_commands: BTreeMap::default(),
snippets: None,
capabilities: Vec::new(),
debug_adapters: BTreeMap::default(),
debug_locators: BTreeMap::default(),
language_model_providers: BTreeMap::default(),
})
}
fn work_dir(&self) -> Arc<Path> {
Arc::from(Path::new("/fake-extension-work-dir"))
}
async fn language_server_command(
&self,
_language_server_id: LanguageServerName,
_language_name: LanguageName,
_worktree: Arc<dyn WorktreeDelegate>,
_language_server_status_source: EntityId,
) -> anyhow::Result<Command> {
anyhow::bail!("not supported by FakeExtension")
}
async fn language_server_initialization_options(
&self,
_language_server_id: LanguageServerName,
_language_name: LanguageName,
_worktree: Arc<dyn WorktreeDelegate>,
_language_server_status_source: EntityId,
) -> anyhow::Result<Option<String>> {
anyhow::bail!("not supported by FakeExtension")
}
async fn language_server_workspace_configuration(
&self,
_language_server_id: LanguageServerName,
_worktree: Arc<dyn WorktreeDelegate>,
_language_server_status_source: EntityId,
) -> anyhow::Result<Option<String>> {
anyhow::bail!("not supported by FakeExtension")
}
async fn language_server_initialization_options_schema(
&self,
_language_server_id: LanguageServerName,
_worktree: Arc<dyn WorktreeDelegate>,
_language_server_status_source: EntityId,
) -> anyhow::Result<Option<String>> {
anyhow::bail!("not supported by FakeExtension")
}
async fn language_server_workspace_configuration_schema(
&self,
_language_server_id: LanguageServerName,
_worktree: Arc<dyn WorktreeDelegate>,
_language_server_status_source: EntityId,
) -> anyhow::Result<Option<String>> {
anyhow::bail!("not supported by FakeExtension")
}
async fn language_server_additional_initialization_options(
&self,
_language_server_id: LanguageServerName,
_target_language_server_id: LanguageServerName,
_worktree: Arc<dyn WorktreeDelegate>,
_language_server_status_source: EntityId,
) -> anyhow::Result<Option<String>> {
anyhow::bail!("not supported by FakeExtension")
}
async fn language_server_additional_workspace_configuration(
&self,
_language_server_id: LanguageServerName,
_target_language_server_id: LanguageServerName,
_worktree: Arc<dyn WorktreeDelegate>,
_language_server_status_source: EntityId,
) -> anyhow::Result<Option<String>> {
anyhow::bail!("not supported by FakeExtension")
}
async fn labels_for_completions(
&self,
_language_server_id: LanguageServerName,
_completions: Vec<Completion>,
) -> anyhow::Result<Vec<Option<CodeLabel>>> {
anyhow::bail!("not supported by FakeExtension")
}
async fn labels_for_symbols(
&self,
_language_server_id: LanguageServerName,
_symbols: Vec<Symbol>,
) -> anyhow::Result<Vec<Option<CodeLabel>>> {
anyhow::bail!("not supported by FakeExtension")
}
async fn complete_slash_command_argument(
&self,
_command: SlashCommand,
_arguments: Vec<String>,
) -> anyhow::Result<Vec<SlashCommandArgumentCompletion>> {
anyhow::bail!("not supported by FakeExtension")
}
async fn run_slash_command(
&self,
_command: SlashCommand,
_arguments: Vec<String>,
_worktree: Option<Arc<dyn WorktreeDelegate>>,
) -> anyhow::Result<SlashCommandOutput> {
anyhow::bail!("not supported by FakeExtension")
}
async fn context_server_command(
&self,
_context_server_id: Arc<str>,
_project: Arc<dyn ProjectDelegate>,
) -> anyhow::Result<Command> {
anyhow::bail!("not supported by FakeExtension")
}
async fn context_server_configuration(
&self,
_context_server_id: Arc<str>,
_project: Arc<dyn ProjectDelegate>,
) -> anyhow::Result<Option<ContextServerConfiguration>> {
anyhow::bail!("not supported by FakeExtension")
}
async fn suggest_docs_packages(&self, _provider: Arc<str>) -> anyhow::Result<Vec<String>> {
anyhow::bail!("not supported by FakeExtension")
}
async fn index_docs(
&self,
_provider: Arc<str>,
_package_name: Arc<str>,
_kv_store: Arc<dyn KeyValueStoreDelegate>,
) -> anyhow::Result<()> {
anyhow::bail!("not supported by FakeExtension")
}
async fn get_dap_binary(
&self,
_dap_name: Arc<str>,
_config: DebugTaskDefinition,
_user_installed_path: Option<PathBuf>,
_worktree: Arc<dyn WorktreeDelegate>,
) -> anyhow::Result<DebugAdapterBinary> {
anyhow::bail!("not supported by FakeExtension")
}
async fn dap_request_kind(
&self,
_dap_name: Arc<str>,
_config: serde_json::Value,
) -> anyhow::Result<StartDebuggingRequestArgumentsRequest> {
anyhow::bail!("not supported by FakeExtension")
}
async fn dap_config_to_scenario(
&self,
_config: ZedDebugConfig,
) -> anyhow::Result<DebugScenario> {
anyhow::bail!("not supported by FakeExtension")
}
async fn dap_locator_create_scenario(
&self,
_locator_name: String,
_build_config_template: BuildTaskTemplate,
_resolved_label: String,
_debug_adapter_name: String,
) -> anyhow::Result<Option<DebugScenario>> {
anyhow::bail!("not supported by FakeExtension")
}
async fn run_dap_locator(
&self,
_locator_name: String,
_config: SpawnInTerminal,
) -> anyhow::Result<DebugRequest> {
anyhow::bail!("not supported by FakeExtension")
}
}