TEMP

ConradIrwin · ConradIrwin · commit ab95ed9ffd41 · 2025-11-10T09:34:39.000-07:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/auto_update/Cargo.toml b/crates/auto_update/Cargo.toml
@@ -33,4 +33,5 @@ workspace.workspace = true
 which.workspace = true
 
 [dev-dependencies]
+clock= { workspace = true, "features" = ["test-support"] }
 gpui = { workspace = true, "features" = ["test-support"] }
diff --git a/crates/auto_update/src/auto_update.rs b/crates/auto_update/src/auto_update.rs
@@ -1,6 +1,5 @@
 use anyhow::{Context as _, Result};
 use client::Client;
-use db::RELEASE_CHANNEL;
 use db::kvp::KEY_VALUE_STORE;
 use gpui::{
     App, AppContext as _, AsyncApp, BackgroundExecutor, Context, Entity, Global, SemanticVersion,
@@ -57,7 +56,7 @@ pub struct AssetQuery<'a> {
     is_staff: Option<bool>,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub enum AutoUpdateStatus {
     Idle,
     Checking,
@@ -67,6 +66,29 @@ pub enum AutoUpdateStatus {
     Errored { error: Arc<anyhow::Error> },
 }
 
+impl PartialEq for AutoUpdateStatus {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (AutoUpdateStatus::Idle, AutoUpdateStatus::Idle) => true,
+            (AutoUpdateStatus::Checking, AutoUpdateStatus::Checking) => true,
+            (
+                AutoUpdateStatus::Downloading { version: v1 },
+                AutoUpdateStatus::Downloading { version: v2 },
+            ) => v1 == v2,
+            (
+                AutoUpdateStatus::Installing { version: v1 },
+                AutoUpdateStatus::Installing { version: v2 },
+            ) => v1 == v2,
+            (
+                AutoUpdateStatus::Updated { version: v1 },
+                AutoUpdateStatus::Updated { version: v2 },
+            ) => v1 == v2,
+            (AutoUpdateStatus::Errored { .. }, AutoUpdateStatus::Errored { .. }) => true, // Compare errors by existence, not content
+            _ => false,
+        }
+    }
+}
+
 impl AutoUpdateStatus {
     pub fn is_updated(&self) -> bool {
         matches!(self, Self::Updated { .. })
@@ -76,12 +98,12 @@ impl AutoUpdateStatus {
 pub struct AutoUpdater {
     status: AutoUpdateStatus,
     current_version: SemanticVersion,
-    http_client: Arc<HttpClientWithUrl>,
+    client: Arc<Client>,
     pending_poll: Option<Task<Option<()>>>,
     quit_subscription: Option<gpui::Subscription>,
 }
 
-#[derive(Deserialize, Clone, Debug)]
+#[derive(Deserialize, Serialize, Clone, Debug)]
 pub struct ReleaseAsset {
     pub version: String,
     pub url: String,
@@ -138,7 +160,7 @@ struct GlobalAutoUpdate(Option<Entity<AutoUpdater>>);
 
 impl Global for GlobalAutoUpdate {}
 
-pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
+pub fn init(client: Arc<Client>, cx: &mut App) {
     AutoUpdateSetting::register(cx);
 
     cx.observe_new(|workspace: &mut Workspace, _window, _cx| {
@@ -152,7 +174,7 @@ pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
 
     let version = release_channel::AppVersion::global(cx);
     let auto_updater = cx.new(|cx| {
-        let updater = AutoUpdater::new(version, http_client, cx);
+        let updater = AutoUpdater::new(version, client, cx);
 
         let poll_for_updates = ReleaseChannel::try_global(cx)
             .map(|channel| channel.poll_for_updates())
@@ -236,7 +258,7 @@ pub fn view_release_notes(_: &ViewReleaseNotes, cx: &mut App) -> Option<()> {
             let current_version = auto_updater.current_version;
             let release_channel = release_channel.dev_name();
             let path = format!("/releases/{release_channel}/{current_version}");
-            let url = &auto_updater.http_client.build_url(&path);
+            let url = &auto_updater.client.http_client().build_url(&path);
             cx.open_url(url);
         }
         ReleaseChannel::Nightly => {
@@ -299,11 +321,7 @@ impl AutoUpdater {
         cx.default_global::<GlobalAutoUpdate>().0.clone()
     }
 
-    fn new(
-        current_version: SemanticVersion,
-        http_client: Arc<HttpClientWithUrl>,
-        cx: &mut Context<Self>,
-    ) -> Self {
+    fn new(current_version: SemanticVersion, client: Arc<Client>, cx: &mut Context<Self>) -> Self {
         // On windows, executable files cannot be overwritten while they are
         // running, so we must wait to overwrite the application until quitting
         // or restarting. When quitting the app, we spawn the auto update helper
@@ -324,13 +342,14 @@ impl AutoUpdater {
         Self {
             status: AutoUpdateStatus::Idle,
             current_version,
-            http_client,
+            client,
             pending_poll: None,
             quit_subscription,
         }
     }
 
     pub fn start_polling(&self, cx: &mut Context<Self>) -> Task<Result<()>> {
+        dbg!("start polling");
         cx.spawn(async move |this, cx| {
             #[cfg(target_os = "windows")]
             {
@@ -351,6 +370,7 @@ impl AutoUpdater {
 
     pub fn poll(&mut self, check_type: UpdateCheckType, cx: &mut Context<Self>) {
         if self.pending_poll.is_some() {
+            dbg!("return");
             return;
         }
 
@@ -435,7 +455,7 @@ impl AutoUpdater {
         let version_path = platform_dir.join(format!("{}.gz", release.version));
         smol::fs::create_dir_all(&platform_dir).await.ok();
 
-        let client = this.read_with(cx, |this, _| this.http_client.clone())?;
+        let client = this.read_with(cx, |this, _| this.client.http_client())?;
 
         if smol::fs::metadata(&version_path).await.is_err() {
             log::info!(
@@ -479,10 +499,10 @@ impl AutoUpdater {
         arch: &str,
         cx: &mut AsyncApp,
     ) -> Result<ReleaseAsset> {
-        let client = this.read_with(cx, |this, _| this.http_client.clone())?;
+        let client = this.read_with(cx, |this, _| this.client.clone())?;
 
         let (system_id, metrics_id, is_staff) = cx.update(|cx| {
-            let telemetry = Client::global(cx).telemetry().clone();
+            let telemetry = client.telemetry().clone();
             if telemetry.metrics_enabled() {
                 (
                     telemetry.system_id(),
@@ -499,9 +519,10 @@ impl AutoUpdater {
         } else {
             "latest".to_string()
         };
+        let http_client = client.http_client();
 
         let path = format!("/releases/{}/{}/asset", release_channel.dev_name(), version,);
-        let url = client.build_zed_cloud_url_with_query(
+        let url = http_client.build_zed_cloud_url_with_query(
             &path,
             AssetQuery {
                 os,
@@ -513,7 +534,9 @@ impl AutoUpdater {
             },
         )?;
 
-        let mut response = client.get(url.as_str(), Default::default(), true).await?;
+        let mut response = http_client
+            .get(url.as_str(), Default::default(), true)
+            .await?;
         let mut body = Vec::new();
         response.body_mut().read_to_end(&mut body).await?;
 
@@ -535,7 +558,7 @@ impl AutoUpdater {
         let (client, installed_version, previous_status, release_channel) =
             this.read_with(cx, |this, cx| {
                 (
-                    this.http_client.clone(),
+                    this.client.http_client(),
                     this.current_version,
                     this.status.clone(),
                     ReleaseChannel::try_global(cx).unwrap_or(ReleaseChannel::Stable),
@@ -555,7 +578,7 @@ impl AutoUpdater {
         let fetched_version = fetched_release_data.clone().version;
         let app_commit_sha = cx.update(|cx| AppCommitSha::try_global(cx).map(|sha| sha.full()));
         let newer_version = Self::check_if_fetched_version_is_newer(
-            *RELEASE_CHANNEL,
+            release_channel,
             app_commit_sha,
             installed_version,
             fetched_version,
@@ -955,8 +978,12 @@ pub async fn finalize_auto_update_on_quit() {
 
 #[cfg(test)]
 mod tests {
+    use client::Client;
+    use clock::FakeSystemClock;
     use gpui::TestAppContext;
+    use http_client::FakeHttpClient;
     use settings::default_settings;
+    use std::sync::Arc;
 
     use super::*;
 
@@ -976,6 +1003,84 @@ mod tests {
         });
     }
 
+    #[gpui::test]
+    async fn test_auto_update_end_to_end(cx: &mut TestAppContext) {
+        cx.update(|cx| {
+            settings::init(cx);
+
+            let current_version = SemanticVersion::new(1, 0, 0);
+            release_channel::init_test(current_version, ReleaseChannel::Stable, cx);
+
+            client::init_settings(cx);
+            let clock = Arc::new(FakeSystemClock::new());
+            let fake_client_http = FakeHttpClient::with_404_response();
+            let client = Client::new(clock, fake_client_http, cx);
+            crate::init(client, cx);
+        });
+
+        let auto_updater = cx.update(|cx| AutoUpdater::get(cx).expect("auto updater should exist"));
+
+        cx.background_executor.run_until_parked();
+
+        // Verify initial state
+        auto_updater.read_with(cx, |updater, _| {
+            assert_eq!(updater.status(), AutoUpdateStatus::Idle);
+            assert_eq!(updater.current_version(), SemanticVersion::new(1, 0, 0));
+        });
+
+        // Trigger manual update check
+        auto_updater.update(cx, |updater, cx| {
+            updater.poll(UpdateCheckType::Manual, cx);
+        });
+
+        // Let the initial state change propagate
+
+        // Verify it transitions to Checking state
+        let status = auto_updater.read_with(cx, |updater, _| updater.status());
+
+        assert_eq!(status, AutoUpdateStatus::Checking);
+
+        // Let the async update process continue
+        cx.background_executor.run_until_parked();
+
+        // The update should progress through states and eventually either:
+        // - Reach AutoUpdateStatus::Updated if mocking is complete
+        // - Reach AutoUpdateStatus::Errored when download/install fails (expected in test)
+        let final_status = auto_updater.read_with(cx, |updater, _| updater.status());
+
+        match final_status {
+            AutoUpdateStatus::Updated { version } => {
+                // If somehow the update completed successfully
+                match version {
+                    VersionCheckType::Semantic(v) => {
+                        assert_eq!(v, SemanticVersion::new(1, 0, 1));
+                    }
+                    _ => panic!("Expected semantic version for stable release"),
+                }
+            }
+            AutoUpdateStatus::Errored { .. } => {
+                // This is expected because we can't actually download/install in tests
+                // The important thing is that it attempted the update process
+                // and went through the checking phase successfully
+            }
+            AutoUpdateStatus::Downloading { version } => {
+                // The update got stuck in downloading state due to our 404 mock
+                match version {
+                    VersionCheckType::Semantic(v) => {
+                        assert_eq!(v, SemanticVersion::new(1, 0, 1));
+                    }
+                    _ => panic!("Expected semantic version for stable release"),
+                }
+            }
+            other => {
+                panic!(
+                    "Expected Updated, Errored, or Downloading state after update attempt, got: {:?}",
+                    other
+                );
+            }
+        }
+    }
+
     #[test]
     fn test_stable_does_not_update_when_fetched_version_is_not_higher() {
         let release_channel = ReleaseChannel::Stable;
diff --git a/crates/release_channel/src/lib.rs b/crates/release_channel/src/lib.rs
@@ -126,6 +126,12 @@ pub fn init(app_version: SemanticVersion, cx: &mut App) {
     cx.set_global(GlobalReleaseChannel(*RELEASE_CHANNEL))
 }
 
+/// Initializes the release channel for tests that rely on fake release channel.
+pub fn init_test(app_version: SemanticVersion, release_channel: ReleaseChannel, cx: &mut App) {
+    cx.set_global(GlobalAppVersion(app_version));
+    cx.set_global(GlobalReleaseChannel(release_channel))
+}
+
 impl ReleaseChannel {
     /// Returns the global [`ReleaseChannel`].
     pub fn global(cx: &App) -> Self {
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
@@ -538,7 +538,7 @@ pub fn main() {
         });
         AppState::set_global(Arc::downgrade(&app_state), cx);
 
-        auto_update::init(client.http_client(), cx);
+        auto_update::init(client, cx);
         dap_adapters::init(cx);
         auto_update_ui::init(cx);
         reliability::init(
