test(plugin): compare a plugin-provided installer against upstream Composer

The fixture plugin registers an InstallerInterface implementation of its own
and installs a package of a custom type with it, recording every contract
call it receives. A fresh install produces a byte-identical project tree on
both implementations, trace included.

A second test pins the divergence a re-run and a `remove` expose: the two
implementations consult getInstaller at different points, so the trace
order — and its length once `remove` re-creates the Composer instance —
differs. It is written in full and marked ignored rather than trimmed.

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

7 files changed, 361 insertions, 0 deletions

diff --git a/crates/shirabe/tests/plugin/e2e_installer_test.rs b/crates/shirabe/tests/plugin/e2e_installer_test.rs
new file mode 100644
index 00000000..dadb5b59
--- /dev/null
+++ b/crates/shirabe/tests/plugin/e2e_installer_test.rs
@@ -0,0 +1,164 @@
+//! Plugin-provided installer E2E compatibility check: upstream Composer and Shirabe each install
+//! a fixture plugin that registers its own `InstallerInterface` through
+//! `InstallationManager::addInstaller`, and the resulting project trees — including the trace the
+//! installer writes on every contract call — are compared.
+//!
+//! The whole fixture is Shirabe-authored (`fixtures/e2e-installer/`), so nothing has to be
+//! fetched; the test skips only while the PHP runtime or the Composer checkout is missing.
+
+use crate::e2e_extension_installer_test::{copy_dir, upstream_composer_bin};
+use crate::plugin_installer_test::{lock_php_worker, php_runtime_available};
+use std::path::{Path, PathBuf};
+use tempfile::TempDir;
+
+fn fixture_dir() -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/plugin/fixtures/e2e-installer")
+}
+
+struct CommandRun {
+    exit_code: i32,
+    stdout: String,
+}
+
+fn run_command(work: &Path, program: &str, prefix_args: &[&str], args: &[&str]) -> CommandRun {
+    let output = std::process::Command::new(program)
+        .args(prefix_args)
+        .args(args)
+        .current_dir(work.join("project"))
+        .env("COMPOSER_HOME", work.join("home"))
+        .env("COMPOSER_CACHE_DIR", work.join("cache"))
+        .env("COMPOSER_NO_INTERACTION", "1")
+        .env("COLUMNS", "120")
+        .env("LINES", "30")
+        .output()
+        .unwrap();
+    CommandRun {
+        exit_code: output.status.code().unwrap_or(-1),
+        stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
+    }
+}
+
+/// Every file under `dir` as (relative path, contents), so two project trees compare as a whole.
+fn tree(dir: &Path) -> Vec<(String, String)> {
+    let mut files = Vec::new();
+    collect(dir, dir, &mut files);
+    files.sort();
+    files
+}
+
+fn collect(root: &Path, dir: &Path, files: &mut Vec<(String, String)>) {
+    for entry in std::fs::read_dir(dir).unwrap() {
+        let entry = entry.unwrap();
+        let path = entry.path();
+        if entry.file_type().unwrap().is_dir() {
+            collect(root, &path, files);
+        } else {
+            let relative = path
+                .strip_prefix(root)
+                .unwrap()
+                .to_str()
+                .unwrap()
+                .to_string();
+            files.push((relative, std::fs::read_to_string(&path).unwrap_or_default()));
+        }
+    }
+}
+
+fn installer_lines(stdout: &str) -> Vec<&str> {
+    stdout
+        .lines()
+        .filter(|line| line.starts_with("asset-installer:"))
+        .collect()
+}
+
+/// Runs `install` in a fresh copy of the fixture and returns the run plus the resulting tree.
+fn install(program: &str, prefix: &[&str]) -> (CommandRun, Vec<(String, String)>, TempDir) {
+    let work = TempDir::new().unwrap();
+    copy_dir(&fixture_dir(), work.path());
+    let run = run_command(work.path(), program, prefix, &["install"]);
+    let tree = tree(&work.path().join("project"));
+    (run, tree, work)
+}
+
+#[test]
+fn test_plugin_provided_installer_matches_upstream_composer() {
+    if !php_runtime_available() {
+        return;
+    }
+    let Some(composer_bin) = upstream_composer_bin() else {
+        return;
+    };
+    let _worker = lock_php_worker();
+    let composer_bin = composer_bin.to_str().unwrap().to_string();
+
+    let (upstream, upstream_tree, _upstream_work) = install("php", &[composer_bin.as_str()]);
+    let (shirabe, shirabe_tree, _shirabe_work) = install(env!("CARGO_BIN_EXE_shirabe"), &[]);
+
+    assert_eq!(0, upstream.exit_code, "upstream install must succeed");
+    assert_eq!(upstream.exit_code, shirabe.exit_code);
+    assert_eq!(
+        installer_lines(&upstream.stdout),
+        installer_lines(&shirabe.stdout)
+    );
+    assert_eq!(
+        vec!["asset-installer: installed shirabe-test/asset-a"],
+        installer_lines(&shirabe.stdout)
+    );
+
+    // The whole project tree, which covers composer.lock, installed.json/installed.php, the
+    // manifest the plugin-provided installer wrote under assets/, and installer-trace.txt — the
+    // ordered log of every InstallerInterface call the installer received.
+    assert_eq!(
+        upstream_tree.iter().map(|(p, _)| p).collect::<Vec<_>>(),
+        shirabe_tree.iter().map(|(p, _)| p).collect::<Vec<_>>()
+    );
+    assert_eq!(upstream_tree, shirabe_tree);
+}
+
+// Re-running `install` over an already installed project, and removing the asset package
+// afterwards, produce the same files on both sides but consult the installers in a different
+// order: upstream resolves `getInstaller('composer-plugin')` before the asset operations run,
+// Shirabe only when the autoload dump asks for the install paths. The counts differ too once a
+// `remove` re-creates the Composer instance.
+#[ignore = "InstallationManager consults getInstaller at different points than upstream; installer-trace.txt diverges in order and count (TODO(plugin))"]
+#[test]
+fn test_plugin_provided_installer_call_order_matches_upstream_composer() {
+    if !php_runtime_available() {
+        return;
+    }
+    let Some(composer_bin) = upstream_composer_bin() else {
+        return;
+    };
+    let _worker = lock_php_worker();
+    let composer_bin = composer_bin.to_str().unwrap().to_string();
+    let implementations: [(&str, Vec<&str>); 2] = [
+        ("php", vec![composer_bin.as_str()]),
+        (env!("CARGO_BIN_EXE_shirabe"), vec![]),
+    ];
+
+    let mut results = Vec::new();
+    for (program, prefix) in &implementations {
+        let work = TempDir::new().unwrap();
+        copy_dir(&fixture_dir(), work.path());
+        let first = run_command(work.path(), program, prefix, &["install"]);
+        let second = run_command(work.path(), program, prefix, &["install"]);
+        let remove = run_command(
+            work.path(),
+            program,
+            prefix,
+            &["remove", "shirabe-test/asset-a"],
+        );
+        let tree = tree(&work.path().join("project"));
+        results.push((first, second, remove, tree));
+    }
+
+    let [upstream, shirabe] = <[_; 2]>::try_from(results).ok().unwrap();
+    let (u_first, u_second, u_remove, u_tree) = upstream;
+    let (s_first, s_second, s_remove, s_tree) = shirabe;
+
+    assert_eq!(0, u_first.exit_code);
+    assert_eq!(u_first.exit_code, s_first.exit_code);
+    assert_eq!(u_second.exit_code, s_second.exit_code);
+    assert_eq!(u_remove.exit_code, s_remove.exit_code);
+    assert_eq!(u_tree, s_tree);
+}
diff --git a/crates/shirabe/tests/plugin/fixtures/e2e-installer/packages/asset-a/composer.json b/crates/shirabe/tests/plugin/fixtures/e2e-installer/packages/asset-a/composer.json
new file mode 100644
index 00000000..4fe63968
--- /dev/null
+++ b/crates/shirabe/tests/plugin/fixtures/e2e-installer/packages/asset-a/composer.json
@@ -0,0 +1,6 @@
+{
+    "name": "shirabe-test/asset-a",
+    "version": "1.0.0",
+    "type": "shirabe-asset",
+    "description": "Fixture package installed by the plugin-provided installer."
+}
diff --git a/crates/shirabe/tests/plugin/fixtures/e2e-installer/plugin/composer.json b/crates/shirabe/tests/plugin/fixtures/e2e-installer/plugin/composer.json
new file mode 100644
index 00000000..8275f2c0
--- /dev/null
+++ b/crates/shirabe/tests/plugin/fixtures/e2e-installer/plugin/composer.json
@@ -0,0 +1,17 @@
+{
+    "name": "shirabe-test/asset-installer",
+    "version": "1.0.0",
+    "type": "composer-plugin",
+    "description": "Fixture plugin registering a custom installer through InstallationManager::addInstaller.",
+    "autoload": {
+        "psr-4": {
+            "ShirabeTest\\AssetInstaller\\": "src/"
+        }
+    },
+    "require": {
+        "composer-plugin-api": "^2.0"
+    },
+    "extra": {
+        "class": "ShirabeTest\\AssetInstaller\\Plugin"
+    }
+}
diff --git a/crates/shirabe/tests/plugin/fixtures/e2e-installer/plugin/src/AssetInstaller.php b/crates/shirabe/tests/plugin/fixtures/e2e-installer/plugin/src/AssetInstaller.php
new file mode 100644
index 00000000..a80eb678
--- /dev/null
+++ b/crates/shirabe/tests/plugin/fixtures/e2e-installer/plugin/src/AssetInstaller.php
@@ -0,0 +1,113 @@
+<?php
+
+namespace ShirabeTest\AssetInstaller;
+
+use Composer\Composer;
+use Composer\Installer\InstallerInterface;
+use Composer\IO\IOInterface;
+use Composer\Package\PackageInterface;
+use Composer\Repository\InstalledRepositoryInterface;
+use React\Promise\PromiseInterface;
+
+/**
+ * Installs `shirabe-asset` packages by writing a manifest of what the installer observed,
+ * without going through the download manager. Every call also appends a trace line, so the
+ * order and arguments of the installer contract are comparable between implementations.
+ */
+class AssetInstaller implements InstallerInterface
+{
+    /** @var IOInterface */
+    private $io;
+
+    /** @var Composer */
+    private $composer;
+
+    public function __construct(IOInterface $io, Composer $composer)
+    {
+        $this->io = $io;
+        $this->composer = $composer;
+    }
+
+    public function supports(string $packageType): bool
+    {
+        $this->trace('supports ' . $packageType);
+
+        return $packageType === 'shirabe-asset';
+    }
+
+    public function isInstalled(InstalledRepositoryInterface $repo, PackageInterface $package): bool
+    {
+        $this->trace('isInstalled ' . $package->getPrettyName());
+
+        return is_file($this->getInstallPath($package) . '/asset.txt');
+    }
+
+    public function download(PackageInterface $package, ?PackageInterface $prevPackage = null): ?PromiseInterface
+    {
+        $this->trace('download ' . $package->getPrettyName() . ' prev=' . $this->name($prevPackage));
+
+        return null;
+    }
+
+    public function prepare(string $type, PackageInterface $package, ?PackageInterface $prevPackage = null): ?PromiseInterface
+    {
+        $this->trace('prepare ' . $type . ' ' . $package->getPrettyName() . ' prev=' . $this->name($prevPackage));
+
+        return null;
+    }
+
+    public function install(InstalledRepositoryInterface $repo, PackageInterface $package): ?PromiseInterface
+    {
+        $path = $this->getInstallPath($package);
+        $this->trace('install ' . $package->getPrettyName() . ' -> ' . $path);
+        @mkdir($path, 0777, true);
+        file_put_contents($path . '/asset.txt', implode("\n", [
+            'name=' . $package->getPrettyName(),
+            'version=' . $package->getPrettyVersion(),
+            'type=' . $package->getType(),
+            'root=' . $this->composer->getPackage()->getName(),
+        ]) . "\n");
+        $this->io->write('asset-installer: installed ' . $package->getPrettyName());
+
+        return null;
+    }
+
+    public function update(InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target): ?PromiseInterface
+    {
+        $this->trace('update ' . $initial->getPrettyName() . ' -> ' . $target->getPrettyName());
+
+        return $this->install($repo, $target);
+    }
+
+    public function uninstall(InstalledRepositoryInterface $repo, PackageInterface $package): ?PromiseInterface
+    {
+        $path = $this->getInstallPath($package);
+        $this->trace('uninstall ' . $package->getPrettyName());
+        @unlink($path . '/asset.txt');
+        @rmdir($path);
+
+        return null;
+    }
+
+    public function cleanup(string $type, PackageInterface $package, ?PackageInterface $prevPackage = null): ?PromiseInterface
+    {
+        $this->trace('cleanup ' . $type . ' ' . $package->getPrettyName());
+
+        return null;
+    }
+
+    public function getInstallPath(PackageInterface $package): string
+    {
+        return 'assets/' . $package->getPrettyName();
+    }
+
+    private function name(?PackageInterface $package): string
+    {
+        return $package === null ? 'null' : $package->getPrettyName();
+    }
+
+    private function trace(string $line): void
+    {
+        file_put_contents('installer-trace.txt', $line . "\n", FILE_APPEND);
+    }
+}
diff --git a/crates/shirabe/tests/plugin/fixtures/e2e-installer/plugin/src/Plugin.php b/crates/shirabe/tests/plugin/fixtures/e2e-installer/plugin/src/Plugin.php
new file mode 100644
index 00000000..24a1d295
--- /dev/null
+++ b/crates/shirabe/tests/plugin/fixtures/e2e-installer/plugin/src/Plugin.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace ShirabeTest\AssetInstaller;
+
+use Composer\Composer;
+use Composer\IO\IOInterface;
+use Composer\Plugin\PluginInterface;
+
+class Plugin implements PluginInterface
+{
+    /** @var AssetInstaller */
+    private $installer;
+
+    public function activate(Composer $composer, IOInterface $io): void
+    {
+        $this->installer = new AssetInstaller($io, $composer);
+        $composer->getInstallationManager()->addInstaller($this->installer);
+    }
+
+    public function deactivate(Composer $composer, IOInterface $io): void
+    {
+        $composer->getInstallationManager()->removeInstaller($this->installer);
+    }
+
+    public function uninstall(Composer $composer, IOInterface $io): void
+    {
+    }
+}
diff --git a/crates/shirabe/tests/plugin/fixtures/e2e-installer/project/composer.json b/crates/shirabe/tests/plugin/fixtures/e2e-installer/project/composer.json
new file mode 100644
index 00000000..64c1bb32
--- /dev/null
+++ b/crates/shirabe/tests/plugin/fixtures/e2e-installer/project/composer.json
@@ -0,0 +1,32 @@
+{
+    "name": "shirabe/e2e-installer",
+    "description": "E2E fixture project: install a custom package type through a plugin-provided installer.",
+    "repositories": [
+        {
+            "type": "path",
+            "url": "../plugin",
+            "options": {
+                "symlink": false
+            }
+        },
+        {
+            "type": "path",
+            "url": "../packages/*",
+            "options": {
+                "symlink": false
+            }
+        },
+        {
+            "packagist.org": false
+        }
+    ],
+    "require": {
+        "shirabe-test/asset-installer": "1.0.0",
+        "shirabe-test/asset-a": "1.0.0"
+    },
+    "config": {
+        "allow-plugins": {
+            "shirabe-test/asset-installer": true
+        }
+    }
+}
diff --git a/crates/shirabe/tests/plugin/main.rs b/crates/shirabe/tests/plugin/main.rs
index a65594be..02db6b03 100644
--- a/crates/shirabe/tests/plugin/main.rs
+++ b/crates/shirabe/tests/plugin/main.rs
@@ -5,6 +5,7 @@ mod config_stub;
 
 mod e2e_command_provider_test;
 mod e2e_extension_installer_test;
+mod e2e_installer_test;
 mod e2e_normalize_test;
 mod plugin_installer_test;
 mod subscriber_test;