Functionality to patch models with changes

src/fixture.rs

@@ -8,6 +8,7 @@ use crate::asset::{Asset, AssetPool, AssetRef};
 use crate::commodity::{
     Commodity, CommodityID, CommodityLevyMap, CommodityType, DemandMap, PricingStrategy,
 };
+use crate::patch::{FilePatch, ModelPatch};
 use crate::process::{
     ActivityLimits, Process, ProcessActivityLimitsMap, ProcessFlow, ProcessFlowsMap,
     ProcessInvestmentConstraintsMap, ProcessMap, ProcessParameter, ProcessParameterMap,
@@ -21,6 +22,7 @@ use crate::units::{
     Activity, ActivityPerCapacity, Capacity, Dimensionless, Flow, MoneyPerActivity,
     MoneyPerCapacity, MoneyPerCapacityPerYear, MoneyPerFlow, Year,
 };
+use anyhow::Result;
 use indexmap::indexmap;
 use indexmap::{IndexMap, IndexSet};
 use itertools::Itertools;
@@ -40,6 +42,44 @@ macro_rules! assert_error {
 }
 pub(crate) use assert_error;
 
+/// Build a patched copy of `examples/simple` to a temporary directory and return the `TempDir`.
+///
+/// If the patched model cannot be built, for whatever reason, this function will panic.
+pub(crate) fn build_patched_simple_tempdir(file_patches: Vec<FilePatch>) -> tempfile::TempDir {
+    ModelPatch::from_example("simple")
+        .with_file_patches(file_patches)
+        .build_to_tempdir()
+        .unwrap()
+}
+
+/// Check whether the simple example passes or fails validation after applying file patches
+macro_rules! patch_and_validate_simple {
+    ($file_patches:expr) => {{
+        (|| -> Result<()> {
+            let tmp = crate::fixture::build_patched_simple_tempdir($file_patches);
+            crate::input::load_model(tmp.path())?;
+            Ok(())
+        })()
+    }};
+}
+pub(crate) use patch_and_validate_simple;
+
+/// Check whether the simple example runs successfully after applying file patches
+macro_rules! patch_and_run_simple {
+    ($file_patches:expr) => {{
+        (|| -> Result<()> {
+            let tmp = crate::fixture::build_patched_simple_tempdir($file_patches);
+            let (model, assets) = crate::input::load_model(tmp.path())?;
+            let output_path = tmp.path().join("output");
+            std::fs::create_dir_all(&output_path)?;
+
+            crate::simulation::run(&model, assets, &output_path, false)?;
+            Ok(())
+        })()
+    }};
+}
+pub(crate) use patch_and_run_simple;
+
 #[fixture]
 pub fn region_id() -> RegionID {
     "GBR".into()
@@ -320,3 +360,34 @@ pub fn appraisal_output(asset: Asset, time_slice: TimeSliceID) -> AppraisalOutpu
         metric: 4.14,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn patch_and_validate_simple_smoke() {
+        let patches = Vec::new();
+        assert!(patch_and_validate_simple!(patches).is_ok());
+    }
+
+    #[test]
+    fn patch_and_run_simple_smoke() {
+        let patches = Vec::new();
+        assert!(patch_and_run_simple!(patches).is_ok());
+    }
+
+    #[test]
+    fn test_patch_and_validate_simple_fail() {
+        let patch = FilePatch::new("commodities.csv")
+            .with_deletion("RSHEAT,Residential heating,svd,daynight");
+        assert!(patch_and_validate_simple!(vec![patch]).is_err());
+    }
+
+    #[test]
+    fn test_patch_and_run_simple_fail() {
+        let patch = FilePatch::new("commodities.csv")
+            .with_deletion("RSHEAT,Residential heating,svd,daynight");
+        assert!(patch_and_run_simple!(vec![patch]).is_err());
+    }
+}

src/lib.rs

@@ -18,6 +18,7 @@ pub mod input;
 pub mod log;
 pub mod model;
 pub mod output;
+pub mod patch;
 pub mod process;
 pub mod region;
 pub mod settings;

src/model/parameters.rs

@@ -25,6 +25,22 @@ pub fn broken_model_options_allowed() -> bool {
         .expect("Broken options flag not set")
 }
 
+/// Set global flag signalling whether broken model options are allowed
+///
+/// Can only be called once; subsequent calls will panic (except in tests, where it can be called
+/// multiple times so long as the value is the same).
+fn set_broken_model_options_flag(allowed: bool) {
+    let result = BROKEN_OPTIONS_ALLOWED.set(allowed);
+    if result.is_err() {
+        if cfg!(test) {
+            // Sanity check
+            assert_eq!(allowed, broken_model_options_allowed());
+        } else {
+            panic!("Attempted to set BROKEN_OPTIONS_ALLOWED twice");
+        }
+    }
+}
+
 macro_rules! define_unit_param_default {
     ($name:ident, $type: ty, $value: expr) => {
         fn $name() -> $type {
@@ -157,10 +173,7 @@ impl ModelParameters {
         let file_path = model_dir.as_ref().join(MODEL_PARAMETERS_FILE_NAME);
         let model_params: ModelParameters = read_toml(&file_path)?;
 
-        // Set flag signalling whether broken model options are allowed or not
-        BROKEN_OPTIONS_ALLOWED
-            .set(model_params.allow_broken_options)
-            .unwrap(); // Will only fail if there is a race condition, which shouldn't happen
+        set_broken_model_options_flag(model_params.allow_broken_options);
 
         model_params
             .validate()