Refactor: remove unwrap() in /src/model/ phase2 and phase3

src/error/chains.rs

@@ -544,6 +544,24 @@ impl ChainError {
             reason: reason.to_string(),
         })
     }
+
+    /// Creates a new error for invalid chain option data price calculation.
+    ///
+    /// This method constructs a `OptionDataError` with the `PriceCalculationError` variant when
+    /// parameters used to build an option chain fail to calculate the option price.
+    ///
+    /// # Parameters
+    ///
+    /// * `reason` - A description explaining why the option price failed to calculate
+    ///
+    /// # Returns
+    ///
+    /// A `ChainError` containing the parameter validation error details
+    pub fn invalid_price_calculation(reason: &str) -> Self {
+        ChainError::OptionDataError(OptionDataErrorKind::PriceCalculationError(
+            reason.to_string(),
+        ))
+    }
 }
 
 impl From<String> for ChainError {
@@ -766,6 +784,15 @@ mod tests_extended {
         ));
     }
 
+    #[test]
+    fn test_invalid_price_calculation_helper_method() {
+        let error = ChainError::invalid_price_calculation("Division by zero");
+        assert_eq!(
+            format!("{error}"),
+            "Option data error: Price calculation error: Division by zero"
+        );
+    }
+
     #[test]
     fn test_chain_error_file_error() {
         let error = ChainError::FileError(FileErrorKind::IOError(io::Error::new(

src/model/utils.rs

@@ -473,10 +473,14 @@ pub fn calculate_optimal_price_range(
 ) -> Result<(Positive, Positive), ChainError> {
     let days_to_expiry = expiration_date.get_days()?;
     let years_to_expiry = Decimal::from(days_to_expiry) / dec!(365.0);
+    let years_to_expiry_sqrt = years_to_expiry.sqrt().ok_or_else(|| {
+        ChainError::invalid_price_calculation(
+            "sqrt() failed to calculate for years_to_expiry value",
+        )
+    })?;
 
     let confidence_interval = dec!(4.0);
-    let volatility_factor =
-        implied_volatility * years_to_expiry.sqrt().unwrap() * confidence_interval;
+    let volatility_factor = implied_volatility * years_to_expiry_sqrt * confidence_interval;
 
     let lower_bound = underlying_price * (dec!(1.0) - volatility_factor);
     let upper_bound = underlying_price * (dec!(1.0) + volatility_factor);
@@ -683,3 +687,27 @@ mod tests_mean_and_std {
         assert_relative_eq!(std.to_f64(), 0.00907213, epsilon = 0.00000001);
     }
 }
+
+#[cfg(test)]
+mod tests_model_utils {
+    use super::*;
+
+    #[test]
+    fn test_calculate_optimal_price_range() {
+        let underlying_price = pos_or_panic!(100.0);
+        let strike_price = pos_or_panic!(90.0);
+        let implied_volatility = pos_or_panic!(0.20);
+        let expiration_date = ExpirationDate::Days(Positive::TWO);
+
+        let (min_price, max_price) = calculate_optimal_price_range(
+            underlying_price,
+            strike_price,
+            implied_volatility,
+            expiration_date,
+        )
+        .unwrap();
+
+        assert_eq!(min_price, pos_or_panic!(62.0));
+        assert_eq!(max_price, pos_or_panic!(118.0));
+    }
+}