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 {
fetcher: &fetcher,
progress: &progress,
cache_root,
};
install_from_lock(&env, proj, opts, hooks)
}
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("source-only"), "{msg}");
}
#[test]
fn tar_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/tar",
"version": "1.0.0",
"dist": {{
"type": "tar",
"url": "https://example/t.tar.gz",
"shasum": "1111111111111111111111111111111111111111"
}}
}}
],
"packages-dev": []
}}"#
);
write_project(&proj, MINIMAL_COMPOSER_JSON, &lock);
let err =
run(&cache_root, &proj, InstallOptions::default(), None).expect_err("must reject tar dist");
let msg = format!("{err:#}");
assert!(msg.contains("acme/tar"), "{msg}");
assert!(msg.contains("`tar`"), "{msg}");
assert!(msg.contains("zip dists"), "{msg}");
}
#[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/tar",
"version": "1.0.0",
"dist": {{
"type": "tar",
"url": "https://example/t.tar.gz",
"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/tar"), "tar: {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 diff_removes_stale_vendor_dirs() {
let tmp = TempDir::new().unwrap();
let proj = tmp.path().join("p");
std::fs::create_dir_all(&proj).unwrap();
let stale_dir = proj.join("vendor/acme/stale");
std::fs::create_dir_all(&stale_dir).unwrap();
let mut old_packages = HashMap::new();
old_packages.insert("acme/foo".into(), "ref1".into());
old_packages.insert("acme/stale".into(), "ref2".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 foo_vendor = proj.join("vendor/acme/foo");
std::fs::create_dir_all(&foo_vendor).unwrap();
let installable = vec![&foo_lock];
let (need_install, up_to_date, removed) = diff_install_set(
&installable,
state.as_ref(),
&proj,
&std::collections::HashSet::new(),
);
assert!(need_install.is_empty(), "acme/foo is up-to-date");
assert_eq!(up_to_date, 1);
assert_eq!(removed, 1, "acme/stale must be removed");
assert!(!stale_dir.exists(), "stale vendor dir must be deleted");
}
#[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, removed) = diff_install_set(
&installable,
state.as_ref(),
&proj,
&std::collections::HashSet::new(),
);
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);
assert_eq!(removed, 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, removed) = diff_install_set(
&installable,
state.as_ref(),
&proj,
&std::collections::HashSet::new(),
);
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);
assert_eq!(removed, 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"));
}