test(dependency-resolver): port PoolTest with shared TestCase helpers

Add tests/common/test_case.rs (get_package, get_version_constraint) ported from
the PHP TestCase, included into the dependency_resolver binary via #[path].
PoolTest's testPool/testPackageById/testWhatProvidesWhenPackageCannotBeFound
pass; testWhatProvidesPackageWithConstraint is #[ignore] (constraint matching
reaches a todo!() in the php-shim).

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

3 files changed, 95 insertions, 0 deletions

diff --git a/crates/shirabe/tests/common/test_case.rs b/crates/shirabe/tests/common/test_case.rs
new file mode 100644
index 0000000..4a54195
--- /dev/null
+++ b/crates/shirabe/tests/common/test_case.rs
@@ -0,0 +1,25 @@
+//! Shared test helpers ported from composer/tests/Composer/Test/TestCase.php.
+//!
+//! Included into each integration-test binary that needs them via
+//! `#[path = "../common/test_case.rs"] mod test_case;`.
+#![allow(dead_code)]
+
+use shirabe::package::handle::{CompletePackageHandle, PackageInterfaceHandle};
+use shirabe_semver::constraint::{AnyConstraint, SimpleConstraint};
+use shirabe_semver::version_parser::VersionParser;
+
+/// ref: TestCase::getPackage (default class CompletePackage)
+pub fn get_package(name: &str, version: &str) -> PackageInterfaceHandle {
+    let norm_version = VersionParser.normalize(version, None).unwrap();
+    CompletePackageHandle::new(name.to_string(), norm_version, version.to_string()).into()
+}
+
+/// ref: TestCase::getVersionConstraint
+pub fn get_version_constraint(operator: &str, version: &str) -> AnyConstraint {
+    let normalized = VersionParser.normalize(version, None).unwrap();
+    AnyConstraint::Simple(SimpleConstraint::new(
+        operator.to_string(),
+        normalized,
+        Some(format!("{} {}", operator, version)),
+    ))
+}
diff --git a/crates/shirabe/tests/dependency_resolver/main.rs b/crates/shirabe/tests/dependency_resolver/main.rs
index f6624a1..e9b2259 100644
--- a/crates/shirabe/tests/dependency_resolver/main.rs
+++ b/crates/shirabe/tests/dependency_resolver/main.rs
@@ -1,2 +1,6 @@
+#[path = "../common/test_case.rs"]
+mod test_case;
+
+mod pool_test;
 mod request_test;
 mod rule_set_iterator_test;
diff --git a/crates/shirabe/tests/dependency_resolver/pool_test.rs b/crates/shirabe/tests/dependency_resolver/pool_test.rs
index 3efd85b..ef2cc8d 100644
--- a/crates/shirabe/tests/dependency_resolver/pool_test.rs
+++ b/crates/shirabe/tests/dependency_resolver/pool_test.rs
@@ -1 +1,67 @@
 //! ref: composer/tests/Composer/Test/DependencyResolver/PoolTest.php
+
+use indexmap::IndexMap;
+use shirabe::dependency_resolver::pool::Pool;
+use shirabe::package::handle::PackageInterfaceHandle;
+
+use crate::test_case::{get_package, get_version_constraint};
+
+// ref: PoolTest::createPool
+fn create_pool(packages: Vec<PackageInterfaceHandle>) -> Pool {
+    Pool::new(
+        packages,
+        vec![],
+        IndexMap::new(),
+        IndexMap::new(),
+        IndexMap::new(),
+        IndexMap::new(),
+    )
+}
+
+fn same_packages(a: &[PackageInterfaceHandle], b: &[PackageInterfaceHandle]) -> bool {
+    a.len() == b.len() && a.iter().zip(b.iter()).all(|(x, y)| x.ptr_eq(y))
+}
+
+#[test]
+fn test_pool() {
+    let package = get_package("foo", "1");
+
+    let mut pool = create_pool(vec![package.clone()]);
+
+    assert!(same_packages(&[package.clone()], &pool.what_provides("foo", None)));
+    assert!(same_packages(&[package], &pool.what_provides("foo", None)));
+}
+
+#[test]
+#[ignore = "what_provides with a constraint reaches a todo!() in the php-shim"]
+fn test_what_provides_package_with_constraint() {
+    let first_package = get_package("foo", "1");
+    let second_package = get_package("foo", "2");
+
+    let mut pool = create_pool(vec![first_package.clone(), second_package.clone()]);
+
+    assert!(same_packages(
+        &[first_package, second_package.clone()],
+        &pool.what_provides("foo", None)
+    ));
+    assert!(same_packages(
+        &[second_package],
+        &pool.what_provides("foo", Some(&get_version_constraint("==", "2")))
+    ));
+}
+
+#[test]
+fn test_package_by_id() {
+    let package = get_package("foo", "1");
+
+    let pool = create_pool(vec![package.clone()]);
+
+    assert!(package.ptr_eq(&pool.package_by_id(1)));
+}
+
+#[test]
+fn test_what_provides_when_package_cannot_be_found() {
+    let mut pool = create_pool(vec![]);
+
+    assert!(pool.what_provides("foo", None).is_empty());
+}