test: strengthen round-trip validation and simplify fixtures

Author: GiggleLiu

examples/regenerate_fixtures.rs

@@ -1,13 +1,15 @@
 /// Regenerate example database fixture files from builder code.
 ///
 /// This binary recomputes all model and rule examples using BruteForce/ILP
-/// and writes the results to `src/example_db/fixtures/`. Run this in release
-/// mode after changing any model or rule to update the stored expected results:
+/// and writes them to `src/example_db/fixtures/` as JSON Lines, one example per
+/// line. Run this in release mode after changing any model or rule to update
+/// the stored expected results:
 ///
 /// ```
 /// cargo run --release --example regenerate_fixtures --features example-db
 /// ```
 use problemreductions::example_db::{compute_model_db, compute_rule_db};
+use problemreductions::export::{write_model_db_to, write_rule_db_to};
 use std::fs;
 use std::path::Path;
 
@@ -21,11 +23,8 @@ fn main() {
     let models_path = fixtures_dir.join("models.json");
     let rules_path = fixtures_dir.join("rules.json");
 
-    let models_json = serde_json::to_string(&model_db).expect("Failed to serialize models");
-    let rules_json = serde_json::to_string(&rule_db).expect("Failed to serialize rules");
-
-    fs::write(&models_path, &models_json).expect("Failed to write models fixture");
-    fs::write(&rules_path, &rules_json).expect("Failed to write rules fixture");
+    write_model_db_to(&fixtures_dir, &model_db);
+    write_rule_db_to(&fixtures_dir, &rule_db);
 
     println!(
         "Regenerated fixtures: {} rule examples, {} model examples",

src/example_db/fixtures/models.json

@@ -3,8 +3,9 @@
 //! The example database has two layers:
 //!
 //! - **Fixtures** (`fixtures/models.json`, `fixtures/rules.json`): pre-computed
-//!   expected results embedded at compile time. These are the "stored expected
-//!   results" used for fast export and lookups.
+//!   expected results embedded at compile time as JSON Lines, one example per
+//!   line. These are the "stored expected results" used for fast export and
+//!   lookups.
 //!
 //! - **Builders** (`model_builders`, `rule_builders`): code that constructs
 //!   problem instances and computes solutions via BruteForce/ILP. Used only
@@ -15,7 +16,8 @@
 
 use crate::error::{ProblemError, Result};
 use crate::export::{
-    examples_output_dir, ModelDb, ModelExample, ProblemRef, RuleDb, RuleExample, EXAMPLE_DB_VERSION,
+    examples_output_dir, parse_model_db_json_lines, parse_rule_db_json_lines, ModelDb,
+    ModelExample, ProblemRef, RuleDb, RuleExample,
 };
 use std::collections::BTreeSet;
 use std::path::PathBuf;
@@ -65,17 +67,15 @@ fn validate_model_uniqueness(models: &[ModelExample]) -> Result<()> {
 /// Load the model database from the embedded fixture file.
 pub fn build_model_db() -> Result<ModelDb> {
     static MODELS_JSON: &str = include_str!("fixtures/models.json");
-    let db: ModelDb =
-        serde_json::from_str(MODELS_JSON).expect("embedded models fixture should parse");
+    let db = parse_model_db_json_lines(MODELS_JSON);
     validate_model_uniqueness(&db.models)?;
     Ok(db)
 }
 
 /// Load the rule database from the embedded fixture file.
 pub fn build_rule_db() -> Result<RuleDb> {
     static RULES_JSON: &str = include_str!("fixtures/rules.json");
-    let db: RuleDb =
-        serde_json::from_str(RULES_JSON).expect("embedded rules fixture should parse");
+    let db = parse_rule_db_json_lines(RULES_JSON);
     validate_rule_uniqueness(&db.rules)?;
     Ok(db)
 }
@@ -87,21 +87,15 @@ pub fn compute_model_db() -> Result<ModelDb> {
     let mut models = model_builders::build_model_examples();
     models.sort_by_key(model_key);
     validate_model_uniqueness(&models)?;
-    Ok(ModelDb {
-        version: EXAMPLE_DB_VERSION,
-        models,
-    })
+    Ok(ModelDb { models })
 }
 
 /// Recompute the rule database from builder code (runs BruteForce/ILP).
 pub fn compute_rule_db() -> Result<RuleDb> {
     let mut rules = rule_builders::build_rule_examples();
     rules.sort_by_key(rule_key);
     validate_rule_uniqueness(&rules)?;
-    Ok(RuleDb {
-        version: EXAMPLE_DB_VERSION,
-        rules,
-    })
+    Ok(RuleDb { rules })
 }
 
 pub fn find_rule_example(source: &ProblemRef, target: &ProblemRef) -> Result<RuleExample> {

src/example_db/fixtures/rules.json

@@ -4,6 +4,7 @@ use crate::expr::Expr;
 use crate::rules::registry::ReductionOverhead;
 use crate::rules::ReductionGraph;
 use crate::traits::Problem;
+use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 use std::env;
@@ -118,19 +119,15 @@ impl ModelExample {
 /// Canonical exported database of rule examples.
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 pub struct RuleDb {
-    pub version: u32,
     pub rules: Vec<RuleExample>,
 }
 
 /// Canonical exported database of model examples.
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 pub struct ModelDb {
-    pub version: u32,
     pub models: Vec<ModelExample>,
 }
 
-pub const EXAMPLE_DB_VERSION: u32 = 1;
-
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 pub struct SampleEval {
     pub config: Vec<usize>,
@@ -198,6 +195,50 @@ fn write_json_file<T: Serialize>(dir: &Path, name: &str, payload: &T) {
     println!("Exported: {}", path.display());
 }
 
+fn parse_json_lines<T>(json_lines: &str, label: &str) -> Vec<T>
+where
+    T: DeserializeOwned,
+{
+    json_lines
+        .lines()
+        .enumerate()
+        .filter_map(|(index, line)| {
+            let line = line.trim();
+            if line.is_empty() {
+                return None;
+            }
+            Some(serde_json::from_str(line).unwrap_or_else(|err| {
+                panic!("Failed to parse {label} fixture line {}: {err}", index + 1)
+            }))
+        })
+        .collect()
+}
+
+fn write_json_lines_file<T: Serialize>(dir: &Path, name: &str, values: &[T]) {
+    fs::create_dir_all(dir).expect("Failed to create examples directory");
+    let path = dir.join(format!("{name}.json"));
+    let mut json_lines = String::new();
+    for value in values {
+        let line = serde_json::to_string(value).expect("Failed to serialize JSON line");
+        json_lines.push_str(&line);
+        json_lines.push('\n');
+    }
+    fs::write(&path, json_lines).expect("Failed to write example JSON lines");
+    println!("Exported: {}", path.display());
+}
+
+pub(crate) fn parse_rule_db_json_lines(json_lines: &str) -> RuleDb {
+    RuleDb {
+        rules: parse_json_lines(json_lines, "rule"),
+    }
+}
+
+pub(crate) fn parse_model_db_json_lines(json_lines: &str) -> ModelDb {
+    ModelDb {
+        models: parse_json_lines(json_lines, "model"),
+    }
+}
+
 /// Write a merged rule example JSON file.
 pub fn write_rule_example_to(dir: &Path, name: &str, example: &RuleExample) {
     write_json_file(dir, name, example);
@@ -220,12 +261,12 @@ pub fn write_model_example(name: &str, example: &ModelExample) {
 
 /// Write the canonical rule database to `rules.json`.
 pub fn write_rule_db_to(dir: &Path, db: &RuleDb) {
-    write_json_file(dir, "rules", db);
+    write_json_lines_file(dir, "rules", &db.rules);
 }
 
 /// Write the canonical model database to `models.json`.
 pub fn write_model_db_to(dir: &Path, db: &ModelDb) {
-    write_json_file(dir, "models", db);
+    write_json_lines_file(dir, "models", &db.models);
 }
 
 #[cfg(test)]

src/example_db/mod.rs

@@ -36,6 +36,8 @@ pub(crate) mod spinglass_maxcut;
 pub(crate) mod spinglass_qubo;
 mod traits;
 pub(crate) mod travelingsalesman_qubo;
+#[cfg(test)]
+pub(crate) mod test_helpers;
 
 pub mod unitdiskmapping;