1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
//! composer/installers E2E compatibility check: upstream Composer and Shirabe each install a
//! project whose packages are placed by the plugin's `LibraryInstaller` subclass, and the
//! resulting project trees are compared.
//!
//! The plugin is fetched by `fixtures/e2e-installers/fetch` into a git-ignored directory; the
//! test skips itself while that directory, 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-installers")
}
fn plugin_fetched() -> bool {
fixture_dir()
.join("ext/composer-installers-2.3.0/src/Composer/Installers/Installer.php")
.is_file()
}
struct CommandRun {
exit_code: i32,
}
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),
}
}
/// 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()));
}
}
}
/// 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_composer_installers_matches_upstream_composer() {
if !php_runtime_available() || !plugin_fetched() {
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);
// The paths alone carry the plugin's whole contribution: `acme/hello-module` and
// `acme/hello-theme` land under modules/ and themes/ rather than vendor/, which only the
// plugin-provided installer's getInstallPath can decide.
let paths = |files: &[(String, String)]| -> Vec<String> {
files
.iter()
.map(|(path, _)| path.clone())
.filter(|path| !path.starts_with("vendor/composer/installers/"))
.collect()
};
assert!(
paths(&shirabe_tree).contains(&"modules/hello-module/composer.json".to_string()),
"the plugin-provided installer must place the module outside vendor/: {:?}",
paths(&shirabe_tree)
);
assert_eq!(paths(&upstream_tree), paths(&shirabe_tree));
assert_eq!(upstream_tree, shirabe_tree);
}
|
