get tests failing again (yay?)

Author: spanishpear

crates/berry-bench-bin/src/main.rs

@@ -46,6 +46,7 @@ struct BenchmarkResult {
   virtual_usage_bytes: Option<usize>,
 }
 
+#[allow(clippy::cast_precision_loss)]
 fn calculate_stats(times: &[f64]) -> (f64, f64, f64, f64) {
   let mean = times.iter().sum::<f64>() / times.len() as f64;
   let variance = times.iter().map(|&x| (x - mean).powi(2)).sum::<f64>() / times.len() as f64;

crates/berry-core/src/parse.rs

@@ -1316,4 +1316,83 @@ __metadata:
       }
     }
   }
+
+  #[test]
+  fn test_parse_peer_dependencies_meta_real_format() {
+    // Test parsing the actual format found in resolutions-patches.yarn.lock
+    // This demonstrates the parsing issue where the parser fails on real-world data
+    let input = r"  peerDependenciesMeta:
+    graphql-ws:
+      optional: true
+    react:
+      optional: true
+    react-dom:
+      optional: true
+    subscriptions-transport-ws:
+      optional: true
+";
+
+    let result = parse_peer_dependencies_meta_block(input);
+
+    match result {
+      Ok((remaining, meta)) => {
+        println!("Successfully parsed peerDependenciesMeta: {meta:?}");
+        println!("Remaining: '{remaining}'");
+        assert_eq!(meta.len(), 4, "Should parse 4 peer dependency meta entries");
+        assert!(remaining.is_empty(), "Should consume all input");
+      }
+      Err(e) => {
+        println!("Failed to parse peerDependenciesMeta: {e:?}");
+        // This test is expected to fail, demonstrating the parsing issue
+        // The parser should be fixed to handle this real-world format
+        panic!("Parser fails on real-world peerDependenciesMeta format: {e:?}");
+      }
+    }
+  }
+
+  #[test]
+  fn test_parse_package_with_peer_dependencies_meta_real_format() {
+    // Test parsing a complete package entry with the real peerDependenciesMeta format
+    let input = r#"  version: 6.0.0
+  resolution: "@actions/github@npm:6.0.0"
+  dependencies:
+    "@actions/http-client": "npm:^2.2.0"
+    "@octokit/core": "npm:^5.0.1"
+    "@octokit/plugin-paginate-rest": "npm:^9.0.0"
+    "@octokit/plugin-rest-endpoint-methods": "npm:^10.0.0"
+  peerDependenciesMeta:
+    graphql-ws:
+      optional: true
+    react:
+      optional: true
+    react-dom:
+      optional: true
+    subscriptions-transport-ws:
+      optional: true
+  checksum: 10/d3744a5416c7ba33057b1ed247fa4b30da167a6b490898968e6e03870424906c3b4b1910829dc5b26622393e3f203b6ad26e7f6a2c2e9505dc0f9e915432482a
+  languageName: node
+  linkType: hard
+"#;
+
+    let result = parse_package_properties(input);
+
+    match result {
+      Ok((remaining, package)) => {
+        println!("Successfully parsed package with peerDependenciesMeta");
+        println!("Remaining: '{remaining}'");
+        assert_eq!(
+          package.peer_dependencies_meta.len(),
+          4,
+          "Should parse 4 peer dependency meta entries"
+        );
+        assert!(remaining.is_empty(), "Should consume all input");
+      }
+      Err(e) => {
+        println!("Failed to parse package with peerDependenciesMeta: {e:?}");
+        // This test is expected to fail, demonstrating the parsing issue
+        // The parser should be fixed to handle this real-world format
+        panic!("Parser fails on real-world package with peerDependenciesMeta: {e:?}");
+      }
+    }
+  }
 }

crates/berry-test/src/lib.rs

@@ -62,7 +62,42 @@ mod tests {
     let result = parse_lockfile(&contents);
     assert!(
       result.is_ok(),
-      "Should successfully parse minimal berry lockfile"
+      "Should successfully parse lockfile: {filename}"
+    );
+
+    let (remaining, lockfile) = result.unwrap();
+
+    // Critical validation: ensure the entire file was parsed
+    if !remaining.is_empty() {
+      println!(
+        "WARNING: {} bytes remaining unparsed in {}",
+        remaining.len(),
+        filename
+      );
+      println!(
+        "First 200 chars of unparsed content: '{}'",
+        &remaining[..remaining.len().min(200)]
+      );
+
+      // For now, we'll allow some unparsed content but log it
+      // TODO: Fix parser to handle all content properly
+      assert!(
+        remaining.len() <= 1000,
+        "Too much content remaining unparsed ({} bytes) in {}",
+        remaining.len(),
+        filename
+      );
+    }
+
+    // Verify we parsed at least some packages
+    assert!(
+      !lockfile.entries.is_empty(),
+      "Should parse at least one package from {filename}"
+    );
+
+    println!(
+      "Successfully parsed {} packages from {filename}",
+      lockfile.entries.len()
     );
   }
 

debug_parse/src/main.rs

@@ -0,0 +1,55 @@
+use berry_core::parse::parse_lockfile;
+use berry_test::load_fixture;
+
+fn main() {
+    let fixture = load_fixture("resolutions-patches.yarn.lock");
+    println!("File size: {} bytes", fixture.len());
+    println!("File lines: {}", fixture.lines().count());
+
+    // Show first 500 characters
+    println!("First 500 chars:");
+    println!("{}", &fixture[..fixture.len().min(500)]);
+
+    let result = parse_lockfile(&fixture);
+    match result {
+        Ok((rest, lockfile)) => {
+            println!("Parse successful!");
+            println!("Remaining unparsed: {} bytes", rest.len());
+            println!("Packages parsed: {}", lockfile.entries.len());
+            println!("Metadata version: {}", lockfile.metadata.version);
+
+            if !rest.is_empty() {
+                println!("First 500 chars of unparsed content:");
+                println!("{}", &rest[..rest.len().min(500)]);
+
+                // Find the first package entry in the unparsed content
+                if let Some(pos) = rest.find("\"@") {
+                    println!("First package entry in unparsed content (around position {}):", pos);
+                    let start = pos.saturating_sub(50);
+                    let end = (pos + 200).min(rest.len());
+                    println!("{}", &rest[start..end]);
+                }
+
+                // Test parsing the problematic section
+                println!("\nTesting problematic section:");
+                let problematic_section = "  peerDependenciesMeta:\n    graphql-ws:\n      optional: true\n    react:\n      optional: true\n    react-dom:\n      optional: true\n    subscriptions-transport-ws:\n      optional: true\n";
+                println!("Problematic section: {}", problematic_section);
+
+                // Try to parse this section manually
+                use berry_core::parse::parse_peer_dependencies_meta_block;
+                match parse_peer_dependencies_meta_block(problematic_section) {
+                    Ok((rest, meta)) => {
+                        println!("Successfully parsed peerDependenciesMeta: {:?}", meta);
+                        println!("Remaining: '{}'", rest);
+                    }
+                    Err(e) => {
+                        println!("Failed to parse peerDependenciesMeta: {:?}", e);
+                    }
+                }
+            }
+        }
+        Err(e) => {
+            println!("Parse failed: {:?}", e);
+        }
+    }
+}