optionstratlib 0.7.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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

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

#[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::CurveError("curve fitting failed".to_string());
    assert_eq!(format!("{curve_err}"), "Curve Error: curve fitting failed");

    let surface_err = MetricsError::SurfaceError("surface modeling error".to_string());
    assert_eq!(
        format!("{surface_err}"),
        "Surface Error: surface modeling error"
    );

    let std_err = MetricsError::StdError {
        reason: "standard error occurred".to_string(),
    };
    assert_eq!(
        format!("{std_err}"),
        "Standard Error: standard error occurred"
    );
}

#[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 std_err = MetricsError::StdError {
        reason: "debug test".to_string(),
    };
    assert!(format!("{std_err:?}").contains("StdError"));
    assert!(format!("{std_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::CurveError(msg) => {
            assert!(msg.contains("invalid point"));
        }
        _ => panic!("Expected CurveError 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::SurfaceError(msg) => {
            assert!(msg.contains("invalid surface point"));
        }
        _ => panic!("Expected SurfaceError variant, got something else"),
    }
}

#[test]
fn test_metrics_error_from_box_dyn_error() {
    // Create a simple error that implements Error trait
    let std_err = std::io::Error::other("IO error occurred");
    let boxed_err: Box<dyn Error> = Box::new(std_err);

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

    // Verify the conversion was successful
    match metrics_err {
        MetricsError::StdError { reason } => {
            assert!(reason.contains("IO error occurred"));
        }
        _ => panic!("Expected StdError variant, got something else"),
    }
}

#[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 Error> = Box::new(error);
    assert_eq!(boxed_error.to_string(), "Basic Error: test error");

    // Test another variant
    let error = MetricsError::StdError {
        reason: "standard error test".to_string(),
    };
    let boxed_error: Box<dyn Error> = Box::new(error);
    assert_eq!(
        boxed_error.to_string(),
        "Standard Error: standard error test"
    );
}