1 files changed, 195 insertions, 0 deletions
diff --git a/crates/shirabe/benches/composer_repository.rs b/crates/shirabe/benches/composer_repository.rs
new file mode 100644
index 00000000..7c8f05da
--- /dev/null
+++ b/crates/shirabe/benches/composer_repository.rs
@@ -0,0 +1,195 @@
+//! Benchmarks for `ComposerRepository::load_packages` against a v2 (metadata-url) repository.
+//!
+//! The responses are real packagist p2 files served through the HTTP downloader mock, so one
+//! iteration covers what `composer update` does per package: decode the response, expand the
+//! minified metadata, filter by constraint and stability, and build the accepted packages. The
+//! constraint decides how many versions survive that filter, which is what the lazy expansion is
+//! meant to exploit.
+
+use criterion::BatchSize;
+use criterion::BenchmarkId;
+use criterion::Criterion;
+use criterion::criterion_group;
+use criterion::criterion_main;
+use indexmap::IndexMap;
+use shirabe::config::Config;
+use shirabe::io::IOInterface;
+use shirabe::io::null_io::NullIO;
+use shirabe::json::json_file::JsonFile;
+use shirabe::package::base_package::STABILITY_STABLE;
+use shirabe::package::version::VersionParser;
+use shirabe::repository::composer_repository::ComposerRepository;
+use shirabe::util::http_downloader::{
+    HttpDownloader, HttpDownloaderMockExpectation, HttpDownloaderMockHandler,
+};
+use shirabe_php_shim::PhpMixed;
+use shirabe_semver::constraint::AnyConstraint;
+use tempfile::TempDir;
+
+#[path = "packagist_fixture.rs"]
+mod packagist_fixture;
+
+const PACKAGES: &[&str] = &["symfony/console", "laravel/framework"];
+
+/// Constraints spanning the acceptance rates a repository sees, from one no version satisfies to
+/// one that takes every version there is. Each case is labelled with how many packages survived,
+/// since that rate is what decides whether deferring the copy pays off.
+const CONSTRAINTS: &[(&str, &str)] = &[
+    ("none", "^99.0"),
+    ("major7", "^7.0"),
+    ("major6-up", ">=6.0"),
+    ("major4-up", ">=4.0"),
+    ("major2-up", ">=2.0"),
+    ("any", "*"),
+];
+
+const REPOSITORY_URL: &str = "https://example.org/packages.json";
+const METADATA_URL: &str = "https://example.org/p2/%package%.json";
+
+/// A root file with nothing but a metadata-url, which is what puts the repository on the lazy
+/// provider path `load_async_packages` serves.
+fn root_file() -> String {
+    let mut root: IndexMap<String, PhpMixed> = IndexMap::new();
+    root.insert("packages".to_string(), PhpMixed::Array(IndexMap::new()));
+    root.insert(
+        "metadata-url".to_string(),
+        PhpMixed::String(METADATA_URL.to_string()),
+    );
+    JsonFile::encode(&PhpMixed::Array(root)).expect("failed to encode the root file")
+}
+
+/// A config whose cache is read-only, so the measurement stays off the filesystem.
+fn config(home: &TempDir) -> Config {
+    let mut config = Config::new(true, None);
+    let mut settings: IndexMap<String, PhpMixed> = IndexMap::new();
+    settings.insert(
+        "home".to_string(),
+        PhpMixed::String(home.path().display().to_string()),
+    );
+    settings.insert("cache-read-only".to_string(), PhpMixed::Bool(true));
+    let mut top: IndexMap<String, PhpMixed> = IndexMap::new();
+    top.insert("config".to_string(), PhpMixed::Array(settings));
+    config.merge(&top, Config::SOURCE_UNKNOWN);
+    config
+}
+
+/// A repository answering exactly two requests, in the order `load_packages` makes them: the root
+/// file, then the package's metadata.
+fn repository(package: &str, root: &str, metadata: &str, config: &Config) -> ComposerRepository {
+    let expectations = vec![
+        HttpDownloaderMockExpectation {
+            url: REPOSITORY_URL.to_string(),
+            options: None,
+            status: 200,
+            body: root.to_string(),
+            headers: vec![String::new()],
+        },
+        HttpDownloaderMockExpectation {
+            url: METADATA_URL.replace("%package%", package),
+            options: None,
+            status: 200,
+            body: metadata.to_string(),
+            headers: vec![String::new()],
+        },
+    ];
+
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+    let http_downloader = std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::__new_mock(
+        io.clone(),
+        std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None))),
+    )));
+    http_downloader.borrow_mut().__expects(
+        expectations,
+        true,
+        HttpDownloaderMockHandler::default(),
+    );
+
+    let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+    repo_config.insert(
+        "url".to_string(),
+        PhpMixed::String(REPOSITORY_URL.to_string()),
+    );
+
+    ComposerRepository::new(repo_config, io, config, http_downloader, None)
+        .expect("failed to build the repository")
+}
+
+fn load(
+    repository: &mut ComposerRepository,
+    package: &str,
+    constraint: &AnyConstraint,
+    acceptable_stabilities: &IndexMap<String, i64>,
+) -> usize {
+    let mut package_name_map: IndexMap<String, Option<AnyConstraint>> = IndexMap::new();
+    package_name_map.insert(package.to_string(), Some(constraint.clone()));
+    repository
+        .load_packages(
+            package_name_map,
+            acceptable_stabilities.clone(),
+            IndexMap::new(),
+            IndexMap::new(),
+        )
+        .expect("load_packages failed")
+        .packages
+        .len()
+}
+
+/// How many versions the p2 file carries, for the `<loaded>of<total>` labels.
+fn version_count(package: &str, metadata: &str) -> usize {
+    JsonFile::parse_json(Some(metadata), None)
+        .expect("invalid fixture JSON")
+        .as_array()
+        .and_then(|response| response.get("packages"))
+        .and_then(|v| v.as_array())
+        .and_then(|packages| packages.get(package))
+        .and_then(|v| v.as_list())
+        .expect("the fixture has no version list for the package")
+        .len()
+}
+
+fn bench_load_packages(c: &mut Criterion) {
+    let home = TempDir::new().expect("failed to create the config home");
+    let config = config(&home);
+    let root = root_file();
+    let version_parser = VersionParser::new();
+
+    let mut acceptable_stabilities: IndexMap<String, i64> = IndexMap::new();
+    acceptable_stabilities.insert("stable".to_string(), STABILITY_STABLE);
+
+    for package in PACKAGES {
+        let metadata = packagist_fixture::fetch(package);
+        let total = version_count(package, &metadata);
+        let mut group = c.benchmark_group(format!("load_packages/{package}"));
+
+        for (label, constraint) in CONSTRAINTS {
+            let constraint: AnyConstraint = version_parser
+                .parse_constraints(constraint)
+                .expect("failed to parse the constraint");
+
+            let mut probe = repository(package, &root, &metadata, &config);
+            let loaded = load(&mut probe, package, &constraint, &acceptable_stabilities);
+            let parameter = format!("{label}/{loaded}of{total}");
+
+            group.bench_function(BenchmarkId::from_parameter(parameter), |b| {
+                b.iter_batched(
+                    || repository(package, &root, &metadata, &config),
+                    |mut repository| {
+                        load(
+                            &mut repository,
+                            package,
+                            &constraint,
+                            &acceptable_stabilities,
+                        )
+                    },
+                    BatchSize::PerIteration,
+                );
+            });
+        }
+
+        group.finish();
+    }
+}
+
+criterion_group!(benches, bench_load_packages);
+criterion_main!(benches);