test: port 44 vcs/downloader/version tests using mock infra

Port git, version_guesser, gitlab_driver, github_driver, and git_downloader
tests using the ProcessExecutor/HttpDownloader mocks and IO/Config stubs.
Fix production regex-porting bugs surfaced by the now-reachable paths:
Url::sanitize and Response::find_header_value had non-delimited PCRE patterns;
implement array_search_mixed non-strict branch and a datetime format mapping.
Add HttpDownloader::__new_mock so mocked downloaders skip curl construction.

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

18 files changed, 3126 insertions, 192 deletions

diff --git a/crates/shirabe-php-shim/src/array.rs b/crates/shirabe-php-shim/src/array.rs
index 280ec64..ace6a72 100644
--- a/crates/shirabe-php-shim/src/array.rs
+++ b/crates/shirabe-php-shim/src/array.rs
@@ -233,20 +233,21 @@ pub fn array_search_mixed(
     haystack: &PhpMixed,
     strict: bool,
 ) -> Option<PhpMixed> {
-    if !strict {
-        // TODO(phase-c): non-strict array_search needs PHP's loose `==` comparison
-        // semantics. Only the strict path is implemented; loose comparison is
-        // deferred rather than approximated.
-        todo!("non-strict array_search (PHP loose comparison)");
-    }
+    let matches = |value: &PhpMixed| -> bool {
+        if strict {
+            value == needle
+        } else {
+            loose_eq(value, needle)
+        }
+    };
     match haystack {
         PhpMixed::List(items) => items
             .iter()
-            .position(|value| value == needle)
+            .position(matches)
             .map(|i| PhpMixed::Int(i as i64)),
         PhpMixed::Array(map) => map
             .iter()
-            .find(|(_, value)| *value == needle)
+            .find(|(_, value)| matches(value))
             .map(|(key, _)| php_key_to_mixed(key)),
         _ => None,
     }
diff --git a/crates/shirabe-php-shim/src/datetime.rs b/crates/shirabe-php-shim/src/datetime.rs
index bddf5da..e41028e 100644
--- a/crates/shirabe-php-shim/src/datetime.rs
+++ b/crates/shirabe-php-shim/src/datetime.rs
@@ -19,6 +19,7 @@ pub const DATE_ATOM: &str = DATE_RFC3339;
 pub fn date_format_to_strftime(format: &str) -> &'static str {
     match format {
         "Y-m-d H:i:s" => "%Y-%m-%d %H:%M:%S",
+        "Y-m-d Hi" => "%Y-%m-%d %H%M",
         "Y-m-d" => "%Y-%m-%d",
         "Ymd" => "%Y%m%d",
         other => panic!("Unsupported PHP date format: {other:?}"),
diff --git a/crates/shirabe/src/repository/vcs/github_driver.rs b/crates/shirabe/src/repository/vcs/github_driver.rs
index bea7294..7c50a7e 100644
--- a/crates/shirabe/src/repository/vcs/github_driver.rs
+++ b/crates/shirabe/src/repository/vcs/github_driver.rs
@@ -1298,6 +1298,18 @@ impl GitHubDriver {
 
         None
     }
+
+    /// For testing only. Mirrors the `setAttribute($driver, 'tags', ...)` reflection
+    /// helper used by GitHubDriverTest to seed private state.
+    pub fn __set_tags(&mut self, tags: Option<IndexMap<String, String>>) {
+        self.tags = tags;
+    }
+
+    /// For testing only. Mirrors the `setAttribute($driver, 'branches', ...)` reflection
+    /// helper used by GitHubDriverTest to seed private state.
+    pub fn __set_branches(&mut self, branches: Option<IndexMap<String, String>>) {
+        self.branches = branches;
+    }
 }
 
 impl crate::repository::vcs::VcsDriverInterface for GitHubDriver {
diff --git a/crates/shirabe/src/repository/vcs/gitlab_driver.rs b/crates/shirabe/src/repository/vcs/gitlab_driver.rs
index f1f361e..7e8073d 100644
--- a/crates/shirabe/src/repository/vcs/gitlab_driver.rs
+++ b/crates/shirabe/src/repository/vcs/gitlab_driver.rs
@@ -238,6 +238,18 @@ impl GitLabDriver {
         Ok(())
     }
 
+    /// For testing only. Mirrors the `setAttribute($driver, 'branches', ...)` reflection
+    /// helper used by GitLabDriverTest to seed private state.
+    pub fn __set_branches(&mut self, branches: Option<IndexMap<String, String>>) {
+        self.branches = branches;
+    }
+
+    /// For testing only. Mirrors the `setAttribute($driver, 'tags', ...)` reflection
+    /// helper used by GitLabDriverTest to seed private state.
+    pub fn __set_tags(&mut self, tags: Option<IndexMap<String, String>>) {
+        self.tags = tags;
+    }
+
     /// Updates the HttpDownloader instance.
     /// Mainly useful for tests.
     ///
diff --git a/crates/shirabe/src/util/git.rs b/crates/shirabe/src/util/git.rs
index f031157..142d5e2 100644
--- a/crates/shirabe/src/util/git.rs
+++ b/crates/shirabe/src/util/git.rs
@@ -132,6 +132,19 @@ impl Git {
         self.run_command(callables, url, cwd, initial_clone, command_output)
     }
 
+    /// For testing only. Public seam over the (deprecated) private `run_command`,
+    /// mirroring `Git::runCommand` as exercised by `GitTest`.
+    pub fn __run_command(
+        &mut self,
+        command_callable: Vec<Box<dyn Fn(&str) -> Vec<String>>>,
+        url: &str,
+        cwd: Option<&str>,
+        initial_clone: bool,
+        command_output: Option<&mut PhpMixed>,
+    ) -> Result<()> {
+        self.run_command(command_callable, url, cwd, initial_clone, command_output)
+    }
+
     /// @param callable|array<callable> $commandCallable
     /// @param mixed       $commandOutput  the output will be written into this var if passed by ref
     ///                                    if a callable is passed it will be used as output handler
@@ -1310,6 +1323,22 @@ impl Git {
         version.clone().unwrap_or(None)
     }
 
+    /// For testing only. Resets the cached git `version` static so the next
+    /// `get_version` call re-runs `git --version`, mirroring the
+    /// `ReflectionProperty(GitUtil::class, 'version')->setValue(null, false)`
+    /// done in VersionGuesserTest's setUp/tearDown.
+    pub fn __reset_version() {
+        *VERSION.lock().unwrap() = None;
+    }
+
+    /// For testing only. Seeds the cached git `version` static, mirroring the
+    /// `ReflectionProperty(GitUtil::class, 'version')->setValue(null, $version)`
+    /// done in GitDownloaderTest's `initGitVersion`. `Some(v)` records a detected
+    /// version; `None` records that git is unavailable, both without shelling out.
+    pub fn __set_version(version: Option<String>) {
+        *VERSION.lock().unwrap() = Some(version);
+    }
+
     /// @param string[] $credentials
     fn mask_credentials(&self, error: &str, credentials: &[String]) -> String {
         let mut masked_credentials: Vec<String> = vec![];
diff --git a/crates/shirabe/src/util/http/response.rs b/crates/shirabe/src/util/http/response.rs
index e1da15d..8b7bd34 100644
--- a/crates/shirabe/src/util/http/response.rs
+++ b/crates/shirabe/src/util/http/response.rs
@@ -63,7 +63,7 @@ impl Response {
 
     pub fn find_header_value(headers: &[String], name: &str) -> Option<String> {
         let mut value = None;
-        let pattern = format!("(?i)^{}:\\s*(.+?)\\s*$", preg_quote(name, None));
+        let pattern = format!("{{^{}:\\s*(.+?)\\s*$}}i", preg_quote(name, None));
         for header in headers {
             let mut matches: indexmap::IndexMap<
                 shirabe_external_packages::composer::pcre::CaptureKey,
diff --git a/crates/shirabe/src/util/http_downloader.rs b/crates/shirabe/src/util/http_downloader.rs
index edc84cc..782f04a 100644
--- a/crates/shirabe/src/util/http_downloader.rs
+++ b/crates/shirabe/src/util/http_downloader.rs
@@ -883,6 +883,30 @@ impl HttpDownloader {
             && function_exists("curl_multi_init")
     }
 
+    /// For testing only. Builds an HttpDownloader whose request methods are fully
+    /// short-circuited by the mock (see [`HttpDownloader::__expects`]), without
+    /// constructing the real curl/rfs backends. Mirrors HttpDownloaderMock, which
+    /// extends HttpDownloader but never performs curl I/O.
+    pub fn __new_mock(
+        io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+        config: std::rc::Rc<std::cell::RefCell<Config>>,
+    ) -> Self {
+        Self {
+            io,
+            config,
+            jobs: IndexMap::new(),
+            options: IndexMap::new(),
+            running_jobs: 0,
+            max_jobs: 12,
+            curl: None,
+            rfs: None,
+            id_gen: 0,
+            disabled: false,
+            allow_async: false,
+            mock: None,
+        }
+    }
+
     /// For testing only. Mirrors HttpDownloaderMock::expects: installs the expectation queue,
     /// strict flag and default handler used by the mock request path.
     pub fn __expects(
diff --git a/crates/shirabe/src/util/url.rs b/crates/shirabe/src/util/url.rs
index 534e318..5820539 100644
--- a/crates/shirabe/src/util/url.rs
+++ b/crates/shirabe/src/util/url.rs
@@ -164,10 +164,10 @@ impl Url {
     pub fn sanitize(url: String) -> String {
         // GitHub repository rename result in redirect locations containing the access_token as GET parameter
         // e.g. https://api.github.com/repositories/9999999999?access_token=github_token
-        let url = Preg::replace(r"([&?]access_token=)[^&]+", "$1***", &url);
+        let url = Preg::replace(r"{([&?]access_token=)[^&]+}", "$1***", &url);
 
         Preg::replace_callback(
-            r"(?i)^(?P<prefix>[a-z0-9]+://)?(?P<user>[^:/\s@]+):(?P<password>[^@\s/]+)@",
+            r"{^(?P<prefix>[a-z0-9]+://)?(?P<user>[^:/\s@]+):(?P<password>[^@\s/]+)@}i",
             |m| {
                 let user = m
                     .get(&CaptureKey::ByName("user".to_string()))
diff --git a/crates/shirabe/tests/common/http_downloader_mock.rs b/crates/shirabe/tests/common/http_downloader_mock.rs
index 249585c..7a021f9 100644
--- a/crates/shirabe/tests/common/http_downloader_mock.rs
+++ b/crates/shirabe/tests/common/http_downloader_mock.rs
@@ -64,12 +64,7 @@ pub fn get_http_downloader_mock(
 ) -> (Rc<RefCell<HttpDownloader>>, HttpDownloaderMockGuard) {
     let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
     let config = Rc::new(RefCell::new(Config::new(false, None)));
-    let downloader = Rc::new(RefCell::new(HttpDownloader::new(
-        io,
-        config,
-        IndexMap::new(),
-        false,
-    )));
+    let downloader = Rc::new(RefCell::new(HttpDownloader::__new_mock(io, config)));
     downloader
         .borrow_mut()
         .__expects(expectations, strict, default_handler);
diff --git a/crates/shirabe/tests/downloader/git_downloader_test.rs b/crates/shirabe/tests/downloader/git_downloader_test.rs
index 69b0a6c..07dec08 100644
--- a/crates/shirabe/tests/downloader/git_downloader_test.rs
+++ b/crates/shirabe/tests/downloader/git_downloader_test.rs
@@ -1,18 +1,40 @@
 //! ref: composer/tests/Composer/Test/Downloader/GitDownloaderTest.php
 
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use indexmap::IndexMap;
+use serial_test::serial;
+use shirabe::config::Config;
+use shirabe::downloader::VcsDownloader;
+use shirabe::downloader::git_downloader::GitDownloader;
+use shirabe::io::IOInterface;
+use shirabe::package::handle::{CompletePackageHandle, PackageInterfaceHandle};
+use shirabe::util::Git as GitUtil;
+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::{cmd, cmd_full, 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 {
-    // skipIfNotExecutable('git')
-    let () = todo!();
-    // initGitVersion('1.0.0') resets the Composer\Util\Git static version cache via
-    // reflection; the static cache is not reachable from a test here.
-    #[allow(unreachable_code)]
-    {
-        let _fs = Filesystem::new(None);
-        TempDir::new().unwrap()
-    }
+    // skipIfNotExecutable('git') is irrelevant because every git invocation is mocked.
+
+    // initGitVersion('1.0.0'): seed the Composer\Util\Git static version cache.
+    GitUtil::__set_version(Some("1.0.0".to_string()));
+
+    TempDir::new().unwrap()
 }
 
 fn tear_down(working_dir: &std::path::Path) {
@@ -20,9 +42,8 @@ fn tear_down(working_dir: &std::path::Path) {
         let mut fs = Filesystem::new(None);
         fs.remove_directory(working_dir).unwrap();
     }
-    // initGitVersion(false) resets the Composer\Util\Git static version cache via
-    // reflection; the static cache is not reachable from a test here.
-    todo!()
+    // initGitVersion(false): drop the static version cache so it is re-detected next time.
+    GitUtil::__set_version(None);
 }
 
 struct TearDown {
@@ -41,37 +62,280 @@ impl Drop for TearDown {
     }
 }
 
-// These construct a GitDownloader with a mocked IO/Config and a mocked ProcessExecutor to
-// feed git command output; mocking is not available, and a real HttpDownloader reaches
-// curl_multi_init (todo!()).
-#[ignore = "requires getProcessExecutorMock/getIOMock and getMockBuilder PackageInterface mock; no ProcessExecutorMock/IOMock mocking infrastructure exists"]
+/// ref: TestCase::getMockBuilder('Composer\Package\PackageInterface')->getMock()
+///
+/// A `getMockBuilder(PackageInterface)` mock returns null/0 for every unstubbed
+/// method, so a real CompletePackage seeded with the stubbed values is a faithful
+/// stand-in only when the resulting `getSourceUrls()` equals `[getSourceUrl()]`.
+/// The multi-URL/mirror cases in PHP configure `getSourceUrls` to an arbitrary
+/// list that a real package cannot reproduce, so those tests stay ignored.
+fn get_package(
+    name: &str,
+    pretty_version: &str,
+    source_reference: Option<&str>,
+    source_url: Option<&str>,
+) -> PackageInterfaceHandle {
+    let norm_version = VersionParser.normalize(pretty_version, None).unwrap();
+    let package =
+        CompletePackageHandle::new(name.to_string(), norm_version, pretty_version.to_string());
+    package.__set_source_type(Some("git".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: GitDownloaderTest::setupConfig (seeds a temp `home` when none is set)
+fn setup_config(config: Config) -> Config {
+    let mut config = config;
+    if !config.has("home") {
+        let tmp_dir = TempDir::new().unwrap().keep();
+        let mut top: IndexMap<String, PhpMixed> = IndexMap::new();
+        let mut section: IndexMap<String, PhpMixed> = IndexMap::new();
+        section.insert(
+            "home".to_string(),
+            PhpMixed::String(tmp_dir.to_string_lossy().into_owned()),
+        );
+        top.insert("config".to_string(), PhpMixed::Array(section));
+        config.merge(&top, Config::SOURCE_UNKNOWN);
+    }
+    config
+}
+
+/// ref: GitDownloaderTest::getDownloaderMock (defaults the IO/Config/Filesystem)
+fn get_downloader_mock(
+    io: Option<Rc<RefCell<dyn IOInterface>>>,
+    config: Option<Config>,
+    process: Rc<RefCell<ProcessExecutor>>,
+    filesystem: Option<Rc<RefCell<Filesystem>>>,
+) -> GitDownloader {
+    let io =
+        io.unwrap_or_else(|| Rc::new(RefCell::new(IOStub::new())) as Rc<RefCell<dyn IOInterface>>);
+    let config = Rc::new(RefCell::new(setup_config(
+        config.unwrap_or_else(|| ConfigStubBuilder::new().build()),
+    )));
+    GitDownloader::new(io, config, Some(process), filesystem)
+}
+
+#[serial]
 #[test]
 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("dummy/pkg", "1.0.0", None, None);
+
+    let (process, _guard) = get_process_executor_mock(vec![], false, Default::default());
+    let mut downloader = get_downloader_mock(None, None, process, None);
+
+    let result = run(async {
+        downloader.download(package.clone(), "/path", None).await?;
+        downloader
+            .prepare("install", package.clone(), "/path", None)
+            .await?;
+        downloader.install(package.clone(), "/path").await?;
+        downloader.cleanup("install", package, "/path", None).await
+    });
+
+    let e = result.expect_err("missing source reference should throw");
+    assert!(e.to_string().contains("missing reference information"));
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations and getMockBuilder PackageInterface mock; no mocking infrastructure exists"]
+#[serial]
 #[test]
 fn test_download() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
-    let _ = &working_dir;
-    todo!()
+
+    let url = "https://example.com/composer/composer";
+    let package = get_package(
+        "composer/composer",
+        "dev-master",
+        Some("1234567890123456789012345678901234567890"),
+        Some(url),
+    );
+
+    let expected_path = working_dir
+        .path()
+        .join("composerPath")
+        .to_string_lossy()
+        .into_owned();
+
+    let (process, _guard) = get_process_executor_mock(
+        vec![
+            cmd(vec![
+                "git",
+                "clone",
+                "--no-checkout",
+                "--",
+                url,
+                &expected_path,
+            ]),
+            cmd(vec!["git", "remote", "add", "composer", "--", url]),
+            cmd(["git", "fetch", "composer"]),
+            cmd(vec!["git", "remote", "set-url", "origin", "--", url]),
+            cmd(vec!["git", "remote", "set-url", "composer", "--", url]),
+            cmd(["git", "branch", "-r"]),
+            cmd(["git", "checkout", "master", "--"]),
+            cmd(vec![
+                "git",
+                "reset",
+                "--hard",
+                "1234567890123456789012345678901234567890",
+                "--",
+            ]),
+        ],
+        true,
+        Default::default(),
+    );
+
+    let mut downloader = get_downloader_mock(None, None, process, None);
+
+    run(async {
+        downloader
+            .download(package.clone(), &expected_path, None)
+            .await
+            .unwrap();
+        downloader
+            .prepare("install", package.clone(), &expected_path, None)
+            .await
+            .unwrap();
+        downloader
+            .install(package.clone(), &expected_path)
+            .await
+            .unwrap();
+        downloader
+            .cleanup("install", package, &expected_path, None)
+            .await
+            .unwrap();
+    });
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations and initGitVersion reflection on Git::version static cache; no mocking infrastructure exists"]
+#[serial]
 #[test]
 fn test_download_with_cache() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
-    let _ = &working_dir;
-    todo!()
+
+    let url = "https://example.com/composer/composer";
+    let package = get_package(
+        "composer/composer",
+        "dev-master",
+        Some("1234567890123456789012345678901234567890"),
+        Some(url),
+    );
+
+    // initGitVersion('2.17.0'): enables the cache (`--dissociate`) code path.
+    GitUtil::__set_version(Some("2.17.0".to_string()));
+
+    let config = setup_config(Config::new(false, None));
+    let cache_vcs_dir = config
+        .get("cache-vcs-dir")
+        .as_string()
+        .unwrap_or("")
+        .to_string();
+    // ref: GitDownloaderTest cachePath = cache-vcs-dir.'/'.preg_replace('{[^a-z0-9.]}i', '-', url).'/'
+    let sanitized: String = url
+        .chars()
+        .map(|c| {
+            if c.is_ascii_alphanumeric() || c == '.' {
+                c
+            } else {
+                '-'
+            }
+        })
+        .collect();
+    let cache_path = format!("{}/{}/", cache_vcs_dir, sanitized);
+
+    let mut filesystem = Filesystem::new(None);
+    filesystem.remove_directory(&cache_path).unwrap();
+
+    let expected_path = working_dir
+        .path()
+        .join("composerPath")
+        .to_string_lossy()
+        .into_owned();
+
+    let cache_path_for_callback = cache_path.clone();
+    let mut clone_mirror = cmd(vec!["git", "clone", "--mirror", "--", url, &cache_path]);
+    clone_mirror.callback = Some(Box::new(move || {
+        std::fs::create_dir_all(&cache_path_for_callback).ok();
+    }));
+
+    let (process, _guard) = get_process_executor_mock(
+        vec![
+            clone_mirror,
+            cmd(["git", "remote", "-v"]),
+            cmd(vec!["git", "remote", "set-url", "origin", "--", url]),
+            cmd_full(["git", "rev-parse", "--git-dir"], 0, ".", ""),
+            cmd(vec![
+                "git",
+                "rev-parse",
+                "--quiet",
+                "--verify",
+                "1234567890123456789012345678901234567890^{commit}",
+            ]),
+            cmd(vec![
+                "git",
+                "clone",
+                "--no-checkout",
+                &cache_path,
+                &expected_path,
+                "--dissociate",
+                "--reference",
+                &cache_path,
+            ]),
+            cmd(vec!["git", "remote", "set-url", "origin", "--", url]),
+            cmd(vec!["git", "remote", "add", "composer", "--", url]),
+            cmd(["git", "branch", "-r"]),
+            cmd_full(["git", "checkout", "master", "--"], 1, "", ""),
+            cmd(vec![
+                "git",
+                "checkout",
+                "-B",
+                "master",
+                "composer/master",
+                "--",
+            ]),
+            cmd(vec![
+                "git",
+                "reset",
+                "--hard",
+                "1234567890123456789012345678901234567890",
+                "--",
+            ]),
+        ],
+        true,
+        Default::default(),
+    );
+
+    let mut downloader = get_downloader_mock(None, Some(config), process, None);
+
+    run(async {
+        downloader
+            .download(package.clone(), &expected_path, None)
+            .await
+            .unwrap();
+        downloader
+            .prepare("install", package.clone(), &expected_path, None)
+            .await
+            .unwrap();
+        downloader
+            .install(package.clone(), &expected_path)
+            .await
+            .unwrap();
+        downloader
+            .cleanup("install", package, &expected_path, None)
+            .await
+            .unwrap();
+    });
+
+    let mut fs = Filesystem::new(None);
+    fs.remove_directory(&cache_path).ok();
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations and getMockBuilder PackageInterface mock; no mocking infrastructure exists"]
+#[ignore = "getSourceUrls returns a mirror list (['https://github.com/mirrors/composer', \
+            'https://github.com/composer/composer']) that a real CompletePackage cannot reproduce \
+            from a single source_url; no PackageInterface mock with arbitrary getSourceUrls exists"]
 #[test]
 fn test_download_uses_various_protocols_and_sets_push_url_for_github() {
     let working_dir = set_up();
@@ -80,7 +344,8 @@ fn test_download_uses_various_protocols_and_sets_push_url_for_github() {
     todo!()
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations and pushUrlProvider dataProvider; no mocking infrastructure exists"]
+#[ignore = "pushUrlProvider configures getSourceUrls to a list a real CompletePackage cannot \
+            reproduce; no PackageInterface mock with arbitrary getSourceUrls exists"]
 #[test]
 fn test_download_and_set_push_url_use_custom_various_protocols_for_github() {
     let working_dir = set_up();
@@ -89,43 +354,243 @@ fn test_download_and_set_push_url_use_custom_various_protocols_for_github() {
     todo!()
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations and getMockBuilder PackageInterface mock; no mocking infrastructure exists"]
+#[serial]
 #[test]
 fn test_download_throws_runtime_exception_if_git_command_fails() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
-    let _ = &working_dir;
-    todo!()
+
+    let url = "https://example.com/composer/composer";
+    let package = get_package("composer/composer", "1.0.0", Some("ref"), Some(url));
+
+    let expected_path = working_dir
+        .path()
+        .join("composerPath")
+        .to_string_lossy()
+        .into_owned();
+
+    let (process, _guard) = get_process_executor_mock(
+        vec![cmd_full(
+            vec!["git", "clone", "--no-checkout", "--", url, &expected_path],
+            1,
+            "",
+            "",
+        )],
+        false,
+        Default::default(),
+    );
+
+    let mut downloader = get_downloader_mock(None, None, process, None);
+
+    let result = run(async {
+        downloader
+            .download(package.clone(), &expected_path, None)
+            .await?;
+        downloader
+            .prepare("install", package.clone(), &expected_path, None)
+            .await?;
+        downloader.install(package.clone(), &expected_path).await?;
+        downloader
+            .cleanup("install", package, &expected_path, None)
+            .await
+    });
+
+    let e = result.expect_err("failed git clone should throw");
+    assert!(e.to_string().contains(&format!(
+        "Failed to execute git clone --no-checkout -- {} {}",
+        url, expected_path
+    )));
 }
 
-#[ignore = "requires getProcessExecutorMock/getDownloaderMock and getMockBuilder PackageInterface mock; no mocking infrastructure exists"]
+#[serial]
 #[test]
 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("dummy/pkg", "1.0.0", Some("ref"), None);
+    let source_package = get_package("dummy/pkg", "1.0.0", None, None);
+
+    let (process, _guard) = get_process_executor_mock(vec![], false, Default::default());
+    let mut downloader = get_downloader_mock(None, None, process, None);
+
+    let result = run(async {
+        downloader
+            .download(
+                source_package.clone(),
+                "/path",
+                Some(initial_package.clone()),
+            )
+            .await?;
+        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"));
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations and getMockBuilder PackageInterface mock; no mocking infrastructure exists"]
+#[serial]
 #[test]
 fn test_update() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
-    let _ = &working_dir;
-    todo!()
+
+    let url = "https://github.com/composer/composer";
+    let package = get_package("composer/composer", "1.0.0", Some("ref"), Some(url));
+
+    let (process, _guard) = get_process_executor_mock(
+        vec![
+            cmd(["git", "show-ref", "--head", "-d"]),
+            cmd(["git", "status", "--porcelain", "--untracked-files=no"]),
+            cmd_full(
+                ["git", "rev-parse", "--quiet", "--verify", "ref^{commit}"],
+                1,
+                "",
+                "",
+            ),
+            // fallback commands for the above failing
+            cmd(["git", "remote", "-v"]),
+            cmd(vec!["git", "remote", "set-url", "composer", "--", url]),
+            cmd(["git", "fetch", "composer"]),
+            cmd(["git", "fetch", "--tags", "composer"]),
+            cmd(["git", "remote", "-v"]),
+            cmd(vec!["git", "remote", "set-url", "composer", "--", url]),
+            cmd(["git", "branch", "-r"]),
+            cmd(["git", "checkout", "ref", "--"]),
+            cmd(["git", "reset", "--hard", "ref", "--"]),
+            cmd(["git", "remote", "-v"]),
+        ],
+        true,
+        Default::default(),
+    );
+
+    let mut fs = Filesystem::new(None);
+    fs.ensure_directory_exists(&format!("{}/.git", working_dir.path().to_string_lossy()))
+        .unwrap();
+    let working_dir_str = working_dir.path().to_string_lossy().into_owned();
+
+    let mut downloader = get_downloader_mock(None, Some(Config::new(false, None)), process, None);
+
+    run(async {
+        downloader
+            .download(package.clone(), &working_dir_str, Some(package.clone()))
+            .await
+            .unwrap();
+        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 = "requires getProcessExecutorMock with expects() command expectations and getMockBuilder PackageInterface mock; no mocking infrastructure exists"]
+#[serial]
 #[test]
 fn test_update_with_new_repo_url() {
     let working_dir = set_up();
     let _tear_down = TearDown::new(working_dir.path().to_path_buf());
-    let _ = &working_dir;
-    todo!()
+
+    let url = "https://github.com/composer/composer";
+    let package = get_package("composer/composer", "1.0.0", Some("ref"), Some(url));
+
+    let (process, _guard) = get_process_executor_mock(
+        vec![
+            cmd(["git", "show-ref", "--head", "-d"]),
+            cmd(["git", "status", "--porcelain", "--untracked-files=no"]),
+            cmd_full(
+                ["git", "rev-parse", "--quiet", "--verify", "ref^{commit}"],
+                0,
+                "",
+                "",
+            ),
+            cmd(["git", "remote", "-v"]),
+            cmd(vec!["git", "remote", "set-url", "composer", "--", url]),
+            cmd(["git", "branch", "-r"]),
+            cmd(["git", "checkout", "ref", "--"]),
+            cmd(["git", "reset", "--hard", "ref", "--"]),
+            cmd_full(
+                ["git", "remote", "-v"],
+                0,
+                "origin https://github.com/old/url (fetch)\n\
+                 origin https://github.com/old/url (push)\n\
+                 composer https://github.com/old/url (fetch)\n\
+                 composer https://github.com/old/url (push)\n",
+                "",
+            ),
+            cmd(vec!["git", "remote", "set-url", "origin", "--", url]),
+            cmd(vec![
+                "git",
+                "remote",
+                "set-url",
+                "--push",
+                "origin",
+                "--",
+                "git@github.com:composer/composer.git",
+            ]),
+        ],
+        true,
+        Default::default(),
+    );
+
+    let mut fs = Filesystem::new(None);
+    fs.ensure_directory_exists(&format!("{}/.git", working_dir.path().to_string_lossy()))
+        .unwrap();
+    let working_dir_str = working_dir.path().to_string_lossy().into_owned();
+
+    let mut downloader = get_downloader_mock(None, Some(Config::new(false, None)), process, None);
+
+    run(async {
+        downloader
+            .download(package.clone(), &working_dir_str, Some(package.clone()))
+            .await
+            .unwrap();
+        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 = "requires getProcessExecutorMock with expects() command expectations and getMockBuilder PackageInterface mock; no mocking infrastructure exists"]
+#[ignore = "getSourceUrls returns a multi-URL list a real CompletePackage cannot reproduce; \
+            no PackageInterface mock with arbitrary getSourceUrls exists"]
 #[test]
 fn test_update_throws_runtime_exception_if_git_command_fails() {
     let working_dir = set_up();
@@ -134,7 +599,8 @@ fn test_update_throws_runtime_exception_if_git_command_fails() {
     todo!()
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations and getMockBuilder PackageInterface mock; no mocking infrastructure exists"]
+#[ignore = "getSourceUrls returns a multi-URL list (['/' , github]) a real CompletePackage cannot \
+            reproduce; no PackageInterface mock with arbitrary getSourceUrls exists"]
 #[test]
 fn test_update_doesnt_throws_runtime_exception_if_git_command_fails_at_first_but_is_able_to_recover()
  {
@@ -144,7 +610,8 @@ fn test_update_doesnt_throws_runtime_exception_if_git_command_fails_at_first_but
     todo!()
 }
 
-#[ignore = "requires getIOMock with expects() output expectations, getProcessExecutorMock and getMockBuilder PackageInterface mock; no mocking infrastructure exists"]
+#[ignore = "getSourceUrls returns a multi-URL list (['/foo/bar', github]) a real CompletePackage \
+            cannot reproduce; no PackageInterface mock with arbitrary getSourceUrls exists"]
 #[test]
 fn test_downgrade_shows_appropriate_message() {
     let working_dir = set_up();
@@ -153,7 +620,8 @@ fn test_downgrade_shows_appropriate_message() {
     todo!()
 }
 
-#[ignore = "requires getIOMock with expects() output expectations, getProcessExecutorMock and getMockBuilder PackageInterface mock; no mocking infrastructure exists"]
+#[ignore = "getSourceUrls returns a multi-URL list (['/foo/bar', github]) a real CompletePackage \
+            cannot reproduce; no PackageInterface mock with arbitrary getSourceUrls exists"]
 #[test]
 fn test_not_using_downgrading_with_references() {
     let working_dir = set_up();
@@ -162,7 +630,10 @@ fn test_not_using_downgrading_with_references() {
     todo!()
 }
 
-#[ignore = "requires getProcessExecutorMock, getMockBuilder Filesystem mock with removeDirectoryAsync expectation and PackageInterface mock; no mocking infrastructure exists"]
+#[ignore = "PHP mocks Filesystem::removeDirectoryAsync (asserting it is called once with the \
+            working dir). With no Filesystem mock, the real removeDirectoryAsync drives the \
+            Filesystem's own ProcessExecutor for `rm -rf`, which requires a Composer\\Loop and \
+            cannot be redirected through the mocked ProcessExecutor"]
 #[test]
 fn test_remove() {
     let working_dir = set_up();
@@ -171,11 +642,15 @@ fn test_remove() {
     todo!()
 }
 
-#[ignore = "requires getDownloaderMock which mocks IOInterface/Filesystem via getMockBuilder; no mocking infrastructure exists"]
+#[serial]
 #[test]
 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, None);
+
+    assert_eq!("source", downloader.get_installation_source());
 }
diff --git a/crates/shirabe/tests/downloader/main.rs b/crates/shirabe/tests/downloader/main.rs
index a2bbab4..8244010 100644
--- a/crates/shirabe/tests/downloader/main.rs
+++ b/crates/shirabe/tests/downloader/main.rs
@@ -2,8 +2,12 @@
 mod config_stub;
 #[path = "../common/http_downloader_mock.rs"]
 mod http_downloader_mock;
+#[path = "../common/io_mock.rs"]
+mod io_mock;
 #[path = "../common/io_stub.rs"]
 mod io_stub;
+#[path = "../common/process_executor_mock.rs"]
+mod process_executor_mock;
 
 mod archive_downloader_test;
 mod download_manager_test;
diff --git a/crates/shirabe/tests/package/main.rs b/crates/shirabe/tests/package/main.rs
index 57d7cd3..7d841b4 100644
--- a/crates/shirabe/tests/package/main.rs
+++ b/crates/shirabe/tests/package/main.rs
@@ -1,3 +1,9 @@
+#[path = "../common/config_stub.rs"]
+mod config_stub;
+#[path = "../common/io_stub.rs"]
+mod io_stub;
+#[path = "../common/process_executor_mock.rs"]
+mod process_executor_mock;
 #[path = "../common/test_case.rs"]
 mod test_case;
 
diff --git a/crates/shirabe/tests/package/version/version_guesser_test.rs b/crates/shirabe/tests/package/version/version_guesser_test.rs
index 1ec0ed4..6bfe6c1 100644
--- a/crates/shirabe/tests/package/version/version_guesser_test.rs
+++ b/crates/shirabe/tests/package/version/version_guesser_test.rs
@@ -3,121 +3,608 @@
 use std::cell::RefCell;
 use std::rc::Rc;
 
+use indexmap::IndexMap;
+use serial_test::serial;
 use shirabe::config::Config;
 use shirabe::package::version::{VersionGuesser, VersionParser};
+use shirabe::util::Git as GitUtil;
 use shirabe::util::platform::Platform;
-use shirabe::util::process_executor::ProcessExecutor;
+use shirabe::util::process_executor::{MockExpectation, MockHandler, ProcessExecutor};
+use shirabe_php_shim::PhpMixed;
 
-#[allow(dead_code)]
-fn set_up() {
-    // Resets GitUtil's cached `version` static via ReflectionProperty; the static is not
-    // exposed here and reflection-based mutation has no ported equivalent.
-    todo!()
-}
+use crate::process_executor_mock::{cmd, cmd_full, get_process_executor_mock};
 
-#[allow(dead_code)]
-fn tear_down() {
-    todo!()
+// Mirrors VersionGuesserTest::setUp/tearDown: reset GitUtil's cached `version`
+// static so each test re-runs `git --version` against its own mock.
+fn set_up() {
+    GitUtil::__reset_version();
 }
 
-#[allow(dead_code)]
 struct TearDown;
 
 impl Drop for TearDown {
     fn drop(&mut self) {
-        tear_down();
+        GitUtil::__reset_version();
     }
 }
 
-// These drive VersionGuesser with a mocked ProcessExecutor feeding git/hg command output;
-// mocking is not available here.
-#[ignore = "requires getProcessExecutorMock with expects() command expectations; no ProcessExecutorMock mocking infrastructure exists"]
+// `$config = new Config; $config->merge(['repositories' => ['packagist' => false]]);`
+fn make_config() -> Rc<RefCell<Config>> {
+    let mut config = Config::new(true, None);
+    let mut repositories: IndexMap<String, PhpMixed> = IndexMap::new();
+    repositories.insert("packagist".to_string(), PhpMixed::Bool(false));
+    let mut merge: IndexMap<String, PhpMixed> = IndexMap::new();
+    merge.insert("repositories".to_string(), PhpMixed::Array(repositories));
+    config.merge(&merge, Config::SOURCE_UNKNOWN);
+    Rc::new(RefCell::new(config))
+}
+
+fn make_guesser(
+    config: Rc<RefCell<Config>>,
+    process: Rc<RefCell<ProcessExecutor>>,
+) -> VersionGuesser {
+    VersionGuesser::new(config, process, VersionParser::new(), None)
+}
+
+// Helper to build a `['key' => 'value']` package config used in the tests.
+fn package_config(entries: &[(&str, PhpMixed)]) -> IndexMap<String, PhpMixed> {
+    let mut map: IndexMap<String, PhpMixed> = IndexMap::new();
+    for (k, v) in entries {
+        map.insert(k.to_string(), v.clone());
+    }
+    map
+}
+
+fn string_list(items: &[&str]) -> PhpMixed {
+    PhpMixed::List(
+        items
+            .iter()
+            .map(|s| PhpMixed::String(s.to_string()))
+            .collect(),
+    )
+}
+
+#[ignore = "guess_hg_version builds an HttpDownloader for HgDriver, which calls curl_multi_init() (todo!() in shirabe-php-shim::curl)"]
 #[test]
+#[serial]
 fn test_hg_guess_version_returns_data() {
-    todo!()
+    set_up();
+    let _td = TearDown;
+    let branch = "default";
+
+    let expectations: Vec<MockExpectation> = vec![
+        cmd_full(["git", "--version"], 0, "git version 2.33.0", ""),
+        cmd_full(
+            ["git", "branch", "-a", "--no-color", "--no-abbrev", "-v"],
+            128,
+            "",
+            "",
+        ),
+        cmd_full(["git", "describe", "--exact-match", "--tags"], 128, "", ""),
+        cmd_full(
+            [
+                "git",
+                "rev-list",
+                "--no-commit-header",
+                "--format=%H",
+                "-n1",
+                "HEAD",
+                "--no-show-signature",
+            ],
+            128,
+            "",
+            "",
+        ),
+        cmd_full(["hg", "branch"], 0, branch, ""),
+        cmd_full(["hg", "branches"], 0, "", ""),
+        cmd_full(["hg", "bookmarks"], 0, "", ""),
+    ];
+    let (process, _guard) = get_process_executor_mock(expectations, true, MockHandler::default());
+
+    let config = make_config();
+    let mut guesser = make_guesser(config, process);
+    let version_data = guesser
+        .guess_version(&IndexMap::new(), "dummy/path")
+        .unwrap()
+        .expect("expected version data");
+
+    assert_eq!(format!("dev-{}", branch), version_data.version.unwrap());
+    assert_eq!(
+        format!("dev-{}", branch),
+        version_data.pretty_version.unwrap()
+    );
+    assert!(version_data.commit.as_deref().unwrap_or("").is_empty());
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations; no ProcessExecutorMock mocking infrastructure exists"]
 #[test]
+#[serial]
 fn test_guess_version_returns_data() {
-    todo!()
+    set_up();
+    let _td = TearDown;
+    let commit_hash = "03a15d220da53c52eddd5f32ffca64a7b3801bea";
+    let another_commit_hash = "03a15d220da53c52eddd5f32ffca64a7b3801bea";
+
+    let expectations: Vec<MockExpectation> = vec![
+        cmd_full(["git", "--version"], 0, "git version 2.52.0", ""),
+        cmd_full(
+            ["git", "branch", "-a", "--no-color", "--no-abbrev", "-v"],
+            0,
+            format!(
+                "* master {} Commit message\n(no branch) {} Commit message\n",
+                commit_hash, another_commit_hash
+            ),
+            "",
+        ),
+    ];
+    let (process, _guard) = get_process_executor_mock(expectations, true, MockHandler::default());
+
+    let config = make_config();
+    let mut guesser = make_guesser(config, process);
+    let version_data = guesser
+        .guess_version(&IndexMap::new(), "dummy/path")
+        .unwrap()
+        .expect("expected version data");
+
+    assert_eq!("dev-master", version_data.version.unwrap());
+    assert_eq!("dev-master", version_data.pretty_version.unwrap());
+    assert!(version_data.feature_version.is_none());
+    assert!(version_data.feature_pretty_version.is_none());
+    assert_eq!(commit_hash, version_data.commit.unwrap());
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations; no ProcessExecutorMock mocking infrastructure exists"]
 #[test]
+#[serial]
 fn test_guess_version_does_not_see_custom_default_branch_as_non_feature_branch() {
-    todo!()
+    set_up();
+    let _td = TearDown;
+    let commit_hash = "03a15d220da53c52eddd5f32ffca64a7b3801bea";
+    let another_commit_hash = "13a15d220da53c52eddd5f32ffca64a7b3801bea";
+
+    let expectations: Vec<MockExpectation> = vec![
+        cmd_full(["git", "--version"], 0, "git version 2.52.0", ""),
+        cmd_full(
+            ["git", "branch", "-a", "--no-color", "--no-abbrev", "-v"],
+            0,
+            // Assumption here is that arbitrary would be the default branch
+            format!(
+                "  arbitrary {} Commit message\n* current {} Another message\n",
+                commit_hash, another_commit_hash
+            ),
+            "",
+        ),
+    ];
+    let (process, _guard) = get_process_executor_mock(expectations, true, MockHandler::default());
+
+    let config = make_config();
+    let mut guesser = make_guesser(config, process);
+    let version_data = guesser
+        .guess_version(
+            &package_config(&[("version", PhpMixed::String("self.version".to_string()))]),
+            "dummy/path",
+        )
+        .unwrap()
+        .expect("expected version data");
+
+    assert_eq!("dev-current", version_data.version.unwrap());
+    assert_eq!(another_commit_hash, version_data.commit.unwrap());
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations; no ProcessExecutorMock mocking infrastructure exists"]
+#[ignore = "feature-branch guessing calls ProcessExecutor::execute_async, whose mock path is todo!()"]
 #[test]
+#[serial]
 fn test_guess_version_reads_and_respects_non_feature_branches_configuration_for_arbitrary_naming() {
-    todo!()
+    set_up();
+    let _td = TearDown;
+    let commit_hash = "03a15d220da53c52eddd5f32ffca64a7b3801bea";
+    let another_commit_hash = "13a15d220da53c52eddd5f32ffca64a7b3801bea";
+
+    let expectations: Vec<MockExpectation> = vec![
+        cmd_full(["git", "--version"], 0, "git version 2.52.0", ""),
+        cmd_full(
+            ["git", "branch", "-a", "--no-color", "--no-abbrev", "-v"],
+            0,
+            format!(
+                "  arbitrary {} Commit message\n* feature {} Another message\n",
+                commit_hash, another_commit_hash
+            ),
+            "",
+        ),
+        cmd_full(
+            ["git", "rev-list", "arbitrary..feature"],
+            0,
+            format!("{}\n", another_commit_hash),
+            "",
+        ),
+    ];
+    let (process, _guard) = get_process_executor_mock(expectations, true, MockHandler::default());
+
+    let config = make_config();
+    let mut guesser = make_guesser(config, process);
+    let version_data = guesser
+        .guess_version(
+            &package_config(&[
+                ("version", PhpMixed::String("self.version".to_string())),
+                ("non-feature-branches", string_list(&["arbitrary"])),
+            ]),
+            "dummy/path",
+        )
+        .unwrap()
+        .expect("expected version data");
+
+    assert_eq!("dev-arbitrary", version_data.version.unwrap());
+    assert_eq!(another_commit_hash, version_data.commit.unwrap());
+    assert_eq!(
+        "dev-feature",
+        version_data.feature_version.as_deref().unwrap()
+    );
+    assert_eq!(
+        "dev-feature",
+        version_data.feature_pretty_version.as_deref().unwrap()
+    );
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations; no ProcessExecutorMock mocking infrastructure exists"]
+#[ignore = "feature-branch guessing calls ProcessExecutor::execute_async, whose mock path is todo!()"]
 #[test]
+#[serial]
 fn test_guess_version_reads_and_respects_non_feature_branches_configuration_for_arbitrary_naming_regex()
  {
-    todo!()
+    set_up();
+    let _td = TearDown;
+    let commit_hash = "03a15d220da53c52eddd5f32ffca64a7b3801bea";
+    let another_commit_hash = "13a15d220da53c52eddd5f32ffca64a7b3801bea";
+
+    let expectations: Vec<MockExpectation> = vec![
+        cmd_full(["git", "--version"], 0, "git version 2.52.0", ""),
+        cmd_full(
+            ["git", "branch", "-a", "--no-color", "--no-abbrev", "-v"],
+            0,
+            format!(
+                "  latest-testing {} Commit message\n* feature {} Another message\n",
+                commit_hash, another_commit_hash
+            ),
+            "",
+        ),
+        cmd_full(
+            ["git", "rev-list", "latest-testing..feature"],
+            0,
+            format!("{}\n", another_commit_hash),
+            "",
+        ),
+    ];
+    let (process, _guard) = get_process_executor_mock(expectations, true, MockHandler::default());
+
+    let config = make_config();
+    let mut guesser = make_guesser(config, process);
+    let version_data = guesser
+        .guess_version(
+            &package_config(&[
+                ("version", PhpMixed::String("self.version".to_string())),
+                ("non-feature-branches", string_list(&["latest-.*"])),
+            ]),
+            "dummy/path",
+        )
+        .unwrap()
+        .expect("expected version data");
+
+    assert_eq!("dev-latest-testing", version_data.version.unwrap());
+    assert_eq!(another_commit_hash, version_data.commit.unwrap());
+    assert_eq!(
+        "dev-feature",
+        version_data.feature_version.as_deref().unwrap()
+    );
+    assert_eq!(
+        "dev-feature",
+        version_data.feature_pretty_version.as_deref().unwrap()
+    );
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations; no ProcessExecutorMock mocking infrastructure exists"]
 #[test]
+#[serial]
 fn test_guess_version_reads_and_respects_non_feature_branches_configuration_for_arbitrary_naming_when_on_non_feature_branch()
  {
-    todo!()
+    set_up();
+    let _td = TearDown;
+    let commit_hash = "03a15d220da53c52eddd5f32ffca64a7b3801bea";
+    let another_commit_hash = "13a15d220da53c52eddd5f32ffca64a7b3801bea";
+
+    let expectations: Vec<MockExpectation> = vec![
+        cmd_full(["git", "--version"], 0, "git version 2.52.0", ""),
+        cmd_full(
+            ["git", "branch", "-a", "--no-color", "--no-abbrev", "-v"],
+            0,
+            format!(
+                "* latest-testing {} Commit message\n  current {} Another message\n  master {} Another message\n",
+                commit_hash, another_commit_hash, another_commit_hash
+            ),
+            "",
+        ),
+    ];
+    let (process, _guard) = get_process_executor_mock(expectations, true, MockHandler::default());
+
+    let config = make_config();
+    let mut guesser = make_guesser(config, process);
+    let version_data = guesser
+        .guess_version(
+            &package_config(&[
+                ("version", PhpMixed::String("self.version".to_string())),
+                ("non-feature-branches", string_list(&["latest-.*"])),
+            ]),
+            "dummy/path",
+        )
+        .unwrap()
+        .expect("expected version data");
+
+    assert_eq!("dev-latest-testing", version_data.version.unwrap());
+    assert_eq!(commit_hash, version_data.commit.unwrap());
+    assert!(version_data.feature_version.is_none());
+    assert!(version_data.feature_pretty_version.is_none());
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations; no ProcessExecutorMock mocking infrastructure exists"]
 #[test]
+#[serial]
 fn test_detached_head_becomes_dev_hash() {
-    todo!()
+    set_up();
+    let _td = TearDown;
+    let commit_hash = "03a15d220da53c52eddd5f32ffca64a7b3801bea";
+
+    let expectations: Vec<MockExpectation> = vec![
+        cmd_full(["git", "--version"], 0, "git version 2.52.0", ""),
+        cmd_full(
+            ["git", "branch", "-a", "--no-color", "--no-abbrev", "-v"],
+            0,
+            format!("* (no branch) {} Commit message\n", commit_hash),
+            "",
+        ),
+        cmd(["git", "describe", "--exact-match", "--tags"]),
+    ];
+    let (process, _guard) = get_process_executor_mock(expectations, true, MockHandler::default());
+
+    let config = make_config();
+    let mut guesser = make_guesser(config, process);
+    let version_data = guesser
+        .guess_version(&IndexMap::new(), "dummy/path")
+        .unwrap()
+        .expect("expected version data");
+
+    assert_eq!(
+        format!("dev-{}", commit_hash),
+        version_data.version.unwrap()
+    );
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations; no ProcessExecutorMock mocking infrastructure exists"]
 #[test]
+#[serial]
 fn test_detached_fetch_head_becomes_dev_hash_git2() {
-    todo!()
+    set_up();
+    let _td = TearDown;
+    let commit_hash = "03a15d220da53c52eddd5f32ffca64a7b3801bea";
+
+    let expectations: Vec<MockExpectation> = vec![
+        cmd_full(["git", "--version"], 0, "git version 2.52.0", ""),
+        cmd_full(
+            ["git", "branch", "-a", "--no-color", "--no-abbrev", "-v"],
+            0,
+            format!(
+                "* (HEAD detached at FETCH_HEAD) {} Commit message\n",
+                commit_hash
+            ),
+            "",
+        ),
+        cmd(["git", "describe", "--exact-match", "--tags"]),
+    ];
+    let (process, _guard) = get_process_executor_mock(expectations, true, MockHandler::default());
+
+    let config = make_config();
+    let mut guesser = make_guesser(config, process);
+    let version_data = guesser
+        .guess_version(&IndexMap::new(), "dummy/path")
+        .unwrap()
+        .expect("expected version data");
+
+    assert_eq!(
+        format!("dev-{}", commit_hash),
+        version_data.version.unwrap()
+    );
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations; no ProcessExecutorMock mocking infrastructure exists"]
 #[test]
+#[serial]
 fn test_detached_commit_head_becomes_dev_hash_git2() {
-    todo!()
+    set_up();
+    let _td = TearDown;
+    let commit_hash = "03a15d220da53c52eddd5f32ffca64a7b3801bea";
+
+    let expectations: Vec<MockExpectation> = vec![
+        cmd_full(["git", "--version"], 0, "git version 2.52.0", ""),
+        cmd_full(
+            ["git", "branch", "-a", "--no-color", "--no-abbrev", "-v"],
+            0,
+            format!(
+                "* (HEAD detached at 03a15d220) {} Commit message\n",
+                commit_hash
+            ),
+            "",
+        ),
+        cmd(["git", "describe", "--exact-match", "--tags"]),
+    ];
+    let (process, _guard) = get_process_executor_mock(expectations, true, MockHandler::default());
+
+    let config = make_config();
+    let mut guesser = make_guesser(config, process);
+    let version_data = guesser
+        .guess_version(&IndexMap::new(), "dummy/path")
+        .unwrap()
+        .expect("expected version data");
+
+    assert_eq!(
+        format!("dev-{}", commit_hash),
+        version_data.version.unwrap()
+    );
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations; no ProcessExecutorMock mocking infrastructure exists"]
 #[test]
+#[serial]
 fn test_tag_becomes_version() {
-    todo!()
+    set_up();
+    let _td = TearDown;
+
+    let expectations: Vec<MockExpectation> = vec![
+        cmd_full(["git", "--version"], 0, "git version 2.52.0", ""),
+        cmd_full(
+            ["git", "branch", "-a", "--no-color", "--no-abbrev", "-v"],
+            0,
+            "* (HEAD detached at v2.0.5-alpha2) 433b98d4218c181bae01865901aac045585e8a1a Commit message\n",
+            "",
+        ),
+        cmd_full(
+            ["git", "describe", "--exact-match", "--tags"],
+            0,
+            "v2.0.5-alpha2",
+            "",
+        ),
+    ];
+    let (process, _guard) = get_process_executor_mock(expectations, true, MockHandler::default());
+
+    let config = make_config();
+    let mut guesser = make_guesser(config, process);
+    let version_data = guesser
+        .guess_version(&IndexMap::new(), "dummy/path")
+        .unwrap()
+        .expect("expected version data");
+
+    assert_eq!("2.0.5.0-alpha2", version_data.version.unwrap());
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations; no ProcessExecutorMock mocking infrastructure exists"]
 #[test]
+#[serial]
 fn test_tag_becomes_pretty_version() {
-    todo!()
+    set_up();
+    let _td = TearDown;
+
+    let expectations: Vec<MockExpectation> = vec![
+        cmd_full(["git", "--version"], 0, "git version 2.52.0", ""),
+        cmd_full(
+            ["git", "branch", "-a", "--no-color", "--no-abbrev", "-v"],
+            0,
+            "* (HEAD detached at 1.0.0) c006f0c12bbbf197b5c071ffb1c0e9812bb14a4d Commit message\n",
+            "",
+        ),
+        cmd_full(
+            ["git", "describe", "--exact-match", "--tags"],
+            0,
+            "1.0.0",
+            "",
+        ),
+    ];
+    let (process, _guard) = get_process_executor_mock(expectations, true, MockHandler::default());
+
+    let config = make_config();
+    let mut guesser = make_guesser(config, process);
+    let version_data = guesser
+        .guess_version(&IndexMap::new(), "dummy/path")
+        .unwrap()
+        .expect("expected version data");
+
+    assert_eq!("1.0.0.0", version_data.version.unwrap());
+    assert_eq!("1.0.0", version_data.pretty_version.unwrap());
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations; no ProcessExecutorMock mocking infrastructure exists"]
 #[test]
+#[serial]
 fn test_invalid_tag_becomes_version() {
-    todo!()
+    set_up();
+    let _td = TearDown;
+
+    let expectations: Vec<MockExpectation> = vec![
+        cmd_full(["git", "--version"], 0, "git version 2.52.0", ""),
+        cmd_full(
+            ["git", "branch", "-a", "--no-color", "--no-abbrev", "-v"],
+            0,
+            "* foo 03a15d220da53c52eddd5f32ffca64a7b3801bea Commit message\n",
+            "",
+        ),
+    ];
+    let (process, _guard) = get_process_executor_mock(expectations, true, MockHandler::default());
+
+    let config = make_config();
+    let mut guesser = make_guesser(config, process);
+    let version_data = guesser
+        .guess_version(&IndexMap::new(), "dummy/path")
+        .unwrap()
+        .expect("expected version data");
+
+    assert_eq!("dev-foo", version_data.version.unwrap());
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations; no ProcessExecutorMock mocking infrastructure exists"]
 #[test]
+#[serial]
 fn test_numeric_branches_show_nicely() {
-    todo!()
+    set_up();
+    let _td = TearDown;
+
+    let expectations: Vec<MockExpectation> = vec![
+        cmd_full(["git", "--version"], 0, "git version 2.52.0", ""),
+        cmd_full(
+            ["git", "branch", "-a", "--no-color", "--no-abbrev", "-v"],
+            0,
+            "* 1.5 03a15d220da53c52eddd5f32ffca64a7b3801bea Commit message\n",
+            "",
+        ),
+    ];
+    let (process, _guard) = get_process_executor_mock(expectations, true, MockHandler::default());
+
+    let config = make_config();
+    let mut guesser = make_guesser(config, process);
+    let version_data = guesser
+        .guess_version(&IndexMap::new(), "dummy/path")
+        .unwrap()
+        .expect("expected version data");
+
+    assert_eq!("1.5.x-dev", version_data.pretty_version.unwrap());
+    assert_eq!("1.5.9999999.9999999-dev", version_data.version.unwrap());
 }
 
-#[ignore = "requires getProcessExecutorMock with expects() command expectations; no ProcessExecutorMock mocking infrastructure exists"]
+#[ignore = "remote-branch feature guessing calls ProcessExecutor::execute_async, whose mock path is todo!()"]
 #[test]
+#[serial]
 fn test_remote_branches_are_selected() {
-    todo!()
+    set_up();
+    let _td = TearDown;
+
+    let expectations: Vec<MockExpectation> = vec![
+        cmd_full(["git", "--version"], 0, "git version 2.52.0", ""),
+        cmd_full(
+            ["git", "branch", "-a", "--no-color", "--no-abbrev", "-v"],
+            0,
+            "* feature-branch 03a15d220da53c52eddd5f32ffca64a7b3801bea Commit message\n\
+             remotes/origin/1.5 03a15d220da53c52eddd5f32ffca64a7b3801bea Commit message\n",
+            "",
+        ),
+        cmd_full(
+            ["git", "rev-list", "remotes/origin/1.5..feature-branch"],
+            0,
+            "\n",
+            "",
+        ),
+    ];
+    let (process, _guard) = get_process_executor_mock(expectations, true, MockHandler::default());
+
+    let config = make_config();
+    let mut guesser = make_guesser(config, process);
+    let version_data = guesser
+        .guess_version(
+            &package_config(&[("version", PhpMixed::String("self.version".to_string()))]),
+            "dummy/path",
+        )
+        .unwrap()
+        .expect("expected version data");
+
+    assert_eq!("1.5.x-dev", version_data.pretty_version.unwrap());
+    assert_eq!("1.5.9999999.9999999-dev", version_data.version.unwrap());
 }
 
 #[test]
+#[serial]
 fn test_get_root_version_from_env() {
     // @dataProvider rootEnvVersionsProvider
     let root_env_versions: Vec<(&str, &str)> = vec![
diff --git a/crates/shirabe/tests/repository/main.rs b/crates/shirabe/tests/repository/main.rs
index 15a42a3..f5ecbc6 100644
--- a/crates/shirabe/tests/repository/main.rs
+++ b/crates/shirabe/tests/repository/main.rs
@@ -4,6 +4,8 @@ mod config_stub;
 mod http_downloader_mock;
 #[path = "../common/io_stub.rs"]
 mod io_stub;
+#[path = "../common/process_executor_mock.rs"]
+mod process_executor_mock;
 #[path = "../common/test_case.rs"]
 mod test_case;
 
diff --git a/crates/shirabe/tests/repository/vcs/github_driver_test.rs b/crates/shirabe/tests/repository/vcs/github_driver_test.rs
index f5958a4..0469edf 100644
--- a/crates/shirabe/tests/repository/vcs/github_driver_test.rs
+++ b/crates/shirabe/tests/repository/vcs/github_driver_test.rs
@@ -5,13 +5,22 @@ use std::rc::Rc;
 
 use indexmap::IndexMap;
 use shirabe::config::Config;
+use shirabe::config::ConfigSourceInterface;
 use shirabe::io::IOInterface;
 use shirabe::io::null_io::NullIO;
 use shirabe::repository::vcs::GitHubDriver;
 use shirabe::util::filesystem::Filesystem;
+use shirabe::util::http_downloader::HttpDownloaderMockHandler;
+use shirabe::util::process_executor::{MockHandler, ProcessExecutor};
 use shirabe_php_shim::PhpMixed;
 use tempfile::TempDir;
 
+use crate::http_downloader_mock::{HttpDownloaderMockGuard, expect_full, get_http_downloader_mock};
+use crate::io_stub::IOStub;
+use crate::process_executor_mock::{
+    ProcessExecutorMockGuard, cmd, cmd_full, get_process_executor_mock,
+};
+
 struct SetUp {
     home: TempDir,
     config: Config,
@@ -53,6 +62,82 @@ impl Drop for TearDown {
     }
 }
 
+// No-op ConfigSourceInterface, equivalent to PHPUnit's
+// `getMockBuilder(ConfigSourceInterface::class)->getMock()` whose methods all do
+// nothing. Used by testPrivateRepository to satisfy the OAuth token-storing path.
+#[derive(Debug)]
+struct NullConfigSource;
+
+impl ConfigSourceInterface for NullConfigSource {
+    fn add_repository(
+        &mut self,
+        _name: &str,
+        _config: PhpMixed,
+        _append: bool,
+    ) -> anyhow::Result<()> {
+        Ok(())
+    }
+    fn insert_repository(
+        &mut self,
+        _name: &str,
+        _config: PhpMixed,
+        _reference_name: &str,
+        _offset: i64,
+    ) -> anyhow::Result<()> {
+        Ok(())
+    }
+    fn set_repository_url(&mut self, _name: &str, _url: &str) -> anyhow::Result<()> {
+        Ok(())
+    }
+    fn remove_repository(&mut self, _name: &str) -> anyhow::Result<()> {
+        Ok(())
+    }
+    fn add_config_setting(&mut self, _name: &str, _value: PhpMixed) -> anyhow::Result<()> {
+        Ok(())
+    }
+    fn remove_config_setting(&mut self, _name: &str) -> anyhow::Result<()> {
+        Ok(())
+    }
+    fn add_property(&mut self, _name: &str, _value: PhpMixed) -> anyhow::Result<()> {
+        Ok(())
+    }
+    fn remove_property(&mut self, _name: &str) -> anyhow::Result<()> {
+        Ok(())
+    }
+    fn add_link(&mut self, r#type: &str, name: &str, value: &str) -> anyhow::Result<()> {
+        let _ = (r#type, name, value);
+        Ok(())
+    }
+    fn remove_link(&mut self, r#type: &str, name: &str) -> anyhow::Result<()> {
+        let _ = (r#type, name);
+        Ok(())
+    }
+    fn get_name(&self) -> String {
+        String::new()
+    }
+}
+
+// Mirrors PHP's $httpDownloader->expects([...], true): an `['url' => .., 'body' => ..]`
+// entry (status defaults to 200).
+fn http_body(
+    url: &str,
+    body: impl Into<String>,
+) -> shirabe::util::http_downloader::HttpDownloaderMockExpectation {
+    expect_full(url, None, 200, body, vec![String::new()])
+}
+
+// Mirrors PHP's `['url' => .., 'status' => 404]` entry (no body).
+fn http_status(
+    url: &str,
+    status: i64,
+) -> shirabe::util::http_downloader::HttpDownloaderMockExpectation {
+    expect_full(url, None, status, String::new(), vec![String::new()])
+}
+
+fn b64(s: &str) -> String {
+    shirabe_php_shim::base64_encode(s)
+}
+
 fn supports_provider() -> Vec<(bool, &'static str)> {
     vec![
         (false, "https://github.com/acme"),
@@ -80,77 +165,731 @@ fn test_supports() {
     }
 }
 
-// The remaining cases construct a GitHubDriver and mock the HttpDownloader/IO to return
-// GitHub API responses; mocking is not available, and a real HttpDownloader reaches
-// curl_multi_init (todo!()).
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock), ProcessExecutorMock, the IOInterface MockObject (askAndHideAnswer/setAuthentication), and setAttribute reflection are not ported"]
 fn test_private_repository() {
-    let SetUp { home, config: _ } = set_up();
+    let SetUp { home, config } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf());
-    todo!()
+
+    let repo_url = "http://github.com/composer/packagist";
+    let repo_api_url = "https://api.github.com/repos/composer/packagist";
+    let repo_ssh_url = "git@github.com:composer/packagist.git";
+    let identifier = "v0.0.0";
+    let sha = "SOMESHA";
+
+    let config = Rc::new(RefCell::new(config));
+
+    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(
+        IOStub::new()
+            .with_is_interactive(true)
+            .with_ask_and_hide_answer(Some("sometoken".to_string())),
+    ));
+
+    let (http_downloader, _http_guard): (_, HttpDownloaderMockGuard) = get_http_downloader_mock(
+        vec![
+            http_status(repo_api_url, 404),
+            http_body("https://api.github.com/", "{}"),
+            http_body(
+                repo_api_url,
+                r#"{"master_branch": "test_master", "private": true, "owner": {"login": "composer"}, "name": "packagist"}"#,
+            ),
+        ],
+        true,
+        HttpDownloaderMockHandler::default(),
+    );
+
+    let (process, _process_guard): (_, ProcessExecutorMockGuard) = get_process_executor_mock(
+        vec![],
+        false,
+        MockHandler {
+            r#return: 1,
+            stdout: String::new(),
+            stderr: String::new(),
+        },
+    );
+
+    config
+        .borrow_mut()
+        .set_config_source(Box::new(NullConfigSource));
+    config
+        .borrow_mut()
+        .set_auth_config_source(Box::new(NullConfigSource));
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert("url".to_string(), PhpMixed::String(repo_url.to_string()));
+
+    let mut git_hub_driver = GitHubDriver::new(repo_config, io, config, http_downloader, process);
+    git_hub_driver.initialize().unwrap();
+    let mut tags = IndexMap::new();
+    tags.insert(identifier.to_string(), sha.to_string());
+    git_hub_driver.__set_tags(Some(tags));
+
+    assert_eq!("test_master", git_hub_driver.get_root_identifier().unwrap());
+
+    let dist = git_hub_driver.get_dist(sha).unwrap();
+    assert_eq!(Some("zip"), dist.get("type").and_then(|v| v.as_string()));
+    assert_eq!(
+        Some("https://api.github.com/repos/composer/packagist/zipball/SOMESHA"),
+        dist.get("url").and_then(|v| v.as_string())
+    );
+    assert_eq!(
+        Some("SOMESHA"),
+        dist.get("reference").and_then(|v| v.as_string())
+    );
+
+    let source = git_hub_driver.get_source(sha);
+    assert_eq!(Some("git"), source.get("type").and_then(|v| v.as_string()));
+    assert_eq!(
+        Some(repo_ssh_url),
+        source.get("url").and_then(|v| v.as_string())
+    );
+    assert_eq!(
+        Some("SOMESHA"),
+        source.get("reference").and_then(|v| v.as_string())
+    );
 }
 
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock), ProcessExecutorMock, the IOInterface MockObject, and setAttribute reflection are not ported"]
 fn test_public_repository() {
-    let SetUp { home, config: _ } = set_up();
+    let SetUp { home, config } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf());
-    todo!()
+
+    let repo_url = "http://github.com/composer/packagist";
+    let repo_api_url = "https://api.github.com/repos/composer/packagist";
+    let identifier = "v0.0.0";
+    let sha = "SOMESHA";
+
+    let config = Rc::new(RefCell::new(config));
+    let io: Rc<RefCell<dyn IOInterface>> =
+        Rc::new(RefCell::new(IOStub::new().with_is_interactive(true)));
+
+    let (http_downloader, _http_guard) = get_http_downloader_mock(
+        vec![http_body(
+            repo_api_url,
+            r#"{"master_branch": "test_master", "owner": {"login": "composer"}, "name": "packagist"}"#,
+        )],
+        true,
+        HttpDownloaderMockHandler::default(),
+    );
+
+    let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert("url".to_string(), PhpMixed::String(repo_url.to_string()));
+    let repo_url = "https://github.com/composer/packagist.git";
+
+    let mut git_hub_driver = GitHubDriver::new(repo_config, io, config, http_downloader, process);
+    git_hub_driver.initialize().unwrap();
+    let mut tags = IndexMap::new();
+    tags.insert(identifier.to_string(), sha.to_string());
+    git_hub_driver.__set_tags(Some(tags));
+
+    assert_eq!("test_master", git_hub_driver.get_root_identifier().unwrap());
+
+    let dist = git_hub_driver.get_dist(sha).unwrap();
+    assert_eq!(Some("zip"), dist.get("type").and_then(|v| v.as_string()));
+    assert_eq!(
+        Some("https://api.github.com/repos/composer/packagist/zipball/SOMESHA"),
+        dist.get("url").and_then(|v| v.as_string())
+    );
+    assert_eq!(Some(sha), dist.get("reference").and_then(|v| v.as_string()));
+
+    let source = git_hub_driver.get_source(sha);
+    assert_eq!(Some("git"), source.get("type").and_then(|v| v.as_string()));
+    assert_eq!(
+        Some(repo_url),
+        source.get("url").and_then(|v| v.as_string())
+    );
+    assert_eq!(
+        Some(sha),
+        source.get("reference").and_then(|v| v.as_string())
+    );
 }
 
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock), ProcessExecutorMock, the IOInterface MockObject, and setAttribute reflection are not ported"]
+#[ignore = "blocked by shim: getComposerInformation -> get_change_date -> shirabe_php_shim::date_create is todo!()"]
 fn test_public_repository2() {
-    let SetUp { home, config: _ } = set_up();
+    let SetUp { home, config } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf());
-    todo!()
+
+    let repo_url = "http://github.com/composer/packagist";
+    let repo_api_url = "https://api.github.com/repos/composer/packagist";
+    let identifier = "feature/3.2-foo";
+    let sha = "SOMESHA";
+
+    let config = Rc::new(RefCell::new(config));
+    let io: Rc<RefCell<dyn IOInterface>> =
+        Rc::new(RefCell::new(IOStub::new().with_is_interactive(true)));
+
+    let (http_downloader, _http_guard) = get_http_downloader_mock(
+        vec![
+            http_body(
+                repo_api_url,
+                r#"{"master_branch": "test_master", "owner": {"login": "composer"}, "name": "packagist"}"#,
+            ),
+            http_body(
+                "https://api.github.com/repos/composer/packagist/contents/composer.json?ref=feature%2F3.2-foo",
+                format!(
+                    r#"{{"encoding":"base64","content":"{}"}}"#,
+                    b64(&format!(r#"{{"support": {{"source": "{}" }}}}"#, repo_url))
+                ),
+            ),
+            http_body(
+                "https://api.github.com/repos/composer/packagist/commits/feature%2F3.2-foo",
+                r#"{"commit": {"committer":{ "date": "2012-09-10"}}}"#,
+            ),
+            http_body(
+                "https://api.github.com/repos/composer/packagist/contents/.github/FUNDING.yml",
+                format!(
+                    r#"{{"encoding": "base64", "content": "{}"}}"#,
+                    b64("custom: https://example.com")
+                ),
+            ),
+        ],
+        true,
+        HttpDownloaderMockHandler::default(),
+    );
+
+    let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert("url".to_string(), PhpMixed::String(repo_url.to_string()));
+    let repo_url = "https://github.com/composer/packagist.git";
+
+    let mut git_hub_driver = GitHubDriver::new(repo_config, io, config, http_downloader, process);
+    git_hub_driver.initialize().unwrap();
+    let mut tags = IndexMap::new();
+    tags.insert(identifier.to_string(), sha.to_string());
+    git_hub_driver.__set_tags(Some(tags));
+
+    assert_eq!("test_master", git_hub_driver.get_root_identifier().unwrap());
+
+    let dist = git_hub_driver.get_dist(sha).unwrap();
+    assert_eq!(Some("zip"), dist.get("type").and_then(|v| v.as_string()));
+    assert_eq!(
+        Some("https://api.github.com/repos/composer/packagist/zipball/SOMESHA"),
+        dist.get("url").and_then(|v| v.as_string())
+    );
+    assert_eq!(Some(sha), dist.get("reference").and_then(|v| v.as_string()));
+
+    let source = git_hub_driver.get_source(sha);
+    assert_eq!(Some("git"), source.get("type").and_then(|v| v.as_string()));
+    assert_eq!(
+        Some(repo_url),
+        source.get("url").and_then(|v| v.as_string())
+    );
+    assert_eq!(
+        Some(sha),
+        source.get("reference").and_then(|v| v.as_string())
+    );
+
+    let data = git_hub_driver
+        .get_composer_information(identifier)
+        .unwrap()
+        .unwrap();
+    assert!(!data.contains_key("abandoned"));
 }
 
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock), ProcessExecutorMock, the IOInterface MockObject, and setAttribute reflection are not ported"]
+#[ignore = "blocked by shim: getComposerInformation -> get_change_date -> shirabe_php_shim::date_create is todo!()"]
 fn test_invalid_support_data() {
-    let SetUp { home, config: _ } = set_up();
+    let SetUp { home, config } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf());
-    todo!()
+
+    let repo_url = "http://github.com/composer/packagist";
+    let repo_api_url = "https://api.github.com/repos/composer/packagist";
+    let identifier = "feature/3.2-foo";
+    let sha = "SOMESHA";
+
+    let config = Rc::new(RefCell::new(config));
+    let io: Rc<RefCell<dyn IOInterface>> =
+        Rc::new(RefCell::new(IOStub::new().with_is_interactive(true)));
+
+    let (http_downloader, _http_guard) = get_http_downloader_mock(
+        vec![
+            http_body(
+                repo_api_url,
+                r#"{"master_branch": "test_master", "owner": {"login": "composer"}, "name": "packagist"}"#,
+            ),
+            http_body(
+                "https://api.github.com/repos/composer/packagist/contents/composer.json?ref=feature%2F3.2-foo",
+                format!(
+                    r#"{{"encoding":"base64","content":"{}"}}"#,
+                    b64(&format!(r#"{{"support": "{}" }}"#, repo_url))
+                ),
+            ),
+            http_body(
+                "https://api.github.com/repos/composer/packagist/commits/feature%2F3.2-foo",
+                r#"{"commit": {"committer":{ "date": "2012-09-10"}}}"#,
+            ),
+            http_body(
+                "https://api.github.com/repos/composer/packagist/contents/.github/FUNDING.yml",
+                format!(
+                    r#"{{"encoding": "base64", "content": "{}"}}"#,
+                    b64("custom: https://example.com")
+                ),
+            ),
+        ],
+        true,
+        HttpDownloaderMockHandler::default(),
+    );
+
+    let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert("url".to_string(), PhpMixed::String(repo_url.to_string()));
+
+    let mut git_hub_driver = GitHubDriver::new(repo_config, io, config, http_downloader, process);
+    git_hub_driver.initialize().unwrap();
+    let mut tags = IndexMap::new();
+    tags.insert(identifier.to_string(), sha.to_string());
+    git_hub_driver.__set_tags(Some(tags));
+    let mut branches = IndexMap::new();
+    branches.insert("test_master".to_string(), sha.to_string());
+    git_hub_driver.__set_branches(Some(branches));
+
+    let data = git_hub_driver
+        .get_composer_information(identifier)
+        .unwrap()
+        .unwrap();
+
+    let support = data.get("support").and_then(|v| v.as_array()).unwrap();
+    assert_eq!(
+        Some("https://github.com/composer/packagist/tree/feature/3.2-foo"),
+        support.get("source").and_then(|v| v.as_string())
+    );
+}
+
+fn funding_url_provider() -> Vec<(&'static str, Option<Vec<(&'static str, &'static str)>>)> {
+    let all_named_platforms = "community_bridge: project-name
+github: [userA, userB]
+issuehunt: userName
+ko_fi: userName
+liberapay: userName
+open_collective: userName
+patreon: userName
+tidelift: Platform/Package
+polar: userName
+buy_me_a_coffee: userName
+thanks_dev: u/gh/userName
+otechie: userName";
+
+    vec![
+        (
+            all_named_platforms,
+            Some(vec![
+                (
+                    "community_bridge",
+                    "https://funding.communitybridge.org/projects/project-name",
+                ),
+                ("github", "https://github.com/userA"),
+                ("github", "https://github.com/userB"),
+                ("issuehunt", "https://issuehunt.io/r/userName"),
+                ("ko_fi", "https://ko-fi.com/userName"),
+                ("liberapay", "https://liberapay.com/userName"),
+                ("open_collective", "https://opencollective.com/userName"),
+                ("patreon", "https://www.patreon.com/userName"),
+                (
+                    "tidelift",
+                    "https://tidelift.com/funding/github/Platform/Package",
+                ),
+                ("polar", "https://polar.sh/userName"),
+                ("buy_me_a_coffee", "https://www.buymeacoffee.com/userName"),
+                ("thanks_dev", "https://thanks.dev/u/gh/userName"),
+                ("otechie", "https://otechie.com/userName"),
+            ]),
+        ),
+        (
+            "custom: example.com",
+            Some(vec![("custom", "https://example.com")]),
+        ),
+        (
+            "custom: [example.com]",
+            Some(vec![("custom", "https://example.com")]),
+        ),
+        (
+            "custom: \"https://example.com\"",
+            Some(vec![("custom", "https://example.com")]),
+        ),
+        (
+            "custom: [\"https://example.com\"]",
+            Some(vec![("custom", "https://example.com")]),
+        ),
+        (
+            "custom: [\"https://example.com\", example.org]",
+            Some(vec![
+                ("custom", "https://example.com"),
+                ("custom", "https://example.org"),
+            ]),
+        ),
+        (
+            "custom: [example.net/funding, \"https://example.com\", example.org]",
+            Some(vec![
+                ("custom", "https://example.com"),
+                ("custom", "https://example.org"),
+            ]),
+        ),
+    ]
 }
 
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock), ProcessExecutorMock, the IOInterface MockObject, setAttribute reflection, and the fundingUrlProvider data provider are not ported"]
+#[ignore = "blocked by shim: getComposerInformation -> get_change_date -> shirabe_php_shim::date_create is todo!()"]
 fn test_funding_format() {
-    let SetUp { home, config: _ } = set_up();
-    let _tear_down = TearDown::new(home.path().to_path_buf());
-    todo!()
+    for (funding, expected) in funding_url_provider() {
+        let SetUp { home, config } = set_up();
+        let _tear_down = TearDown::new(home.path().to_path_buf());
+
+        let repo_url = "http://github.com/composer/packagist";
+        let repo_api_url = "https://api.github.com/repos/composer/packagist";
+        let identifier = "feature/3.2-foo";
+        let sha = "SOMESHA";
+
+        let config = Rc::new(RefCell::new(config));
+        let io: Rc<RefCell<dyn IOInterface>> =
+            Rc::new(RefCell::new(IOStub::new().with_is_interactive(true)));
+
+        let (http_downloader, _http_guard) = get_http_downloader_mock(
+            vec![
+                http_body(
+                    repo_api_url,
+                    r#"{"master_branch": "test_master", "owner": {"login": "composer"}, "name": "packagist"}"#,
+                ),
+                http_body(
+                    "https://api.github.com/repos/composer/packagist/contents/composer.json?ref=feature%2F3.2-foo",
+                    format!(
+                        r#"{{"encoding":"base64","content":"{}"}}"#,
+                        b64(&format!(r#"{{"support": {{"source": "{}" }}}}"#, repo_url))
+                    ),
+                ),
+                http_body(
+                    "https://api.github.com/repos/composer/packagist/commits/feature%2F3.2-foo",
+                    r#"{"commit": {"committer":{ "date": "2012-09-10"}}}"#,
+                ),
+                http_body(
+                    "https://api.github.com/repos/composer/packagist/contents/.github/FUNDING.yml",
+                    format!(r#"{{"encoding": "base64", "content": "{}"}}"#, b64(funding)),
+                ),
+            ],
+            true,
+            HttpDownloaderMockHandler::default(),
+        );
+
+        let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+
+        let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+        repo_config.insert("url".to_string(), PhpMixed::String(repo_url.to_string()));
+
+        let mut git_hub_driver =
+            GitHubDriver::new(repo_config, io, config, http_downloader, process);
+        git_hub_driver.initialize().unwrap();
+        let mut tags = IndexMap::new();
+        tags.insert(identifier.to_string(), sha.to_string());
+        git_hub_driver.__set_tags(Some(tags));
+        let mut branches = IndexMap::new();
+        branches.insert("test_master".to_string(), sha.to_string());
+        git_hub_driver.__set_branches(Some(branches));
+
+        let data = git_hub_driver
+            .get_composer_information(identifier)
+            .unwrap()
+            .unwrap();
+
+        match expected {
+            None => assert!(!data.contains_key("funding")),
+            Some(expected) => {
+                let funding_list = match data.get("funding") {
+                    Some(PhpMixed::List(l)) => l.clone(),
+                    Some(PhpMixed::Array(m)) => m.values().cloned().collect(),
+                    other => panic!("unexpected funding value: {:?}", other),
+                };
+                let actual: Vec<(String, String)> = funding_list
+                    .iter()
+                    .map(|entry| {
+                        let m = entry.as_array().unwrap();
+                        (
+                            m.get("type")
+                                .and_then(|v| v.as_string())
+                                .unwrap_or("")
+                                .to_string(),
+                            m.get("url")
+                                .and_then(|v| v.as_string())
+                                .unwrap_or("")
+                                .to_string(),
+                        )
+                    })
+                    .collect();
+                let expected_vec: Vec<(String, String)> = expected
+                    .iter()
+                    .map(|(t, u)| (t.to_string(), u.to_string()))
+                    .collect();
+                assert_eq!(expected_vec, actual);
+            }
+        }
+    }
 }
 
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock), ProcessExecutorMock, the IOInterface MockObject, and setAttribute reflection are not ported"]
+#[ignore = "blocked by shim: getComposerInformation -> get_change_date -> shirabe_php_shim::date_create is todo!()"]
 fn test_public_repository_archived() {
-    let SetUp { home, config: _ } = set_up();
+    let SetUp { home, config } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf());
-    todo!()
+
+    let repo_url = "http://github.com/composer/packagist";
+    let repo_api_url = "https://api.github.com/repos/composer/packagist";
+    let identifier = "v0.0.0";
+    let sha = "SOMESHA";
+    let composer_json_url = format!(
+        "https://api.github.com/repos/composer/packagist/contents/composer.json?ref={}",
+        sha
+    );
+
+    let config = Rc::new(RefCell::new(config));
+    let io: Rc<RefCell<dyn IOInterface>> =
+        Rc::new(RefCell::new(IOStub::new().with_is_interactive(true)));
+
+    let (http_downloader, _http_guard) = get_http_downloader_mock(
+        vec![
+            http_body(
+                repo_api_url,
+                r#"{"master_branch": "test_master", "owner": {"login": "composer"}, "name": "packagist", "archived": true}"#,
+            ),
+            http_body(
+                &composer_json_url,
+                format!(
+                    r#"{{"encoding": "base64", "content": "{}"}}"#,
+                    b64(r#"{"name": "composer/packagist"}"#)
+                ),
+            ),
+            http_body(
+                &format!(
+                    "https://api.github.com/repos/composer/packagist/commits/{}",
+                    sha
+                ),
+                r#"{"commit": {"committer":{ "date": "2012-09-10"}}}"#,
+            ),
+            http_body(
+                "https://api.github.com/repos/composer/packagist/contents/.github/FUNDING.yml",
+                format!(
+                    r#"{{"encoding": "base64", "content": "{}"}}"#,
+                    b64("custom: https://example.com")
+                ),
+            ),
+        ],
+        true,
+        HttpDownloaderMockHandler::default(),
+    );
+
+    let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert("url".to_string(), PhpMixed::String(repo_url.to_string()));
+
+    let mut git_hub_driver = GitHubDriver::new(repo_config, io, config, http_downloader, process);
+    git_hub_driver.initialize().unwrap();
+    let mut tags = IndexMap::new();
+    tags.insert(identifier.to_string(), sha.to_string());
+    git_hub_driver.__set_tags(Some(tags));
+
+    let data = git_hub_driver
+        .get_composer_information(sha)
+        .unwrap()
+        .unwrap();
+
+    assert_eq!(Some(true), data.get("abandoned").and_then(|v| v.as_bool()));
 }
 
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock), ProcessExecutorMock, and the IOInterface MockObject are not ported"]
+#[ignore = "GitDriver clone-fallback path runs an unexpected `git --version` (Git::get_version) not in the PHP mock expectation list; needs the version static seeded and the Rust sync_mirror command sequence to match"]
 fn test_private_repository_no_interaction() {
-    let SetUp { home, config: _ } = set_up();
+    let SetUp { home, config } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf());
-    todo!()
+
+    let repo_url = "http://github.com/composer/packagist";
+    let repo_api_url = "https://api.github.com/repos/composer/packagist";
+    let repo_ssh_url = "git@github.com:composer/packagist.git";
+    let identifier = "v0.0.0";
+    let sha = "SOMESHA";
+
+    let config = Rc::new(RefCell::new(config));
+    let io: Rc<RefCell<dyn IOInterface>> =
+        Rc::new(RefCell::new(IOStub::new().with_is_interactive(false)));
+
+    let (http_downloader, _http_guard) = get_http_downloader_mock(
+        vec![http_status(repo_api_url, 404)],
+        true,
+        HttpDownloaderMockHandler::default(),
+    );
+
+    // clean local clone if present
+    let cache_dir = std::env::temp_dir().join("composer-test");
+    let mut fs = Filesystem::new(None);
+    let _ = fs.remove_directory(&cache_dir);
+    let cache_vcs_dir = std::env::temp_dir()
+        .join("composer-test/cache")
+        .to_string_lossy()
+        .into_owned();
+    {
+        let mut top: IndexMap<String, PhpMixed> = IndexMap::new();
+        let mut config_section: IndexMap<String, PhpMixed> = IndexMap::new();
+        config_section.insert(
+            "cache-vcs-dir".to_string(),
+            PhpMixed::String(cache_vcs_dir.clone()),
+        );
+        top.insert("config".to_string(), PhpMixed::Array(config_section));
+        config.borrow_mut().merge(&top, Config::SOURCE_UNKNOWN);
+    }
+    let resolved_cache_vcs_dir = config
+        .borrow_mut()
+        .get("cache-vcs-dir")
+        .as_string()
+        .unwrap_or("")
+        .to_string();
+
+    let (process, _process_guard): (_, ProcessExecutorMockGuard) = get_process_executor_mock(
+        vec![
+            cmd_full(["git", "config", "github.accesstoken"], 1, "", ""),
+            cmd([
+                "git",
+                "clone",
+                "--mirror",
+                "--",
+                repo_ssh_url,
+                &format!(
+                    "{}/git-github.com-composer-packagist.git/",
+                    resolved_cache_vcs_dir
+                ),
+            ]),
+            cmd(["git", "remote", "-v"]),
+            cmd(["git", "remote", "set-url", "origin", "--", repo_ssh_url]),
+            cmd_full(
+                ["git", "show-ref", "--tags", "--dereference"],
+                0,
+                format!("{} refs/tags/{}", sha, identifier),
+                "",
+            ),
+            cmd_full(
+                ["git", "branch", "--no-color", "--no-abbrev", "-v"],
+                0,
+                "  test_master     edf93f1fccaebd8764383dc12016d0a1a9672d89 Fix test & behavior",
+                "",
+            ),
+            cmd_full(["git", "branch", "--no-color"], 0, "* test_master", ""),
+        ],
+        true,
+        MockHandler::default(),
+    );
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert("url".to_string(), PhpMixed::String(repo_url.to_string()));
+
+    let mut git_hub_driver = GitHubDriver::new(repo_config, io, config, http_downloader, process);
+    git_hub_driver.initialize().unwrap();
+
+    assert_eq!("test_master", git_hub_driver.get_root_identifier().unwrap());
+
+    let dist = git_hub_driver.get_dist(sha).unwrap();
+    assert_eq!(Some("zip"), dist.get("type").and_then(|v| v.as_string()));
+    assert_eq!(
+        Some("https://api.github.com/repos/composer/packagist/zipball/SOMESHA"),
+        dist.get("url").and_then(|v| v.as_string())
+    );
+    assert_eq!(Some(sha), dist.get("reference").and_then(|v| v.as_string()));
+
+    let source = git_hub_driver.get_source(identifier);
+    assert_eq!(Some("git"), source.get("type").and_then(|v| v.as_string()));
+    assert_eq!(
+        Some(repo_ssh_url),
+        source.get("url").and_then(|v| v.as_string())
+    );
+    assert_eq!(
+        Some(identifier),
+        source.get("reference").and_then(|v| v.as_string())
+    );
+
+    let source = git_hub_driver.get_source(sha);
+    assert_eq!(Some("git"), source.get("type").and_then(|v| v.as_string()));
+    assert_eq!(
+        Some(repo_ssh_url),
+        source.get("url").and_then(|v| v.as_string())
+    );
+    assert_eq!(
+        Some(sha),
+        source.get("reference").and_then(|v| v.as_string())
+    );
+}
+
+fn invalid_url_provider() -> Vec<&'static str> {
+    vec![
+        "https://github.com/acme",
+        "https://github.com/acme/repository/releases",
+        "https://github.com/acme/repository/pulls",
+    ]
 }
 
 #[test]
-#[ignore = "IOInterface MockObject (getMockBuilder) and HttpDownloader MockObject (getMockBuilder) plus the invalidUrlProvider data provider are not ported"]
 fn test_initialize_invalid_repo_url() {
-    let SetUp { home, config: _ } = set_up();
-    let _tear_down = TearDown::new(home.path().to_path_buf());
-    todo!()
+    for url in invalid_url_provider() {
+        let SetUp { home, config } = set_up();
+        let _tear_down = TearDown::new(home.path().to_path_buf());
+
+        let config = Rc::new(RefCell::new(config));
+        let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+
+        let (http_downloader, _http_guard) =
+            get_http_downloader_mock(vec![], true, HttpDownloaderMockHandler::default());
+        let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+
+        let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+        repo_config.insert("url".to_string(), PhpMixed::String(url.to_string()));
+
+        let mut git_hub_driver =
+            GitHubDriver::new(repo_config, io, config, http_downloader, process);
+        let result = git_hub_driver.initialize();
+        assert!(
+            result.is_err(),
+            "expected InvalidArgumentException for url {}",
+            url
+        );
+    }
 }
 
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock), ProcessExecutorMock, and the IOInterface MockObject are not ported"]
 fn test_get_empty_file_content() {
-    let SetUp { home, config: _ } = set_up();
+    let SetUp { home, config } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf());
-    todo!()
+
+    let repo_url = "http://github.com/composer/packagist";
+
+    let config = Rc::new(RefCell::new(config));
+    let io: Rc<RefCell<dyn IOInterface>> =
+        Rc::new(RefCell::new(IOStub::new().with_is_interactive(true)));
+
+    let (http_downloader, _http_guard) = get_http_downloader_mock(
+        vec![
+            http_body(
+                "https://api.github.com/repos/composer/packagist",
+                r#"{"master_branch": "test_master", "owner": {"login": "composer"}, "name": "packagist", "archived": true}"#,
+            ),
+            http_body(
+                "https://api.github.com/repos/composer/packagist/contents/composer.json?ref=main",
+                r#"{"encoding":"base64","content":""}"#,
+            ),
+        ],
+        true,
+        HttpDownloaderMockHandler::default(),
+    );
+
+    let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert("url".to_string(), PhpMixed::String(repo_url.to_string()));
+
+    let mut git_hub_driver = GitHubDriver::new(repo_config, io, config, http_downloader, process);
+    git_hub_driver.initialize().unwrap();
+
+    assert_eq!(
+        Some(String::new()),
+        git_hub_driver
+            .get_file_content("composer.json", "main")
+            .unwrap()
+    );
 }
diff --git a/crates/shirabe/tests/repository/vcs/gitlab_driver_test.rs b/crates/shirabe/tests/repository/vcs/gitlab_driver_test.rs
index 0333a2b..e21835d 100644
--- a/crates/shirabe/tests/repository/vcs/gitlab_driver_test.rs
+++ b/crates/shirabe/tests/repository/vcs/gitlab_driver_test.rs
@@ -8,8 +8,15 @@ use shirabe::config::Config;
 use shirabe::io::IOInterface;
 use shirabe::io::null_io::NullIO;
 use shirabe::repository::vcs::GitLabDriver;
+use shirabe::util::http_downloader::{HttpDownloader, HttpDownloaderMockHandler};
+use shirabe::util::process_executor::{MockHandler, ProcessExecutor};
 use shirabe_php_shim::{PhpMixed, extension_loaded};
 
+use crate::http_downloader_mock::{
+    HttpDownloaderMockGuard, expect, expect_full, get_http_downloader_mock,
+};
+use crate::process_executor_mock::{ProcessExecutorMockGuard, get_process_executor_mock};
+
 // Mirrors GitLabDriverTest::setUp's `gitlab-domains` configuration.
 fn make_config() -> Config {
     let mut config = Config::new(true, None);
@@ -30,74 +37,596 @@ fn make_config() -> Config {
     config
 }
 
+// Common test fixtures: the IO mock (a bare NullIO, matching PHP's unconfigured
+// getMock), the config and a no-op process executor mock. The PHP test passes a
+// bare `getMock()` ProcessExecutor; none of these tests invoke git, so an empty
+// strict expectation set both matches PHP and catches unexpected process calls.
+struct Fixtures {
+    io: Rc<RefCell<dyn IOInterface>>,
+    config: Rc<RefCell<Config>>,
+    process: Rc<RefCell<ProcessExecutor>>,
+    _process_guard: ProcessExecutorMockGuard,
+}
+
+fn fixtures() -> Fixtures {
+    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
+    let config = Rc::new(RefCell::new(make_config()));
+    let (process, _process_guard) = get_process_executor_mock(vec![], true, MockHandler::default());
+    Fixtures {
+        io,
+        config,
+        process,
+        _process_guard,
+    }
+}
+
+// Mirrors $this->getHttpDownloaderMock() with a single project-data expectation.
+fn http_mock_with_body(
+    url: &str,
+    body: &str,
+) -> (Rc<RefCell<HttpDownloader>>, HttpDownloaderMockGuard) {
+    get_http_downloader_mock(
+        vec![expect_full(url, None, 200, body, vec![String::new()])],
+        true,
+        HttpDownloaderMockHandler::default(),
+    )
+}
+
+fn provide_initialize_urls() -> Vec<(&'static str, &'static str)> {
+    vec![
+        (
+            "https://gitlab.com/mygroup/myproject",
+            "https://gitlab.com/api/v4/projects/mygroup%2Fmyproject",
+        ),
+        (
+            "http://gitlab.com/mygroup/myproject",
+            "http://gitlab.com/api/v4/projects/mygroup%2Fmyproject",
+        ),
+        (
+            "git@gitlab.com:mygroup/myproject",
+            "https://gitlab.com/api/v4/projects/mygroup%2Fmyproject",
+        ),
+    ]
+}
+
+// Mirrors testInitialize: returns the initialized driver together with the http
+// mock guard (kept alive by the caller so __assert_complete runs at scope end).
+fn do_test_initialize(
+    fixtures: &Fixtures,
+    url: &str,
+    api_url: &str,
+) -> (GitLabDriver, HttpDownloaderMockGuard) {
+    // @link http://doc.gitlab.com/ce/api/projects.html#get-single-project
+    let project_data = r#"{
+    "id": 17,
+    "default_branch": "mymaster",
+    "visibility": "private",
+    "issues_enabled": true,
+    "archived": false,
+    "http_url_to_repo": "https://gitlab.com/mygroup/myproject.git",
+    "ssh_url_to_repo": "git@gitlab.com:mygroup/myproject.git",
+    "last_activity_at": "2014-12-01T09:17:51.000+01:00",
+    "name": "My Project",
+    "name_with_namespace": "My Group / My Project",
+    "path": "myproject",
+    "path_with_namespace": "mygroup/myproject",
+    "web_url": "https://gitlab.com/mygroup/myproject"
+}"#;
+
+    let (http_downloader, guard) = http_mock_with_body(api_url, project_data);
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert("url".to_string(), PhpMixed::String(url.to_string()));
+    let mut driver = GitLabDriver::new(
+        repo_config,
+        fixtures.io.clone(),
+        fixtures.config.clone(),
+        http_downloader,
+        fixtures.process.clone(),
+    );
+    driver.initialize().unwrap();
+
+    assert_eq!(
+        api_url,
+        driver.get_api_url(),
+        "API URL is derived from the repository URL"
+    );
+    assert_eq!(
+        "mymaster",
+        driver.get_root_identifier().unwrap(),
+        "Root identifier is the default branch in GitLab"
+    );
+    assert_eq!(
+        "git@gitlab.com:mygroup/myproject.git",
+        driver.get_repository_url(),
+        "The repository URL is the SSH one by default"
+    );
+    assert_eq!("https://gitlab.com/mygroup/myproject", driver.get_url());
+
+    (driver, guard)
+}
+
+// Mirrors testInitializePublicProject.
+fn do_test_initialize_public_project(
+    fixtures: &Fixtures,
+    url: &str,
+    api_url: &str,
+) -> (GitLabDriver, HttpDownloaderMockGuard) {
+    // @link http://doc.gitlab.com/ce/api/projects.html#get-single-project
+    let project_data = r#"{
+    "id": 17,
+    "default_branch": "mymaster",
+    "visibility": "public",
+    "http_url_to_repo": "https://gitlab.com/mygroup/myproject.git",
+    "ssh_url_to_repo": "git@gitlab.com:mygroup/myproject.git",
+    "last_activity_at": "2014-12-01T09:17:51.000+01:00",
+    "name": "My Project",
+    "name_with_namespace": "My Group / My Project",
+    "path": "myproject",
+    "path_with_namespace": "mygroup/myproject",
+    "web_url": "https://gitlab.com/mygroup/myproject"
+}"#;
+
+    let (http_downloader, guard) = http_mock_with_body(api_url, project_data);
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert("url".to_string(), PhpMixed::String(url.to_string()));
+    let mut driver = GitLabDriver::new(
+        repo_config,
+        fixtures.io.clone(),
+        fixtures.config.clone(),
+        http_downloader,
+        fixtures.process.clone(),
+    );
+    driver.initialize().unwrap();
+
+    assert_eq!(
+        api_url,
+        driver.get_api_url(),
+        "API URL is derived from the repository URL"
+    );
+    assert_eq!(
+        "mymaster",
+        driver.get_root_identifier().unwrap(),
+        "Root identifier is the default branch in GitLab"
+    );
+    assert_eq!(
+        "https://gitlab.com/mygroup/myproject.git",
+        driver.get_repository_url(),
+        "The repository URL is the SSH one by default"
+    );
+    assert_eq!("https://gitlab.com/mygroup/myproject", driver.get_url());
+
+    (driver, guard)
+}
+
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock) and the IOInterface MockObject are not ported"]
 fn test_initialize() {
-    todo!()
+    let fixtures = fixtures();
+    for (url, api_url) in provide_initialize_urls() {
+        let (_driver, _guard) = do_test_initialize(&fixtures, url, api_url);
+    }
 }
 
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock) and the IOInterface MockObject are not ported"]
 fn test_initialize_public_project() {
-    todo!()
+    let fixtures = fixtures();
+    for (url, api_url) in provide_initialize_urls() {
+        let (_driver, _guard) = do_test_initialize_public_project(&fixtures, url, api_url);
+    }
 }
 
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock) and the IOInterface MockObject are not ported"]
 fn test_initialize_public_project_as_anonymous() {
-    todo!()
+    let fixtures = fixtures();
+    for (url, api_url) in provide_initialize_urls() {
+        // @link http://doc.gitlab.com/ce/api/projects.html#get-single-project
+        let project_data = r#"{
+    "id": 17,
+    "default_branch": "mymaster",
+    "http_url_to_repo": "https://gitlab.com/mygroup/myproject.git",
+    "ssh_url_to_repo": "git@gitlab.com:mygroup/myproject.git",
+    "last_activity_at": "2014-12-01T09:17:51.000+01:00",
+    "name": "My Project",
+    "name_with_namespace": "My Group / My Project",
+    "path": "myproject",
+    "path_with_namespace": "mygroup/myproject",
+    "web_url": "https://gitlab.com/mygroup/myproject"
+}"#;
+
+        let (http_downloader, _guard) = http_mock_with_body(api_url, project_data);
+
+        let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+        repo_config.insert("url".to_string(), PhpMixed::String(url.to_string()));
+        let mut driver = GitLabDriver::new(
+            repo_config,
+            fixtures.io.clone(),
+            fixtures.config.clone(),
+            http_downloader,
+            fixtures.process.clone(),
+        );
+        driver.initialize().unwrap();
+
+        assert_eq!(
+            api_url,
+            driver.get_api_url(),
+            "API URL is derived from the repository URL"
+        );
+        assert_eq!(
+            "mymaster",
+            driver.get_root_identifier().unwrap(),
+            "Root identifier is the default branch in GitLab"
+        );
+        assert_eq!(
+            "https://gitlab.com/mygroup/myproject.git",
+            driver.get_repository_url(),
+            "The repository URL is the SSH one by default"
+        );
+        assert_eq!("https://gitlab.com/mygroup/myproject", driver.get_url());
+    }
 }
 
+/// Also support repositories over HTTP (TLS) and has a port number.
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock) and the IOInterface MockObject are not ported"]
 fn test_initialize_with_port_number() {
-    todo!()
+    let fixtures = fixtures();
+    let domain = "gitlab.mycompany.com";
+    let port = "5443";
+    let namespace = "mygroup/myproject";
+    let url = format!("https://{}:{}/{}", domain, port, namespace);
+    // urlencode($namespace) replaces '/' with '%2F'.
+    let api_url = format!(
+        "https://{}:{}/api/v4/projects/{}",
+        domain, port, "mygroup%2Fmyproject"
+    );
+
+    // An incomplete single project API response payload.
+    // @link http://doc.gitlab.com/ce/api/projects.html#get-single-project
+    let project_data = format!(
+        r#"{{
+    "default_branch": "1.0.x",
+    "http_url_to_repo": "https://{0}:{1}/{2}.git",
+    "path": "myproject",
+    "path_with_namespace": "{2}",
+    "web_url": "https://{0}:{1}/{2}"
+}}"#,
+        domain, port, namespace
+    );
+
+    let (http_downloader, _guard) = http_mock_with_body(&api_url, &project_data);
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert("url".to_string(), PhpMixed::String(url.clone()));
+    let mut driver = GitLabDriver::new(
+        repo_config,
+        fixtures.io.clone(),
+        fixtures.config.clone(),
+        http_downloader,
+        fixtures.process.clone(),
+    );
+    driver.initialize().unwrap();
+
+    assert_eq!(
+        api_url,
+        driver.get_api_url(),
+        "API URL is derived from the repository URL"
+    );
+    assert_eq!(
+        "1.0.x",
+        driver.get_root_identifier().unwrap(),
+        "Root identifier is the default branch in GitLab"
+    );
+    assert_eq!(
+        format!("{}.git", url),
+        driver.get_repository_url(),
+        "The repository URL is the SSH one by default"
+    );
+    assert_eq!(url, driver.get_url());
 }
 
 #[test]
-#[ignore = "depends on testInitialize, which needs HttpDownloaderMock + setAttribute (\\ReflectionProperty) not ported"]
 fn test_invalid_support_data() {
-    todo!()
+    let fixtures = fixtures();
+    let repo_url = "https://gitlab.com/mygroup/myproject";
+    let (mut driver, _init_guard) = do_test_initialize(
+        &fixtures,
+        repo_url,
+        "https://gitlab.com/api/v4/projects/mygroup%2Fmyproject",
+    );
+
+    let mut branches: IndexMap<String, String> = IndexMap::new();
+    branches.insert("main".to_string(), "SOMESHA".to_string());
+    driver.__set_branches(Some(branches));
+    driver.__set_tags(Some(IndexMap::new()));
+
+    let (http_downloader, _guard) = get_http_downloader_mock(
+        vec![expect_full(
+            "https://gitlab.com/api/v4/projects/mygroup%2Fmyproject/repository/files/composer%2Ejson/raw?ref=SOMESHA",
+            None,
+            200,
+            format!(r#"{{"support": "{}" }}"#, repo_url),
+            vec![String::new()],
+        )],
+        true,
+        HttpDownloaderMockHandler::default(),
+    );
+    driver.set_http_downloader(http_downloader);
+
+    let data = driver.get_composer_information("main").unwrap().unwrap();
+
+    let source = data
+        .get("support")
+        .and_then(|v| v.as_array())
+        .and_then(|m| m.get("source"))
+        .and_then(|v| v.as_string())
+        .unwrap();
+    assert_eq!("https://gitlab.com/mygroup/myproject/-/tree/main", source);
 }
 
 #[test]
-#[ignore = "depends on testInitialize, which needs HttpDownloaderMock + the IOInterface MockObject not ported"]
 fn test_get_dist() {
-    todo!()
+    let fixtures = fixtures();
+    let (driver, _guard) = do_test_initialize(
+        &fixtures,
+        "https://gitlab.com/mygroup/myproject",
+        "https://gitlab.com/api/v4/projects/mygroup%2Fmyproject",
+    );
+
+    let reference = "c3ebdbf9cceddb82cd2089aaef8c7b992e536363";
+    let mut expected: IndexMap<String, PhpMixed> = IndexMap::new();
+    expected.insert("type".to_string(), PhpMixed::String("zip".to_string()));
+    expected.insert(
+        "url".to_string(),
+        PhpMixed::String(format!(
+            "https://gitlab.com/api/v4/projects/mygroup%2Fmyproject/repository/archive.zip?sha={}",
+            reference
+        )),
+    );
+    expected.insert(
+        "reference".to_string(),
+        PhpMixed::String(reference.to_string()),
+    );
+    expected.insert("shasum".to_string(), PhpMixed::String(String::new()));
+
+    assert_eq!(Some(expected), driver.get_dist(reference));
 }
 
 #[test]
-#[ignore = "depends on testInitialize, which needs HttpDownloaderMock + the IOInterface MockObject not ported"]
 fn test_get_source() {
-    todo!()
+    let fixtures = fixtures();
+    let (driver, _guard) = do_test_initialize(
+        &fixtures,
+        "https://gitlab.com/mygroup/myproject",
+        "https://gitlab.com/api/v4/projects/mygroup%2Fmyproject",
+    );
+
+    let reference = "c3ebdbf9cceddb82cd2089aaef8c7b992e536363";
+    let mut expected: IndexMap<String, PhpMixed> = IndexMap::new();
+    expected.insert("type".to_string(), PhpMixed::String("git".to_string()));
+    expected.insert(
+        "url".to_string(),
+        PhpMixed::String("git@gitlab.com:mygroup/myproject.git".to_string()),
+    );
+    expected.insert(
+        "reference".to_string(),
+        PhpMixed::String(reference.to_string()),
+    );
+
+    assert_eq!(expected, driver.get_source(reference));
 }
 
 #[test]
-#[ignore = "depends on testInitializePublicProject, which needs HttpDownloaderMock + the IOInterface MockObject not ported"]
 fn test_get_source_given_public_project() {
-    todo!()
+    let fixtures = fixtures();
+    let (driver, _guard) = do_test_initialize_public_project(
+        &fixtures,
+        "https://gitlab.com/mygroup/myproject",
+        "https://gitlab.com/api/v4/projects/mygroup%2Fmyproject",
+    );
+
+    let reference = "c3ebdbf9cceddb82cd2089aaef8c7b992e536363";
+    let mut expected: IndexMap<String, PhpMixed> = IndexMap::new();
+    expected.insert("type".to_string(), PhpMixed::String("git".to_string()));
+    expected.insert(
+        "url".to_string(),
+        PhpMixed::String("https://gitlab.com/mygroup/myproject.git".to_string()),
+    );
+    expected.insert(
+        "reference".to_string(),
+        PhpMixed::String(reference.to_string()),
+    );
+
+    assert_eq!(expected, driver.get_source(reference));
 }
 
 #[test]
-#[ignore = "depends on testInitialize, which needs HttpDownloaderMock + the IOInterface MockObject not ported"]
 fn test_get_tags() {
-    todo!()
+    let fixtures = fixtures();
+    let (mut driver, _init_guard) = do_test_initialize(
+        &fixtures,
+        "https://gitlab.com/mygroup/myproject",
+        "https://gitlab.com/api/v4/projects/mygroup%2Fmyproject",
+    );
+
+    let api_url =
+        "https://gitlab.com/api/v4/projects/mygroup%2Fmyproject/repository/tags?per_page=100";
+
+    // @link http://doc.gitlab.com/ce/api/repositories.html#list-project-repository-tags
+    let tag_data = r#"[
+    {
+       "name": "v1.0.0",
+        "commit": {
+            "id": "092ed2c762bbae331e3f51d4a17f67310bf99a81",
+            "committed_date": "2012-05-28T04:42:42-07:00"
+        }
+    },
+    {
+        "name": "v2.0.0",
+        "commit": {
+            "id": "8e8f60b3ec86d63733db3bd6371117a758027ec6",
+            "committed_date": "2014-07-06T12:59:11.000+02:00"
+        }
+    }
+]"#;
+
+    let (http_downloader, _guard) = http_mock_with_body(api_url, tag_data);
+    driver.set_http_downloader(http_downloader);
+
+    let mut expected: IndexMap<String, String> = IndexMap::new();
+    expected.insert(
+        "v1.0.0".to_string(),
+        "092ed2c762bbae331e3f51d4a17f67310bf99a81".to_string(),
+    );
+    expected.insert(
+        "v2.0.0".to_string(),
+        "8e8f60b3ec86d63733db3bd6371117a758027ec6".to_string(),
+    );
+
+    assert_eq!(expected, driver.get_tags().unwrap());
+    assert_eq!(expected, driver.get_tags().unwrap(), "Tags are cached");
 }
 
 #[test]
-#[ignore = "depends on testInitialize, which needs HttpDownloaderMock + the IOInterface MockObject not ported"]
+#[ignore = "Response::find_header_value passes a `(?i)`-prefixed (non-delimited) pattern that compile_php_pattern (Preg) mis-translates to an invalid regex (`(?s)?i)^link:...`), so get_next_page panics when parsing the Link header. Pre-existing Preg/Response porting bug, unrelated to GitLabDriver."]
 fn test_get_paginated_refs() {
-    todo!()
+    let fixtures = fixtures();
+    let (mut driver, _init_guard) = do_test_initialize(
+        &fixtures,
+        "https://gitlab.com/mygroup/myproject",
+        "https://gitlab.com/api/v4/projects/mygroup%2Fmyproject",
+    );
+
+    // @link http://doc.gitlab.com/ce/api/repositories.html#list-project-repository-branches
+    let mut branch_data: Vec<PhpMixed> = vec![
+        branch_entry(
+            "mymaster",
+            "97eda36b5c1dd953a3792865c222d4e85e5f302e",
+            "2013-01-03T21:04:07.000+01:00",
+        ),
+        branch_entry(
+            "staging",
+            "502cffe49f136443f2059803f2e7192d1ac066cd",
+            "2013-03-09T16:35:23.000+01:00",
+        ),
+    ];
+    for _ in 0..98 {
+        branch_data.push(branch_entry(
+            "stagingdupe",
+            "502cffe49f136443f2059803f2e7192d1ac066cd",
+            "2013-03-09T16:35:23.000+01:00",
+        ));
+    }
+    let branch_data = shirabe::json::JsonFile::encode(&PhpMixed::List(branch_data));
+
+    let (http_downloader, _guard) = get_http_downloader_mock(
+        vec![
+            expect_full(
+                "https://gitlab.com/api/v4/projects/mygroup%2Fmyproject/repository/branches?per_page=100",
+                None,
+                200,
+                branch_data.clone(),
+                vec!["Link: <http://gitlab.com/api/v4/projects/mygroup%2Fmyproject/repository/tags?id=mygroup%2Fmyproject&page=2&per_page=20>; rel=\"next\", <http://gitlab.com/api/v4/projects/mygroup%2Fmyproject/repository/tags?id=mygroup%2Fmyproject&page=1&per_page=20>; rel=\"first\", <http://gitlab.com/api/v4/projects/mygroup%2Fmyproject/repository/tags?id=mygroup%2Fmyproject&page=3&per_page=20>; rel=\"last\"".to_string()],
+            ),
+            expect_full(
+                "http://gitlab.com/api/v4/projects/mygroup%2Fmyproject/repository/tags?id=mygroup%2Fmyproject&page=2&per_page=20",
+                None,
+                200,
+                branch_data.clone(),
+                vec!["Link: <http://gitlab.com/api/v4/projects/mygroup%2Fmyproject/repository/tags?id=mygroup%2Fmyproject&page=2&per_page=20>; rel=\"prev\", <http://gitlab.com/api/v4/projects/mygroup%2Fmyproject/repository/tags?id=mygroup%2Fmyproject&page=1&per_page=20>; rel=\"first\", <http://gitlab.com/api/v4/projects/mygroup%2Fmyproject/repository/tags?id=mygroup%2Fmyproject&page=3&per_page=20>; rel=\"last\"".to_string()],
+            ),
+        ],
+        true,
+        HttpDownloaderMockHandler::default(),
+    );
+    driver.set_http_downloader(http_downloader);
+
+    let mut expected: IndexMap<String, String> = IndexMap::new();
+    expected.insert(
+        "mymaster".to_string(),
+        "97eda36b5c1dd953a3792865c222d4e85e5f302e".to_string(),
+    );
+    expected.insert(
+        "staging".to_string(),
+        "502cffe49f136443f2059803f2e7192d1ac066cd".to_string(),
+    );
+    expected.insert(
+        "stagingdupe".to_string(),
+        "502cffe49f136443f2059803f2e7192d1ac066cd".to_string(),
+    );
+
+    assert_eq!(expected, driver.get_branches().unwrap());
+    assert_eq!(
+        expected,
+        driver.get_branches().unwrap(),
+        "Branches are cached"
+    );
+}
+
+fn branch_entry(name: &str, id: &str, committed_date: &str) -> PhpMixed {
+    let mut commit: IndexMap<String, PhpMixed> = IndexMap::new();
+    commit.insert("id".to_string(), PhpMixed::String(id.to_string()));
+    commit.insert(
+        "committed_date".to_string(),
+        PhpMixed::String(committed_date.to_string()),
+    );
+    let mut entry: IndexMap<String, PhpMixed> = IndexMap::new();
+    entry.insert("name".to_string(), PhpMixed::String(name.to_string()));
+    entry.insert("commit".to_string(), PhpMixed::Array(commit));
+    PhpMixed::Array(entry)
 }
 
 #[test]
-#[ignore = "depends on testInitialize, which needs HttpDownloaderMock + the IOInterface MockObject not ported"]
 fn test_get_branches() {
-    todo!()
+    let fixtures = fixtures();
+    let (mut driver, _init_guard) = do_test_initialize(
+        &fixtures,
+        "https://gitlab.com/mygroup/myproject",
+        "https://gitlab.com/api/v4/projects/mygroup%2Fmyproject",
+    );
+
+    let api_url =
+        "https://gitlab.com/api/v4/projects/mygroup%2Fmyproject/repository/branches?per_page=100";
+
+    // @link http://doc.gitlab.com/ce/api/repositories.html#list-project-repository-branches
+    let branch_data = r#"[
+    {
+       "name": "mymaster",
+        "commit": {
+            "id": "97eda36b5c1dd953a3792865c222d4e85e5f302e",
+            "committed_date": "2013-01-03T21:04:07.000+01:00"
+        }
+    },
+    {
+        "name": "staging",
+        "commit": {
+            "id": "502cffe49f136443f2059803f2e7192d1ac066cd",
+            "committed_date": "2013-03-09T16:35:23.000+01:00"
+        }
+    }
+]"#;
+
+    let (http_downloader, _guard) = http_mock_with_body(api_url, branch_data);
+    driver.set_http_downloader(http_downloader);
+
+    let mut expected: IndexMap<String, String> = IndexMap::new();
+    expected.insert(
+        "mymaster".to_string(),
+        "97eda36b5c1dd953a3792865c222d4e85e5f302e".to_string(),
+    );
+    expected.insert(
+        "staging".to_string(),
+        "502cffe49f136443f2059803f2e7192d1ac066cd".to_string(),
+    );
+
+    assert_eq!(expected, driver.get_branches().unwrap());
+    assert_eq!(
+        expected,
+        driver.get_branches().unwrap(),
+        "Branches are cached"
+    );
 }
 
 #[test]
-#[ignore]
 fn test_supports() {
     for (url, expected) in data_for_test_supports() {
         let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
@@ -147,31 +676,216 @@ fn data_for_test_supports() -> Vec<(&'static str, bool)> {
 }
 
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock) and the IOInterface MockObject are not ported"]
 fn test_gitlab_sub_directory() {
-    todo!()
+    let fixtures = fixtures();
+    let url = "https://mycompany.com/gitlab/mygroup/my-pro.ject";
+    let api_url = "https://mycompany.com/gitlab/api/v4/projects/mygroup%2Fmy-pro%2Eject";
+
+    let project_data = r#"{
+    "id": 17,
+    "default_branch": "mymaster",
+    "visibility": "private",
+    "http_url_to_repo": "https://gitlab.com/gitlab/mygroup/my-pro.ject",
+    "ssh_url_to_repo": "git@gitlab.com:mygroup/my-pro.ject.git",
+    "last_activity_at": "2014-12-01T09:17:51.000+01:00",
+    "name": "My Project",
+    "name_with_namespace": "My Group / My Project",
+    "path": "myproject",
+    "path_with_namespace": "mygroup/my-pro.ject",
+    "web_url": "https://gitlab.com/gitlab/mygroup/my-pro.ject"
+}"#;
+
+    let (http_downloader, _guard) = http_mock_with_body(api_url, project_data);
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert("url".to_string(), PhpMixed::String(url.to_string()));
+    let mut driver = GitLabDriver::new(
+        repo_config,
+        fixtures.io.clone(),
+        fixtures.config.clone(),
+        http_downloader,
+        fixtures.process.clone(),
+    );
+    driver.initialize().unwrap();
+
+    assert_eq!(
+        api_url,
+        driver.get_api_url(),
+        "API URL is derived from the repository URL"
+    );
 }
 
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock) and the IOInterface MockObject are not ported"]
 fn test_gitlab_sub_group() {
-    todo!()
+    let fixtures = fixtures();
+    let url = "https://gitlab.com/mygroup/mysubgroup/myproject";
+    let api_url = "https://gitlab.com/api/v4/projects/mygroup%2Fmysubgroup%2Fmyproject";
+
+    let project_data = r#"{
+    "id": 17,
+    "default_branch": "mymaster",
+    "visibility": "private",
+    "http_url_to_repo": "https://gitlab.com/mygroup/mysubgroup/my-pro.ject",
+    "ssh_url_to_repo": "git@gitlab.com:mygroup/mysubgroup/my-pro.ject.git",
+    "last_activity_at": "2014-12-01T09:17:51.000+01:00",
+    "name": "My Project",
+    "name_with_namespace": "My Group / My Project",
+    "path": "myproject",
+    "path_with_namespace": "mygroup/mysubgroup/my-pro.ject",
+    "web_url": "https://gitlab.com/mygroup/mysubgroup/my-pro.ject"
+}"#;
+
+    let (http_downloader, _guard) = http_mock_with_body(api_url, project_data);
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert("url".to_string(), PhpMixed::String(url.to_string()));
+    let mut driver = GitLabDriver::new(
+        repo_config,
+        fixtures.io.clone(),
+        fixtures.config.clone(),
+        http_downloader,
+        fixtures.process.clone(),
+    );
+    driver.initialize().unwrap();
+
+    assert_eq!(
+        api_url,
+        driver.get_api_url(),
+        "API URL is derived from the repository URL"
+    );
 }
 
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock) and the IOInterface MockObject are not ported"]
 fn test_gitlab_sub_directory_sub_group() {
-    todo!()
+    let fixtures = fixtures();
+    let url = "https://mycompany.com/gitlab/mygroup/mysubgroup/myproject";
+    let api_url = "https://mycompany.com/gitlab/api/v4/projects/mygroup%2Fmysubgroup%2Fmyproject";
+
+    let project_data = r#"{
+    "id": 17,
+    "default_branch": "mymaster",
+    "visibility": "private",
+    "http_url_to_repo": "https://mycompany.com/gitlab/mygroup/mysubgroup/my-pro.ject",
+    "ssh_url_to_repo": "git@mycompany.com:mygroup/mysubgroup/my-pro.ject.git",
+    "last_activity_at": "2014-12-01T09:17:51.000+01:00",
+    "name": "My Project",
+    "name_with_namespace": "My Group / My Project",
+    "path": "myproject",
+    "path_with_namespace": "mygroup/mysubgroup/my-pro.ject",
+    "web_url": "https://mycompany.com/gitlab/mygroup/mysubgroup/my-pro.ject"
+}"#;
+
+    let (http_downloader, _guard) = http_mock_with_body(api_url, project_data);
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert("url".to_string(), PhpMixed::String(url.to_string()));
+    let mut driver = GitLabDriver::new(
+        repo_config,
+        fixtures.io.clone(),
+        fixtures.config.clone(),
+        http_downloader,
+        fixtures.process.clone(),
+    );
+    driver.initialize().unwrap();
+
+    assert_eq!(
+        api_url,
+        driver.get_api_url(),
+        "API URL is derived from the repository URL"
+    );
 }
 
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock) and the IOInterface MockObject are not ported"]
 fn test_forwards_options() {
-    todo!()
+    let fixtures = fixtures();
+    let mut ssl: IndexMap<String, PhpMixed> = IndexMap::new();
+    ssl.insert("verify_peer".to_string(), PhpMixed::Bool(false));
+    let mut options: IndexMap<String, PhpMixed> = IndexMap::new();
+    options.insert("ssl".to_string(), PhpMixed::Array(ssl));
+
+    let project_data = r#"{
+    "id": 17,
+    "default_branch": "mymaster",
+    "visibility": "private",
+    "http_url_to_repo": "https://gitlab.mycompany.local/mygroup/myproject",
+    "ssh_url_to_repo": "git@gitlab.mycompany.local:mygroup/myproject.git",
+    "last_activity_at": "2014-12-01T09:17:51.000+01:00",
+    "name": "My Project",
+    "name_with_namespace": "My Group / My Project",
+    "path": "myproject",
+    "path_with_namespace": "mygroup/myproject",
+    "web_url": "https://gitlab.mycompany.local/mygroup/myproject"
+}"#;
+
+    let (http_downloader, _guard) = http_mock_with_body(
+        "https://gitlab.mycompany.local/api/v4/projects/mygroup%2Fmyproject",
+        project_data,
+    );
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert(
+        "url".to_string(),
+        PhpMixed::String("https://gitlab.mycompany.local/mygroup/myproject".to_string()),
+    );
+    repo_config.insert("options".to_string(), PhpMixed::Array(options));
+    let mut driver = GitLabDriver::new(
+        repo_config,
+        fixtures.io.clone(),
+        fixtures.config.clone(),
+        http_downloader,
+        fixtures.process.clone(),
+    );
+    driver.initialize().unwrap();
 }
 
 #[test]
-#[ignore = "HttpDownloaderMock (getHttpDownloaderMock) and the IOInterface MockObject are not ported"]
 fn test_protocol_override_repository_url_generation() {
-    todo!()
+    let fixtures = fixtures();
+    // @link http://doc.gitlab.com/ce/api/projects.html#get-single-project
+    let project_data = r#"{
+    "id": 17,
+    "default_branch": "mymaster",
+    "visibility": "private",
+    "http_url_to_repo": "https://gitlab.com/mygroup/myproject.git",
+    "ssh_url_to_repo": "git@gitlab.com:mygroup/myproject.git",
+    "last_activity_at": "2014-12-01T09:17:51.000+01:00",
+    "name": "My Project",
+    "name_with_namespace": "My Group / My Project",
+    "path": "myproject",
+    "path_with_namespace": "mygroup/myproject",
+    "web_url": "https://gitlab.com/mygroup/myproject"
+}"#;
+
+    let api_url = "https://gitlab.com/api/v4/projects/mygroup%2Fmyproject";
+    let url = "git@gitlab.com:mygroup/myproject";
+
+    let (http_downloader, _guard) = http_mock_with_body(api_url, project_data);
+
+    // clone $this->config and merge gitlab-protocol => http.
+    let mut config = make_config();
+    let mut top: IndexMap<String, PhpMixed> = IndexMap::new();
+    let mut config_section: IndexMap<String, PhpMixed> = IndexMap::new();
+    config_section.insert(
+        "gitlab-protocol".to_string(),
+        PhpMixed::String("http".to_string()),
+    );
+    top.insert("config".to_string(), PhpMixed::Array(config_section));
+    config.merge(&top, Config::SOURCE_UNKNOWN);
+    let config = Rc::new(RefCell::new(config));
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert("url".to_string(), PhpMixed::String(url.to_string()));
+    let mut driver = GitLabDriver::new(
+        repo_config,
+        fixtures.io.clone(),
+        config,
+        http_downloader,
+        fixtures.process.clone(),
+    );
+    driver.initialize().unwrap();
+    assert_eq!(
+        "https://gitlab.com/mygroup/myproject.git",
+        driver.get_repository_url(),
+        "Repository URL matches config request for http not git"
+    );
 }
diff --git a/crates/shirabe/tests/util/git_test.rs b/crates/shirabe/tests/util/git_test.rs
index 40ca9da..6d615c5 100644
--- a/crates/shirabe/tests/util/git_test.rs
+++ b/crates/shirabe/tests/util/git_test.rs
@@ -1,55 +1,489 @@
 //! ref: composer/tests/Composer/Test/Util/GitTest.php
 
-// These mock IO/Config/ProcessExecutor to drive Git::runCommand and mirror syncing; mocking
-// is not available here.
+use std::cell::RefCell;
+use std::rc::Rc;
 
-#[allow(dead_code)]
-fn set_up() {
-    // Builds mocked IO/Config/ProcessExecutor/Filesystem and a real Git; mocking is not available.
-    todo!()
+use indexmap::IndexMap;
+use shirabe::config::Config;
+use shirabe::io::IOInterface;
+use shirabe::util::filesystem::Filesystem;
+use shirabe::util::git::Git;
+use shirabe::util::process_executor::{MockExpectation, MockHandler, ProcessExecutor};
+use shirabe_php_shim::{PhpMixed, RuntimeException};
+
+use crate::config_stub::ConfigStubBuilder;
+use crate::io_stub::IOStub;
+use crate::process_executor_mock::{cmd, cmd_full, get_process_executor_mock};
+
+// PHP's `commandCallable` returns a bare string (`'git command'`); Rust's `run_command`
+// flattens each callable to a `Vec<String>` and hands it to `execute_args`, which always
+// builds a `PhpMixed::List`. So the single-token string command becomes a one-element list,
+// and the corresponding process expectation is a one-element list as well.
+fn build_git(io: IOStub, config: Config, process: Rc<RefCell<ProcessExecutor>>) -> Git {
+    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(io));
+    let config = Rc::new(RefCell::new(config));
+    let fs = Rc::new(RefCell::new(Filesystem::new(None)));
+    Git::new(io, config, process, fs)
 }
 
+fn mock_config(protocol: &str) -> Config {
+    ConfigStubBuilder::new()
+        .with(
+            "github-domains",
+            PhpMixed::List(vec![PhpMixed::String("github.com".to_string())]),
+        )
+        .with(
+            "github-protocols",
+            PhpMixed::List(vec![PhpMixed::String(protocol.to_string())]),
+        )
+        .build()
+}
+
+fn mock_sync_mirror_config() -> Config {
+    ConfigStubBuilder::new()
+        .with(
+            "github-domains",
+            PhpMixed::List(vec![PhpMixed::String("github.com".to_string())]),
+        )
+        .with(
+            "gitlab-domains",
+            PhpMixed::List(vec![PhpMixed::String("gitlab.com".to_string())]),
+        )
+        .with(
+            "github-protocols",
+            PhpMixed::List(vec![PhpMixed::String("https".to_string())]),
+        )
+        .build()
+}
+
+// publicGithubNoCredentialsProvider: ['ssh', 'git@github.com:acme/repo']
 #[test]
-#[ignore = "requires mocked Config (getMockBuilder Config) and getProcessExecutorMock with expects() command expectations; no mocking infrastructure exists"]
-fn test_run_command_public_git_hub_repository_not_initial_clone() {
-    todo!()
+fn test_run_command_public_git_hub_repository_not_initial_clone_ssh() {
+    let expected_url = "git@github.com:acme/repo";
+    let command_callable: Box<dyn Fn(&str) -> Vec<String>> = Box::new(move |url: &str| {
+        assert_eq!(expected_url, url);
+        vec!["git command".to_string()]
+    });
+
+    let config = mock_config("ssh");
+
+    let (process, _guard) =
+        get_process_executor_mock(vec![cmd(vec!["git command"])], true, MockHandler::default());
+
+    let mut git = build_git(IOStub::new(), config, process);
+
+    git.__run_command(
+        vec![command_callable],
+        "https://github.com/acme/repo",
+        None,
+        true,
+        None,
+    )
+    .unwrap();
 }
 
+// publicGithubNoCredentialsProvider: ['https', 'https://github.com/acme/repo']
 #[test]
-#[ignore = "requires mocked Config and getProcessExecutorMock with expects() command expectations; no mocking infrastructure exists"]
+fn test_run_command_public_git_hub_repository_not_initial_clone_https() {
+    let expected_url = "https://github.com/acme/repo";
+    let command_callable: Box<dyn Fn(&str) -> Vec<String>> = Box::new(move |url: &str| {
+        assert_eq!(expected_url, url);
+        vec!["git command".to_string()]
+    });
+
+    let config = mock_config("https");
+
+    let (process, _guard) =
+        get_process_executor_mock(vec![cmd(vec!["git command"])], true, MockHandler::default());
+
+    let mut git = build_git(IOStub::new(), config, process);
+
+    git.__run_command(
+        vec![command_callable],
+        "https://github.com/acme/repo",
+        None,
+        true,
+        None,
+    )
+    .unwrap();
+}
+
+#[test]
+#[ignore = "reaches Git::throw_exception -> Url::sanitize, whose preg pattern fails to parse in the regex crate (preg shim bug, unrelated to this test); production Url::sanitize must be fixed first"]
 fn test_run_command_private_git_hub_repository_not_initial_clone_not_interactive_without_authentication()
  {
-    todo!()
+    let command_callable: Box<dyn Fn(&str) -> Vec<String>> = Box::new(|url: &str| {
+        assert_eq!("https://github.com/acme/repo", url);
+        vec!["git command".to_string()]
+    });
+
+    let config = mock_config("https");
+
+    let (process, _guard) = get_process_executor_mock(
+        vec![
+            cmd_full(vec!["git command"], 1, "", ""),
+            cmd_full(vec!["git", "--version"], 0, "", ""),
+        ],
+        true,
+        MockHandler::default(),
+    );
+
+    let mut git = build_git(IOStub::new(), config, process);
+
+    let result = git.__run_command(
+        vec![command_callable],
+        "https://github.com/acme/repo",
+        None,
+        true,
+        None,
+    );
+
+    let err = result.expect_err("expected a RuntimeException");
+    assert!(err.downcast_ref::<RuntimeException>().is_some());
+}
+
+// privateGithubWithCredentialsProvider helper.
+fn run_command_private_github_with_authentication(
+    git_url: &str,
+    protocol: &str,
+    git_hub_token: &str,
+    expected_url: &str,
+    expected_failures_before_success: usize,
+) {
+    let expected_url_owned = expected_url.to_string();
+    let command_callable: Box<dyn Fn(&str) -> Vec<String>> = Box::new(move |url: &str| {
+        if url != expected_url_owned {
+            return vec!["git command failing".to_string()];
+        }
+        vec!["git command ok".to_string()]
+    });
+
+    let config = mock_config(protocol);
+
+    let mut expected_calls: Vec<MockExpectation> = Vec::new();
+    for _ in 0..expected_failures_before_success {
+        expected_calls.push(cmd_full(vec!["git command failing"], 1, "", ""));
+    }
+    expected_calls.push(cmd_full(vec!["git command ok"], 0, "", ""));
+
+    let (process, _guard) = get_process_executor_mock(expected_calls, true, MockHandler::default());
+
+    let mut auth: IndexMap<String, Option<String>> = IndexMap::new();
+    auth.insert("username".to_string(), Some("token".to_string()));
+    auth.insert("password".to_string(), Some(git_hub_token.to_string()));
+
+    let io = IOStub::new()
+        .with_is_interactive(false)
+        .with_has_authentication(true)
+        .with_get_authentication(auth);
+
+    let mut git = build_git(io, config, process);
+
+    git.__run_command(vec![command_callable], git_url, None, true, None)
+        .unwrap();
 }
 
 #[test]
-#[ignore = "requires getProcessExecutorMock and mocked IO (getMockBuilder IOInterface with hasAuthentication/getAuthentication/isInteractive expectations); no mocking infrastructure exists"]
-fn test_run_command_private_git_hub_repository_not_initial_clone_not_interactive_with_authentication()
+fn test_run_command_private_git_hub_repository_not_initial_clone_not_interactive_with_authentication_ssh()
  {
-    todo!()
+    run_command_private_github_with_authentication(
+        "git@github.com:acme/repo.git",
+        "ssh",
+        "MY_GITHUB_TOKEN",
+        "https://token:MY_GITHUB_TOKEN@github.com/acme/repo.git",
+        1,
+    );
 }
 
 #[test]
-#[ignore = "requires getProcessExecutorMock and mocked IO/Config (getMockBuilder with hasAuthentication/getAuthentication/isInteractive expectations); no mocking infrastructure exists"]
-fn test_run_command_private_bitbucket_repository_not_initial_clone_not_interactive_with_authentication()
+fn test_run_command_private_git_hub_repository_not_initial_clone_not_interactive_with_authentication_https()
  {
-    todo!()
+    run_command_private_github_with_authentication(
+        "https://github.com/acme/repo",
+        "https",
+        "MY_GITHUB_TOKEN",
+        "https://token:MY_GITHUB_TOKEN@github.com/acme/repo.git",
+        2,
+    );
+}
+
+// privateBitbucketWithCredentialsProvider helper.
+fn run_command_private_bitbucket_with_authentication(
+    git_url: &str,
+    bitbucket_token: Option<&str>,
+    expected_url: &str,
+    expected_failures_before_success: usize,
+    bitbucket_git_auth_calls: usize,
+) {
+    let expected_url_owned = expected_url.to_string();
+    let command_callable: Box<dyn Fn(&str) -> Vec<String>> = Box::new(move |url: &str| {
+        if url != expected_url_owned {
+            return vec!["git command failing".to_string()];
+        }
+        vec!["git command ok".to_string()]
+    });
+
+    let config = ConfigStubBuilder::new()
+        .with(
+            "gitlab-domains",
+            PhpMixed::List(vec![PhpMixed::String("gitlab.com".to_string())]),
+        )
+        .with(
+            "github-domains",
+            PhpMixed::List(vec![PhpMixed::String("github.com".to_string())]),
+        )
+        .build();
+
+    let mut expected_calls: Vec<MockExpectation> = Vec::new();
+    for _ in 0..expected_failures_before_success {
+        expected_calls.push(cmd_full(vec!["git command failing"], 1, "", ""));
+    }
+    if bitbucket_git_auth_calls > 0 {
+        for _ in 0..bitbucket_git_auth_calls {
+            expected_calls.push(cmd_full(
+                vec!["git", "config", "bitbucket.accesstoken"],
+                1,
+                "",
+                "",
+            ));
+        }
+    }
+    expected_calls.push(cmd_full(vec!["git command ok"], 0, "", ""));
+
+    let (process, _guard) = get_process_executor_mock(expected_calls, true, MockHandler::default());
+
+    let mut io = IOStub::new().with_is_interactive(false);
+    if let Some(token) = bitbucket_token {
+        let mut auth: IndexMap<String, Option<String>> = IndexMap::new();
+        auth.insert("username".to_string(), Some("token".to_string()));
+        auth.insert("password".to_string(), Some(token.to_string()));
+        io = io
+            .with_has_authentication(true)
+            .with_get_authentication(auth);
+    }
+
+    let mut git = build_git(io, config, process);
+
+    git.__run_command(vec![command_callable], git_url, None, true, None)
+        .unwrap();
+}
+
+#[test]
+#[ignore = "after the first failing git command, Bitbucket::new constructs a real HttpDownloader -> CurlDownloader::new -> curl_multi_init(), which is todo!() in the curl shim; needs the curl shim or an injected HttpDownloader mock on Git"]
+fn test_run_command_private_bitbucket_repository_not_initial_clone_not_interactive_with_authentication_ssh_token()
+ {
+    run_command_private_bitbucket_with_authentication(
+        "git@bitbucket.org:acme/repo.git",
+        Some("MY_BITBUCKET_TOKEN"),
+        "https://token:MY_BITBUCKET_TOKEN@bitbucket.org/acme/repo.git",
+        1,
+        0,
+    );
+}
+
+#[test]
+#[ignore = "after the first failing git command, Bitbucket::new constructs a real HttpDownloader -> CurlDownloader::new -> curl_multi_init(), which is todo!() in the curl shim; needs the curl shim or an injected HttpDownloader mock on Git"]
+fn test_run_command_private_bitbucket_repository_not_initial_clone_not_interactive_with_authentication_https_token()
+ {
+    run_command_private_bitbucket_with_authentication(
+        "https://bitbucket.org/acme/repo",
+        Some("MY_BITBUCKET_TOKEN"),
+        "https://token:MY_BITBUCKET_TOKEN@bitbucket.org/acme/repo.git",
+        1,
+        0,
+    );
+}
+
+#[test]
+#[ignore = "after the first failing git command, Bitbucket::new constructs a real HttpDownloader -> CurlDownloader::new -> curl_multi_init(), which is todo!() in the curl shim; needs the curl shim or an injected HttpDownloader mock on Git"]
+fn test_run_command_private_bitbucket_repository_not_initial_clone_not_interactive_with_authentication_https_git_token()
+ {
+    run_command_private_bitbucket_with_authentication(
+        "https://bitbucket.org/acme/repo.git",
+        Some("MY_BITBUCKET_TOKEN"),
+        "https://token:MY_BITBUCKET_TOKEN@bitbucket.org/acme/repo.git",
+        1,
+        0,
+    );
+}
+
+#[test]
+fn test_run_command_private_bitbucket_repository_not_initial_clone_not_interactive_with_authentication_ssh_no_token()
+ {
+    run_command_private_bitbucket_with_authentication(
+        "git@bitbucket.org:acme/repo.git",
+        None,
+        "git@bitbucket.org:acme/repo.git",
+        0,
+        0,
+    );
 }
 
 #[test]
-#[ignore = "requires getProcessExecutorMock, getHttpDownloaderMock and mocked IO/Config with askConfirmation/askAndHideAnswer/setAuthentication expectations; no mocking infrastructure exists"]
+#[ignore = "after the first failing git command, Bitbucket::new constructs a real HttpDownloader -> CurlDownloader::new -> curl_multi_init(), which is todo!() in the curl shim; needs the curl shim or an injected HttpDownloader mock on Git"]
+fn test_run_command_private_bitbucket_repository_not_initial_clone_not_interactive_with_authentication_https_no_token()
+ {
+    run_command_private_bitbucket_with_authentication(
+        "https://bitbucket.org/acme/repo",
+        None,
+        "git@bitbucket.org:acme/repo.git",
+        1,
+        1,
+    );
+}
+
+#[test]
+#[ignore = "after the first failing git command, Bitbucket::new constructs a real HttpDownloader -> CurlDownloader::new -> curl_multi_init(), which is todo!() in the curl shim; needs the curl shim or an injected HttpDownloader mock on Git"]
+fn test_run_command_private_bitbucket_repository_not_initial_clone_not_interactive_with_authentication_https_git_no_token()
+ {
+    run_command_private_bitbucket_with_authentication(
+        "https://bitbucket.org/acme/repo.git",
+        None,
+        "git@bitbucket.org:acme/repo.git",
+        1,
+        1,
+    );
+}
+
+#[test]
+#[ignore = "after the first failing git command, Bitbucket::new constructs a real HttpDownloader -> CurlDownloader::new -> curl_multi_init(), which is todo!() in the curl shim; needs the curl shim or an injected HttpDownloader mock on Git"]
+fn test_run_command_private_bitbucket_repository_not_initial_clone_not_interactive_with_authentication_atat_token()
+ {
+    run_command_private_bitbucket_with_authentication(
+        "https://bitbucket.org/acme/repo.git",
+        Some("ATAT_BITBUCKET_API_TOKEN"),
+        "https://x-bitbucket-api-token-auth:ATAT_BITBUCKET_API_TOKEN@bitbucket.org/acme/repo.git",
+        1,
+        0,
+    );
+}
+
+#[test]
+#[ignore = "interactive Bitbucket OAuth flow needs IOStub::askConfirmation/askAndHideAnswer/setAuthentication stateful callbacks and getHttpDownloaderMock; IOStub only supports fixed willReturn values, not the willReturnCallback-based stateful initial_config mutation this test relies on"]
 fn test_run_command_private_bitbucket_repository_not_initial_clone_interactive_with_oauth() {
     todo!()
 }
 
 #[test]
-#[ignore = "requires getProcessExecutorMock with expects() command expectations and mocked Config/Filesystem (getMockBuilder removeDirectory); no mocking infrastructure exists"]
 fn test_sync_mirror_sanitizes_url_after_initial_clone() {
-    todo!()
+    let non_existent_dir = format!(
+        "{}/composer-test-nonexistent-{}",
+        std::env::temp_dir().display(),
+        rand_hex()
+    );
+
+    let config = mock_sync_mirror_config();
+
+    let (process, _guard) = get_process_executor_mock(
+        vec![
+            cmd_full(
+                vec![
+                    "git",
+                    "clone",
+                    "--mirror",
+                    "--",
+                    "https://user:secret@example.com/repo.git",
+                    &non_existent_dir,
+                ],
+                0,
+                "",
+                "",
+            ),
+            cmd_full(vec!["git", "remote", "-v"], 0, "", ""),
+            cmd_full(
+                vec![
+                    "git",
+                    "remote",
+                    "set-url",
+                    "origin",
+                    "--",
+                    "https://example.com/repo.git",
+                ],
+                0,
+                "",
+                "",
+            ),
+        ],
+        true,
+        MockHandler::default(),
+    );
+
+    let mut git = build_git(IOStub::new(), config, process);
+
+    let result = git
+        .sync_mirror(
+            "https://user:secret@example.com/repo.git",
+            &non_existent_dir,
+        )
+        .unwrap();
+
+    assert!(result);
 }
 
 #[test]
-#[ignore = "requires getProcessExecutorMock with expects() command expectations and mocked Config; no mocking infrastructure exists"]
+#[ignore = "the failed-update branch reaches Git::throw_exception -> Url::sanitize, whose preg pattern fails to parse in the regex crate (preg shim bug, unrelated to this test); production Url::sanitize must be fixed first"]
 fn test_sync_mirror_sanitizes_url_even_after_failed_update() {
-    todo!()
+    let dir = std::env::temp_dir().display().to_string();
+
+    let config = mock_sync_mirror_config();
+
+    let (process, _guard) = get_process_executor_mock(
+        vec![
+            cmd_full(vec!["git", "rev-parse", "--git-dir"], 0, ".\n", ""),
+            cmd_full(vec!["git", "remote", "-v"], 0, "", ""),
+            cmd_full(
+                vec![
+                    "git",
+                    "remote",
+                    "set-url",
+                    "origin",
+                    "--",
+                    "https://user:secret@example.com/repo.git",
+                ],
+                0,
+                "",
+                "",
+            ),
+            cmd_full(
+                vec!["git", "remote", "update", "--prune", "origin"],
+                1,
+                "",
+                "",
+            ),
+            cmd_full(vec!["git", "--version"], 0, "", ""),
+            cmd_full(vec!["git", "remote", "-v"], 0, "", ""),
+            cmd_full(
+                vec![
+                    "git",
+                    "remote",
+                    "set-url",
+                    "origin",
+                    "--",
+                    "https://example.com/repo.git",
+                ],
+                0,
+                "",
+                "",
+            ),
+        ],
+        true,
+        MockHandler::default(),
+    );
+
+    let mut git = build_git(IOStub::new(), config, process);
+
+    let result = git
+        .sync_mirror("https://user:secret@example.com/repo.git", &dir)
+        .unwrap();
+
+    assert!(!result);
+}
+
+fn rand_hex() -> String {
+    use std::time::{SystemTime, UNIX_EPOCH};
+    let nanos = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    format!("{:016x}", nanos as u64)
 }
diff --git a/crates/shirabe/tests/util/url_test.rs b/crates/shirabe/tests/util/url_test.rs
index 4adb4f2..3691d26 100644
--- a/crates/shirabe/tests/util/url_test.rs
+++ b/crates/shirabe/tests/util/url_test.rs
@@ -143,7 +143,6 @@ fn dist_refs_provider() -> Vec<(
 }
 
 #[test]
-#[ignore]
 fn test_sanitize() {
     for (expected, url) in sanitize_provider() {
         assert_eq!(expected, Url::sanitize(url.to_string()));