use super::*;
use crate::fetch::ReqwestFetcher;
use crate::progress::NoProgress;
use std::collections::HashMap;
use std::path::Path;
use tempfile::TempDir;
fn cache_in(tmp: &Path) -> PathBuf {
let cache = tmp.join("cache");
std::fs::create_dir_all(&cache).unwrap();
cache
}
fn run(
cache_root: &Path,
proj: &Path,
opts: InstallOptions,
hooks: Option<&dyn ScriptHooks>,
) -> Result<InstallSummary> {
let fetcher = ReqwestFetcher::new().unwrap();
let progress = NoProgress;
let env = InstallEnv::new(&fetcher, &progress, cache_root);
install_from_lock(&env, proj, opts, hooks)
}
fn run_with_git(cache_root: &Path, proj: &Path) -> Result<InstallSummary> {
let fetcher = ReqwestFetcher::new().unwrap();
let progress = NoProgress;
let git = crate::GitSourceFetcher::new(cache_root.with_file_name("vcs"));
let env = InstallEnv::new(&fetcher, &progress, cache_root).with_source_fetcher(&git);
install_from_lock(&env, proj, InstallOptions::default(), None)
}
fn write_project(dir: &Path, json: &str, lock: &str) {
std::fs::write(dir.join("composer.json"), json).unwrap();
std::fs::write(dir.join("composer.lock"), lock).unwrap();
}
fn hash_for(composer_json: &str) -> String {
composer_manifest::lockfile::content_hash(composer_json.as_bytes()).unwrap()
}
const MINIMAL_COMPOSER_JSON: &str = r#"{
"name": "acme/test",
"require": {}
}"#;
#[test]
fn content_hash_mismatch_warns_but_installs() {
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let lock = r#"{
"content-hash": "0000000000000000000000000000000a",
"packages": [],
"packages-dev": []
}"#;
write_project(&proj, MINIMAL_COMPOSER_JSON, lock);
let summary = run(&cache_root, &proj, InstallOptions::default(), None)
.expect("stale lock must warn, not error");
let warning = summary
.warnings
.iter()
.find(|w| w.contains("out of sync"))
.unwrap_or_else(|| {
panic!(
"expected a content-hash warning, got {:?}",
summary.warnings
)
});
assert!(warning.contains("composer update"), "{warning}");
}
#[test]
fn missing_composer_lock_errors_with_helpful_message() {
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
std::fs::write(proj.join("composer.json"), MINIMAL_COMPOSER_JSON).unwrap();
let err = run(&cache_root, &proj, InstallOptions::default(), None)
.expect_err("must error when lock is missing");
let msg = format!("{err:#}");
assert!(msg.contains("composer.lock"), "{msg}");
assert!(msg.contains("composer update"), "must suggest fix: {msg}");
}
#[test]
fn missing_composer_json_errors_with_helpful_message() {
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let err = run(&cache_root, &proj, InstallOptions::default(), None)
.expect_err("must error when composer.json is missing");
let msg = format!("{err:#}");
assert!(msg.contains("not a Composer project"), "{msg}");
}
#[test]
fn composer_plugin_package_warns_but_installs_files() {
use std::io::Write as _;
use wiremock::matchers::{method, path as wm_path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let mut zip_body: Vec<u8> = Vec::new();
{
let mut zw = zip::ZipWriter::new(std::io::Cursor::new(&mut zip_body));
let opts = zip::write::SimpleFileOptions::default()
.compression_method(zip::CompressionMethod::Stored);
zw.start_file("acme-plugin/composer.json", opts).unwrap();
zw.write_all(br#"{"name":"acme/plugin","type":"composer-plugin"}"#)
.unwrap();
zw.finish().unwrap();
}
let rt = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.unwrap();
let (uri, _server) = rt.block_on(async {
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(wm_path("/p.zip"))
.respond_with(ResponseTemplate::new(200).set_body_bytes(zip_body))
.mount(&server)
.await;
(server.uri(), server)
});
let hash = hash_for(MINIMAL_COMPOSER_JSON);
let lock = format!(
r#"{{
"content-hash": "{hash}",
"packages": [
{{
"name": "acme/plugin",
"version": "1.0.0",
"type": "composer-plugin",
"dist": {{
"type": "zip",
"url": "{uri}/p.zip",
"shasum": ""
}}
}}
],
"packages-dev": []
}}"#
);
write_project(&proj, MINIMAL_COMPOSER_JSON, &lock);
let summary = run(&cache_root, &proj, InstallOptions::default(), None)
.expect("install must succeed; the plugin installs, only its hook is skipped");
assert_eq!(summary.packages_installed, 1);
assert!(
proj.join("vendor/acme/plugin/composer.json").is_file(),
"plugin files must be extracted into vendor/",
);
assert_eq!(summary.plugin_hooks_skipped, 1);
let warning = summary
.warnings
.iter()
.find(|w| w.contains("acme/plugin"))
.unwrap_or_else(|| panic!("expected a plugin warning, got {:?}", summary.warnings));
assert!(warning.contains("Composer plugin"), "{warning}");
}
#[test]
fn source_only_package_is_rejected_in_preflight() {
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let hash = hash_for(MINIMAL_COMPOSER_JSON);
let lock = format!(
r#"{{
"content-hash": "{hash}",
"packages": [
{{
"name": "acme/sourceonly",
"version": "1.0.0",
"source": {{
"type": "git",
"url": "https://example/acme/sourceonly.git",
"reference": "abc"
}}
}}
],
"packages-dev": []
}}"#
);
write_project(&proj, MINIMAL_COMPOSER_JSON, &lock);
let err = run(&cache_root, &proj, InstallOptions::default(), None)
.expect_err("must reject source-only package");
let msg = format!("{err:#}");
assert!(msg.contains("acme/sourceonly"), "{msg}");
assert!(msg.contains("not enabled"), "{msg}");
}
#[test]
fn non_git_source_is_rejected_in_preflight() {
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let hash = hash_for(MINIMAL_COMPOSER_JSON);
let lock = format!(
r#"{{
"content-hash": "{hash}",
"packages": [
{{
"name": "acme/sourceonly",
"version": "1.0.0",
"source": {{
"type": "svn",
"url": "https://svn.example/acme/sourceonly",
"reference": "42"
}}
}}
],
"packages-dev": []
}}"#
);
write_project(&proj, MINIMAL_COMPOSER_JSON, &lock);
let err = run_with_git(&cache_root, &proj).expect_err("must reject non-git source");
let msg = format!("{err:#}");
assert!(msg.contains("acme/sourceonly"), "{msg}");
assert!(msg.contains("`svn` source"), "{msg}");
assert!(msg.contains("git sources"), "{msg}");
}
#[cfg(unix)]
#[test]
fn git_source_package_installs_from_lock() {
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let (url, _first, sha) = crate::source::tests::fixture_repo(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let hash = hash_for(MINIMAL_COMPOSER_JSON);
let lock = format!(
r#"{{
"content-hash": "{hash}",
"packages": [
{{
"name": "acme/lib",
"version": "1.0.0",
"source": {{ "type": "git", "url": "{url}", "reference": "{sha}" }},
"autoload": {{ "classmap": ["."] }}
}}
],
"packages-dev": []
}}"#
);
write_project(&proj, MINIMAL_COMPOSER_JSON, &lock);
let summary = run_with_git(&cache_root, &proj).expect("git source install must succeed");
assert_eq!(summary.packages_installed, 1, "{summary:?}");
assert!(proj.join("vendor/acme/lib/second.php").is_file());
assert!(proj.join("vendor/autoload.php").is_file(), "autoloader ran");
let again = run_with_git(&cache_root, &proj).expect("re-install must succeed");
assert_eq!(again.packages_installed, 0, "up to date: {again:?}");
}
#[test]
fn plugin_package_dist_is_checked_in_preflight() {
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let hash = hash_for(MINIMAL_COMPOSER_JSON);
let lock = format!(
r#"{{
"content-hash": "{hash}",
"packages": [
{{
"name": "acme/plugin",
"version": "1.0.0",
"type": "composer-plugin",
"source": {{
"type": "git",
"url": "https://example/acme/plugin.git",
"reference": "abc"
}}
}}
],
"packages-dev": []
}}"#
);
write_project(&proj, MINIMAL_COMPOSER_JSON, &lock);
let err = run(&cache_root, &proj, InstallOptions::default(), None)
.expect_err("a plugin with no dist must be rejected up front");
let msg = format!("{err:#}");
assert!(msg.contains("acme/plugin"), "{msg}");
assert!(msg.contains("no `dist` block"), "{msg}");
}
#[test]
fn missing_files_and_unsupported_locks_are_typed_errors() {
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let err = run(&cache_root, &proj, InstallOptions::default(), None).unwrap_err();
assert!(matches!(
err.downcast_ref::<InstallError>(),
Some(InstallError::MissingManifest { .. })
));
std::fs::write(proj.join("composer.json"), MINIMAL_COMPOSER_JSON).unwrap();
let err = run(&cache_root, &proj, InstallOptions::default(), None).unwrap_err();
assert!(matches!(
err.downcast_ref::<InstallError>(),
Some(InstallError::MissingLock { .. })
));
let hash = hash_for(MINIMAL_COMPOSER_JSON);
let lock = format!(
r#"{{
"content-hash": "{hash}",
"packages": [
{{ "name": "acme/a", "version": "1.0.0",
"dist": {{ "type": "xz", "url": "https://example/a.xz" }} }},
{{ "name": "acme/b", "version": "1.0.0",
"source": {{ "type": "hg", "url": "https://example/b", "reference": "1" }} }}
],
"packages-dev": []
}}"#
);
write_project(&proj, MINIMAL_COMPOSER_JSON, &lock);
let err = run(&cache_root, &proj, InstallOptions::default(), None).unwrap_err();
match err.downcast_ref::<InstallError>() {
Some(InstallError::Unsupported { reasons }) => assert_eq!(reasons.len(), 2, "{reasons:?}"),
other => panic!("expected Unsupported, got {other:?}"),
}
}
#[test]
fn the_autoload_marker_name_is_configurable() {
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let hash = hash_for(MINIMAL_COMPOSER_JSON);
let lock = format!(r#"{{ "content-hash": "{hash}", "packages": [], "packages-dev": [] }}"#);
write_project(&proj, MINIMAL_COMPOSER_JSON, &lock);
let fetcher = ReqwestFetcher::new().unwrap();
let env = InstallEnv::new(&fetcher, &NoProgress, &cache_root)
.with_autoload_marker(".my-tool-autoload-fresh");
install_from_lock(&env, &proj, InstallOptions::default(), None).unwrap();
let composer_dir = proj.join("vendor/composer");
assert!(composer_dir.join(".my-tool-autoload-fresh").is_file());
assert!(!composer_dir.join(AUTOLOAD_FRESH_MARKER).exists());
}
#[test]
fn unsupported_dist_kind_is_rejected() {
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let hash = hash_for(MINIMAL_COMPOSER_JSON);
let lock = format!(
r#"{{
"content-hash": "{hash}",
"packages": [
{{
"name": "acme/xz",
"version": "1.0.0",
"dist": {{
"type": "xz",
"url": "https://example/t.tar.xz",
"shasum": "1111111111111111111111111111111111111111"
}}
}}
],
"packages-dev": []
}}"#
);
write_project(&proj, MINIMAL_COMPOSER_JSON, &lock);
let err =
run(&cache_root, &proj, InstallOptions::default(), None).expect_err("must reject xz dist");
let msg = format!("{err:#}");
assert!(msg.contains("acme/xz"), "{msg}");
assert!(msg.contains("`xz`"), "{msg}");
assert!(msg.contains("`zip` and `tar`"), "{msg}");
}
#[test]
fn tar_dist_kind_passes_preflight() {
let tmp = TempDir::new().unwrap();
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let hash = hash_for(MINIMAL_COMPOSER_JSON);
let lock_json = format!(
r#"{{
"content-hash": "{hash}",
"packages": [
{{
"name": "mirasvit/module-email",
"version": "1.0.0",
"dist": {{
"type": "tar",
"url": "https://example/module-email.tar",
"shasum": "1111111111111111111111111111111111111111"
}}
}}
],
"packages-dev": []
}}"#
);
let lock_path = proj.join("composer.lock");
std::fs::write(&lock_path, &lock_json).unwrap();
let lock = Lock::read(&lock_path).unwrap();
let warnings = preflight(
MINIMAL_COMPOSER_JSON.as_bytes(),
&lock,
false,
false,
false,
&Wording::default(),
)
.expect("tar dist must pass preflight");
assert!(warnings.is_empty(), "no warnings expected: {warnings:?}");
}
#[test]
fn composer_json_with_scripts_warns() {
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let composer_json = r#"{
"name": "acme/test",
"require": {},
"scripts": {"post-install-cmd": "echo hi"}
}"#;
let hash = hash_for(composer_json);
let lock = format!(
r#"{{
"content-hash": "{hash}",
"packages": [],
"packages-dev": []
}}"#
);
write_project(&proj, composer_json, &lock);
let summary = run(&cache_root, &proj, InstallOptions::default(), None)
.expect("install must succeed; scripts produce a warning, not an error");
assert_eq!(summary.warnings.len(), 1, "{:?}", summary.warnings);
assert!(
summary.warnings[0].contains("scripts"),
"{:?}",
summary.warnings
);
}
#[test]
fn preflight_reports_all_hard_blockers_together() {
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let composer_json = r#"{
"name": "acme/big",
"require": {},
"scripts": {"pre-autoload-dump": "echo"}
}"#;
let hash = hash_for(composer_json);
let lock = format!(
r#"{{
"content-hash": "{hash}",
"packages": [
{{
"name": "acme/plugin",
"version": "1.0.0",
"type": "composer-plugin",
"dist": {{
"type": "zip",
"url": "https://example/p.zip",
"shasum": "1111111111111111111111111111111111111111"
}}
}},
{{
"name": "acme/xz",
"version": "1.0.0",
"dist": {{
"type": "xz",
"url": "https://example/t.tar.xz",
"shasum": "2222222222222222222222222222222222222222"
}}
}},
{{
"name": "acme/sourceonly",
"version": "1.0.0",
"source": {{
"type": "git",
"url": "https://example/acme/sourceonly.git",
"reference": "abc"
}}
}}
],
"packages-dev": []
}}"#
);
write_project(&proj, composer_json, &lock);
let err = run(&cache_root, &proj, InstallOptions::default(), None)
.expect_err("hard blockers must still fail install");
let msg = format!("{err:#}");
assert!(msg.contains("acme/xz"), "xz: {msg}");
assert!(msg.contains("acme/sourceonly"), "sourceonly: {msg}");
}
#[test]
fn no_dev_hides_dev_only_packages_from_preflight() {
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let hash = hash_for(MINIMAL_COMPOSER_JSON);
let lock = format!(
r#"{{
"content-hash": "{hash}",
"packages": [],
"packages-dev": [
{{
"name": "acme/dev-plugin",
"version": "1.0.0",
"type": "composer-plugin",
"dist": {{
"type": "zip",
"url": "https://example/p.zip",
"shasum": "1111111111111111111111111111111111111111"
}}
}}
]
}}"#
);
write_project(&proj, MINIMAL_COMPOSER_JSON, &lock);
let summary = run(
&cache_root,
&proj,
InstallOptions {
no_dev: true,
..Default::default()
},
None,
)
.expect("preflight should pass with --no-dev");
assert_eq!(summary.packages_installed, 0);
assert_eq!(summary.packages_already_present, 0);
assert_eq!(summary.plugin_hooks_skipped, 0);
assert!(summary.warnings.is_empty(), "{:?}", summary.warnings);
assert!(summary.no_dev);
}
#[test]
fn install_attaches_per_host_auth_to_dist_download() {
use sha1::Digest as _;
use std::io::Write as _;
use wiremock::matchers::{header, method, path as wm_path};
use wiremock::{Mock, MockServer, ResponseTemplate};
fn rt() -> tokio::runtime::Runtime {
tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.unwrap()
}
fn sha1_hex(bytes: &[u8]) -> String {
let digest = sha1::Sha1::digest(bytes);
let mut s = String::with_capacity(40);
for b in digest {
use std::fmt::Write as _;
let _ = write!(s, "{b:02x}");
}
s
}
fn build_zip(top: &str) -> Vec<u8> {
let mut buf: Vec<u8> = Vec::new();
let cursor = std::io::Cursor::new(&mut buf);
let mut zw = zip::ZipWriter::new(cursor);
let opts = zip::write::SimpleFileOptions::default()
.compression_method(zip::CompressionMethod::Stored);
zw.start_file(format!("{top}/composer.json"), opts).unwrap();
zw.write_all(br#"{"name":"acme/foo"}"#).unwrap();
zw.finish().unwrap();
buf
}
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let zip_body = build_zip("acme-foo-abc");
let zip_sha1 = sha1_hex(&zip_body);
let rt = rt();
let (uri, _server) = rt.block_on(async {
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(wm_path("/dists/acme-foo.zip"))
.and(header("Authorization", "Basic dXNlcjpwYXNz"))
.respond_with(ResponseTemplate::new(200).set_body_bytes(zip_body))
.mount(&server)
.await;
Mock::given(method("GET"))
.and(wm_path("/dists/acme-foo.zip"))
.respond_with(ResponseTemplate::new(401))
.mount(&server)
.await;
(server.uri(), server)
});
let host = uri.trim_start_matches("http://");
let composer_json = format!(
r#"{{
"name": "acme/test",
"require": {{"acme/foo": "1.0.0"}},
"config": {{
"http-basic": {{
"{host}": {{"username": "user", "password": "pass"}}
}}
}}
}}"#
);
let content_hash = hash_for(&composer_json);
let lock = format!(
r#"{{
"content-hash": "{content_hash}",
"packages": [
{{
"name": "acme/foo",
"version": "1.0.0",
"type": "library",
"dist": {{
"type": "zip",
"url": "{uri}/dists/acme-foo.zip",
"shasum": "{zip_sha1}"
}}
}}
],
"packages-dev": []
}}"#
);
write_project(&proj, &composer_json, &lock);
let summary = run(&cache_root, &proj, InstallOptions::default(), None)
.expect("install must succeed with the auth header attached");
assert_eq!(summary.packages_installed, 1);
assert!(
proj.join("vendor/acme/foo/composer.json").is_file(),
"package must be extracted into vendor/",
);
}
#[test]
fn install_accepts_empty_shasum_via_github_zipball_style_dist() {
use std::io::Write as _;
use wiremock::matchers::{method, path as wm_path};
use wiremock::{Mock, MockServer, ResponseTemplate};
fn rt() -> tokio::runtime::Runtime {
tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.unwrap()
}
fn build_zip(top: &str) -> Vec<u8> {
let mut buf: Vec<u8> = Vec::new();
let cursor = std::io::Cursor::new(&mut buf);
let mut zw = zip::ZipWriter::new(cursor);
let opts = zip::write::SimpleFileOptions::default()
.compression_method(zip::CompressionMethod::Stored);
zw.start_file(format!("{top}/composer.json"), opts).unwrap();
zw.write_all(br#"{"name":"acme/zipball"}"#).unwrap();
zw.finish().unwrap();
buf
}
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let reference = "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef";
let zip_body = build_zip(&format!("acme-zipball-{}", &reference[..7]));
let rt = rt();
let (uri, _server) = rt.block_on(async {
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(wm_path(format!("/repos/acme/zipball/zipball/{reference}")))
.respond_with(ResponseTemplate::new(200).set_body_bytes(zip_body))
.mount(&server)
.await;
(server.uri(), server)
});
let composer_json = r#"{
"name": "acme/consumer",
"require": {"acme/zipball": "1.0.0"}
}"#;
let content_hash = hash_for(composer_json);
let lock = format!(
r#"{{
"content-hash": "{content_hash}",
"packages": [
{{
"name": "acme/zipball",
"version": "1.0.0",
"type": "library",
"dist": {{
"type": "zip",
"url": "{uri}/repos/acme/zipball/zipball/{reference}",
"reference": "{reference}",
"shasum": ""
}}
}}
],
"packages-dev": []
}}"#
);
write_project(&proj, composer_json, &lock);
let summary = run(&cache_root, &proj, InstallOptions::default(), None)
.expect("install must succeed despite empty shasum");
assert_eq!(summary.packages_installed, 1);
assert!(
proj.join("vendor/acme/zipball/composer.json").is_file(),
"package must be extracted into vendor/ via reference-keyed cache",
);
}
#[test]
fn second_install_skips_up_to_date_packages() {
use std::io::Write as _;
use wiremock::matchers::{method, path as wm_path};
use wiremock::{Mock, MockServer, ResponseTemplate};
fn rt() -> tokio::runtime::Runtime {
tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.unwrap()
}
fn build_zip(top: &str) -> Vec<u8> {
let mut buf: Vec<u8> = Vec::new();
let cursor = std::io::Cursor::new(&mut buf);
let mut zw = zip::ZipWriter::new(cursor);
let opts = zip::write::SimpleFileOptions::default()
.compression_method(zip::CompressionMethod::Stored);
zw.start_file(format!("{top}/composer.json"), opts).unwrap();
zw.write_all(br#"{"name":"acme/bar"}"#).unwrap();
zw.finish().unwrap();
buf
}
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let reference = "aabbccddaabbccddaabbccddaabbccddaabbccdd";
let zip_body = build_zip(&format!("acme-bar-{}", &reference[..7]));
let rt = rt();
let (uri, _server) = rt.block_on(async {
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(wm_path(format!("/repos/acme/bar/zipball/{reference}")))
.respond_with(ResponseTemplate::new(200).set_body_bytes(zip_body))
.mount(&server)
.await;
(server.uri(), server)
});
let composer_json = r#"{
"name": "acme/consumer",
"require": {"acme/bar": "2.0.0"}
}"#;
let content_hash = hash_for(composer_json);
let lock = format!(
r#"{{
"content-hash": "{content_hash}",
"packages": [
{{
"name": "acme/bar",
"version": "2.0.0",
"type": "library",
"dist": {{
"type": "zip",
"url": "{uri}/repos/acme/bar/zipball/{reference}",
"reference": "{reference}",
"shasum": ""
}}
}}
],
"packages-dev": []
}}"#
);
write_project(&proj, composer_json, &lock);
let s1 = run(&cache_root, &proj, InstallOptions::default(), None)
.expect("first install must succeed");
assert_eq!(s1.packages_installed, 1);
assert_eq!(s1.packages_up_to_date, 0);
assert!(proj.join("vendor/acme/bar/composer.json").is_file());
assert!(proj.join("vendor/composer/installed.json").is_file());
let s2 = run(&cache_root, &proj, InstallOptions::default(), None)
.expect("second install must succeed");
assert_eq!(s2.packages_installed, 0, "no fresh downloads");
assert_eq!(s2.packages_already_present, 0, "no cache-only extractions");
assert_eq!(s2.packages_up_to_date, 1, "package is up to date");
assert!(
proj.join("vendor/acme/bar/composer.json").is_file(),
"vendor dir must still be intact",
);
}
#[test]
fn missing_vendor_dir_forces_reinstall() {
let tmp = TempDir::new().unwrap();
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let mut old_packages = HashMap::new();
old_packages.insert("acme/foo".into(), "ref1".into());
let state = Some(InstalledState {
packages: old_packages,
});
let foo_lock: LockPackage = serde_json::from_value(serde_json::json!({
"name": "acme/foo",
"version": "1.0.0",
"dist": {
"type": "zip",
"url": "https://example/foo.zip",
"reference": "ref1",
"shasum": "0000000000000000000000000000000000000000"
}
}))
.unwrap();
let installable = vec![&foo_lock];
let (need_install, up_to_date) = diff_install_set(&installable, state.as_ref(), &proj);
assert_eq!(
need_install.len(),
1,
"must re-install when vendor dir is missing"
);
assert_eq!(need_install[0].name, "acme/foo");
assert_eq!(up_to_date, 0);
}
#[test]
fn changed_reference_forces_reinstall() {
let tmp = TempDir::new().unwrap();
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let mut old_packages = HashMap::new();
old_packages.insert("acme/foo".into(), "old_ref".into());
let state = Some(InstalledState {
packages: old_packages,
});
let foo_lock: LockPackage = serde_json::from_value(serde_json::json!({
"name": "acme/foo",
"version": "2.0.0",
"dist": {
"type": "zip",
"url": "https://example/foo.zip",
"reference": "new_ref",
"shasum": "0000000000000000000000000000000000000000"
}
}))
.unwrap();
std::fs::create_dir_all(proj.join("vendor/acme/foo")).unwrap();
let installable = vec![&foo_lock];
let (need_install, up_to_date) = diff_install_set(&installable, state.as_ref(), &proj);
assert_eq!(
need_install.len(),
1,
"must re-install when reference changed"
);
assert_eq!(need_install[0].name, "acme/foo");
assert_eq!(up_to_date, 0);
}
use std::cell::RefCell;
#[derive(Default)]
struct RecordingHooks {
events: RefCell<Vec<&'static str>>,
}
impl ScriptHooks for RecordingHooks {
fn pre_cmd(&self) -> Result<()> {
self.events.borrow_mut().push("pre_cmd");
Ok(())
}
fn pre_autoload_dump(&self) -> Result<()> {
self.events.borrow_mut().push("pre_autoload_dump");
Ok(())
}
fn post_autoload_dump(&self) -> Result<()> {
self.events.borrow_mut().push("post_autoload_dump");
Ok(())
}
fn post_cmd(&self) -> Result<()> {
self.events.borrow_mut().push("post_cmd");
Ok(())
}
}
const SCRIPTED_COMPOSER_JSON: &str = r#"{
"name": "acme/test",
"require": {},
"scripts": {
"post-install-cmd": ["echo hi"]
}
}"#;
fn empty_lock_for(json: &str) -> String {
format!(
r#"{{
"content-hash": "{}",
"packages": [],
"packages-dev": []
}}"#,
hash_for(json)
)
}
#[test]
fn hooks_fire_in_lifecycle_order() {
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
write_project(
&proj,
MINIMAL_COMPOSER_JSON,
&empty_lock_for(MINIMAL_COMPOSER_JSON),
);
let hooks = RecordingHooks::default();
run(&cache_root, &proj, InstallOptions::default(), Some(&hooks))
.expect("install with hooks must succeed");
assert_eq!(
hooks.events.into_inner(),
vec![
"pre_cmd",
"pre_autoload_dump",
"post_autoload_dump",
"post_cmd"
],
);
}
#[test]
fn scripts_warning_suppressed_when_hooks_present() {
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
write_project(
&proj,
SCRIPTED_COMPOSER_JSON,
&empty_lock_for(SCRIPTED_COMPOSER_JSON),
);
let hooks = RecordingHooks::default();
let on = run(&cache_root, &proj, InstallOptions::default(), Some(&hooks)).unwrap();
assert!(
!on.warnings.iter().any(|w| w.contains("declares `scripts`")),
"scripts-on must not warn: {:?}",
on.warnings
);
let off = run(&cache_root, &proj, InstallOptions::default(), None).unwrap();
let warning = off
.warnings
.iter()
.find(|w| w.contains("declares `scripts`"))
.unwrap_or_else(|| panic!("scripts-off must warn: {:?}", off.warnings));
assert!(warning.contains("ScriptHooks"), "{warning}");
}
#[test]
fn scripts_warning_suppressed_for_only_reproduced_scripts() {
let json = r#"{
"name": "acme/test",
"require": {},
"scripts": {
"post-autoload-dump": ["@php artisan package:discover"]
}
}"#;
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
write_project(&proj, json, &empty_lock_for(json));
let summary = run(&cache_root, &proj, InstallOptions::default(), None).unwrap();
assert!(
!summary
.warnings
.iter()
.any(|w| w.contains("declares `scripts`")),
"pure-discovery scripts must not warn: {:?}",
summary.warnings
);
}
#[test]
fn laravel_drift_guard_skipped_when_scripts_on() {
let json = r#"{
"name": "acme/test",
"require": {},
"scripts": {
"post-autoload-dump": ["@php artisan custom:thing"]
}
}"#;
let lock = format!(
r#"{{
"content-hash": "{}",
"packages": [
{{
"name": "laravel/framework",
"version": "11.0.0",
"type": "metapackage"
}}
],
"packages-dev": []
}}"#,
hash_for(json)
);
let tmp = TempDir::new().unwrap();
let cache_root = cache_in(tmp.path());
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
write_project(&proj, json, &lock);
let err = run(&cache_root, &proj, InstallOptions::default(), None)
.expect_err("drift guard must block when scripts are off");
assert!(format!("{err:#}").contains("post-autoload-dump"), "{err:#}");
let hooks = RecordingHooks::default();
run(&cache_root, &proj, InstallOptions::default(), Some(&hooks))
.expect("scripts-on must skip the drift guard");
assert!(hooks.events.into_inner().contains(&"post_autoload_dump"));
}
#[test]
fn wording_names_the_calling_tool_in_warnings_and_blockers() {
let wording = Wording {
tool: "acme",
update_command: "acme update",
install_command: "acme run -- composer install",
scripts_hint: "Pass `--scripts` to run them.",
..Wording::default()
};
let lock: Lock = serde_json::from_str(r#"{ "packages": [], "packages-dev": [] }"#).unwrap();
let json = br#"{ "name": "acme/app", "scripts": { "post-install-cmd": "echo hi" } }"#;
let warnings = preflight(json, &lock, false, false, false, &wording).unwrap();
assert_eq!(warnings.len(), 1, "{warnings:?}");
assert!(warnings[0].ends_with("Pass `--scripts` to run them."));
assert!(!warnings[0].contains("ScriptHooks"));
let stale: Lock =
serde_json::from_str(r#"{ "content-hash": "0000", "packages": [], "packages-dev": [] }"#)
.unwrap();
let warning = content_hash_warning(json, &stale, &wording)
.unwrap()
.expect("a stale lock warns");
assert!(warning.contains("Run `acme update`"), "{warning}");
let svn: Lock = serde_json::from_str(
r#"{ "packages": [ { "name": "acme/lib", "version": "1.0.0",
"source": { "type": "svn", "url": "https://svn.example/lib", "reference": "1" } } ],
"packages-dev": [] }"#,
)
.unwrap();
let err = preflight(b"{}", &svn, false, false, true, &wording).unwrap_err();
let msg = err.to_string();
assert!(msg.contains("acme can only install git sources"), "{msg}");
assert!(msg.contains("`acme run -- composer install`"), "{msg}");
}