test: port 32 command/repository/downloader tests

Add create_installed_json/create_composer_lock test helpers. Port command (8),
repository path/forgejo/perforce/vcs (11), and fossil/hg/download_manager (13)
tests. Fix production porting bugs: root_package_loader/forgejo_url/version_bumper
regex delimiters, repository_manager create_repository_by_class, array_loader
isset, licenses_command RefCell borrow; implement disk_free_space and
touch2/touch3 via libc.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

4 files changed, 384 insertions, 80 deletions

diff --git a/crates/shirabe/tests/downloader/download_manager_test.rs b/crates/shirabe/tests/downloader/download_manager_test.rs
index b7fa976..2405b4b 100644
--- a/crates/shirabe/tests/downloader/download_manager_test.rs
+++ b/crates/shirabe/tests/downloader/download_manager_test.rs
@@ -1,225 +1,242 @@
 //! ref: composer/tests/Composer/Test/Downloader/DownloadManagerTest.php
 
-fn set_up() {
-    // The Filesystem and IO mocks are not ported.
-    todo!()
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use shirabe::downloader::DownloaderInterface;
+use shirabe::downloader::download_manager::DownloadManager;
+use shirabe::io::IOInterface;
+use shirabe::package::handle::{CompletePackageHandle, PackageInterfaceHandle};
+use shirabe_semver::VersionParser;
+
+use crate::downloader_stub::DownloaderStub;
+use crate::io_stub::IOStub;
+
+/// ref: DownloadManagerTest::createPackageMock
+///
+/// PHPUnit returns a `PackageInterface` mock; a real CompletePackage with the
+/// relevant fields left at their defaults is an equivalent stand-in for the
+/// installation-source/type dispatch logic exercised by the ported cases.
+fn create_package_mock() -> PackageInterfaceHandle {
+    let norm_version = VersionParser.normalize("1.0.0", None).unwrap();
+    CompletePackageHandle::new("dummy/pkg".to_string(), norm_version, "1.0.0".to_string()).into()
+}
+
+/// ref: DownloadManagerTest::createDownloaderMock
+fn create_downloader_mock() -> Rc<RefCell<dyn DownloaderInterface>> {
+    Rc::new(RefCell::new(DownloaderStub::new())) as Rc<RefCell<dyn DownloaderInterface>>
+}
+
+fn create_manager() -> DownloadManager {
+    let io = Rc::new(RefCell::new(IOStub::new())) as Rc<RefCell<dyn IOInterface>>;
+    DownloadManager::new(io, false, None)
 }
 
-// These mock IO and individual downloaders to drive DownloadManager's selection/download/
-// update/remove logic; mocking is not available here.
-#[ignore = "requires PHPUnit mock of DownloaderInterface (createDownloaderMock)"]
 #[test]
 fn test_set_get_downloader() {
-    set_up();
-    todo!()
+    let downloader = create_downloader_mock();
+    let mut manager = create_manager();
+
+    manager.set_downloader("test", downloader.clone());
+    assert!(Rc::ptr_eq(
+        &downloader,
+        &manager.get_downloader("test").unwrap()
+    ));
+
+    let result = manager.get_downloader("unregistered");
+    assert!(result.is_err());
 }
 
-#[ignore = "requires PHPUnit mock of PackageInterface (createPackageMock)"]
 #[test]
 fn test_get_downloader_for_incorrectly_installed_package() {
-    set_up();
-    todo!()
+    // getInstallationSource() => null (the default for a fresh package).
+    let package = create_package_mock();
+
+    let manager = create_manager();
+
+    let result = manager.get_downloader_for_package(package);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_get_downloader_for_metapackage() {
+    let package = create_package_mock();
+    package.__set_type("metapackage".to_string());
+
+    let manager = create_manager();
+
+    assert!(
+        manager
+            .get_downloader_for_package(package)
+            .unwrap()
+            .is_none()
+    );
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloader"]
 #[test]
 fn test_get_downloader_for_correctly_installed_dist_package() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloader"]
 #[test]
 fn test_get_downloader_for_incorrectly_installed_dist_package() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloader"]
 #[test]
 fn test_get_downloader_for_correctly_installed_source_package() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloader"]
 #[test]
 fn test_get_downloader_for_incorrectly_installed_source_package() {
-    set_up();
-    todo!()
-}
-
-#[ignore = "requires PHPUnit mock of PackageInterface (createPackageMock)"]
-#[test]
-fn test_get_downloader_for_metapackage() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_full_package_download() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_full_package_download_failover() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mock of PackageInterface (createPackageMock)"]
 #[test]
 fn test_bad_package_download() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_dist_only_package_download() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_source_only_package_download() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_metapackage_package_download() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_full_package_download_with_source_preferred() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_dist_only_package_download_with_source_preferred() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_source_only_package_download_with_source_preferred() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mock of PackageInterface (createPackageMock)"]
 #[test]
 fn test_bad_package_download_with_source_preferred() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks of PackageInterface and DownloaderInterface"]
 #[test]
 fn test_update_dist_with_equal_types() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks of PackageInterface and DownloaderInterface"]
 #[test]
 fn test_update_dist_with_not_equal_types() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mock of PackageInterface and ReflectionMethod for private getAvailableSources"]
 #[test]
 fn test_get_available_sources_update_sticks_to_same_source() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_update_metapackage() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_remove() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_metapackage_remove() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_install_preference_without_preference_dev() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_install_preference_without_preference_no_dev() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_install_preference_without_match_dev() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_install_preference_without_match_no_dev() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_install_preference_with_match_auto_dev() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_install_preference_with_match_auto_no_dev() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_install_preference_with_match_source() {
-    set_up();
     todo!()
 }
 
 #[ignore = "requires PHPUnit mocks and partial mock of DownloadManager::getDownloaderForPackage"]
 #[test]
 fn test_install_preference_with_match_dist() {
-    set_up();
     todo!()
 }
diff --git a/crates/shirabe/tests/downloader/fossil_downloader_test.rs b/crates/shirabe/tests/downloader/fossil_downloader_test.rs
index 0c45d2c..e403229 100644
--- a/crates/shirabe/tests/downloader/fossil_downloader_test.rs
+++ b/crates/shirabe/tests/downloader/fossil_downloader_test.rs
@@ -1,8 +1,30 @@
 //! ref: composer/tests/Composer/Test/Downloader/FossilDownloaderTest.php
 
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use shirabe::config::Config;
+use shirabe::downloader::VcsDownloader;
+use shirabe::downloader::fossil_downloader::FossilDownloader;
+use shirabe::io::IOInterface;
+use shirabe::package::handle::{CompletePackageHandle, PackageInterfaceHandle};
+use shirabe::util::ProcessExecutor;
 use shirabe::util::filesystem::Filesystem;
+use shirabe_php_shim::PhpMixed;
+use shirabe_semver::VersionParser;
 use tempfile::TempDir;
 
+use crate::config_stub::ConfigStubBuilder;
+use crate::io_stub::IOStub;
+use crate::process_executor_mock::get_process_executor_mock;
+
+fn run<F: std::future::Future>(future: F) -> F::Output {
+    tokio::runtime::Builder::new_current_thread()
+        .build()
+        .unwrap()
+        .block_on(future)
+}
+
 fn set_up() -> TempDir {
     TempDir::new().unwrap()
 }
@@ -30,48 +52,168 @@ impl Drop for TearDown {
     }
 }
 
-// Every case constructs a FossilDownloader with a mocked IO/Config and a mocked
-// ProcessExecutor to feed fossil command output; a real HttpDownloader reaches
-// curl_multi_init (todo!()), and ProcessExecutor mocking is not available.
+/// ref: TestCase::getMockBuilder('Composer\Package\PackageInterface')->getMock()
+///
+/// A real CompletePackage seeded with the stubbed values is a faithful stand-in
+/// for a PackageInterface mock as long as `getSourceUrls()` equals
+/// `[getSourceUrl()]`, which holds for every non-ignored case here.
+fn get_package(source_reference: Option<&str>, source_url: Option<&str>) -> PackageInterfaceHandle {
+    let norm_version = VersionParser.normalize("1.0.0", None).unwrap();
+    let package =
+        CompletePackageHandle::new("dummy/pkg".to_string(), norm_version, "1.0.0".to_string());
+    package.__set_source_type(Some("fossil".to_string()));
+    package.set_source_reference(source_reference.map(|s| s.to_string()));
+    package.set_source_url(source_url.map(|s| s.to_string()));
+    package.into()
+}
+
+/// ref: FossilDownloaderTest::getDownloaderMock
+fn get_downloader_mock(
+    io: Option<Rc<RefCell<dyn IOInterface>>>,
+    config: Option<Config>,
+    process: Rc<RefCell<ProcessExecutor>>,
+) -> FossilDownloader {
+    let io =
+        io.unwrap_or_else(|| Rc::new(RefCell::new(IOStub::new())) as Rc<RefCell<dyn IOInterface>>);
+    // ref: getConfig(['secure-http' => false])
+    let config = Rc::new(RefCell::new(config.unwrap_or_else(|| {
+        ConfigStubBuilder::new()
+            .with("secure-http", PhpMixed::Bool(false))
+            .build()
+    })));
+    let fs = Rc::new(RefCell::new(Filesystem::new(None)));
+    FossilDownloader::new(io, config, process, fs)
+}
 
 #[test]
-#[ignore = "needs ProcessExecutorMock and PHPUnit mocks of IOInterface/PackageInterface/Filesystem for getDownloaderMock; not available"]
 fn test_install_for_package_without_source_reference() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
-    let _ = &working_dir;
-    todo!()
+
+    let package = get_package(None, None);
+
+    let (process, _guard) = get_process_executor_mock(vec![], false, Default::default());
+    let mut downloader = get_downloader_mock(None, None, process);
+
+    let path = format!("{}/path", working_dir.path().to_string_lossy());
+    let result = run(downloader.install(package, &path));
+
+    let e = result.expect_err("missing source reference should throw");
+    assert!(e.to_string().contains("missing reference information"));
 }
 
 #[test]
-#[ignore = "needs ProcessExecutorMock with expects() command-sequence assertions and PHPUnit PackageInterface mock; not available"]
 fn test_install() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
-    let _ = &working_dir;
-    todo!()
+
+    let working_dir_str = working_dir.path().to_string_lossy().into_owned();
+    let package = get_package(Some("trunk"), Some("http://fossil.kd2.org/kd2fw/"));
+
+    let repo_file = format!("{}.fossil", working_dir_str);
+    let (process, _guard) = get_process_executor_mock(
+        vec![
+            crate::process_executor_mock::cmd(vec![
+                "fossil",
+                "clone",
+                "--",
+                "http://fossil.kd2.org/kd2fw/",
+                &repo_file,
+            ]),
+            crate::process_executor_mock::cmd(vec!["fossil", "open", "--nested", "--", &repo_file]),
+            crate::process_executor_mock::cmd(vec!["fossil", "update", "--", "trunk"]),
+        ],
+        true,
+        Default::default(),
+    );
+
+    let mut downloader = get_downloader_mock(None, None, process);
+    run(downloader.install(package, &working_dir_str)).unwrap();
 }
 
 #[test]
-#[ignore = "needs ProcessExecutorMock and PHPUnit mocks of IOInterface/PackageInterface/Filesystem for getDownloaderMock; not available"]
 fn test_updatefor_package_without_source_reference() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
-    let _ = &working_dir;
-    todo!()
+
+    let initial_package = get_package(Some("ref"), None);
+    let source_package = get_package(None, None);
+
+    let (process, _guard) = get_process_executor_mock(vec![], false, Default::default());
+    let mut downloader = get_downloader_mock(None, None, process);
+
+    let result = run(async {
+        downloader
+            .prepare(
+                "update",
+                source_package.clone(),
+                "/path",
+                Some(initial_package.clone()),
+            )
+            .await?;
+        downloader
+            .update(initial_package.clone(), source_package.clone(), "/path")
+            .await?;
+        downloader
+            .cleanup("update", source_package, "/path", Some(initial_package))
+            .await
+    });
+
+    let e = result.expect_err("missing source reference should throw");
+    assert!(e.to_string().contains("missing reference information"));
 }
 
 #[test]
-#[ignore = "needs ProcessExecutorMock with expects() command-sequence assertions and PHPUnit PackageInterface mock; not available"]
 fn test_update() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
-    let _ = &working_dir;
-    todo!()
+
+    let working_dir_str = working_dir.path().to_string_lossy().into_owned();
+
+    // Ensure the .fslckout metadata file exists.
+    let fslckout = format!("{}/.fslckout", working_dir_str);
+    if !std::path::Path::new(&fslckout).exists() {
+        std::fs::File::create(&fslckout).unwrap();
+    }
+
+    let package = get_package(Some("trunk"), Some("http://fossil.kd2.org/kd2fw/"));
+
+    let (process, _guard) = get_process_executor_mock(
+        vec![
+            crate::process_executor_mock::cmd(vec!["fossil", "changes"]),
+            crate::process_executor_mock::cmd(vec!["fossil", "pull"]),
+            crate::process_executor_mock::cmd(vec!["fossil", "up", "--", "trunk"]),
+        ],
+        true,
+        Default::default(),
+    );
+
+    let mut downloader = get_downloader_mock(None, None, process);
+    run(async {
+        downloader
+            .prepare(
+                "update",
+                package.clone(),
+                &working_dir_str,
+                Some(package.clone()),
+            )
+            .await
+            .unwrap();
+        downloader
+            .update(package.clone(), package.clone(), &working_dir_str)
+            .await
+            .unwrap();
+        downloader
+            .cleanup("update", package.clone(), &working_dir_str, Some(package))
+            .await
+            .unwrap();
+    });
 }
 
+#[ignore = "PHP mocks Filesystem::removeDirectoryAsync; with a real Filesystem the actual \
+            removeDirectoryAsync drives its own ProcessExecutor for `rm -rf` through the \
+            unported execute_async mock seam"]
 #[test]
-#[ignore = "needs ProcessExecutorMock and a PHPUnit Filesystem mock asserting removeDirectoryAsync; not available"]
 fn test_remove() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
@@ -80,10 +222,13 @@ fn test_remove() {
 }
 
 #[test]
-#[ignore = "needs ProcessExecutorMock and PHPUnit mocks of IOInterface/Filesystem for getDownloaderMock; not available"]
 fn test_get_installation_source() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
     let _ = &working_dir;
-    todo!()
+
+    let (process, _guard) = get_process_executor_mock(vec![], false, Default::default());
+    let downloader = get_downloader_mock(None, None, process);
+
+    assert_eq!("source", downloader.get_installation_source());
 }
diff --git a/crates/shirabe/tests/downloader/hg_downloader_test.rs b/crates/shirabe/tests/downloader/hg_downloader_test.rs
index 67a13cb..c331533 100644
--- a/crates/shirabe/tests/downloader/hg_downloader_test.rs
+++ b/crates/shirabe/tests/downloader/hg_downloader_test.rs
@@ -1,8 +1,28 @@
 //! ref: composer/tests/Composer/Test/Downloader/HgDownloaderTest.php
 
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use shirabe::config::Config;
+use shirabe::downloader::VcsDownloader;
+use shirabe::downloader::hg_downloader::HgDownloader;
+use shirabe::io::IOInterface;
+use shirabe::package::handle::{CompletePackageHandle, PackageInterfaceHandle};
+use shirabe::util::ProcessExecutor;
 use shirabe::util::filesystem::Filesystem;
+use shirabe_semver::VersionParser;
 use tempfile::TempDir;
 
+use crate::io_stub::IOStub;
+use crate::process_executor_mock::{cmd, get_process_executor_mock};
+
+fn run<F: std::future::Future>(future: F) -> F::Output {
+    tokio::runtime::Builder::new_current_thread()
+        .build()
+        .unwrap()
+        .block_on(future)
+}
+
 fn set_up() -> TempDir {
     TempDir::new().unwrap()
 }
@@ -30,48 +50,165 @@ impl Drop for TearDown {
     }
 }
 
-// Every case constructs an HgDownloader with a mocked IO/Config and a mocked
-// ProcessExecutor to feed hg command output; a real HttpDownloader reaches
-// curl_multi_init (todo!()), and ProcessExecutor mocking is not available.
+/// ref: TestCase::getMockBuilder('Composer\Package\PackageInterface')->getMock()
+///
+/// A real CompletePackage seeded with the stubbed values is a faithful stand-in
+/// for a PackageInterface mock as long as `getSourceUrls()` equals
+/// `[getSourceUrl()]`, which holds for every non-ignored case here.
+fn get_package(source_reference: Option<&str>, source_url: Option<&str>) -> PackageInterfaceHandle {
+    let norm_version = VersionParser.normalize("1.0.0", None).unwrap();
+    let package =
+        CompletePackageHandle::new("dummy/pkg".to_string(), norm_version, "1.0.0".to_string());
+    package.__set_source_type(Some("hg".to_string()));
+    package.set_source_reference(source_reference.map(|s| s.to_string()));
+    package.set_source_url(source_url.map(|s| s.to_string()));
+    package.into()
+}
+
+/// ref: HgDownloaderTest::getDownloaderMock
+///
+/// PHP uses a `getMockBuilder('Composer\Config')->getMock()`, whose `get()`
+/// returns null for everything; a default real `Config` resolves the only
+/// relevant key (`secure-http`) compatibly for the https URLs used here.
+fn get_downloader_mock(
+    io: Option<Rc<RefCell<dyn IOInterface>>>,
+    config: Option<Config>,
+    process: Rc<RefCell<ProcessExecutor>>,
+) -> HgDownloader {
+    let io =
+        io.unwrap_or_else(|| Rc::new(RefCell::new(IOStub::new())) as Rc<RefCell<dyn IOInterface>>);
+    let config = Rc::new(RefCell::new(
+        config.unwrap_or_else(|| Config::new(false, None)),
+    ));
+    let fs = Rc::new(RefCell::new(Filesystem::new(None)));
+    HgDownloader::new(io, config, process, fs)
+}
 
 #[test]
-#[ignore = "needs PHPUnit mocks of IOInterface/Config/Filesystem/PackageInterface for getDownloaderMock; not available"]
 fn test_download_for_package_without_source_reference() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
     let _ = &working_dir;
-    todo!()
+
+    let package = get_package(None, None);
+
+    let (process, _guard) = get_process_executor_mock(vec![], false, Default::default());
+    let mut downloader = get_downloader_mock(None, None, process);
+
+    let result = run(downloader.install(package, "/path"));
+    let e = result.expect_err("missing source reference should throw");
+    assert!(e.to_string().contains("missing reference information"));
 }
 
 #[test]
-#[ignore = "needs ProcessExecutorMock with expects() command-sequence assertions and PHPUnit PackageInterface mock; not available"]
 fn test_download() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
-    let _ = &working_dir;
-    todo!()
+
+    let working_dir_str = working_dir.path().to_string_lossy().into_owned();
+    let package = get_package(Some("ref"), Some("https://mercurial.dev/l3l0/composer"));
+
+    let (process, _guard) = get_process_executor_mock(
+        vec![
+            cmd(vec![
+                "hg",
+                "clone",
+                "--",
+                "https://mercurial.dev/l3l0/composer",
+                &working_dir_str,
+            ]),
+            cmd(vec!["hg", "up", "--", "ref"]),
+        ],
+        true,
+        Default::default(),
+    );
+
+    let mut downloader = get_downloader_mock(None, None, process);
+    run(downloader.install(package, &working_dir_str)).unwrap();
 }
 
 #[test]
-#[ignore = "needs PHPUnit mocks of IOInterface/Config/Filesystem/PackageInterface for getDownloaderMock; not available"]
 fn test_updatefor_package_without_source_reference() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
     let _ = &working_dir;
-    todo!()
+
+    let initial_package = get_package(Some("ref"), None);
+    let source_package = get_package(None, None);
+
+    let (process, _guard) = get_process_executor_mock(vec![], false, Default::default());
+    let mut downloader = get_downloader_mock(None, None, process);
+
+    let result = run(async {
+        downloader
+            .prepare(
+                "update",
+                source_package.clone(),
+                "/path",
+                Some(initial_package.clone()),
+            )
+            .await?;
+        downloader
+            .update(initial_package.clone(), source_package.clone(), "/path")
+            .await?;
+        downloader
+            .cleanup("update", source_package, "/path", Some(initial_package))
+            .await
+    });
+
+    let e = result.expect_err("missing source reference should throw");
+    assert!(e.to_string().contains("missing reference information"));
 }
 
 #[test]
-#[ignore = "needs ProcessExecutorMock with expects() command-sequence assertions and PHPUnit PackageInterface mock; not available"]
 fn test_update() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
-    let _ = &working_dir;
-    todo!()
+
+    let working_dir_str = working_dir.path().to_string_lossy().into_owned();
+
+    let mut fs = Filesystem::new(None);
+    fs.ensure_directory_exists(&format!("{}/.hg", working_dir_str))
+        .unwrap();
+
+    let package = get_package(Some("ref"), Some("https://github.com/l3l0/composer"));
+
+    let (process, _guard) = get_process_executor_mock(
+        vec![
+            cmd(vec!["hg", "st"]),
+            cmd(vec!["hg", "pull", "--", "https://github.com/l3l0/composer"]),
+            cmd(vec!["hg", "up", "--", "ref"]),
+        ],
+        true,
+        Default::default(),
+    );
+
+    let mut downloader = get_downloader_mock(None, None, process);
+    run(async {
+        downloader
+            .prepare(
+                "update",
+                package.clone(),
+                &working_dir_str,
+                Some(package.clone()),
+            )
+            .await
+            .unwrap();
+        downloader
+            .update(package.clone(), package.clone(), &working_dir_str)
+            .await
+            .unwrap();
+        downloader
+            .cleanup("update", package.clone(), &working_dir_str, Some(package))
+            .await
+            .unwrap();
+    });
 }
 
+#[ignore = "PHP mocks Filesystem::removeDirectoryAsync; with a real Filesystem the actual \
+            removeDirectoryAsync drives its own ProcessExecutor for `rm -rf` through the \
+            unported execute_async mock seam"]
 #[test]
-#[ignore = "needs ProcessExecutorMock and PHPUnit Filesystem mock with removeDirectoryAsync expectation; not available"]
 fn test_remove() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
@@ -80,10 +217,13 @@ fn test_remove() {
 }
 
 #[test]
-#[ignore = "needs PHPUnit mocks of IOInterface/Config/Filesystem for getDownloaderMock; not available"]
 fn test_get_installation_source() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
     let _ = &working_dir;
-    todo!()
+
+    let (process, _guard) = get_process_executor_mock(vec![], false, Default::default());
+    let downloader = get_downloader_mock(None, None, process);
+
+    assert_eq!("source", downloader.get_installation_source());
 }
diff --git a/crates/shirabe/tests/downloader/main.rs b/crates/shirabe/tests/downloader/main.rs
index 8244010..d6e07e4 100644
--- a/crates/shirabe/tests/downloader/main.rs
+++ b/crates/shirabe/tests/downloader/main.rs
@@ -1,5 +1,7 @@
 #[path = "../common/config_stub.rs"]
 mod config_stub;
+#[path = "../common/downloader_stub.rs"]
+mod downloader_stub;
 #[path = "../common/http_downloader_mock.rs"]
 mod http_downloader_mock;
 #[path = "../common/io_mock.rs"]