pub struct AggregateTestHarness<S: AggregateState> { /* private fields */ }Expand description
A test harness that simulates the DuckDB aggregate function lifecycle in
pure Rust, without requiring a DuckDB instance.
§Usage
use quack_rs::testing::AggregateTestHarness;
use quack_rs::aggregate::AggregateState;
#[derive(Default, Debug, PartialEq)]
struct Counter { n: u64 }
impl AggregateState for Counter {}
let mut harness = AggregateTestHarness::<Counter>::new();
harness.update(|c| c.n += 1);
harness.update(|c| c.n += 1);
harness.update(|c| c.n += 1);
let state = harness.finalize();
assert_eq!(state.n, 3);Implementations§
Source§impl<S: AggregateState> AggregateTestHarness<S>
impl<S: AggregateState> AggregateTestHarness<S>
Sourcepub fn new() -> Self
pub fn new() -> Self
Creates a new harness with a fresh S::default() state.
§Example
use quack_rs::testing::AggregateTestHarness;
use quack_rs::aggregate::AggregateState;
#[derive(Default)]
struct MyState { count: u64 }
impl AggregateState for MyState {}
let harness = AggregateTestHarness::<MyState>::new();Sourcepub const fn with_state(state: S) -> Self
pub const fn with_state(state: S) -> Self
Creates a harness with an explicit initial state.
Useful for testing combine with a pre-populated state.
Sourcepub fn update<F>(&mut self, f: F)
pub fn update<F>(&mut self, f: F)
Applies an update to the current state.
Simulates one row being processed by the aggregate’s update callback.
§Example
use quack_rs::testing::AggregateTestHarness;
use quack_rs::aggregate::AggregateState;
#[derive(Default)]
struct Sum { total: i64 }
impl AggregateState for Sum {}
let mut h = AggregateTestHarness::<Sum>::new();
h.update(|s| s.total += 5);
h.update(|s| s.total += 3);Sourcepub fn combine<F>(&mut self, source: &Self, combine_fn: F)
pub fn combine<F>(&mut self, source: &Self, combine_fn: F)
Simulates a combine operation: merges the source harness’s state into
this harness’s state using the provided combine function.
This tests the correctness of your combine implementation, including the
critical requirement that all configuration fields are propagated from source
to target (Pitfall L1 / Problem 4).
§Example
use quack_rs::testing::AggregateTestHarness;
use quack_rs::aggregate::AggregateState;
#[derive(Default, Clone)]
struct Sum { total: i64 }
impl AggregateState for Sum {}
let mut h1 = AggregateTestHarness::<Sum>::new();
h1.update(|s| s.total += 10);
let mut h2 = AggregateTestHarness::<Sum>::new();
h2.update(|s| s.total += 20);
// Combine h1 into h2
h2.combine(&h1, |source, target| target.total += source.total);
let result = h2.finalize();
assert_eq!(result.total, 30);Sourcepub fn finalize(self) -> S
pub fn finalize(self) -> S
Consumes the harness and returns the final state.
Simulates DuckDB calling the finalize callback.
§Example
use quack_rs::testing::AggregateTestHarness;
use quack_rs::aggregate::AggregateState;
#[derive(Default, Debug, PartialEq)]
struct Sum { total: i64 }
impl AggregateState for Sum {}
let mut h = AggregateTestHarness::<Sum>::new();
h.update(|s| s.total = 42);
assert_eq!(h.finalize().total, 42);Sourcepub const fn state(&self) -> &S
pub const fn state(&self) -> &S
Borrows the current state for inspection without consuming the harness.
Useful for asserting intermediate state during a sequence of updates.
§Example
use quack_rs::testing::AggregateTestHarness;
use quack_rs::aggregate::AggregateState;
#[derive(Default)]
struct Sum { total: i64 }
impl AggregateState for Sum {}
let mut h = AggregateTestHarness::<Sum>::new();
h.update(|s| s.total += 5);
assert_eq!(h.state().total, 5);
h.update(|s| s.total += 3);
assert_eq!(h.state().total, 8);Sourcepub fn reset(&mut self)
pub fn reset(&mut self)
Resets the state to S::default().
Useful for running multiple scenarios with a single harness.
Sourcepub fn aggregate<I, T, F>(inputs: I, update_fn: F) -> S
pub fn aggregate<I, T, F>(inputs: I, update_fn: F) -> S
Runs a sequence of updates from an iterator and returns the final state.
This is a convenience method for testing aggregate functions over a collection of input values.
§Example
use quack_rs::testing::AggregateTestHarness;
use quack_rs::aggregate::AggregateState;
#[derive(Default)]
struct Sum { total: i64 }
impl AggregateState for Sum {}
let result = AggregateTestHarness::<Sum>::aggregate(
[1_i64, 2, 3, 4, 5],
|s, v| s.total += v,
);
assert_eq!(result.total, 15);