Fix get_max_profit/get_max_loss for single-leg strategies

src/strategies/long_call.rs

@@ -1,7 +1,6 @@
 use super::base::{BreakEvenable, Positionable, StrategyType};
 use crate::backtesting::results::{SimulationResult, SimulationStatsResult};
 use crate::chains::OptionChain;
-use crate::error::strategies::ProfitLossErrorKind;
 use crate::error::{
     GreeksError, PricingError, ProbabilityError, SimulationError, StrategyError,
     position::{PositionError, PositionValidationErrorKind},
@@ -277,28 +276,11 @@ impl BreakEvenable for LongCall {
 
 impl Strategies for LongCall {
     fn get_max_profit(&self) -> Result<Positive, StrategyError> {
-        let profit = self.calculate_profit_at(&self.long_call.option.strike_price)?;
-        if profit >= Decimal::ZERO {
-            Ok(Positive::new_decimal(profit)?)
-        } else {
-            Err(StrategyError::ProfitLossError(
-                ProfitLossErrorKind::MaxProfitError {
-                    reason: "Net premium received is negative".to_string(),
-                },
-            ))
-        }
+        Ok(Positive::INFINITY) // Theoretically unlimited
     }
     fn get_max_loss(&self) -> Result<Positive, StrategyError> {
-        let loss = self.calculate_profit_at(&self.long_call.option.strike_price)?;
-        if loss <= Decimal::ZERO {
-            Ok(Positive::new_decimal(loss.abs()).unwrap_or(Positive::ZERO))
-        } else {
-            Err(StrategyError::ProfitLossError(
-                ProfitLossErrorKind::MaxLossError {
-                    reason: "Max loss is negative".to_string(),
-                },
-            ))
-        }
+        // Max loss for a long call is the premium paid (at any price ≤ strike).
+        Ok(self.get_total_cost()?)
     }
     fn get_profit_area(&self) -> Result<Decimal, StrategyError> {
         let high = self.get_max_profit().unwrap_or(Positive::ZERO);

src/strategies/long_put.rs

@@ -274,28 +274,21 @@ impl BreakEvenable for LongPut {
 
 impl Strategies for LongPut {
     fn get_max_profit(&self) -> Result<Positive, StrategyError> {
-        let profit = self.calculate_profit_at(&self.long_put.option.strike_price)?;
+        // Max profit for a long put occurs at price = 0: strike - premium.
+        let profit = self.calculate_profit_at(&Positive::ZERO)?;
         if profit >= Decimal::ZERO {
             Ok(Positive::new_decimal(profit)?)
         } else {
             Err(StrategyError::ProfitLossError(
                 ProfitLossErrorKind::MaxProfitError {
-                    reason: "Net premium received is negative".to_string(),
+                    reason: "Max profit is negative".to_string(),
                 },
             ))
         }
     }
     fn get_max_loss(&self) -> Result<Positive, StrategyError> {
-        let loss = self.calculate_profit_at(&self.long_put.option.strike_price)?;
-        if loss <= Decimal::ZERO {
-            Ok(Positive::new_decimal(loss.abs()).unwrap_or(Positive::ZERO))
-        } else {
-            Err(StrategyError::ProfitLossError(
-                ProfitLossErrorKind::MaxLossError {
-                    reason: "Max loss is negative".to_string(),
-                },
-            ))
-        }
+        // Max loss for a long put is the premium paid (at any price ≥ strike).
+        Ok(self.get_total_cost()?)
     }
     fn get_profit_area(&self) -> Result<Decimal, StrategyError> {
         let high = self.get_max_profit().unwrap_or(Positive::ZERO);

src/strategies/short_call.rs

@@ -2,7 +2,6 @@ use super::base::{BreakEvenable, Positionable, StrategyType};
 use crate::backtesting::results::{SimulationResult, SimulationStatsResult};
 
 use crate::chains::OptionChain;
-use crate::error::strategies::ProfitLossErrorKind;
 use crate::error::{
     GreeksError, PricingError, ProbabilityError, SimulationError, StrategyError,
     position::{PositionError, PositionValidationErrorKind},
@@ -289,24 +288,11 @@ impl BreakEvenable for ShortCall {
 
 impl Strategies for ShortCall {
     fn get_max_profit(&self) -> Result<Positive, StrategyError> {
-        let profit = self.calculate_profit_at(&self.short_call.option.strike_price)?;
-        if profit >= Decimal::ZERO {
-            Ok(Positive::new_decimal(profit)?)
-        } else {
-            Err(StrategyError::ProfitLossError(
-                ProfitLossErrorKind::MaxProfitError {
-                    reason: "Net premium received is negative".to_string(),
-                },
-            ))
-        }
+        // Max profit for a short call is the net premium received (at any price ≤ strike).
+        self.get_net_premium_received()
     }
     fn get_max_loss(&self) -> Result<Positive, StrategyError> {
-        // Max loss for a short call is theoretically unlimited.
-        Err(StrategyError::ProfitLossError(
-            ProfitLossErrorKind::MaxLossError {
-                reason: "Maximum loss is unlimited for a short call.".to_string(),
-            },
-        ))
+        Ok(Positive::INFINITY) // Theoretically unlimited
     }
     fn get_profit_area(&self) -> Result<Decimal, StrategyError> {
         let high = self.get_max_profit().unwrap_or(Positive::ZERO);

src/strategies/short_put.rs

@@ -279,19 +279,12 @@ impl BreakEvenable for ShortPut {
 
 impl Strategies for ShortPut {
     fn get_max_profit(&self) -> Result<Positive, StrategyError> {
-        let profit = self.calculate_profit_at(&self.short_put.option.strike_price)?;
-        if profit >= Decimal::ZERO {
-            Ok(Positive::new_decimal(profit)?)
-        } else {
-            Err(StrategyError::ProfitLossError(
-                ProfitLossErrorKind::MaxProfitError {
-                    reason: "Net premium received is negative".to_string(),
-                },
-            ))
-        }
+        // Max profit for a short put is the net premium received (at any price ≥ strike).
+        self.get_net_premium_received()
     }
     fn get_max_loss(&self) -> Result<Positive, StrategyError> {
-        let loss = self.calculate_profit_at(&self.short_put.option.strike_price)?;
+        // Max loss for a short put occurs at price = 0: strike - premium.
+        let loss = self.calculate_profit_at(&Positive::ZERO)?;
         if loss <= Decimal::ZERO {
             Ok(Positive::new_decimal(loss.abs()).unwrap_or(Positive::ZERO))
         } else {

tests/unit/strategies/long_call_test.rs

@@ -188,36 +188,9 @@ fn test_long_call_break_even_points() {
 #[test]
 fn test_long_call_get_max_profit() {
     let long_call = create_test_long_call();
-    let result = long_call.get_max_profit();
-    // For a Long Call, the maximum profit is theoretically infinite
-    // but in practice it depends on the implementation
-    match result {
-        Ok(profit) => {
-            // Verify that the maximum profit is positive
-            assert!(profit > Positive::ZERO);
-            // For a long call with strike 100, premium 5, and underlying at 100,
-            // the profit at a very high price like 200 would be approximately:
-            // (200 - 100) - 5 - 0.5 - 0.5 = 94
-            // This is a rough approximation of what the max profit could be
-            let expected_min_profit = Positive::new(90.0).unwrap();
-            assert!(
-                profit >= expected_min_profit,
-                "Max profit should be at least {expected_min_profit}"
-            );
-        }
-        Err(e) => {
-            // If there is an error, it could be due to various reasons related to profit calculation
-            // The actual error message might vary depending on implementation
-            assert!(
-                e.to_string().contains("profit")
-                    || e.to_string().contains("Profit")
-                    || e.to_string().contains("premium")
-                    || e.to_string().contains("infinite")
-                    || e.to_string().contains("unlimited"),
-                "Error message should be related to profit calculation: {e}"
-            );
-        }
-    }
+    let max_profit = long_call.get_max_profit().unwrap();
+    // Long Call has theoretically unlimited upside
+    assert_eq!(max_profit, Positive::INFINITY);
 }
 
 #[test]
@@ -331,7 +304,10 @@ fn test_long_call_get_positions() {
 #[test]
 fn test_long_call_get_profit_ratio() {
     let long_call = create_test_long_call();
-
     let ratio = long_call.get_profit_ratio().unwrap();
-    assert_eq!(ratio, Decimal::ZERO);
+    // max_profit = INFINITY, so INFINITY / max_loss * 100 overflows Decimal → unwrap_or(ZERO)
+    assert!(
+        ratio < Decimal::new(1, 1),
+        "Expected near-zero ratio for unlimited profit strategy, got {ratio}"
+    );
 }

tests/unit/strategies/long_put_test.rs

@@ -189,66 +189,19 @@ fn test_long_put_break_even_points() {
 #[test]
 fn test_long_put_get_max_profit() {
     let long_put = create_test_long_put();
-    let result = long_put.get_max_profit();
-
-    // For a Long Put, the maximum profit is the strike price minus the premium and fees
-    match result {
-        Ok(profit) => {
-            // Verify that the maximum profit is positive
-            assert!(profit > Positive::ZERO);
-
-            // For a long put with strike 100, premium 5, and fees 1,
-            // the max profit would be approximately: 100 - 5 - 0.5 - 0.5 = 94
-            let expected_profit = Positive::new(94.0).unwrap();
-            assert!(
-                (profit.to_f64() - expected_profit.to_f64()).abs() < 1.0,
-                "Max profit should be close to {expected_profit}, but was {profit}"
-            );
-        }
-        Err(e) => {
-            // If there is an error, it could be due to various reasons related to profit calculation
-            assert!(
-                e.to_string().contains("profit")
-                    || e.to_string().contains("Profit")
-                    || e.to_string().contains("premium")
-                    || e.to_string().contains("infinite")
-                    || e.to_string().contains("unlimited"),
-                "Error message should be related to profit calculation: {e}"
-            );
-        }
-    }
+    let max_profit = long_put.get_max_profit().unwrap();
+    // Max profit for a long put: strike - premium - fees = 100 - 5 - 0.5 - 0.5 = 94
+    let expected_profit = Positive::new(94.0).unwrap();
+    assert_eq!(max_profit, expected_profit);
 }
 
 #[test]
 fn test_long_put_get_max_loss() {
     let long_put = create_test_long_put();
-    let result = long_put.get_max_loss();
-
-    // For a Long Put, the maximum loss is limited to the premium paid plus fees
-    match result {
-        Ok(loss) => {
-            // Verify that the maximum loss is positive
-            assert!(loss > Positive::ZERO);
-
-            // For a long put with premium 5 and fees 0.5 + 0.5 = 1, the max loss should be 6
-            let expected_max_loss = Positive::new(6.0).unwrap();
-            assert!(
-                (loss.to_f64() - expected_max_loss.to_f64()).abs() < 1.0,
-                "Max loss should be close to {expected_max_loss}, but was {loss}"
-            );
-        }
-        Err(e) => {
-            // If there is an error, it could be due to various reasons related to loss calculation
-            assert!(
-                e.to_string().contains("loss")
-                    || e.to_string().contains("Loss")
-                    || e.to_string().contains("negative")
-                    || e.to_string().contains("infinite")
-                    || e.to_string().contains("unlimited"),
-                "Error message should be related to loss calculation: {e}"
-            );
-        }
-    }
+    let max_loss = long_put.get_max_loss().unwrap();
+    // Max loss for a long put is the total cost: premium + fees = 5 + 0.5 + 0.5 = 6
+    let expected_max_loss = Positive::new(6.0).unwrap();
+    assert_eq!(max_loss, expected_max_loss);
 }
 
 #[test]
@@ -357,29 +310,12 @@ fn test_long_put_get_positions() {
 #[test]
 fn test_long_put_get_profit_ratio() {
     let long_put = create_test_long_put();
-
-    // The profit/loss ratio can be positive, zero, or even undefined
-    // depending on how the calculation is implemented
-    match long_put.get_profit_ratio() {
-        Ok(ratio) => {
-            // If a ratio is returned, we simply verify that it exists
-            // The actual ratio may vary depending on implementation details
-            assert!(
-                ratio >= Decimal::ZERO,
-                "Profit ratio should be non-negative, but was {ratio}"
-            );
-        }
-        Err(e) => {
-            // If there is an error, we verify that it's because the ratio is undefined
-            // (for example, if the maximum loss is zero or the profit is infinite)
-            assert!(
-                e.to_string().contains("division")
-                    || e.to_string().contains("infinite")
-                    || e.to_string().contains("undefined"),
-                "Error message should indicate an issue with ratio calculation: {e}"
-            );
-        }
-    }
+    let ratio = long_put.get_profit_ratio().unwrap();
+    // Max profit (94) / Max loss (6) * 100 ≈ 1566.67%
+    assert!(
+        ratio > Decimal::ZERO,
+        "Profit ratio should be positive, got {ratio}"
+    );
 }
 
 #[test]

tests/unit/strategies/short_call_test.rs

@@ -1,8 +1,6 @@
 use chrono::Utc;
 use optionstratlib::{
     ExpirationDate, Options,
-    error::StrategyError,
-    error::strategies::ProfitLossErrorKind,
     model::{
         position::Position,
         types::{OptionStyle, OptionType, Side},
@@ -164,16 +162,9 @@ fn test_short_call_get_max_profit() {
 fn test_short_call_get_max_loss() {
     let short_call = create_test_short_call();
     let result = short_call.get_max_loss();
-    assert!(result.is_err());
-    match result.err().unwrap() {
-        StrategyError::ProfitLossError(kind) => match kind {
-            ProfitLossErrorKind::MaxLossError { reason } => {
-                assert!(reason.to_lowercase().contains("unlimited"));
-            }
-            _ => panic!("Expected MaxLossError, got {kind:?}"),
-        },
-        e => panic!("Expected ProfitLossError, got {e:?}"),
-    }
+    // Max loss for a short call is theoretically unlimited (Positive::INFINITY).
+    assert!(result.is_ok());
+    assert_eq!(result.unwrap(), Positive::INFINITY);
 }
 
 #[test]
@@ -300,12 +291,11 @@ fn test_short_call_get_positions() {
 fn test_short_call_get_profit_ratio() {
     let short_call = create_test_short_call();
     let ratio_result = short_call.get_profit_ratio();
-    // For a short call, max loss is unlimited, so profit ratio should be Decimal::MAX (or an error if not handled gracefully)
-    // The current implementation returns Decimal::MAX if max_loss is zero, which is not the case here.
-    // If max_profit > 0 and max_loss is effectively infinite (represented by an error), then the ratio is effectively zero or very small.
-    // However, the current `short_call.get_max_loss()` returns an error because loss is unlimited.
-    // The `get_profit_ratio` in `short_call.rs` handles this by returning Decimal::MAX if `get_max_loss` is an error (interpreted as max_loss -> infinity, so profit/infinity -> 0, but the code has it as Decimal::MAX)
-    // Let's adjust the expectation based on the `ShortCall` implementation of `get_profit_ratio`.
+    // Max loss is Positive::INFINITY, so profit_ratio = max_profit / INFINITY * 100 ≈ 0.
     assert!(ratio_result.is_ok());
-    assert_eq!(ratio_result.unwrap(), Decimal::MAX); // Based on current ShortCall impl
+    let ratio = ratio_result.unwrap();
+    assert!(
+        ratio < Decimal::new(1, 1),
+        "Expected near-zero ratio, got {ratio}"
+    );
 }

tests/unit/strategies/short_put_test.rs

@@ -199,40 +199,10 @@ fn test_short_put_get_max_profit() {
 #[test]
 fn test_short_put_get_max_loss() {
     let short_put = create_test_short_put();
-    let result = short_put.get_max_loss();
-
-    // For a Short Put, the maximum loss can be the strike price minus the premium received
-    // or it can be theoretically infinite if the underlying reaches zero
-    match result {
-        Ok(loss) => {
-            // If a value is returned, verify that it is positive
-            assert!(loss > Positive::ZERO);
-
-            // If we want to be more specific, we can verify that it is close to the expected value
-            // In this case: 100 (strike) - 5 (premium) + 0.5 + 0.5 (fees) = 96
-            let expected_max_loss = Positive::new(96.0).unwrap();
-            assert!(
-                (loss.to_f64() - expected_max_loss.to_f64()).abs() < 1.0,
-                "Max loss should be close to {expected_max_loss}, but was {loss}"
-            );
-
-            // Also verify that the loss is less than the strike price
-            let strike = Positive::new(100.0).unwrap();
-            assert!(loss < strike, "Max loss should be less than strike price");
-        }
-        Err(e) => {
-            // If there is an error, it could be due to various reasons related to loss calculation
-            // The actual error message might vary depending on implementation
-            assert!(
-                e.to_string().contains("loss")
-                    || e.to_string().contains("Loss")
-                    || e.to_string().contains("negative")
-                    || e.to_string().contains("infinite")
-                    || e.to_string().contains("unlimited"),
-                "Error message should be related to loss calculation: {e}"
-            );
-        }
-    }
+    let max_loss = short_put.get_max_loss().unwrap();
+    // Max loss for a short put: strike - premium + fees = 100 - 5 + 0.5 + 0.5 = 96
+    let expected_max_loss = Positive::new(96.0).unwrap();
+    assert_eq!(max_loss, expected_max_loss);
 }
 
 #[test]