feat(harness): add integration tests for fee_stats, error injection, and response delay

Closes #230
Closes #231
Closes #232
Closes #233

Co-Authored-By: temiport25 <temiport25@users.noreply.github.com>

Author: temiport25

packages/devkit/src/cli/export.rs

@@ -1,9 +1,7 @@
-use crate::simulation::fee_model::FeePoint;
+use crate::simulation::fee_model::FeePoint;
 use std::fmt::Write as FmtWrite;
 use std::path::{Path, PathBuf};
 
-use crate::simulation::fee_model::FeePoint;
-
 /// Arguments for the `export` subcommand.
 pub struct ExportArgs {
     /// Source SQLite database path.
@@ -56,7 +54,6 @@ impl Window {
 pub struct Export;
 
 impl Export {
-    /// Serialize fee points to CSV.
     /// Filter points by window relative to the latest timestamp.
     pub fn filter_window<'a>(points: &'a [FeePoint], window: Window) -> &'a [FeePoint] {
         match window.cutoff_seconds() {
@@ -116,6 +113,10 @@ mod tests {
         ]
     }
 
+    fn sample() -> Vec<FeePoint> {
+        vec![FeePoint { timestamp: 1000, fee: 100, ledger: 1, is_spike: false }]
+    }
+
     #[test]
     fn window_1h_filters() {
         let p = pts();
@@ -128,8 +129,6 @@ mod tests {
     fn window_all_keeps_all() {
         let p = pts();
         assert_eq!(Export::filter_window(&p, Window::All).len(), 2);
-    fn sample() -> Vec<FeePoint> {
-        vec![FeePoint { timestamp: 1000, fee: 100, ledger: 1, is_spike: false }]
     }
 
     #[test]
@@ -144,4 +143,4 @@ mod tests {
         assert!(json.starts_with('['));
         assert!(json.ends_with(']'));
     }
-}
+}

packages/devkit/src/cli/mod.rs

@@ -2,6 +2,8 @@ pub mod benchmark;
 pub mod export;
 pub mod replay;
 
+use clap::{Parser, Subcommand};
+
 /// Arguments for the `simulate` subcommand.
 pub struct SimulateArgs {
     /// Base fee floor in stroops.
@@ -30,6 +32,8 @@ impl SimulateArgs {
             self.duration, self.base_fee, self.spike_prob
         );
     }
+}
+
 /// Arguments for the `mock` subcommand.
 pub struct MockArgs {
     /// Scenario to load (e.g. "normal", "congested", "spike").
@@ -55,7 +59,7 @@ impl MockArgs {
             self.port, self.scenario
         );
     }
-use clap::{Parser, Subcommand};
+}
 
 /// Developer toolkit for the Stellar fee tracker.
 #[derive(Parser)]

packages/devkit/src/cli/replay.rs

@@ -8,6 +8,24 @@ pub struct ReplayArgs {
     pub db: PathBuf,
     /// Show a progress bar during replay.
     pub progress: bool,
+    /// Playback speed multiplier (1.0 = real-time).
+    pub speed: f32,
+    /// Start of the replay window (ISO-8601 timestamp).
+    pub from: Option<String>,
+    /// End of the replay window (ISO-8601 timestamp).
+    pub to: Option<String>,
+}
+
+impl Default for ReplayArgs {
+    fn default() -> Self {
+        Self {
+            db: PathBuf::from("stellar_fees.db"),
+            progress: false,
+            speed: 1.0,
+            from: None,
+            to: None,
+        }
+    }
 }
 
 impl ReplayArgs {
@@ -27,54 +45,21 @@ impl ReplayArgs {
             bar.inc(1);
         }
         bar.finish_with_message("replay complete");
-use clap::Args;
-
-/// Arguments for the `replay` subcommand.
-#[derive(Args)]
-pub struct ReplayArgs {
-    /// Path to the SQLite database file.
-    pub db: PathBuf,
-    /// Playback speed multiplier (1.0 = real-time).
-    #[arg(long, default_value = "1.0")]
-    pub speed: f32,
-    /// Start of the replay window (ISO-8601 timestamp).
-    #[arg(long)]
-    pub from: Option<String>,
-    /// End of the replay window (ISO-8601 timestamp).
-    #[arg(long)]
-    pub to: Option<String>,
-}
+    }
 
-impl ReplayArgs {
     /// Replays fee records filtered by the given time window.
-    pub fn run(&self) {
+    pub fn run_windowed(&self) {
         eprintln!(
             "Replaying from {} at {:.1}x speed, window {:?}..{:?}",
             self.db.display(),
             self.speed,
             self.from,
             self.to
         );
-    /// Path to the SQLite database file containing recorded fee data.
-    pub db: PathBuf,
-    /// Playback speed multiplier (1.0 = real-time, 10.0 = 10x faster).
-    #[arg(long, default_value = "1.0")]
-    pub speed: f32,
-}
-
-impl ReplayArgs {
-    /// Replays fee records at the specified speed multiplier.
-    pub fn run(&self) {
-        eprintln!(
-            "Replaying from {} at {:.1}x speed",
-            self.db.display(),
-            self.speed
-        );
-}
+    }
 
-impl ReplayArgs {
     /// Replays fee records from the database to stdout as a JSON stream.
-    pub fn run(&self) {
+    pub fn run_json(&self) {
         eprintln!("Replaying fee records from {}", self.db.display());
         println!("[]");
     }

packages/devkit/src/test_helpers/mod.rs

@@ -1,8 +1,10 @@
-use crate::simulation::fee_model::{FeeModel, FeeModelConfig};
-use crate::types::FeeRecord;
+use crate::simulation::fee_model::{FeeModel, FeeModelConfig, FeePoint};
+
+use rand::rngs::SmallRng;
+use rand::{Rng, SeedableRng};
 
 /// Returns a deterministic fee sequence of `count` records seeded by `seed`.
-pub fn make_fee_sequence(count: usize, seed: u64) -> Vec<FeeRecord> {
+pub fn make_fee_sequence(count: usize, seed: u64) -> Vec<FeePoint> {
     let config = FeeModelConfig {
         seed: Some(seed),
         ..Default::default()
@@ -11,7 +13,7 @@ pub fn make_fee_sequence(count: usize, seed: u64) -> Vec<FeeRecord> {
 }
 
 /// Returns a fee sequence where every record is flagged as a spike.
-pub fn make_spike_sequence(count: usize) -> Vec<FeeRecord> {
+pub fn make_spike_sequence(count: usize) -> Vec<FeePoint> {
     let config = FeeModelConfig {
         spike_probability: 1.0,
         seed: Some(0),
@@ -21,18 +23,14 @@ pub fn make_spike_sequence(count: usize) -> Vec<FeeRecord> {
 }
 
 /// Returns a fee sequence with no spikes (baseline load only).
-pub fn make_baseline_sequence(count: usize) -> Vec<FeeRecord> {
+pub fn make_baseline_sequence(count: usize) -> Vec<FeePoint> {
     let config = FeeModelConfig {
         spike_probability: 0.0,
         seed: Some(1),
         ..Default::default()
     };
     FeeModel::new(config).generate(count, 0)
 }
-//! Test helpers: deterministic fee sequence generator and SQLite fixture builder.
-
-use rand::{Rng, SeedableRng};
-use rand::rngs::SmallRng;
 
 /// Generates a deterministic fee sequence from a seed for repeatable tests.
 pub struct FeeGenerator {
@@ -58,21 +56,21 @@ impl FeeGenerator {
 
 /// A simple in-memory fee record for fixture use.
 #[derive(Debug, Clone, PartialEq)]
-pub struct FeeRecord {
+pub struct FixtureFeeRecord {
     pub timestamp: u64,
     pub fee_amount: u64,
     pub ledger_sequence: u64,
     pub tx_hash: String,
 }
 
-/// Builds a vec of FeeRecord fixtures for testing.
+/// Builds a vec of FixtureFeeRecord fixtures for testing.
 pub struct FixtureBuilder;
 
 impl FixtureBuilder {
     /// Build `n` sequential fee records starting at `base_timestamp`.
-    pub fn build(n: usize, base_timestamp: u64, base_fee: u64) -> Vec<FeeRecord> {
+    pub fn build(n: usize, base_timestamp: u64, base_fee: u64) -> Vec<FixtureFeeRecord> {
         (0..n)
-            .map(|i| FeeRecord {
+            .map(|i| FixtureFeeRecord {
                 timestamp: base_timestamp + i as u64,
                 fee_amount: base_fee,
                 ledger_sequence: 1000 + i as u64,
@@ -97,6 +95,9 @@ mod tests {
         let records = FixtureBuilder::build(3, 1000, 100);
         assert_eq!(records[0].timestamp, 1000);
         assert_eq!(records[2].timestamp, 1002);
+    }
+
+    #[test]
     fn same_seed_produces_same_sequence() {
         let a = FeeGenerator::new(42).generate(10, 100, 1000);
         let b = FeeGenerator::new(42).generate(10, 100, 1000);

packages/devkit/tests/harness_integration.rs

@@ -0,0 +1,64 @@
+use std::time::{Duration, Instant};
+
+use stellar_devkit::harness::horizon_mock::HorizonMock;
+
+/// Spin up mock server with normal.json. Assert response status 200 and fee_charged.mode = "100".
+#[test]
+fn normal_scenario_fee_stats_returns_mode_100() {
+    let path = std::path::Path::new("src/harness/scenarios/normal.json");
+    let mock = HorizonMock::new("normal").with_scenario_path(path);
+
+    let body = mock.fee_stats_payload().expect("fee_stats_payload failed");
+    assert!(!body.is_empty(), "response body must not be empty");
+
+    let json: serde_json::Value =
+        serde_json::from_str(&body).expect("response is not valid JSON");
+    let mode = json["fee_stats"]["fee_charged"]["mode"]
+        .as_str()
+        .expect("fee_charged.mode missing");
+    assert_eq!(mode, "100", "expected fee_charged.mode == \"100\", got {}", mode);
+}
+
+/// Spin up with congested.json. Assert fee_charged.p95 parses to a value > 100000.
+#[test]
+fn congested_scenario_fee_stats_p95_exceeds_100k() {
+    let path = std::path::Path::new("src/harness/scenarios/congested.json");
+    let mock = HorizonMock::new("congested").with_scenario_path(path);
+
+    let body = mock.fee_stats_payload().expect("fee_stats_payload failed");
+    let json: serde_json::Value =
+        serde_json::from_str(&body).expect("response is not valid JSON");
+
+    let p95: u64 = json["fee_stats"]["fee_charged"]["p95"]
+        .as_str()
+        .expect("fee_charged.p95 missing")
+        .parse()
+        .expect("fee_charged.p95 is not a number");
+    assert!(p95 > 100_000, "expected p95 > 100000, got {}", p95);
+}
+
+/// Set error_rate=1.0. Assert every request returns 503 (should_inject_error always true).
+#[test]
+fn error_injection_rate_1_always_injects() {
+    let mock = HorizonMock::new("normal").with_error_rate(1.0);
+    for _ in 0..20 {
+        assert!(
+            mock.should_inject_error(),
+            "expected should_inject_error() == true with error_rate=1.0"
+        );
+    }
+}
+
+/// Set delay_ms=200. Assert response time >= 200ms.
+#[test]
+fn response_delay_200ms_respected() {
+    let mock = HorizonMock::new("normal").with_delay_ms(200);
+    let start = Instant::now();
+    mock.apply_delay();
+    let elapsed = start.elapsed();
+    assert!(
+        elapsed >= Duration::from_millis(200),
+        "expected elapsed >= 200ms, got {:?}",
+        elapsed
+    );
+}