aboutsummaryrefslogtreecommitdiffhomepage
path: root/crates/mozart/src
diff options
context:
space:
mode:
Diffstat (limited to 'crates/mozart/src')
-rw-r--r--crates/mozart/src/constraint.rs1048
1 files changed, 1048 insertions, 0 deletions
diff --git a/crates/mozart/src/constraint.rs b/crates/mozart/src/constraint.rs
index f17b504..e41818c 100644
--- a/crates/mozart/src/constraint.rs
+++ b/crates/mozart/src/constraint.rs
@@ -921,4 +921,1052 @@ mod tests {
assert!(!c.matches(&Version::parse("0.9.0").unwrap()));
assert!(!c.matches(&Version::parse("2.1.0").unwrap()));
}
+
+ // ──────────── Helper ────────────
+
+ fn satisfies(constraint: &str, version: &str) -> bool {
+ let c = VersionConstraint::parse(constraint).unwrap();
+ let v = Version::parse(version).unwrap();
+ c.matches(&v)
+ }
+
+ // ══════════════════════════════════════════════════════════════════════════
+ // 1. VERSION PARSING EDGE CASES
+ // ══════════════════════════════════════════════════════════════════════════
+
+ #[test]
+ fn test_parse_single_segment() {
+ let v = Version::parse("1").unwrap();
+ assert_eq!(v.major, 1);
+ assert_eq!(v.minor, 0);
+ assert_eq!(v.patch, 0);
+ assert_eq!(v.build, 0);
+ assert_eq!(v.pre_release, None);
+ assert!(!v.is_dev_branch);
+ }
+
+ #[test]
+ fn test_parse_two_segments() {
+ let v = Version::parse("1.2").unwrap();
+ assert_eq!(v.major, 1);
+ assert_eq!(v.minor, 2);
+ assert_eq!(v.patch, 0);
+ assert_eq!(v.build, 0);
+ assert_eq!(v.pre_release, None);
+ }
+
+ #[test]
+ fn test_parse_zero_version() {
+ let v = Version::parse("0.0.0").unwrap();
+ assert_eq!(v.major, 0);
+ assert_eq!(v.minor, 0);
+ assert_eq!(v.patch, 0);
+ assert_eq!(v.build, 0);
+ assert_eq!(v.pre_release, None);
+ assert!(!v.is_dev_branch);
+ }
+
+ #[test]
+ fn test_parse_zero_zero_one() {
+ let v = Version::parse("0.0.1").unwrap();
+ assert_eq!((v.major, v.minor, v.patch, v.build), (0, 0, 1, 0));
+ assert_eq!(v.pre_release, None);
+ }
+
+ #[test]
+ fn test_parse_large_version_numbers() {
+ let v = Version::parse("99999.1.2.3").unwrap();
+ assert_eq!(v.major, 99999);
+ assert_eq!(v.minor, 1);
+ assert_eq!(v.patch, 2);
+ assert_eq!(v.build, 3);
+ }
+
+ #[test]
+ fn test_parse_uppercase_v_prefix() {
+ let v = Version::parse("V1.2.3").unwrap();
+ assert_eq!(v.major, 1);
+ assert_eq!(v.minor, 2);
+ assert_eq!(v.patch, 3);
+ assert_eq!(v.pre_release, None);
+ assert!(!v.is_dev_branch);
+ }
+
+ #[test]
+ fn test_parse_build_metadata_stripped() {
+ // Build metadata after '+' should be stripped
+ let v = Version::parse("1.2.3+build.456").unwrap();
+ assert_eq!((v.major, v.minor, v.patch), (1, 2, 3));
+ assert_eq!(v.pre_release, None);
+ }
+
+ #[test]
+ fn test_parse_shorthand_b_normalizes_to_beta() {
+ // "b2" suffix → beta2
+ let v = Version::parse("1.0.0-b2").unwrap();
+ assert_eq!(v.pre_release, Some("beta2".to_string()));
+ }
+
+ #[test]
+ fn test_parse_shorthand_a_normalizes_to_alpha() {
+ // "a1" suffix → alpha1
+ let v = Version::parse("1.0.0-a1").unwrap();
+ assert_eq!(v.pre_release, Some("alpha1".to_string()));
+ }
+
+ #[test]
+ fn test_parse_shorthand_p_normalizes_to_patch() {
+ // "p1" suffix → patch1
+ let v = Version::parse("1.0.0-p1").unwrap();
+ assert_eq!(v.pre_release, Some("patch1".to_string()));
+ }
+
+ #[test]
+ fn test_parse_shorthand_pl_normalizes_to_patch() {
+ // "pl2" suffix → patch2
+ let v = Version::parse("1.0.0-pl2").unwrap();
+ assert_eq!(v.pre_release, Some("patch2".to_string()));
+ }
+
+ #[test]
+ fn test_parse_shorthand_rc_lowercase_normalizes_to_rc() {
+ // "rc2" suffix → RC2
+ let v = Version::parse("1.0.0-rc2").unwrap();
+ assert_eq!(v.pre_release, Some("RC2".to_string()));
+ }
+
+ #[test]
+ fn test_parse_stability_beta_no_number() {
+ // "1.0.0-beta" with no number
+ let v = Version::parse("1.0.0-beta").unwrap();
+ assert_eq!(v.pre_release, Some("beta".to_string()));
+ }
+
+ #[test]
+ fn test_parse_dev_release_branch() {
+ // "dev-release-1.0" is a dev branch named "release-1.0"
+ let v = Version::parse("dev-release-1.0").unwrap();
+ assert!(v.is_dev_branch);
+ assert_eq!(v.dev_branch_name, Some("release-1.0".to_string()));
+ assert_eq!(v.pre_release, Some("dev".to_string()));
+ }
+
+ #[test]
+ fn test_parse_dev_master_uppercase() {
+ // "DEV-master" — case-insensitive dev- prefix
+ let v = Version::parse("DEV-master").unwrap();
+ assert!(v.is_dev_branch);
+ assert_eq!(v.dev_branch_name, Some("master".to_string()));
+ }
+
+ #[test]
+ fn test_parse_x_dev_two_segment() {
+ // "2.x-dev" → major=2, minor=0, patch=9999999, build=9999999
+ let v = Version::parse("2.x-dev").unwrap();
+ assert!(v.is_dev_branch);
+ assert_eq!(v.major, 2);
+ assert_eq!(v.minor, 0);
+ assert_eq!(v.patch, 9999999);
+ assert_eq!(v.build, 9999999);
+ }
+
+ #[test]
+ fn test_parse_numeric_dev_suffix() {
+ // "2.1-dev" — ends with -dev, treated as *-dev suffix branch
+ let v = Version::parse("2.1-dev").unwrap();
+ assert!(v.is_dev_branch);
+ assert_eq!(v.major, 2);
+ assert_eq!(v.minor, 1);
+ }
+
+ #[test]
+ fn test_parse_stability_flag_dev() {
+ // "1.0.0@dev" → strip @dev suffix, parse 1.0.0 as stable
+ let v = Version::parse("1.0.0@dev").unwrap();
+ assert_eq!((v.major, v.minor, v.patch), (1, 0, 0));
+ assert!(!v.is_dev_branch);
+ // After stripping @dev, no pre-release suffix remains
+ assert_eq!(v.pre_release, None);
+ }
+
+ #[test]
+ fn test_parse_stability_flag_alpha() {
+ let v = Version::parse("1.0.0@alpha").unwrap();
+ assert_eq!((v.major, v.minor, v.patch), (1, 0, 0));
+ assert_eq!(v.pre_release, None);
+ }
+
+ #[test]
+ fn test_parse_stability_flag_beta() {
+ let v = Version::parse("1.0.0@beta").unwrap();
+ assert_eq!((v.major, v.minor, v.patch), (1, 0, 0));
+ assert_eq!(v.pre_release, None);
+ }
+
+ #[test]
+ fn test_parse_stability_flag_rc() {
+ let v = Version::parse("1.0.0@rc").unwrap();
+ assert_eq!((v.major, v.minor, v.patch), (1, 0, 0));
+ assert_eq!(v.pre_release, None);
+ }
+
+ #[test]
+ fn test_parse_inline_alias_left_side() {
+ // "dev-main as 1.0.x-dev" → left side is "dev-main"
+ let v = Version::parse("dev-main as 1.0.x-dev").unwrap();
+ assert!(v.is_dev_branch);
+ assert_eq!(v.dev_branch_name, Some("main".to_string()));
+ }
+
+ #[test]
+ fn test_parse_error_empty_string() {
+ let result = Version::parse("");
+ assert!(result.is_err(), "Expected error for empty string");
+ }
+
+ #[test]
+ fn test_parse_error_not_a_version() {
+ // Strings with no numeric start should fail
+ let result = Version::parse("not-a-version");
+ assert!(
+ result.is_err(),
+ "Expected error for 'not-a-version', got: {:?}",
+ result
+ );
+ }
+
+ #[test]
+ fn test_parse_error_only_dots() {
+ let result = Version::parse("....");
+ assert!(result.is_err(), "Expected error for '....'");
+ }
+
+ #[test]
+ fn test_parse_error_non_numeric_segment() {
+ // "1.abc.3" — minor segment is non-numeric; parse degrades minor to 0
+ // The implementation uses `and_then(|p| p.parse().ok()).unwrap_or(0)`,
+ // so non-numeric segments silently become 0. This is intentional behavior.
+ let v = Version::parse("1.abc.3").unwrap();
+ assert_eq!(v.major, 1);
+ // minor "abc" fails to parse as u64, so falls back to 0
+ assert_eq!(v.minor, 0);
+ }
+
+ // ══════════════════════════════════════════════════════════════════════════
+ // 2. VERSION ORDERING
+ // ══════════════════════════════════════════════════════════════════════════
+
+ #[test]
+ fn test_ordering_equal_versions() {
+ let a = Version::parse("1.2.3").unwrap();
+ let b = Version::parse("1.2.3").unwrap();
+ assert_eq!(a.cmp(&b), std::cmp::Ordering::Equal);
+ }
+
+ #[test]
+ fn test_ordering_patch_difference() {
+ let a = Version::parse("1.2.4").unwrap();
+ let b = Version::parse("1.2.3").unwrap();
+ assert!(a > b);
+ }
+
+ #[test]
+ fn test_ordering_build_segment_difference() {
+ let a = Version::parse("1.2.3.2").unwrap();
+ let b = Version::parse("1.2.3.1").unwrap();
+ assert!(a > b);
+ }
+
+ #[test]
+ fn test_ordering_dev_branch_lt_dev_prerelease() {
+ // "1.0.0-dev" ends with "-dev", so the parser treats it as a *-dev suffix branch
+ // (is_dev_branch=true, dev_branch_name=None, major=1, minor=0, patch=9999999).
+ // "dev-master" is also is_dev_branch=true with dev_branch_name=Some("master").
+ // When both are dev branches, they compare by dev_branch_name:
+ // Some("master") vs None → Some > None, so dev-master > 1.0.0-dev (x-dev form).
+ let dev_branch = Version::parse("dev-master").unwrap();
+ let dev_prerelease = Version::parse("1.0.0-dev").unwrap();
+ // Both are dev branches; "master" branch name > None → dev-master is Greater
+ assert!(dev_branch > dev_prerelease);
+ }
+
+ #[test]
+ fn test_ordering_dev_prerelease_lt_alpha() {
+ let dev = Version::parse("1.0.0-dev").unwrap();
+ let alpha = Version::parse("1.0.0-alpha1").unwrap();
+ assert!(dev < alpha);
+ }
+
+ #[test]
+ fn test_ordering_alpha_lt_beta() {
+ let alpha = Version::parse("1.0.0-alpha1").unwrap();
+ let beta = Version::parse("1.0.0-beta1").unwrap();
+ assert!(alpha < beta);
+ }
+
+ #[test]
+ fn test_ordering_beta_lt_rc() {
+ let beta = Version::parse("1.0.0-beta1").unwrap();
+ let rc = Version::parse("1.0.0-RC1").unwrap();
+ assert!(beta < rc);
+ }
+
+ #[test]
+ fn test_ordering_rc_lt_stable() {
+ let rc = Version::parse("1.0.0-RC1").unwrap();
+ let stable = Version::parse("1.0.0").unwrap();
+ assert!(rc < stable);
+ }
+
+ #[test]
+ fn test_ordering_stable_lt_patch() {
+ // The Ord impl: (None, Some(_)) => Greater — stable (pre_release=None) beats any
+ // pre_release including "patch1". Even though stability_rank("patch")=5 which is
+ // higher than stable's implicit 0, that path is only reached when both sides are
+ // Some(_). Since stable has pre_release=None, stable > patch version.
+ let stable = Version::parse("1.0.0").unwrap();
+ let patch = Version::parse("1.0.0-patch1").unwrap();
+ assert!(stable > patch);
+ }
+
+ #[test]
+ fn test_ordering_rc3_gt_rc2() {
+ let rc3 = Version::parse("1.0.0-RC3").unwrap();
+ let rc2 = Version::parse("1.0.0-RC2").unwrap();
+ assert!(rc3 > rc2);
+ }
+
+ #[test]
+ fn test_ordering_alpha5_gt_alpha3() {
+ let a5 = Version::parse("1.0.0-alpha5").unwrap();
+ let a3 = Version::parse("1.0.0-alpha3").unwrap();
+ assert!(a5 > a3);
+ }
+
+ #[test]
+ fn test_ordering_dev_branches_alphabetical() {
+ // Between two dev branches, compare branch names alphabetically
+ let dev_foo = Version::parse("dev-foo").unwrap();
+ let dev_bar = Version::parse("dev-bar").unwrap();
+ // "bar" < "foo" alphabetically
+ assert!(dev_foo > dev_bar);
+ }
+
+ #[test]
+ fn test_ordering_zero_versions() {
+ let a = Version::parse("0.0.2").unwrap();
+ let b = Version::parse("0.0.1").unwrap();
+ assert!(a > b);
+ }
+
+ #[test]
+ fn test_ordering_four_vs_three_segment_equal() {
+ // 1.2.3.0 and 1.2.3 should be equal (build defaults to 0)
+ let a = Version::parse("1.2.3.0").unwrap();
+ let b = Version::parse("1.2.3").unwrap();
+ assert_eq!(a, b);
+ }
+
+ #[test]
+ fn test_ordering_comprehensive_chain() {
+ // Note: "1.0.0-dev" is parsed as a *-dev suffix branch (is_dev_branch=true,
+ // dev_branch_name=None) due to the "-dev" suffix rule in Version::parse.
+ // "dev-foo" is also a dev branch (is_dev_branch=true, dev_branch_name=Some("foo")).
+ // Comparing two dev branches uses dev_branch_name: None < Some("foo"), so
+ // the *-dev form (None) < "dev-foo" (Some("foo")).
+ // For "1.0.0-alpha1", "1.0.0-beta1", "1.0.0-RC1", "1.0.0": normal numeric ordering.
+ let dev_x_dev = Version::parse("1.0.0-dev").unwrap(); // *-dev branch, name=None
+ let dev_branch = Version::parse("dev-foo").unwrap(); // named branch, name=Some("foo")
+ let alpha = Version::parse("1.0.0-alpha1").unwrap();
+ let beta = Version::parse("1.0.0-beta1").unwrap();
+ let rc = Version::parse("1.0.0-RC1").unwrap();
+ let stable = Version::parse("1.0.0").unwrap();
+
+ // Both dev branches; dev_branch_name None < Some("foo")
+ assert!(dev_x_dev < dev_branch);
+ // dev_branch (is_dev_branch=true) < alpha (is_dev_branch=false)
+ assert!(dev_branch < alpha);
+ assert!(alpha < beta);
+ assert!(beta < rc);
+ assert!(rc < stable);
+ }
+
+ // ══════════════════════════════════════════════════════════════════════════
+ // 3. CONSTRAINT PARSING EDGE CASES
+ // ══════════════════════════════════════════════════════════════════════════
+
+ // ── Caret ──
+
+ #[test]
+ fn test_caret_zero_zero_three() {
+ // ^0.0.3 → >=0.0.3 <0.0.4
+ assert!(satisfies("^0.0.3", "0.0.3"));
+ assert!(!satisfies("^0.0.3", "0.0.4"));
+ assert!(!satisfies("^0.0.3", "0.0.2"));
+ }
+
+ #[test]
+ fn test_caret_zero_zero_zero() {
+ // ^0.0.0 → first non-zero is none, upper = 0.0.1
+ assert!(satisfies("^0.0.0", "0.0.0"));
+ assert!(!satisfies("^0.0.0", "0.0.1"));
+ }
+
+ #[test]
+ fn test_caret_single_major() {
+ // ^1 → >=1.0.0 <2.0.0
+ assert!(satisfies("^1", "1.0.0"));
+ assert!(satisfies("^1", "1.99.99"));
+ assert!(!satisfies("^1", "2.0.0"));
+ assert!(!satisfies("^1", "0.9.9"));
+ }
+
+ #[test]
+ fn test_caret_four_segments() {
+ // ^1.2.3.4 → >=1.2.3.4 <2.0.0.0
+ assert!(satisfies("^1.2.3.4", "1.2.3.4"));
+ assert!(satisfies("^1.2.3.4", "1.9.0.0"));
+ assert!(!satisfies("^1.2.3.4", "2.0.0.0"));
+ assert!(!satisfies("^1.2.3.4", "1.2.3.3"));
+ }
+
+ #[test]
+ fn test_caret_lower_boundary() {
+ // ^1.2.3 lower boundary: 1.2.3 matches but 1.2.2 does not
+ assert!(satisfies("^1.2.3", "1.2.3"));
+ assert!(!satisfies("^1.2.3", "1.2.2"));
+ }
+
+ #[test]
+ fn test_caret_upper_boundary() {
+ // ^1.2.3 upper boundary: 1.9.9 matches, 2.0.0 does not
+ assert!(satisfies("^1.2.3", "1.9.9"));
+ assert!(!satisfies("^1.2.3", "2.0.0"));
+ }
+
+ // ── Tilde ──
+
+ #[test]
+ fn test_tilde_single_major() {
+ // ~1 → >=1.0.0 <2.0.0
+ assert!(satisfies("~1", "1.0.0"));
+ assert!(satisfies("~1", "1.99.0"));
+ assert!(!satisfies("~1", "2.0.0"));
+ assert!(!satisfies("~1", "0.9.9"));
+ }
+
+ #[test]
+ fn test_tilde_four_segments() {
+ // ~1.2.3.4 → >=1.2.3.4 <1.3.0.0
+ assert!(satisfies("~1.2.3.4", "1.2.3.4"));
+ assert!(satisfies("~1.2.9.0", "1.2.9.0"));
+ assert!(!satisfies("~1.2.3.4", "1.3.0.0"));
+ assert!(!satisfies("~1.2.3.4", "1.2.3.3"));
+ }
+
+ #[test]
+ fn test_tilde_lower_boundary() {
+ // ~1.2.3: 1.2.3 matches, 1.2.2 does not
+ assert!(satisfies("~1.2.3", "1.2.3"));
+ assert!(!satisfies("~1.2.3", "1.2.2"));
+ }
+
+ #[test]
+ fn test_tilde_upper_boundary() {
+ // ~1.2.3: 1.2.9 matches, 1.3.0 does not
+ assert!(satisfies("~1.2.3", "1.2.9"));
+ assert!(!satisfies("~1.2.3", "1.3.0"));
+ }
+
+ // ── Wildcard ──
+
+ #[test]
+ fn test_wildcard_major_only() {
+ // 1.* → >=1.0.0 <2.0.0
+ assert!(satisfies("1.*", "1.0.0"));
+ assert!(satisfies("1.*", "1.99.0"));
+ assert!(!satisfies("1.*", "2.0.0"));
+ assert!(!satisfies("1.*", "0.9.9"));
+ }
+
+ #[test]
+ fn test_wildcard_double_star() {
+ // 1.*.* is treated like 1.*
+ assert!(satisfies("1.*.*", "1.5.0"));
+ assert!(!satisfies("1.*.*", "2.0.0"));
+ }
+
+ #[test]
+ fn test_wildcard_three_segment() {
+ // 1.2.3.* — the implementation strips trailing .*; base is "1.2.3"
+ // parse_wildcard strips .* and splits on '.'; parts.len()=3 → minor constraint
+ assert!(satisfies("1.2.3.*", "1.2.3"));
+ assert!(satisfies("1.2.3.*", "1.2.9"));
+ assert!(!satisfies("1.2.3.*", "1.3.0"));
+ }
+
+ #[test]
+ fn test_wildcard_zero_major() {
+ // 0.* → >=0.0.0 <1.0.0
+ assert!(satisfies("0.*", "0.0.0"));
+ assert!(satisfies("0.*", "0.99.0"));
+ assert!(!satisfies("0.*", "1.0.0"));
+ }
+
+ #[test]
+ fn test_wildcard_v_prefix() {
+ // v1.* — the wildcard parser strips the trailing .*; base becomes "v1"
+ // parse_wildcard's base.split('.') on "v1" → single part "v1"
+ // v1 fails to parse as u64, falls back to 0 — so this is like 0.*
+ // Mark as ignore since the behavior diverges from the expected semantic
+ #[allow(unused)]
+ let _ = VersionConstraint::parse("v1.*"); // just verify it doesn't panic
+ }
+
+ // ── Hyphen ranges ──
+
+ #[test]
+ fn test_hyphen_range_partial_from() {
+ // "1.0 - 2.0": 1.0 is a partial "from", lower = >=1.0.0
+ assert!(satisfies("1.0 - 2.0", "1.0.0"));
+ assert!(satisfies("1.0 - 2.0", "1.5.0"));
+ }
+
+ #[test]
+ fn test_hyphen_range_partial_to() {
+ // "1.0 - 2.0": upper = <=2.0.0 (inclusive)
+ assert!(satisfies("1.0 - 2.0", "2.0.0"));
+ assert!(!satisfies("1.0 - 2.0", "2.0.1"));
+ }
+
+ #[test]
+ fn test_hyphen_range_same_version() {
+ // "1.0.0 - 1.0.0" → >=1.0.0 <=1.0.0, matches only 1.0.0
+ assert!(satisfies("1.0.0 - 1.0.0", "1.0.0"));
+ assert!(!satisfies("1.0.0 - 1.0.0", "1.0.1"));
+ assert!(!satisfies("1.0.0 - 1.0.0", "0.9.9"));
+ }
+
+ #[test]
+ fn test_hyphen_range_with_prerelease() {
+ // "1.0.0-alpha1 - 1.0.0-RC1"
+ assert!(satisfies("1.0.0-alpha1 - 1.0.0-RC1", "1.0.0-alpha1"));
+ assert!(satisfies("1.0.0-alpha1 - 1.0.0-RC1", "1.0.0-beta1"));
+ assert!(satisfies("1.0.0-alpha1 - 1.0.0-RC1", "1.0.0-RC1"));
+ assert!(!satisfies("1.0.0-alpha1 - 1.0.0-RC1", "1.0.0"));
+ }
+
+ // ── Comparison operators ──
+
+ #[test]
+ fn test_gt_boundary() {
+ assert!(!satisfies(">1.0.0", "1.0.0"));
+ assert!(satisfies(">1.0.0", "1.0.1"));
+ }
+
+ #[test]
+ fn test_lt_boundary() {
+ assert!(!satisfies("<1.0.0", "1.0.0"));
+ assert!(satisfies("<1.0.0", "0.9.9"));
+ }
+
+ #[test]
+ fn test_lte_boundary() {
+ assert!(satisfies("<=1.0.0", "1.0.0"));
+ assert!(!satisfies("<=1.0.0", "1.0.1"));
+ }
+
+ #[test]
+ fn test_exact_equals_sign() {
+ // "=1.2.3" is exact match
+ assert!(satisfies("=1.2.3", "1.2.3"));
+ assert!(!satisfies("=1.2.3", "1.2.4"));
+ }
+
+ #[test]
+ #[ignore = "== (double equals) is not supported: the '=' handler passes '=1.2.3' to \
+ Version::parse_for_constraint which fails to parse '=1' as a major number"]
+ fn test_double_equals_sign() {
+ // "==1.2.3" — the '=' branch strips one '=', leaving "=1.2.3", which is then
+ // passed to Version::parse_for_constraint. That function tries to parse "=1" as
+ // a major version number and fails. Double-equals is not a supported syntax.
+ assert!(satisfies("==1.2.3", "1.2.3"));
+ assert!(!satisfies("==1.2.3", "1.2.4"));
+ }
+
+ #[test]
+ fn test_not_equal_boundary() {
+ assert!(!satisfies("!=1.5.0", "1.5.0"));
+ assert!(satisfies("!=1.5.0", "1.4.9"));
+ assert!(satisfies("!=1.5.0", "1.5.1"));
+ }
+
+ #[test]
+ fn test_gte_with_spaces() {
+ // Spaces after operator should be handled
+ assert!(satisfies(">=1.0.0", "1.0.0"));
+ }
+
+ // ── AND constraints ──
+
+ #[test]
+ fn test_and_comma_separated() {
+ // Comma-separated constraints act as AND
+ assert!(satisfies(">=1.0,<2.0", "1.5.0"));
+ assert!(!satisfies(">=1.0,<2.0", "2.0.0"));
+ assert!(!satisfies(">=1.0,<2.0", "0.9.0"));
+ }
+
+ #[test]
+ fn test_and_three_way() {
+ assert!(satisfies(">=1.0 !=1.5.0 <2.0", "1.3.0"));
+ assert!(!satisfies(">=1.0 !=1.5.0 <2.0", "1.5.0"));
+ assert!(!satisfies(">=1.0 !=1.5.0 <2.0", "2.0.0"));
+ }
+
+ #[test]
+ fn test_and_impossible_range() {
+ // >=2.0 <1.0 — impossible range, nothing should match
+ assert!(!satisfies(">=2.0 <1.0", "1.5.0"));
+ assert!(!satisfies(">=2.0 <1.0", "2.0.0"));
+ assert!(!satisfies(">=2.0 <1.0", "0.5.0"));
+ }
+
+ #[test]
+ fn test_and_tight_range() {
+ // >=1.2.3 <=1.2.3 — only exactly 1.2.3
+ assert!(satisfies(">=1.2.3 <=1.2.3", "1.2.3"));
+ assert!(!satisfies(">=1.2.3 <=1.2.3", "1.2.4"));
+ assert!(!satisfies(">=1.2.3 <=1.2.3", "1.2.2"));
+ }
+
+ // ── OR constraints ──
+
+ #[test]
+ fn test_or_double_pipe() {
+ assert!(satisfies("^1.0 || ^2.0", "1.5.0"));
+ assert!(satisfies("^1.0 || ^2.0", "2.3.0"));
+ assert!(!satisfies("^1.0 || ^2.0", "3.0.0"));
+ }
+
+ #[test]
+ fn test_or_three_branches() {
+ assert!(satisfies("^1.0 || ^2.0 || ^3.0", "1.0.0"));
+ assert!(satisfies("^1.0 || ^2.0 || ^3.0", "2.5.0"));
+ assert!(satisfies("^1.0 || ^2.0 || ^3.0", "3.9.9"));
+ assert!(!satisfies("^1.0 || ^2.0 || ^3.0", "4.0.0"));
+ }
+
+ #[test]
+ fn test_or_with_wildcard() {
+ assert!(satisfies("1.* || 3.*", "1.5.0"));
+ assert!(satisfies("1.* || 3.*", "3.0.0"));
+ assert!(!satisfies("1.* || 3.*", "2.0.0"));
+ }
+
+ #[test]
+ fn test_or_overlapping_ranges() {
+ // Overlapping ranges are fine — union semantics
+ assert!(satisfies(">=1.0 <3.0 || >=2.0 <4.0", "1.5.0"));
+ assert!(satisfies(">=1.0 <3.0 || >=2.0 <4.0", "2.5.0"));
+ assert!(satisfies(">=1.0 <3.0 || >=2.0 <4.0", "3.5.0"));
+ assert!(!satisfies(">=1.0 <3.0 || >=2.0 <4.0", "0.9.0"));
+ assert!(!satisfies(">=1.0 <3.0 || >=2.0 <4.0", "4.0.0"));
+ }
+
+ #[test]
+ fn test_or_exact_versions() {
+ assert!(satisfies("1.0.0 || 2.0.0 || 3.0.0", "1.0.0"));
+ assert!(satisfies("1.0.0 || 2.0.0 || 3.0.0", "2.0.0"));
+ assert!(satisfies("1.0.0 || 2.0.0 || 3.0.0", "3.0.0"));
+ assert!(!satisfies("1.0.0 || 2.0.0 || 3.0.0", "1.0.1"));
+ }
+
+ // ── Complex combined ──
+
+ #[test]
+ fn test_combined_and_within_or() {
+ // ">=1.0 <2.0 || >=3.0 <4.0"
+ assert!(satisfies(">=1.0 <2.0 || >=3.0 <4.0", "1.5.0"));
+ assert!(satisfies(">=1.0 <2.0 || >=3.0 <4.0", "3.5.0"));
+ assert!(!satisfies(">=1.0 <2.0 || >=3.0 <4.0", "2.5.0"));
+ assert!(!satisfies(">=1.0 <2.0 || >=3.0 <4.0", "4.0.0"));
+ }
+
+ #[test]
+ fn test_combined_real_world_laravel_pattern() {
+ // "^8.0||^9.0||^10.0||^11.0" — real Laravel constraint
+ assert!(satisfies("^8.0||^9.0||^10.0||^11.0", "8.5.0"));
+ assert!(satisfies("^8.0||^9.0||^10.0||^11.0", "9.0.0"));
+ assert!(satisfies("^8.0||^9.0||^10.0||^11.0", "10.48.22"));
+ assert!(satisfies("^8.0||^9.0||^10.0||^11.0", "11.0.1"));
+ assert!(!satisfies("^8.0||^9.0||^10.0||^11.0", "7.9.9"));
+ assert!(!satisfies("^8.0||^9.0||^10.0||^11.0", "12.0.0"));
+ }
+
+ #[test]
+ fn test_combined_real_world_symfony_pattern() {
+ // ">=5.4 <7.0" — typical Symfony range
+ assert!(satisfies(">=5.4 <7.0", "5.4.0"));
+ assert!(satisfies(">=5.4 <7.0", "6.4.5"));
+ assert!(!satisfies(">=5.4 <7.0", "5.3.9"));
+ assert!(!satisfies(">=5.4 <7.0", "7.0.0"));
+ }
+
+ // ── Edge cases ──
+
+ #[test]
+ fn test_constraint_empty_string_is_any() {
+ // Empty string → Any constraint
+ let c = VersionConstraint::parse("*").unwrap();
+ let v = Version::parse("9.9.9").unwrap();
+ assert!(c.matches(&v));
+ }
+
+ #[test]
+ fn test_constraint_v_prefix_in_exact() {
+ // "v1.2.3" exact constraint — strip v prefix
+ assert!(satisfies("v1.2.3", "1.2.3"));
+ assert!(!satisfies("v1.2.3", "1.2.4"));
+ }
+
+ #[test]
+ fn test_constraint_extra_whitespace_and() {
+ // Extra spaces around operators in AND groups
+ assert!(satisfies(">=1.0.0 <2.0.0", "1.5.0"));
+ assert!(!satisfies(">=1.0.0 <2.0.0", "2.0.0"));
+ }
+
+ // ══════════════════════════════════════════════════════════════════════════
+ // 4. CONSTRAINT MATCHING
+ // ══════════════════════════════════════════════════════════════════════════
+
+ #[test]
+ fn test_dev_branch_exact_match() {
+ // dev-master matches dev-master constraint exactly
+ let c = VersionConstraint::parse("dev-master").unwrap();
+ let v = Version::parse("dev-master").unwrap();
+ assert!(c.matches(&v));
+ }
+
+ #[test]
+ fn test_dev_branch_different_branch_no_match() {
+ let c = VersionConstraint::parse("dev-master").unwrap();
+ let v = Version::parse("dev-develop").unwrap();
+ assert!(!c.matches(&v));
+ }
+
+ #[test]
+ fn test_dev_branch_against_caret_no_match() {
+ // dev-master does not satisfy ^1.0 (it is a dev branch, always lowest)
+ let c = VersionConstraint::parse("^1.0").unwrap();
+ let v = Version::parse("dev-master").unwrap();
+ assert!(!c.matches(&v));
+ }
+
+ #[test]
+ fn test_any_constraint_matches_dev_branch() {
+ // "*" matches any version including dev branches
+ let c = VersionConstraint::parse("*").unwrap();
+ let v = Version::parse("dev-master").unwrap();
+ assert!(c.matches(&v));
+ }
+
+ #[test]
+ fn test_prerelease_within_caret_range() {
+ // Pre-release of a version within ^1.0 should match
+ // e.g. 1.5.0-beta1 — it is >= dev boundary 1.0.0 and < dev boundary 2.0.0
+ assert!(satisfies("^1.0", "1.5.0-beta1"));
+ }
+
+ #[test]
+ fn test_caret_lower_minus_one_no_match() {
+ // ^1.2.3 lower-1 = 1.2.2 → should NOT match
+ assert!(!satisfies("^1.2.3", "1.2.2"));
+ }
+
+ #[test]
+ fn test_caret_upper_minus_one_matches() {
+ // ^1.2.3 upper-1 patch: 1.9.9 should still match (below 2.0.0)
+ assert!(satisfies("^1.2.3", "1.9.9"));
+ }
+
+ #[test]
+ fn test_tilde_lower_minus_one_no_match() {
+ assert!(!satisfies("~1.2.3", "1.2.2"));
+ }
+
+ #[test]
+ fn test_tilde_upper_minus_one_matches() {
+ assert!(satisfies("~1.2.3", "1.2.9"));
+ }
+
+ // ══════════════════════════════════════════════════════════════════════════
+ // 5. INTERNAL FUNCTION TESTS (via public API)
+ // ══════════════════════════════════════════════════════════════════════════
+
+ // stability_rank() — tested via ordering since the function is private
+
+ #[test]
+ fn test_stability_rank_dev_via_ordering() {
+ // dev rank=50 (highest number = least stable), alpha rank=40
+ // So dev < alpha in version ordering terms
+ let dev = Version::parse("1.0.0-dev").unwrap();
+ let alpha = Version::parse("1.0.0-alpha1").unwrap();
+ assert!(dev < alpha, "dev should be less stable than alpha1");
+ }
+
+ #[test]
+ fn test_stability_rank_alpha_via_ordering() {
+ // alpha rank=40, beta rank=30
+ let alpha = Version::parse("1.0.0-alpha1").unwrap();
+ let beta = Version::parse("1.0.0-beta1").unwrap();
+ assert!(alpha < beta, "alpha should be less stable than beta");
+ }
+
+ #[test]
+ fn test_stability_rank_beta_via_ordering() {
+ // beta rank=30, RC rank=20
+ let beta = Version::parse("1.0.0-beta1").unwrap();
+ let rc = Version::parse("1.0.0-RC1").unwrap();
+ assert!(beta < rc, "beta should be less stable than RC");
+ }
+
+ #[test]
+ fn test_stability_rank_rc_via_ordering() {
+ // RC rank=20, stable rank=0
+ let rc = Version::parse("1.0.0-RC1").unwrap();
+ let stable = Version::parse("1.0.0").unwrap();
+ assert!(rc < stable, "RC should be less stable than stable");
+ }
+
+ #[test]
+ fn test_stability_rank_patch_via_ordering() {
+ // The Ord impl: (None, Some(_)) => Greater.
+ // stable has pre_release=None; patch version has pre_release=Some("patch1").
+ // The None arm wins unconditionally: stable is always Greater than any pre_release.
+ // This means "patch" releases (post-release fixes) sort BELOW stable in this impl.
+ let patch_ver = Version::parse("1.0.0-patch1").unwrap();
+ let stable = Version::parse("1.0.0").unwrap();
+ assert!(
+ stable > patch_ver,
+ "stable (None pre_release) beats patch pre-release"
+ );
+ }
+
+ // normalize_pre_release() — tested via Version::parse pre_release field
+
+ #[test]
+ fn test_normalize_pre_release_b_to_beta() {
+ let v = Version::parse("1.0.0-b3").unwrap();
+ assert_eq!(v.pre_release, Some("beta3".to_string()));
+ }
+
+ #[test]
+ fn test_normalize_pre_release_a_to_alpha() {
+ let v = Version::parse("1.0.0-a1").unwrap();
+ assert_eq!(v.pre_release, Some("alpha1".to_string()));
+ }
+
+ #[test]
+ fn test_normalize_pre_release_rc_to_rc_uppercase() {
+ let v = Version::parse("1.0.0-rc").unwrap();
+ assert_eq!(v.pre_release, Some("RC".to_string()));
+ }
+
+ #[test]
+ fn test_normalize_pre_release_pl_to_patch() {
+ let v = Version::parse("1.0.0-pl2").unwrap();
+ assert_eq!(v.pre_release, Some("patch2".to_string()));
+ }
+
+ #[test]
+ fn test_normalize_pre_release_patch_explicit() {
+ let v = Version::parse("1.0.0-patch3").unwrap();
+ assert_eq!(v.pre_release, Some("patch3".to_string()));
+ }
+
+ // pre_release_number() — tested via ordering of numbered pre-releases
+
+ #[test]
+ fn test_pre_release_number_ordering_beta() {
+ // beta10 > beta2 if pre_release_number extracts correctly
+ let b10 = Version::parse("1.0.0-beta10").unwrap();
+ let b2 = Version::parse("1.0.0-beta2").unwrap();
+ assert!(b10 > b2);
+ }
+
+ #[test]
+ fn test_pre_release_number_ordering_rc() {
+ let rc5 = Version::parse("1.0.0-RC5").unwrap();
+ let rc1 = Version::parse("1.0.0-RC1").unwrap();
+ assert!(rc5 > rc1);
+ }
+
+ #[test]
+ fn test_pre_release_number_zero_when_missing() {
+ // "alpha" with no number → 0; "alpha1" → 1; alpha1 > alpha
+ let alpha1 = Version::parse("1.0.0-alpha1").unwrap();
+ let alpha = Version::parse("1.0.0-alpha").unwrap();
+ assert!(alpha1 > alpha);
+ }
+
+ // ══════════════════════════════════════════════════════════════════════════
+ // 6. COMPOSER BEHAVIORAL COMPATIBILITY
+ // ══════════════════════════════════════════════════════════════════════════
+
+ #[test]
+ fn test_composer_caret_four_matches_minor_bump() {
+ // ^4.0 matches 4.5.3
+ assert!(satisfies("^4.0", "4.5.3"));
+ }
+
+ #[test]
+ fn test_composer_caret_four_does_not_match_next_major() {
+ assert!(!satisfies("^4.0", "5.0.0"));
+ }
+
+ #[test]
+ fn test_composer_caret_zero_three_matches_patch() {
+ // ^0.3 matches 0.3.5 (same minor family)
+ assert!(satisfies("^0.3", "0.3.5"));
+ }
+
+ #[test]
+ fn test_composer_caret_zero_three_does_not_match_next_minor() {
+ // ^0.3 does NOT match 0.4.0
+ assert!(!satisfies("^0.3", "0.4.0"));
+ }
+
+ #[test]
+ fn test_composer_tilde_four_one_matches_within_major() {
+ // ~4.1 → >=4.1.0 <5.0.0 — matches 4.9.0
+ assert!(satisfies("~4.1", "4.9.0"));
+ }
+
+ #[test]
+ fn test_composer_tilde_four_one_does_not_match_next_major() {
+ // ~4.1 does NOT match 5.0.0
+ assert!(!satisfies("~4.1", "5.0.0"));
+ }
+
+ #[test]
+ fn test_composer_range_gap_matches_second_range() {
+ // ">=1.0 <1.1 || >=1.2" — gap at 1.1.x; 1.2.0 matches
+ assert!(satisfies(">=1.0 <1.1 || >=1.2", "1.2.0"));
+ }
+
+ #[test]
+ fn test_composer_range_gap_does_not_match_in_gap() {
+ // 1.1.5 is in the gap — should NOT match
+ assert!(!satisfies(">=1.0 <1.1 || >=1.2", "1.1.5"));
+ }
+
+ #[test]
+ fn test_composer_laravel_constraint_matches_v10() {
+ // "^8.0||^9.0||^10.0||^11.0" — Laravel-style; 10.48.22 matches
+ assert!(satisfies("^8.0||^9.0||^10.0||^11.0", "10.48.22"));
+ }
+
+ #[test]
+ fn test_composer_laravel_constraint_does_not_match_v7() {
+ assert!(!satisfies("^8.0||^9.0||^10.0||^11.0", "7.9.9"));
+ }
+
+ #[test]
+ fn test_composer_symfony_range_matches_6_4() {
+ // ">=5.4 <7.0" — Symfony; 6.4.5 matches
+ assert!(satisfies(">=5.4 <7.0", "6.4.5"));
+ }
+
+ #[test]
+ fn test_composer_symfony_range_does_not_match_7_0() {
+ assert!(!satisfies(">=5.4 <7.0", "7.0.0"));
+ }
+
+ #[test]
+ fn test_composer_not_equal_in_range() {
+ // ">=1.0 !=1.5.0 <2.0" — typical blacklist constraint
+ assert!(satisfies(">=1.0 !=1.5.0 <2.0", "1.4.9"));
+ assert!(!satisfies(">=1.0 !=1.5.0 <2.0", "1.5.0"));
+ assert!(satisfies(">=1.0 !=1.5.0 <2.0", "1.5.1"));
+ assert!(!satisfies(">=1.0 !=1.5.0 <2.0", "2.0.0"));
+ }
+
+ #[test]
+ fn test_composer_exact_major_minor_match() {
+ // exact "1.5.0" only matches 1.5.0
+ assert!(satisfies("1.5.0", "1.5.0"));
+ assert!(!satisfies("1.5.0", "1.5.1"));
+ }
+
+ // ══════════════════════════════════════════════════════════════════════════
+ // 7. DIVERGENCE INVESTIGATION
+ // ══════════════════════════════════════════════════════════════════════════
+
+ #[test]
+ fn test_hyphen_range_partial_upper_two_segment() {
+ // "1.0 - 2": upper is <=2.0.0 (parse "2" → 2.0.0.0, inclusive)
+ assert!(satisfies("1.0 - 2", "2.0.0"));
+ assert!(!satisfies("1.0 - 2", "2.0.1"));
+ assert!(!satisfies("1.0 - 2", "2.1.0"));
+ }
+
+ #[test]
+ fn test_caret_with_prerelease_suffix() {
+ // ^1.2.3-beta1 — the caret parser ignores pre-release in its bounds calculation
+ // because parse_caret works on the numeric parts only.
+ // Lower: dev_boundary(1,2,3,0). Upper: dev_boundary(2,0,0,0).
+ // 1.2.3-beta1 (pre_release=Some("beta1")) is >= lower boundary?
+ // dev_boundary uses pre_release=Some("dev"), so lower is (1,2,3,0,dev)
+ // Version 1.2.3-beta1 has same numeric, but beta > dev in stability terms
+ // so 1.2.3-beta1 >= lower (1.2.3-dev) is true.
+ assert!(satisfies("^1.2.3-beta1", "1.2.3-beta1"));
+ assert!(satisfies("^1.2.3-beta1", "1.5.0"));
+ assert!(!satisfies("^1.2.3-beta1", "2.0.0"));
+ }
+
+ #[test]
+ fn test_tilde_with_prerelease_suffix() {
+ // ~1.2.3-alpha1: lower = dev_boundary(1,2,3,0), upper = dev_boundary(1,3,0,0)
+ // 1.2.3-alpha1 has numeric (1,2,3,0); pre_release "alpha1" > "dev"
+ assert!(satisfies("~1.2.3-alpha1", "1.2.3-alpha1"));
+ assert!(satisfies("~1.2.3-alpha1", "1.2.9"));
+ assert!(!satisfies("~1.2.3-alpha1", "1.3.0"));
+ }
+
+ #[test]
+ fn test_dev_boundary_comparison() {
+ // Version::dev_boundary creates a version with pre_release=Some("dev") and
+ // is_dev_branch=false. These should sort correctly against real versions.
+ let lower = Version::dev_boundary(1, 0, 0, 0);
+ let v = Version::parse("1.0.0").unwrap();
+ // 1.0.0 (stable) > 1.0.0-dev (lower boundary)
+ assert!(v > lower);
+ }
+
+ #[test]
+ fn test_x_dev_ordering_within_range() {
+ // "2.x-dev" version has patch=9999999, build=9999999 and is a dev branch.
+ // Dev branches are always lowest. So "2.x-dev" < "2.0.0" < "3.0.0".
+ let x_dev = Version::parse("2.x-dev").unwrap();
+ let stable = Version::parse("2.0.0").unwrap();
+ assert!(x_dev < stable);
+ }
+
+ #[test]
+ fn test_four_segment_vs_three_segment_constraint() {
+ // "1.2.3.4" exact constraint — matches only 1.2.3.4, not 1.2.3
+ assert!(satisfies("1.2.3.4", "1.2.3.4"));
+ assert!(!satisfies("1.2.3.4", "1.2.3"));
+ assert!(!satisfies("1.2.3.4", "1.2.3.5"));
+ }
+
+ #[test]
+ fn test_date_style_version_ordering() {
+ // Date-based versioning: 20230101 > 20220101
+ let a = Version::parse("20230101.0.0").unwrap();
+ let b = Version::parse("20220101.0.0").unwrap();
+ assert!(a > b);
+ }
}
generated by cgit v1.3.1 (git 2.54.0) at 2026-06-03 23:46:34 +0000