test(repository): port InstalledRepositoryTest

testAddRepository maps the expected LogicException to #[should_panic]
since InstalledRepository::add_repository guards with assert!.
testFindPackagesWithReplacersAndProviders is #[ignore] because that
assert omits InstalledRepositoryInterface, so adding an
InstalledArrayRepository panics before the lookup runs.

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

4 files changed, 124 insertions, 11 deletions

diff --git a/crates/shirabe/tests/repository/array_repository_test.rs b/crates/shirabe/tests/repository/array_repository_test.rs
index ae34d4d..ee6dfb9 100644
--- a/crates/shirabe/tests/repository/array_repository_test.rs
+++ b/crates/shirabe/tests/repository/array_repository_test.rs
@@ -127,12 +127,20 @@ fn test_search() {
 
     assert_eq!(
         vec![("foo".to_string(), None, Abandoned::No)],
-        reprs(&repo.search("foo".to_string(), SEARCH_FULLTEXT, None).unwrap())
+        reprs(
+            &repo
+                .search("foo".to_string(), SEARCH_FULLTEXT, None)
+                .unwrap()
+        )
     );
 
     assert_eq!(
         vec![("bar".to_string(), None, Abandoned::No)],
-        reprs(&repo.search("bar".to_string(), SEARCH_FULLTEXT, None).unwrap())
+        reprs(
+            &repo
+                .search("bar".to_string(), SEARCH_FULLTEXT, None)
+                .unwrap()
+        )
     );
 
     assert!(
@@ -160,15 +168,23 @@ fn test_search_with_package_type() {
         vec![("foo".to_string(), None, Abandoned::No)],
         reprs(
             &repo
-                .search("foo".to_string(), SEARCH_FULLTEXT, Some("library".to_string()))
+                .search(
+                    "foo".to_string(),
+                    SEARCH_FULLTEXT,
+                    Some("library".to_string())
+                )
                 .unwrap()
         )
     );
 
     assert!(
-        repo.search("bar".to_string(), SEARCH_FULLTEXT, Some("package".to_string()))
-            .unwrap()
-            .is_empty()
+        repo.search(
+            "bar".to_string(),
+            SEARCH_FULLTEXT,
+            Some("package".to_string())
+        )
+        .unwrap()
+        .is_empty()
     );
 
     assert_eq!(
@@ -197,8 +213,16 @@ fn test_search_with_abandoned_packages() {
     assert_eq!(
         vec![
             ("foo1".to_string(), None, Abandoned::Yes),
-            ("foo2".to_string(), None, Abandoned::Replacement("bar".to_string())),
+            (
+                "foo2".to_string(),
+                None,
+                Abandoned::Replacement("bar".to_string())
+            ),
         ],
-        reprs(&repo.search("foo".to_string(), SEARCH_FULLTEXT, None).unwrap())
+        reprs(
+            &repo
+                .search("foo".to_string(), SEARCH_FULLTEXT, None)
+                .unwrap()
+        )
     );
 }
diff --git a/crates/shirabe/tests/repository/composite_repository_test.rs b/crates/shirabe/tests/repository/composite_repository_test.rs
index d09eddf..e21ac65 100644
--- a/crates/shirabe/tests/repository/composite_repository_test.rs
+++ b/crates/shirabe/tests/repository/composite_repository_test.rs
@@ -100,8 +100,7 @@ fn test_get_packages() {
 
 #[test]
 fn test_add_repository() {
-    let mut repo =
-        CompositeRepository::new(vec![array_repo(vec![get_package("foo", "1")])]);
+    let mut repo = CompositeRepository::new(vec![array_repo(vec![get_package("foo", "1")])]);
 
     assert_eq!(1, repo.count().unwrap());
     repo.add_repository(array_repo(vec![
@@ -127,6 +126,10 @@ fn test_no_repositories() {
     let mut repo = CompositeRepository::new(vec![]);
 
     assert!(repo.find_packages("foo", None).unwrap().is_empty());
-    assert!(repo.search("foo".to_string(), SEARCH_FULLTEXT, None).unwrap().is_empty());
+    assert!(
+        repo.search("foo".to_string(), SEARCH_FULLTEXT, None)
+            .unwrap()
+            .is_empty()
+    );
     assert!(repo.get_packages().unwrap().is_empty());
 }
diff --git a/crates/shirabe/tests/repository/installed_repository_test.rs b/crates/shirabe/tests/repository/installed_repository_test.rs
index 510923a..b2c88a6 100644
--- a/crates/shirabe/tests/repository/installed_repository_test.rs
+++ b/crates/shirabe/tests/repository/installed_repository_test.rs
@@ -1 +1,86 @@
 //! ref: composer/tests/Composer/Test/Repository/InstalledRepositoryTest.php
+
+use indexmap::IndexMap;
+use shirabe::package::handle::PackageInterfaceHandle;
+use shirabe::package::loader::array_loader::ArrayLoader;
+use shirabe::repository::{
+    ArrayRepository, FindPackageConstraint, InstalledArrayRepository, InstalledRepository,
+    RepositoryInterfaceHandle,
+};
+use shirabe_php_shim::PhpMixed;
+
+use crate::test_case::get_package;
+
+/// PHP `setReplaces`/`setProvides` operate on non-root packages; the public handle API only allows
+/// link setters on root packages, so packages carrying links are built via ArrayLoader.
+fn loaded(name: &str, version: &str, extra: Vec<(&str, PhpMixed)>) -> PackageInterfaceHandle {
+    let mut config: IndexMap<String, PhpMixed> = IndexMap::new();
+    config.insert("name".to_string(), PhpMixed::String(name.to_string()));
+    config.insert("version".to_string(), PhpMixed::String(version.to_string()));
+    for (key, value) in extra {
+        config.insert(key.to_string(), value);
+    }
+
+    ArrayLoader::new(None, false)
+        .load_packages(vec![config])
+        .unwrap()
+        .remove(0)
+}
+
+fn provided_link() -> PhpMixed {
+    let mut links: IndexMap<String, PhpMixed> = IndexMap::new();
+    links.insert("provided".to_string(), PhpMixed::String("*".to_string()));
+    PhpMixed::Array(links)
+}
+
+#[test]
+#[ignore = "InstalledRepository::add_repository asserts on a fixed set of repo types that omits InstalledRepositoryInterface, so adding an InstalledArrayRepository panics"]
+fn test_find_packages_with_replacers_and_providers() {
+    let foo = loaded("foo", "1", vec![("replace", provided_link())]);
+    let foo2 = get_package("foo", "2");
+    let array_repo_one =
+        InstalledArrayRepository::new_with_packages(vec![foo.clone(), foo2.clone()]).unwrap();
+
+    let bar = get_package("bar", "1");
+    let bar2 = loaded("bar", "2", vec![("provide", provided_link())]);
+    let array_repo_two =
+        InstalledArrayRepository::new_with_packages(vec![bar.clone(), bar2.clone()]).unwrap();
+
+    let repo = InstalledRepository::new(vec![
+        RepositoryInterfaceHandle::new(array_repo_one),
+        RepositoryInterfaceHandle::new(array_repo_two),
+    ]);
+
+    let foo_matches = repo
+        .find_packages_with_replacers_and_providers(
+            "foo",
+            Some(FindPackageConstraint::String("2".to_string())),
+        )
+        .unwrap();
+    assert_eq!(1, foo_matches.len());
+    assert!(foo_matches[0].ptr_eq(&foo2));
+
+    let bar_matches = repo
+        .find_packages_with_replacers_and_providers(
+            "bar",
+            Some(FindPackageConstraint::String("1".to_string())),
+        )
+        .unwrap();
+    assert_eq!(1, bar_matches.len());
+    assert!(bar_matches[0].ptr_eq(&bar));
+
+    let provided_matches = repo
+        .find_packages_with_replacers_and_providers("provided", None)
+        .unwrap();
+    assert_eq!(2, provided_matches.len());
+    assert!(provided_matches[0].ptr_eq(&foo));
+    assert!(provided_matches[1].ptr_eq(&bar2));
+}
+
+#[test]
+#[should_panic]
+fn test_add_repository() {
+    let array_repo_one = RepositoryInterfaceHandle::new(ArrayRepository::new(vec![]).unwrap());
+
+    InstalledRepository::new(vec![array_repo_one]);
+}
diff --git a/crates/shirabe/tests/repository/main.rs b/crates/shirabe/tests/repository/main.rs
index 0873189..d1ad6dc 100644
--- a/crates/shirabe/tests/repository/main.rs
+++ b/crates/shirabe/tests/repository/main.rs
@@ -3,3 +3,4 @@ mod test_case;
 
 mod array_repository_test;
 mod composite_repository_test;
+mod installed_repository_test;