refactor: rename aim to upm and extract appimage module

crates/upm-core/tests/remove_flow.rs

@@ -0,0 +1,196 @@
+use std::path::Path;
+use tempfile::tempdir;
+use upm_core::app::interaction::{InteractionKind, InteractionRequest};
+use upm_core::app::list::build_list_rows;
+use upm_core::app::progress::{OperationEvent, OperationStage};
+use upm_core::app::remove::{
+    build_removal_plan, remove_registered_app_with_reporter, resolve_registered_app,
+};
+use upm_core::domain::app::{AppRecord, InstallMetadata, InstallScope};
+use upm_core::domain::source::{NormalizedSourceKind, SourceInputKind, SourceKind, SourceRef};
+
+#[test]
+fn remove_flow_rejects_unknown_app_names() {
+    let result = resolve_registered_app("bat", &[]);
+
+    assert!(result.is_err());
+}
+
+#[test]
+fn list_flow_returns_display_rows_for_registered_apps() {
+    let rows = build_list_rows(&[AppRecord {
+        stable_id: "bat".to_owned(),
+        display_name: "Bat".to_owned(),
+        source_input: Some("sharkdp/bat".to_owned()),
+        source: Some(SourceRef {
+            kind: SourceKind::GitHub,
+            input_kind: SourceInputKind::RepoShorthand,
+            normalized_kind: NormalizedSourceKind::GitHubRepository,
+            locator: "sharkdp/bat".to_owned(),
+            canonical_locator: Some("sharkdp/bat".to_owned()),
+            requested_tag: None,
+            requested_asset_name: None,
+            tracks_latest: true,
+        }),
+        installed_version: Some("0.25.0".to_owned()),
+        update_strategy: None,
+        metadata: Vec::new(),
+        install: None,
+    }]);
+
+    assert_eq!(rows.len(), 1);
+    assert_eq!(rows[0].stable_id, "bat");
+    assert_eq!(rows[0].display_name, "Bat");
+    assert_eq!(rows[0].version.as_deref(), Some("0.25.0"));
+    assert_eq!(rows[0].source, "sharkdp/bat");
+}
+
+#[test]
+fn ambiguous_remove_matches_include_stable_ids_for_client_choice() {
+    let apps = [
+        AppRecord {
+            stable_id: "bat".to_owned(),
+            display_name: "Bat".to_owned(),
+            source_input: None,
+            source: None,
+            installed_version: None,
+            update_strategy: None,
+            metadata: Vec::new(),
+            install: None,
+        },
+        AppRecord {
+            stable_id: "bat-nightly".to_owned(),
+            display_name: "Bat".to_owned(),
+            source_input: None,
+            source: None,
+            installed_version: None,
+            update_strategy: None,
+            metadata: Vec::new(),
+            install: None,
+        },
+    ];
+
+    let error = resolve_registered_app("Bat", &apps).unwrap_err();
+
+    assert_eq!(
+        error,
+        upm_core::app::remove::ResolveRegisteredAppError::Ambiguous {
+            request: InteractionRequest {
+                key: "select-registered-app".to_owned(),
+                kind: InteractionKind::SelectRegisteredApp {
+                    query: "Bat".to_owned(),
+                    matches: vec!["Bat (bat)".to_owned(), "Bat (bat-nightly)".to_owned()],
+                },
+            },
+        }
+    );
+}
+
+#[test]
+fn removal_plan_prefers_persisted_install_metadata_paths() {
+    let app = AppRecord {
+        stable_id: "bat".to_owned(),
+        display_name: "Bat".to_owned(),
+        source_input: None,
+        source: None,
+        installed_version: None,
+        update_strategy: None,
+        metadata: Vec::new(),
+        install: Some(InstallMetadata {
+            scope: InstallScope::System,
+            payload_path: Some("/opt/upm/appimages/bat.AppImage".to_owned()),
+            desktop_entry_path: Some("/usr/share/applications/upm-bat.desktop".to_owned()),
+            icon_path: Some("/usr/share/icons/hicolor/256x256/apps/bat.png".to_owned()),
+        }),
+    };
+
+    let plan = build_removal_plan(&app, Path::new("/home/test"));
+
+    assert_eq!(plan.stable_id, "bat");
+    assert_eq!(
+        plan.artifact_paths,
+        vec![
+            "/opt/upm/appimages/bat.AppImage".to_owned(),
+            "/usr/share/applications/upm-bat.desktop".to_owned(),
+            "/usr/share/icons/hicolor/256x256/apps/bat.png".to_owned(),
+        ]
+    );
+}
+
+#[test]
+fn removal_plan_falls_back_to_derived_managed_user_paths() {
+    let app = AppRecord {
+        stable_id: "bat".to_owned(),
+        display_name: "Bat".to_owned(),
+        source_input: None,
+        source: None,
+        installed_version: None,
+        update_strategy: None,
+        metadata: Vec::new(),
+        install: None,
+    };
+
+    let plan = build_removal_plan(&app, Path::new("/home/test"));
+
+    assert_eq!(
+        plan.artifact_paths,
+        vec![
+            "/home/test/.local/lib/upm/appimages/bat.AppImage".to_owned(),
+            "/home/test/.local/share/applications/upm-bat.desktop".to_owned(),
+            "/home/test/.local/share/icons/hicolor/256x256/apps/bat.png".to_owned(),
+        ]
+    );
+}
+
+#[test]
+fn remove_flow_reports_resolution_and_cleanup_events() {
+    let install_home = tempdir().unwrap();
+    let app = AppRecord {
+        stable_id: "bat".to_owned(),
+        display_name: "Bat".to_owned(),
+        source_input: None,
+        source: None,
+        installed_version: None,
+        update_strategy: None,
+        metadata: Vec::new(),
+        install: Some(InstallMetadata {
+            scope: InstallScope::User,
+            payload_path: Some(
+                install_home
+                    .path()
+                    .join(".local/lib/upm/appimages/bat.AppImage")
+                    .display()
+                    .to_string(),
+            ),
+            desktop_entry_path: None,
+            icon_path: None,
+        }),
+    };
+    let mut events: Vec<OperationEvent> = Vec::new();
+    let mut reporter = |event: &OperationEvent| events.push(event.clone());
+
+    let result =
+        remove_registered_app_with_reporter("bat", &[app], install_home.path(), &mut reporter)
+            .unwrap();
+
+    assert_eq!(result.removed.stable_id, "bat");
+    assert_eq!(result.removed_paths.len(), 0);
+    assert!(events.iter().any(|event| {
+        matches!(
+            event,
+            OperationEvent::StageChanged {
+                stage: OperationStage::ResolveQuery,
+                ..
+            }
+        )
+    }));
+    assert!(events.iter().any(|event| {
+        matches!(
+            event,
+            OperationEvent::StageChanged {
+                stage: OperationStage::Finalize,
+                ..
+            }
+        )
+    }));
+}