appraisal.rs: Factor out comparing assets to separate function

Author: alexdewar

src/asset.rs

@@ -195,6 +195,32 @@ impl Asset {
         )
     }
 
+    /// Create a new commissioned asset
+    ///
+    /// This is only used for testing. WARNING: These assets always have an ID of zero, so can
+    /// create hash collisions. Use with care.
+    #[cfg(test)]
+    pub fn new_commissioned(
+        agent_id: AgentID,
+        process: Rc<Process>,
+        region_id: RegionID,
+        capacity: Capacity,
+        commission_year: u32,
+    ) -> Result<Self> {
+        Self::new_with_state(
+            AssetState::Commissioned {
+                id: AssetID(0),
+                agent_id,
+                mothballed_year: None,
+            },
+            process,
+            region_id,
+            capacity,
+            commission_year,
+            None,
+        )
+    }
+
     /// Private helper to create an asset with the given state
     fn new_with_state(
         state: AssetState,

src/simulation/investment/appraisal.rs

@@ -1,7 +1,7 @@
 //! Calculation for investment tools such as Levelised Cost of X (LCOX) and Net Present Value (NPV).
 use super::DemandMap;
 use crate::agent::ObjectiveType;
-use crate::asset::AssetRef;
+use crate::asset::{Asset, AssetRef};
 use crate::commodity::Commodity;
 use crate::finance::{lcox, profitability_index};
 use crate::model::Model;
@@ -67,25 +67,28 @@ impl AppraisalOutput {
             "Appraisal metrics must be equal"
         );
 
-        // Favour commissioned assets over non-commissioned
-        if self.asset.is_commissioned() && !other.asset.is_commissioned() {
-            return Ordering::Less;
-        }
-        if !self.asset.is_commissioned() && other.asset.is_commissioned() {
-            return Ordering::Greater;
-        }
+        compare_asset_fallback(&self.asset, &other.asset)
+    }
+}
 
-        // if both commissioned, favour newer ones
-        if self.asset.is_commissioned() && other.asset.is_commissioned() {
-            return self
-                .asset
-                .commission_year()
-                .cmp(&other.asset.commission_year())
-                .reverse();
-        }
+fn compare_asset_fallback(asset1: &Asset, asset2: &Asset) -> Ordering {
+    // Favour commissioned assets over non-commissioned
+    if asset1.is_commissioned() && !asset2.is_commissioned() {
+        return Ordering::Less;
+    }
+    if !asset1.is_commissioned() && asset2.is_commissioned() {
+        return Ordering::Greater;
+    }
 
-        Ordering::Equal
+    // if both commissioned, favour newer ones
+    if asset1.is_commissioned() && asset2.is_commissioned() {
+        return asset1
+            .commission_year()
+            .cmp(&asset2.commission_year())
+            .reverse();
     }
+
+    Ordering::Equal
 }
 
 /// Calculate LCOX for a hypothetical investment in the given asset.
@@ -192,3 +195,44 @@ pub fn appraise_investment(
     };
     appraisal_method(model, asset, max_capacity, commodity, coefficients, demand)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::agent::AgentID;
+    use crate::asset::Asset;
+    use crate::fixture::{agent_id, process, region_id};
+    use crate::process::Process;
+    use crate::region::RegionID;
+    use crate::units::Capacity;
+    use rstest::rstest;
+    use std::rc::Rc;
+
+    #[rstest]
+    fn test_compare_assets_fallback(process: Process, region_id: RegionID, agent_id: AgentID) {
+        let process = Rc::new(process);
+        let capacity = Capacity(2.0);
+        let asset1 = Asset::new_commissioned(
+            agent_id.clone(),
+            process.clone(),
+            region_id.clone(),
+            capacity,
+            2015,
+        )
+        .unwrap();
+        let asset2 =
+            Asset::new_candidate(process.clone(), region_id.clone(), capacity, 2015).unwrap();
+        let asset3 =
+            Asset::new_commissioned(agent_id, process, region_id.clone(), capacity, 2010).unwrap();
+
+        assert!(compare_asset_fallback(&asset1, &asset1).is_eq());
+        assert!(compare_asset_fallback(&asset2, &asset2).is_eq());
+        assert!(compare_asset_fallback(&asset3, &asset3).is_eq());
+        assert!(compare_asset_fallback(&asset1, &asset2).is_lt());
+        assert!(compare_asset_fallback(&asset2, &asset1).is_gt());
+        assert!(compare_asset_fallback(&asset1, &asset3).is_lt());
+        assert!(compare_asset_fallback(&asset3, &asset1).is_gt());
+        assert!(compare_asset_fallback(&asset3, &asset2).is_lt());
+        assert!(compare_asset_fallback(&asset2, &asset3).is_gt());
+    }
+}