Merge pull request #520 from danielships/feat/analytics-unit-tests

test(devkit/analytics): add unit tests for trend direction, fee velocity, volatility, and Bollinger Bands

Author: Tinna23

packages/devkit/tests/analytics_trend.rs

@@ -0,0 +1,160 @@
+//! Unit tests for the fee trend direction detector and fee velocity calculator.
+//!
+//! Covers:
+//! - `TrendDirection` detection (Upward / Downward / Sideways) on synthetic sequences
+//! - Boundary conditions at the ±5% slope threshold used by `analyze_trend`
+//! - `fee_velocity` on sequences with a known rate of change
+
+use stellar_devkit::analytics::trend::{analyze_trend, fee_velocity, TrendDirection};
+
+// ---------------------------------------------------------------------------
+// TrendDirection detection — issue #459
+// ---------------------------------------------------------------------------
+
+#[test]
+fn upward_trend_on_strictly_rising_sequence() {
+    let fees: Vec<f64> = (0..30).map(|i| 100.0 + i as f64 * 20.0).collect();
+    let result = analyze_trend(&fees);
+    assert_eq!(
+        result.direction,
+        TrendDirection::Upward,
+        "strictly rising sequence must be Upward"
+    );
+    assert!(result.slope > 0.0, "slope must be positive");
+}
+
+#[test]
+fn downward_trend_on_strictly_falling_sequence() {
+    let fees: Vec<f64> = (0..30).map(|i| 600.0 - i as f64 * 15.0).collect();
+    let result = analyze_trend(&fees);
+    assert_eq!(
+        result.direction,
+        TrendDirection::Downward,
+        "strictly falling sequence must be Downward"
+    );
+    assert!(result.slope < 0.0, "slope must be negative");
+}
+
+#[test]
+fn sideways_trend_on_constant_sequence() {
+    let fees = vec![200.0_f64; 50];
+    let result = analyze_trend(&fees);
+    assert_eq!(
+        result.direction,
+        TrendDirection::Sideways,
+        "constant sequence must be Sideways"
+    );
+    assert!(
+        result.slope.abs() < 1e-6,
+        "slope must be effectively zero, got {}",
+        result.slope
+    );
+}
+
+#[test]
+fn sideways_trend_on_oscillating_sequence() {
+    // Fees alternating ±5 around a constant mean — no net trend.
+    let fees: Vec<f64> = (0..40)
+        .map(|i| if i % 2 == 0 { 300.0 } else { 310.0 })
+        .collect();
+    let result = analyze_trend(&fees);
+    // Slope should be near zero for this symmetric oscillation.
+    assert!(
+        result.slope.abs() < 1.0,
+        "alternating sequence should have near-zero slope, got {}",
+        result.slope
+    );
+}
+
+#[test]
+fn trend_on_empty_sequence_is_sideways_with_zero_slope() {
+    let result = analyze_trend(&[]);
+    assert_eq!(result.direction, TrendDirection::Sideways);
+    assert_eq!(result.slope, 0.0);
+    assert_eq!(result.r_squared, 0.0);
+}
+
+#[test]
+fn upward_r_squared_close_to_one_for_perfect_line() {
+    let fees: Vec<f64> = (0..20).map(|i| 100.0 + i as f64 * 5.0).collect();
+    let result = analyze_trend(&fees);
+    assert!(
+        result.r_squared > 0.99,
+        "R² should be ~1.0 for a perfect linear sequence, got {}",
+        result.r_squared
+    );
+}
+
+#[test]
+fn mean_is_correct() {
+    let fees = vec![100.0, 200.0, 300.0];
+    let result = analyze_trend(&fees);
+    assert!((result.mean - 200.0).abs() < f64::EPSILON, "mean should be 200");
+}
+
+// ---------------------------------------------------------------------------
+// Fee velocity calculator — issue #460
+// ---------------------------------------------------------------------------
+
+#[test]
+fn fee_velocity_known_rate_of_change() {
+    // Fees rise by 100 stroops per second.
+    // Timestamps: 0 ms, 1000 ms, 2000 ms (1 s apart).
+    // Fee values:  0,  100,  200.
+    let fees: Vec<(u64, u64)> = vec![(0, 0), (1_000, 100), (2_000, 200)];
+    let v = fee_velocity(&fees, 10);
+    assert!(
+        (v - 100.0).abs() < 0.01,
+        "expected ~100 stroops/sec, got {}",
+        v
+    );
+}
+
+#[test]
+fn fee_velocity_zero_when_fees_flat() {
+    let fees: Vec<(u64, u64)> = vec![(0, 500), (1_000, 500), (2_000, 500)];
+    let v = fee_velocity(&fees, 10);
+    assert!(v.abs() < f64::EPSILON, "flat fees must yield zero velocity");
+}
+
+#[test]
+fn fee_velocity_declining_fees() {
+    // Fees drop by 50 stroops per second.
+    let fees: Vec<(u64, u64)> = vec![(0, 200), (1_000, 150), (2_000, 100)];
+    let v = fee_velocity(&fees, 10);
+    assert!(
+        (v - (-50.0)).abs() < 0.01,
+        "expected -50 stroops/sec, got {}",
+        v
+    );
+}
+
+#[test]
+fn fee_velocity_empty_slice_is_zero() {
+    assert_eq!(fee_velocity(&[], 5), 0.0);
+}
+
+#[test]
+fn fee_velocity_single_point_is_zero() {
+    assert_eq!(fee_velocity(&[(1000, 200)], 5), 0.0);
+}
+
+#[test]
+fn fee_velocity_respects_window() {
+    // Build a long sequence where only the last 2 s have a rate of change.
+    // Everything before should be filtered out by the window.
+    let mut fees: Vec<(u64, u64)> = (0..100)
+        .map(|i| (i as u64 * 100, 200u64))  // flat for 10 s
+        .collect();
+    // Add two more points 1 s apart with a rising fee.
+    let last_ts = fees.last().unwrap().0;
+    fees.push((last_ts + 1_000, 200));
+    fees.push((last_ts + 2_000, 400));
+    // With window_secs=2, only the last two points matter → 200 stroops/sec.
+    let v = fee_velocity(&fees, 2);
+    assert!(
+        (v - 200.0).abs() < 1.0,
+        "expected ~200 stroops/sec within window, got {}",
+        v
+    );
+}

packages/devkit/tests/analytics_volatility.rs

@@ -0,0 +1,156 @@
+//! Unit tests for the fee volatility calculators and Bollinger Bands.
+//!
+//! Covers:
+//! - `compute_volatility` — standard deviation and coefficient of variation
+//! - CV scale-invariance: CV([1,2,3]) == CV([10,20,30])
+//! - Bollinger Bands ordering: upper > sma > lower at every point
+//! - Bandwidth > 0 for non-constant sequences
+
+use stellar_devkit::analytics::volatility::{bollinger_bands, compute_volatility};
+
+// ---------------------------------------------------------------------------
+// Volatility calculators — issue #461
+// ---------------------------------------------------------------------------
+
+#[test]
+fn std_dev_on_known_distribution() {
+    // For values [2, 4, 4, 4, 5, 5, 7, 9], population std dev ≈ 2.0
+    let fees = vec![2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0];
+    let v = compute_volatility(&fees);
+    assert!(
+        (v.standard_deviation - 2.0).abs() < 0.01,
+        "expected std_dev ≈ 2.0, got {}",
+        v.standard_deviation
+    );
+}
+
+#[test]
+fn std_dev_zero_for_constant_sequence() {
+    let fees = vec![100.0_f64; 20];
+    let v = compute_volatility(&fees);
+    assert!(
+        v.standard_deviation < f64::EPSILON,
+        "constant sequence must have zero std_dev"
+    );
+}
+
+#[test]
+fn cv_is_scale_invariant() {
+    let small: Vec<f64> = vec![1.0, 2.0, 3.0];
+    let large: Vec<f64> = vec![10.0, 20.0, 30.0];
+    let cv_small = compute_volatility(&small).coefficient_of_variation;
+    let cv_large = compute_volatility(&large).coefficient_of_variation;
+    assert!(
+        (cv_small - cv_large).abs() < 1e-10,
+        "CV must be scale-invariant: {} vs {}",
+        cv_small,
+        cv_large
+    );
+}
+
+#[test]
+fn cv_zero_for_constant_sequence() {
+    let fees = vec![250.0_f64; 10];
+    let v = compute_volatility(&fees);
+    assert!(
+        v.coefficient_of_variation < f64::EPSILON,
+        "constant sequence must have zero CV"
+    );
+}
+
+#[test]
+fn volatility_max_and_min_correct() {
+    let fees = vec![50.0, 100.0, 200.0, 75.0, 150.0];
+    let v = compute_volatility(&fees);
+    assert_eq!(v.max, 200.0);
+    assert_eq!(v.min, 50.0);
+    assert_eq!(v.range, 150.0);
+}
+
+#[test]
+fn volatility_empty_slice_returns_zeros() {
+    let v = compute_volatility(&[]);
+    assert_eq!(v.standard_deviation, 0.0);
+    assert_eq!(v.coefficient_of_variation, 0.0);
+    assert_eq!(v.max, 0.0);
+    assert_eq!(v.min, 0.0);
+}
+
+// ---------------------------------------------------------------------------
+// Bollinger Bands — issue #462
+// ---------------------------------------------------------------------------
+
+#[test]
+fn bollinger_upper_gt_sma_gt_lower_for_non_constant_sequence() {
+    let fees: Vec<f64> = (0..50).map(|i| 100.0 + (i as f64 * 7.3).sin() * 30.0).collect();
+    let bands = bollinger_bands(&fees, 10);
+    // For any point where std_dev > 0 (non-constant window), upper > sma > lower.
+    for b in &bands {
+        if b.bandwidth > f64::EPSILON {
+            assert!(
+                b.upper_band > b.sma,
+                "upper_band ({}) must be > sma ({})",
+                b.upper_band,
+                b.sma
+            );
+            assert!(
+                b.sma > b.lower_band,
+                "sma ({}) must be > lower_band ({})",
+                b.sma,
+                b.lower_band
+            );
+        }
+    }
+}
+
+#[test]
+fn bollinger_bandwidth_positive_for_non_constant() {
+    let fees: Vec<f64> = (0..30).map(|i| 100.0 + i as f64 * 5.0).collect();
+    let bands = bollinger_bands(&fees, 5);
+    // After the first window fills (index >= window-1), bandwidth must be > 0.
+    for b in bands.iter().skip(4) {
+        assert!(
+            b.bandwidth > 0.0,
+            "bandwidth must be > 0 for non-constant window, got {}",
+            b.bandwidth
+        );
+    }
+}
+
+#[test]
+fn bollinger_bandwidth_zero_for_constant_sequence() {
+    let fees = vec![200.0_f64; 20];
+    let bands = bollinger_bands(&fees, 5);
+    for b in &bands {
+        assert!(
+            b.bandwidth < f64::EPSILON,
+            "constant sequence must have zero bandwidth, got {}",
+            b.bandwidth
+        );
+    }
+}
+
+#[test]
+fn bollinger_count_equals_input_length() {
+    let fees: Vec<f64> = (0..100).map(|i| i as f64).collect();
+    let bands = bollinger_bands(&fees, 20);
+    assert_eq!(bands.len(), fees.len());
+}
+
+#[test]
+fn bollinger_sma_correct_at_full_window() {
+    // First 5 values: 0, 1, 2, 3, 4 → SMA = 2.0 at index 4 with window=5.
+    let fees: Vec<f64> = (0..10).map(|i| i as f64).collect();
+    let bands = bollinger_bands(&fees, 5);
+    assert!(
+        (bands[4].sma - 2.0).abs() < 1e-10,
+        "SMA at index 4 should be 2.0, got {}",
+        bands[4].sma
+    );
+}
+
+#[test]
+fn bollinger_bands_empty_input_returns_empty() {
+    let bands = bollinger_bands(&[], 10);
+    assert!(bands.is_empty());
+}