diff options
Diffstat (limited to 'crates/shirabe/tests/plugin/value_round_trip_test.rs')
| -rw-r--r-- | crates/shirabe/tests/plugin/value_round_trip_test.rs | 168 |
1 files changed, 168 insertions, 0 deletions
diff --git a/crates/shirabe/tests/plugin/value_round_trip_test.rs b/crates/shirabe/tests/plugin/value_round_trip_test.rs new file mode 100644 index 00000000..3e01422a --- /dev/null +++ b/crates/shirabe/tests/plugin/value_round_trip_test.rs @@ -0,0 +1,168 @@ +//! Shirabe-specific integration tests for the immutable values that cross the plugin boundary +//! as real PHP objects: `Composer\Package\Link` with its `composer/semver` constraint, and the +//! `\DateTimeInterface` release date. Upstream Composer has no test for this (its plugins run +//! in-process), so the fixture `fixtures/values-v1` is Shirabe-owned. + +use crate::async_runtime::run; +use crate::plugin_installer_test::{lock_php_worker, new_installer, php_runtime_available, set_up}; +use indexmap::IndexMap; +use shirabe::installer::InstallerInterface; +use shirabe::package::Link; +use shirabe::package::PackageInterfaceHandle; +use shirabe::package::loader::{ArrayLoader, JsonLoader, JsonLoaderInput}; +use shirabe_semver::constraint::{ + AnyConstraint, MatchAllConstraint, MatchNoneConstraint, MultiConstraint, SimpleConstraint, +}; + +fn values_fixture_package() -> PackageInterfaceHandle { + let loader = JsonLoader::new(Box::new(ArrayLoader::new(None, false))); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("tests/plugin/fixtures/values-v1/composer.json"); + loader + .load(JsonLoaderInput::String( + path.canonicalize().unwrap().to_str().unwrap().to_string(), + )) + .unwrap() +} + +fn simple(operator: &str, version: &str, pretty_string: Option<&str>) -> AnyConstraint { + AnyConstraint::Simple(SimpleConstraint::new( + operator.to_string(), + version.to_string(), + pretty_string.map(str::to_string), + )) +} + +fn link(target: &str, constraint: AnyConstraint, pretty_constraint: &str) -> Link { + Link::new( + "dummy/root".to_string(), + target.to_string(), + constraint, + Some(Link::TYPE_REQUIRE.to_string()), + pretty_constraint.to_string(), + ) +} + +/// Every constraint shape the codec knows, so the rendering the plugin writes covers all four +/// classes and both the set and the unset pretty string. +fn seeded_requires() -> IndexMap<String, Link> { + let mut requires = IndexMap::new(); + requires.insert( + "foo/simple".to_string(), + link("foo/simple", simple(">=", "1.0.0.0", None), ">=1.0"), + ); + requires.insert( + "foo/multi".to_string(), + link( + "foo/multi", + AnyConstraint::Multi(MultiConstraint::new( + vec![ + simple(">=", "1.0.0.0", None), + simple("<", "2.0.0.0", Some("<2.0")), + ], + true, + Some("^1.0".to_string()), + )), + "^1.0", + ), + ); + requires.insert( + "foo/all".to_string(), + link( + "foo/all", + AnyConstraint::MatchAll(MatchAllConstraint::new(None)), + "*", + ), + ); + requires.insert( + "foo/none".to_string(), + link( + "foo/none", + AnyConstraint::MatchNone(MatchNoneConstraint::new(Some("nothing".to_string()))), + "", + ), + ); + requires +} + +fn describe(constraint: &AnyConstraint) -> String { + let shape = match constraint { + AnyConstraint::Simple(c) => { + format!("Constraint({} {})", c.get_operator(), c.get_version()) + } + AnyConstraint::Multi(c) => format!( + "MultiConstraint({}: {})", + if c.is_conjunctive() { "and" } else { "or" }, + c.get_constraints() + .iter() + .map(describe) + .collect::<Vec<_>>() + .join(", ") + ), + AnyConstraint::MatchAll(_) => "MatchAllConstraint()".to_string(), + AnyConstraint::MatchNone(_) => "MatchNoneConstraint()".to_string(), + }; + format!("{shape} pretty={}", constraint.get_pretty_string()) +} + +fn describe_links(links: &IndexMap<String, Link>) -> Vec<String> { + links + .iter() + .map(|(name, link)| { + format!( + "{name} | {} | {} | {} | {} | {}", + link.get_source(), + link.get_target(), + link.get_description(), + link.get_pretty_constraint(), + describe(link.get_constraint()) + ) + }) + .collect() +} + +#[test] +fn test_links_and_release_date_round_trip_through_the_plugin() { + if !php_runtime_available() { + return; + } + let _worker = lock_php_worker(); + let set_up = set_up(); + let package = set_up.composer.borrow().get_package().clone(); + package.set_requires(seeded_requires()); + + let installer = new_installer(&set_up); + set_up.pm.borrow_mut().load_installed_plugins().unwrap(); + run(installer.install(&set_up.repository, values_fixture_package())).unwrap(); + + // What the plugin saw: each seeded link rebuilt in the child as a real Link over a real + // composer/semver constraint. + assert_eq!( + "foo/simple | dummy/root | foo/simple | requires | >=1.0 | Constraint(>= 1.0.0.0) pretty=>= 1.0.0.0\n\ + foo/multi | dummy/root | foo/multi | requires | ^1.0 | MultiConstraint(and: Constraint(>= 1.0.0.0) pretty=>= 1.0.0.0, Constraint(< 2.0.0.0) pretty=<2.0) pretty=^1.0\n\ + foo/all | dummy/root | foo/all | requires | * | MatchAllConstraint() pretty=*\n\ + foo/none | dummy/root | foo/none | requires | | MatchNoneConstraint() pretty=nothing\n\ + release date: 2024-03-03T20:06:07.123456+00:00\n", + set_up.io.borrow().get_output() + ); + + // What the plugin wrote back: links it built PHP-side, decoded into Rust values. + assert_eq!( + vec![ + "bar/plain | dummy/root | bar/plain | requires | 2.0 | Constraint(== 2.0.0.0) pretty=2.0", + "bar/multi | dummy/root | bar/multi | requires (for development) | <1.0 || >=3.0 | MultiConstraint(or: Constraint(< 1.0.0.0) pretty=< 1.0.0.0, Constraint(>= 3.0.0.0) pretty=>= 3.0.0.0) pretty=[< 1.0.0.0 || >= 3.0.0.0]", + "bar/all | dummy/root | bar/all | requires | * | MatchAllConstraint() pretty=*", + "bar/none | dummy/root | bar/none | requires | | MatchNoneConstraint() pretty=nothing", + ], + describe_links(&package.get_requires()) + ); + // The plugin wrote an Asia/Tokyo instant with microseconds; both survive the crossing, + // and the child sees the same instant back in UTC. + assert_eq!( + "2024-03-03T20:06:07.123456Z", + package + .get_release_date() + .unwrap() + .to_rfc3339_opts(chrono::SecondsFormat::Micros, true) + ); +} |