optionstratlib 0.17.3

OptionStratLib is a comprehensive Rust library for options trading and strategy development across multiple asset classes.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use optionstratlib::error::{CurveError, MetricsError, SurfaceError};

#[test]
fn test_metrics_error_display() {
    // Test each variant of MetricsError for Display implementation
    let basic_err = MetricsError::BasicError("calculation failed".to_string());
    assert_eq!(format!("{basic_err}"), "Basic Error: calculation failed");

    let shape_err = MetricsError::ShapeError("incompatible dimensions".to_string());
    assert_eq!(
        format!("{shape_err}"),
        "Shape Error: incompatible dimensions"
    );

    let range_err = MetricsError::RangeError("value out of bounds".to_string());
    assert_eq!(format!("{range_err}"), "Range Error: value out of bounds");

    let trend_err = MetricsError::TrendError("trend analysis failed".to_string());
    assert_eq!(format!("{trend_err}"), "Trend Error: trend analysis failed");

    let risk_err = MetricsError::RiskError("risk calculation error".to_string());
    assert_eq!(format!("{risk_err}"), "Risk Error: risk calculation error");

    let curve_err = MetricsError::Curve(CurveError::Point2DError {
        reason: "curve fitting failed",
    });
    assert!(format!("{curve_err}").contains("curve fitting failed"));

    let surface_err = MetricsError::Surface(SurfaceError::Point3DError {
        reason: "surface modeling error",
    });
    assert!(format!("{surface_err}").contains("surface modeling error"));
}

#[test]
fn test_metrics_error_debug() {
    // Test Debug implementation for a few variants
    let basic_err = MetricsError::BasicError("test message".to_string());
    assert!(format!("{basic_err:?}").contains("BasicError"));
    assert!(format!("{basic_err:?}").contains("test message"));

    let range_err = MetricsError::RangeError("debug test".to_string());
    assert!(format!("{range_err:?}").contains("RangeError"));
    assert!(format!("{range_err:?}").contains("debug test"));
}

#[test]
fn test_metrics_error_from_curve_error() {
    // Create a CurveError
    let curve_err = CurveError::Point2DError {
        reason: "invalid point",
    };

    // Convert to MetricsError using From trait
    let metrics_err: MetricsError = curve_err.into();

    // Verify the conversion was successful
    match metrics_err {
        MetricsError::Curve(_) => {
            // Conversion successful
        }
        _ => panic!("Expected Curve variant, got something else"),
    }
}

#[test]
fn test_metrics_error_from_surface_error() {
    // Create a SurfaceError
    let surface_err = SurfaceError::Point3DError {
        reason: "invalid surface point",
    };

    // Convert to MetricsError using From trait
    let metrics_err: MetricsError = surface_err.into();

    // Verify the conversion was successful
    match metrics_err {
        MetricsError::Surface(_) => {
            // Conversion successful
        }
        _ => panic!("Expected Surface variant, got something else"),
    }
}

#[test]
fn test_metrics_error_basic_error_display() {
    let error = MetricsError::BasicError("basic calc failed".to_string());
    assert_eq!(format!("{error}"), "Basic Error: basic calc failed");
}

#[test]
fn test_metrics_error_as_error() {
    // Create a MetricsError
    let error = MetricsError::BasicError("test error".to_string());

    // Verify it can be used as a Box<dyn Error>
    let boxed_error: Box<dyn std::error::Error> = Box::new(error);
    assert_eq!(boxed_error.to_string(), "Basic Error: test error");

    // Test another variant
    let error = MetricsError::RangeError("out of range".to_string());
    let boxed_error: Box<dyn std::error::Error> = Box::new(error);
    assert_eq!(boxed_error.to_string(), "Range Error: out of range");
}