rsta 0.1.0

Technical analysis indicators, streaming signals, and a single-asset backtesting engine for Rust
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
132
133
134
135
136
137
138
139

//! Error types for technical indicators
//!
//! This module defines the common error types used by all indicator implementations
//! in the library.

use thiserror::Error;

/// Common error types for technical indicators
///
/// This enum represents the standard error types that can occur when working with
/// technical indicators. All indicator methods that can fail return a `Result`
/// with this error type.
///
/// # Examples
///
/// ```rust,no_run
/// use rsta::indicators::Sma;
/// use rsta::indicators::IndicatorError;
/// use rsta::indicators::Indicator;
///
/// // Handle a parameter validation error
/// match Sma::new(0) {
///     Err(IndicatorError::InvalidParameter(msg)) => println!("Invalid parameter: {}", msg),
///     _ => println!("Unexpected result"),
/// }
/// ```
///
/// ```rust
/// use rsta::indicators::Sma;
/// use rsta::indicators::IndicatorError;
/// use rsta::indicators::Indicator;
///
/// // Handle an insufficient data error
/// let mut sma = Sma::new(14).unwrap();
/// let prices = vec![1.0, 2.0]; // Not enough data
/// match sma.calculate(&prices) {
///     Err(IndicatorError::InsufficientData(msg)) => println!("Not enough data: {}", msg),
///     _ => println!("Unexpected result"),
/// }
/// ```
#[derive(Error, Debug, Clone, PartialEq)]
pub enum IndicatorError {
    /// Error for invalid parameters (e.g., negative period, invalid multiplier)
    #[error("Invalid parameter: {0}")]
    InvalidParameter(String),

    /// Error for insufficient data to perform calculations
    #[error("Insufficient data: {0}")]
    InsufficientData(String),

    /// Error during calculation (e.g., division by zero)
    #[error("Calculation error: {0}")]
    CalculationError(String),
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fmt::{Debug, Display};

    #[test]
    fn test_invalid_parameter_error() {
        // Create the error
        let error = IndicatorError::InvalidParameter("Period must be greater than 0".to_string());

        // Test Debug trait
        assert!(format!("{:?}", error).contains("InvalidParameter"));
        assert!(format!("{:?}", error).contains("Period must be greater than 0"));

        // Test Display trait (error message)
        assert_eq!(
            format!("{}", error),
            "Invalid parameter: Period must be greater than 0"
        );
    }

    #[test]
    fn test_insufficient_data_error() {
        // Create the error
        let error = IndicatorError::InsufficientData("Need at least 14 data points".to_string());

        // Test Debug trait
        assert!(format!("{:?}", error).contains("InsufficientData"));
        assert!(format!("{:?}", error).contains("Need at least 14 data points"));

        // Test Display trait (error message)
        assert_eq!(
            format!("{}", error),
            "Insufficient data: Need at least 14 data points"
        );
    }

    #[test]
    fn test_calculation_error() {
        // Create the error
        let error = IndicatorError::CalculationError("Division by zero".to_string());

        // Test Debug trait
        assert!(format!("{:?}", error).contains("CalculationError"));
        assert!(format!("{:?}", error).contains("Division by zero"));

        // Test Display trait (error message)
        assert_eq!(format!("{}", error), "Calculation error: Division by zero");
    }

    #[test]
    fn test_error_conversion() {
        // Test that errors can be used with the ? operator
        fn returns_indicator_error() -> Result<(), IndicatorError> {
            Err(IndicatorError::InvalidParameter("Test error".to_string()))
        }

        fn propagates_error() -> Result<(), IndicatorError> {
            returns_indicator_error()?;
            Ok(())
        }

        let result = propagates_error();
        assert!(result.is_err());
        if let Err(error) = result {
            match error {
                IndicatorError::InvalidParameter(msg) => {
                    assert_eq!(msg, "Test error");
                }
                _ => panic!("Wrong error type"),
            }
        }
    }

    // Test that IndicatorError implements the required traits
    fn assert_traits<T: Debug + Display + std::error::Error>() {}

    #[test]
    fn test_error_traits() {
        // This will fail to compile if IndicatorError doesn't implement
        // the required traits
        assert_traits::<IndicatorError>();
    }
}