use std::collections::HashMap;
use redis_tower::RedisExecutor;
use redis_tower_commands::{
BfAdd, BfExists, BfInfo, BfInsert, BfMAdd, BfMExists, BfReserve, CfAdd, CfAddNx, CfCount,
CfDel, CfExists, CfInfo, CfInsert, CfInsertNx, CfMExists, CfReserve, CmsIncrBy,
CmsInfo as CmsInfoCmd, CmsInitByDim, CmsInitByProb, CmsMerge, CmsQuery, CommandArg, TdigestAdd,
TdigestByRank, TdigestByRevRank, TdigestCdf, TdigestCreate, TdigestInfo, TdigestMax,
TdigestMerge, TdigestMin, TdigestQuantile, TdigestRank, TdigestReset, TdigestRevRank,
TdigestTrimmedMean, TopkAdd, TopkCount, TopkIncrBy, TopkInfo, TopkList, TopkQuery, TopkReserve,
};
use redis_tower_core::{Frame, RedisError};
fn parse_kv_key(frame: Frame) -> Result<String, RedisError> {
let bytes = match frame {
Frame::BulkString(Some(bytes)) | Frame::SimpleString(bytes) => bytes,
other => {
return Err(RedisError::UnexpectedResponse {
expected: "bulk or simple string key",
actual: format!("{other:?}"),
});
}
};
String::from_utf8(bytes.to_vec()).map_err(|_| RedisError::UnexpectedResponse {
expected: "valid UTF-8 key",
actual: format!("{bytes:?}"),
})
}
fn parse_kv_entries(
entries: impl IntoIterator<Item = (Frame, Frame)>,
) -> Result<HashMap<String, Frame>, RedisError> {
let mut map = HashMap::new();
for (key, value) in entries {
let key = parse_kv_key(key)?;
if map.insert(key.clone(), value).is_some() {
return Err(RedisError::UnexpectedResponse {
expected: "unique key-value fields",
actual: format!("duplicate field `{key}`"),
});
}
}
Ok(map)
}
fn parse_flat_kv_frame(frame: Frame) -> Result<HashMap<String, Frame>, RedisError> {
match frame {
Frame::Array(Some(items)) => {
if items.len() % 2 != 0 {
return Err(RedisError::UnexpectedResponse {
expected: "even-length flat key-value array",
actual: format!("{items:?}"),
});
}
let mut entries = Vec::with_capacity(items.len() / 2);
let mut items = items.into_iter();
while let Some(key) = items.next() {
let Some(value) = items.next() else {
return Err(RedisError::UnexpectedResponse {
expected: "even-length flat key-value array",
actual: "missing value for final key".to_string(),
});
};
entries.push((key, value));
}
parse_kv_entries(entries)
}
Frame::Map(entries) | Frame::StreamedMap(entries) => parse_kv_entries(entries),
other => Err(RedisError::UnexpectedResponse {
expected: "flat key-value array or map",
actual: format!("{other:?}"),
}),
}
}
fn get_i64(map: &HashMap<String, Frame>, field: &str) -> Result<i64, RedisError> {
match map.get(field) {
Some(Frame::Integer(n)) => Ok(*n),
Some(other) => Err(RedisError::UnexpectedResponse {
expected: "integer",
actual: format!("{other:?}"),
}),
None => Err(RedisError::UnexpectedResponse {
expected: "field present in response",
actual: format!("field `{field}` not found"),
}),
}
}
fn get_f64(map: &HashMap<String, Frame>, field: &str) -> Result<f64, RedisError> {
match map.get(field) {
Some(Frame::Double(v)) => Ok(*v),
Some(Frame::BulkString(Some(b))) => {
let s = std::str::from_utf8(b).map_err(|_| RedisError::UnexpectedResponse {
expected: "valid UTF-8",
actual: format!("{b:?}"),
})?;
s.parse::<f64>()
.map_err(|_| RedisError::UnexpectedResponse {
expected: "float",
actual: s.to_string(),
})
}
Some(other) => Err(RedisError::UnexpectedResponse {
expected: "double or bulk string",
actual: format!("{other:?}"),
}),
None => Err(RedisError::UnexpectedResponse {
expected: "field present in response",
actual: format!("field `{field}` not found"),
}),
}
}
#[derive(Debug, Clone)]
pub struct BloomFilterInfo {
pub capacity: i64,
pub size: i64,
pub num_filters: i64,
pub num_items_inserted: i64,
pub expansion_rate: i64,
}
#[derive(Debug, Clone, Default)]
pub struct BfInsertConfig {
pub capacity: Option<i64>,
pub error_rate: Option<f64>,
pub expansion: Option<i64>,
pub nocreate: bool,
pub nonscaling: bool,
}
pub struct BloomFilter<'a, C> {
key: CommandArg,
conn: &'a mut C,
}
impl<'a, C: RedisExecutor + Send> BloomFilter<'a, C> {
pub fn new(conn: &'a mut C, key: impl Into<CommandArg>) -> Self {
Self {
key: key.into(),
conn,
}
}
pub async fn reserve(&mut self, error_rate: f64, capacity: i64) -> Result<(), RedisError> {
self.conn
.execute(BfReserve::new(&self.key, error_rate, capacity))
.await
}
pub async fn reserve_nonscaling(
&mut self,
error_rate: f64,
capacity: i64,
) -> Result<(), RedisError> {
self.conn
.execute(BfReserve::new(&self.key, error_rate, capacity).nonscaling())
.await
}
pub async fn reserve_with_expansion(
&mut self,
error_rate: f64,
capacity: i64,
expansion: i64,
) -> Result<(), RedisError> {
self.conn
.execute(BfReserve::new(&self.key, error_rate, capacity).expansion(expansion))
.await
}
pub async fn add(&mut self, item: impl Into<CommandArg>) -> Result<bool, RedisError> {
self.conn.execute(BfAdd::new(&self.key, item)).await
}
pub async fn madd(
&mut self,
items: impl IntoIterator<Item = impl Into<CommandArg>>,
) -> Result<Vec<bool>, RedisError> {
self.conn.execute(BfMAdd::new(&self.key, items)).await
}
pub async fn insert(
&mut self,
items: impl IntoIterator<Item = impl Into<CommandArg>>,
) -> Result<Vec<bool>, RedisError> {
self.conn.execute(BfInsert::new(&self.key, items)).await
}
pub async fn insert_with_config(
&mut self,
items: impl IntoIterator<Item = impl Into<CommandArg>>,
config: BfInsertConfig,
) -> Result<Vec<bool>, RedisError> {
let mut cmd = BfInsert::new(&self.key, items);
if let Some(cap) = config.capacity {
cmd = cmd.capacity(cap);
}
if let Some(err) = config.error_rate {
cmd = cmd.error(err);
}
if let Some(exp) = config.expansion {
cmd = cmd.expansion(exp);
}
if config.nocreate {
cmd = cmd.nocreate();
}
if config.nonscaling {
cmd = cmd.nonscaling();
}
self.conn.execute(cmd).await
}
pub async fn exists(&mut self, item: impl Into<CommandArg>) -> Result<bool, RedisError> {
self.conn.execute(BfExists::new(&self.key, item)).await
}
pub async fn mexists(
&mut self,
items: impl IntoIterator<Item = impl Into<CommandArg>>,
) -> Result<Vec<bool>, RedisError> {
self.conn.execute(BfMExists::new(&self.key, items)).await
}
pub async fn info(&mut self) -> Result<BloomFilterInfo, RedisError> {
let frame = self.conn.execute(BfInfo::new(&self.key)).await?;
let map = parse_flat_kv_frame(frame)?;
Ok(BloomFilterInfo {
capacity: get_i64(&map, "Capacity")?,
size: get_i64(&map, "Size")?,
num_filters: get_i64(&map, "Number of filters")?,
num_items_inserted: get_i64(&map, "Number of items inserted")?,
expansion_rate: get_i64(&map, "Expansion rate")?,
})
}
}
#[derive(Debug, Clone)]
pub struct CuckooFilterInfo {
pub size: i64,
pub num_buckets: i64,
pub num_filters: i64,
pub num_items_inserted: i64,
pub num_items_deleted: i64,
pub bucket_size: i64,
pub expansion_rate: i64,
pub max_iterations: i64,
}
#[derive(Debug, Clone, Default)]
pub struct CfReserveConfig {
pub bucketsize: Option<i64>,
pub maxiterations: Option<i64>,
pub expansion: Option<i64>,
}
pub struct CuckooFilter<'a, C> {
key: CommandArg,
conn: &'a mut C,
}
impl<'a, C: RedisExecutor + Send> CuckooFilter<'a, C> {
pub fn new(conn: &'a mut C, key: impl Into<CommandArg>) -> Self {
Self {
key: key.into(),
conn,
}
}
pub async fn reserve(&mut self, capacity: i64) -> Result<(), RedisError> {
self.conn.execute(CfReserve::new(&self.key, capacity)).await
}
pub async fn reserve_with_config(
&mut self,
capacity: i64,
config: CfReserveConfig,
) -> Result<(), RedisError> {
let mut cmd = CfReserve::new(&self.key, capacity);
if let Some(bs) = config.bucketsize {
cmd = cmd.bucketsize(bs);
}
if let Some(mi) = config.maxiterations {
cmd = cmd.maxiterations(mi);
}
if let Some(exp) = config.expansion {
cmd = cmd.expansion(exp);
}
self.conn.execute(cmd).await
}
pub async fn add(&mut self, item: impl Into<CommandArg>) -> Result<bool, RedisError> {
self.conn.execute(CfAdd::new(&self.key, item)).await
}
pub async fn add_nx(&mut self, item: impl Into<CommandArg>) -> Result<bool, RedisError> {
self.conn.execute(CfAddNx::new(&self.key, item)).await
}
pub async fn insert(
&mut self,
items: impl IntoIterator<Item = impl Into<CommandArg>>,
) -> Result<Vec<bool>, RedisError> {
self.conn.execute(CfInsert::new(&self.key, items)).await
}
pub async fn insert_nx(
&mut self,
items: impl IntoIterator<Item = impl Into<CommandArg>>,
) -> Result<Vec<bool>, RedisError> {
self.conn.execute(CfInsertNx::new(&self.key, items)).await
}
pub async fn exists(&mut self, item: impl Into<CommandArg>) -> Result<bool, RedisError> {
self.conn.execute(CfExists::new(&self.key, item)).await
}
pub async fn mexists(
&mut self,
items: impl IntoIterator<Item = impl Into<CommandArg>>,
) -> Result<Vec<bool>, RedisError> {
self.conn.execute(CfMExists::new(&self.key, items)).await
}
pub async fn count(&mut self, item: impl Into<CommandArg>) -> Result<i64, RedisError> {
self.conn.execute(CfCount::new(&self.key, item)).await
}
pub async fn del(&mut self, item: impl Into<CommandArg>) -> Result<bool, RedisError> {
self.conn.execute(CfDel::new(&self.key, item)).await
}
pub async fn info(&mut self) -> Result<CuckooFilterInfo, RedisError> {
let frame = self.conn.execute(CfInfo::new(&self.key)).await?;
let map = parse_flat_kv_frame(frame)?;
Ok(CuckooFilterInfo {
size: get_i64(&map, "Size")?,
num_buckets: get_i64(&map, "Number of buckets")?,
num_filters: get_i64(&map, "Number of filters")?,
num_items_inserted: get_i64(&map, "Number of items inserted")?,
num_items_deleted: get_i64(&map, "Number of items deleted")?,
bucket_size: get_i64(&map, "Bucket size")?,
expansion_rate: get_i64(&map, "Expansion rate")?,
max_iterations: get_i64(&map, "Max iterations")?,
})
}
}
#[derive(Debug, Clone)]
pub struct CmsInfo {
pub width: i64,
pub depth: i64,
pub count: i64,
}
pub struct CountMinSketch<'a, C> {
key: CommandArg,
conn: &'a mut C,
}
impl<'a, C: RedisExecutor + Send> CountMinSketch<'a, C> {
pub fn new(conn: &'a mut C, key: impl Into<CommandArg>) -> Self {
Self {
key: key.into(),
conn,
}
}
pub async fn init_by_dim(&mut self, width: i64, depth: i64) -> Result<(), RedisError> {
self.conn
.execute(CmsInitByDim::new(&self.key, width, depth))
.await
}
pub async fn init_by_prob(&mut self, error: f64, probability: f64) -> Result<(), RedisError> {
self.conn
.execute(CmsInitByProb::new(&self.key, error, probability))
.await
}
pub async fn incrby(
&mut self,
items: &[(impl AsRef<[u8]>, i64)],
) -> Result<Vec<i64>, RedisError> {
self.conn
.execute(CmsIncrBy::new(
&self.key,
items
.iter()
.map(|(item, count)| (CommandArg::copy_from_slice(item.as_ref()), *count)),
))
.await
}
pub async fn query(
&mut self,
items: impl IntoIterator<Item = impl Into<CommandArg>>,
) -> Result<Vec<i64>, RedisError> {
self.conn.execute(CmsQuery::new(&self.key, items)).await
}
pub async fn merge(
&mut self,
destination: impl Into<CommandArg>,
sources: impl IntoIterator<Item = impl Into<CommandArg>>,
) -> Result<(), RedisError> {
self.conn.execute(CmsMerge::new(destination, sources)).await
}
pub async fn merge_weighted(
&mut self,
destination: impl Into<CommandArg>,
sources: &[(impl AsRef<[u8]>, i64)],
) -> Result<(), RedisError> {
let keys: Vec<CommandArg> = sources
.iter()
.map(|(key, _)| CommandArg::copy_from_slice(key.as_ref()))
.collect();
let weights: Vec<i64> = sources.iter().map(|(_, w)| *w).collect();
self.conn
.execute(CmsMerge::new(destination, keys).weights(weights))
.await
}
pub async fn info(&mut self) -> Result<CmsInfo, RedisError> {
let frame = self.conn.execute(CmsInfoCmd::new(&self.key)).await?;
let map = parse_flat_kv_frame(frame)?;
Ok(CmsInfo {
width: get_i64(&map, "width")?,
depth: get_i64(&map, "depth")?,
count: get_i64(&map, "count")?,
})
}
}
#[derive(Debug, Clone)]
pub struct TopKInfo {
pub k: i64,
pub width: i64,
pub depth: i64,
pub decay: f64,
}
pub struct TopK<'a, C> {
key: CommandArg,
conn: &'a mut C,
}
impl<'a, C: RedisExecutor + Send> TopK<'a, C> {
pub fn new(conn: &'a mut C, key: impl Into<CommandArg>) -> Self {
Self {
key: key.into(),
conn,
}
}
pub async fn reserve(&mut self, k: i64) -> Result<(), RedisError> {
self.conn.execute(TopkReserve::new(&self.key, k)).await
}
pub async fn reserve_with_params(
&mut self,
k: i64,
width: i64,
depth: i64,
decay: f64,
) -> Result<(), RedisError> {
self.conn
.execute(TopkReserve::new(&self.key, k).params(width, depth, decay))
.await
}
pub async fn add(
&mut self,
items: impl IntoIterator<Item = impl Into<CommandArg>>,
) -> Result<Vec<Option<bytes::Bytes>>, RedisError> {
self.conn.execute(TopkAdd::new(&self.key, items)).await
}
pub async fn incrby(
&mut self,
items: &[(impl AsRef<[u8]>, i64)],
) -> Result<Vec<Option<bytes::Bytes>>, RedisError> {
self.conn
.execute(TopkIncrBy::new(
&self.key,
items
.iter()
.map(|(item, count)| (CommandArg::copy_from_slice(item.as_ref()), *count)),
))
.await
}
pub async fn query(
&mut self,
items: impl IntoIterator<Item = impl Into<CommandArg>>,
) -> Result<Vec<bool>, RedisError> {
self.conn.execute(TopkQuery::new(&self.key, items)).await
}
pub async fn count(
&mut self,
items: impl IntoIterator<Item = impl Into<CommandArg>>,
) -> Result<Vec<i64>, RedisError> {
self.conn.execute(TopkCount::new(&self.key, items)).await
}
pub async fn list(&mut self) -> Result<Vec<bytes::Bytes>, RedisError> {
let frame = self.conn.execute(TopkList::new(&self.key)).await?;
match frame {
Frame::Array(Some(items)) => items
.into_iter()
.map(|f| match f {
Frame::BulkString(Some(bytes)) => Ok(bytes),
other => Err(RedisError::UnexpectedResponse {
expected: "bulk string",
actual: format!("{other:?}"),
}),
})
.collect(),
other => Err(RedisError::UnexpectedResponse {
expected: "array",
actual: format!("{other:?}"),
}),
}
}
pub async fn list_with_counts(&mut self) -> Result<Vec<(bytes::Bytes, i64)>, RedisError> {
let frame = self
.conn
.execute(TopkList::new(&self.key).withcount())
.await?;
match frame {
Frame::Array(Some(items)) => {
let mut result = Vec::new();
let mut iter = items.into_iter();
while let (Some(item_f), Some(count_f)) = (iter.next(), iter.next()) {
let item = match item_f {
Frame::BulkString(Some(bytes)) => bytes,
other => {
return Err(RedisError::UnexpectedResponse {
expected: "bulk string item",
actual: format!("{other:?}"),
});
}
};
let count = match count_f {
Frame::Integer(n) => n,
other => {
return Err(RedisError::UnexpectedResponse {
expected: "integer count",
actual: format!("{other:?}"),
});
}
};
result.push((item, count));
}
Ok(result)
}
other => Err(RedisError::UnexpectedResponse {
expected: "array",
actual: format!("{other:?}"),
}),
}
}
pub async fn info(&mut self) -> Result<TopKInfo, RedisError> {
let frame = self.conn.execute(TopkInfo::new(&self.key)).await?;
let map = parse_flat_kv_frame(frame)?;
Ok(TopKInfo {
k: get_i64(&map, "k")?,
width: get_i64(&map, "width")?,
depth: get_i64(&map, "depth")?,
decay: get_f64(&map, "decay")?,
})
}
}
#[derive(Debug, Clone)]
pub struct TDigestInfo {
pub compression: i64,
pub capacity: i64,
pub merged_nodes: i64,
pub unmerged_nodes: i64,
pub merged_weight: f64,
pub unmerged_weight: f64,
pub total_compressions: i64,
pub memory_usage: i64,
}
pub struct TDigest<'a, C> {
key: CommandArg,
conn: &'a mut C,
}
impl<'a, C: RedisExecutor + Send> TDigest<'a, C> {
pub fn new(conn: &'a mut C, key: impl Into<CommandArg>) -> Self {
Self {
key: key.into(),
conn,
}
}
pub async fn create(&mut self) -> Result<(), RedisError> {
self.conn.execute(TdigestCreate::new(&self.key)).await
}
pub async fn create_with_compression(&mut self, compression: i64) -> Result<(), RedisError> {
self.conn
.execute(TdigestCreate::new(&self.key).compression(compression))
.await
}
pub async fn add(&mut self, values: &[f64]) -> Result<(), RedisError> {
self.conn
.execute(TdigestAdd::new(&self.key, values.iter().copied()))
.await
}
pub async fn merge(
&mut self,
destination: impl Into<CommandArg>,
sources: impl IntoIterator<Item = impl Into<CommandArg>>,
) -> Result<(), RedisError> {
self.conn
.execute(TdigestMerge::new(destination, sources))
.await
}
pub async fn reset(&mut self) -> Result<(), RedisError> {
self.conn.execute(TdigestReset::new(&self.key)).await
}
pub async fn cdf(&mut self, values: &[f64]) -> Result<Vec<f64>, RedisError> {
self.conn
.execute(TdigestCdf::new(&self.key, values.iter().copied()))
.await
}
pub async fn quantile(&mut self, quantiles: &[f64]) -> Result<Vec<f64>, RedisError> {
self.conn
.execute(TdigestQuantile::new(&self.key, quantiles.iter().copied()))
.await
}
pub async fn min(&mut self) -> Result<f64, RedisError> {
self.conn.execute(TdigestMin::new(&self.key)).await
}
pub async fn max(&mut self) -> Result<f64, RedisError> {
self.conn.execute(TdigestMax::new(&self.key)).await
}
pub async fn trimmed_mean(&mut self, low: f64, high: f64) -> Result<f64, RedisError> {
self.conn
.execute(TdigestTrimmedMean::new(&self.key, low, high))
.await
}
pub async fn rank(&mut self, values: &[f64]) -> Result<Vec<i64>, RedisError> {
self.conn
.execute(TdigestRank::new(&self.key, values.iter().copied()))
.await
}
pub async fn revrank(&mut self, values: &[f64]) -> Result<Vec<i64>, RedisError> {
self.conn
.execute(TdigestRevRank::new(&self.key, values.iter().copied()))
.await
}
pub async fn byrank(&mut self, ranks: &[i64]) -> Result<Vec<f64>, RedisError> {
self.conn
.execute(TdigestByRank::new(&self.key, ranks.iter().copied()))
.await
}
pub async fn byrevrank(&mut self, ranks: &[i64]) -> Result<Vec<f64>, RedisError> {
self.conn
.execute(TdigestByRevRank::new(&self.key, ranks.iter().copied()))
.await
}
pub async fn info(&mut self) -> Result<TDigestInfo, RedisError> {
let frame = self.conn.execute(TdigestInfo::new(&self.key)).await?;
let map = parse_flat_kv_frame(frame)?;
Ok(TDigestInfo {
compression: get_i64(&map, "Compression")?,
capacity: get_i64(&map, "Capacity")?,
merged_nodes: get_i64(&map, "Merged nodes")?,
unmerged_nodes: get_i64(&map, "Unmerged nodes")?,
merged_weight: get_f64(&map, "Merged weight")?,
unmerged_weight: get_f64(&map, "Unmerged weight")?,
total_compressions: get_i64(&map, "Total compressions")?,
memory_usage: get_i64(&map, "Memory usage")?,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::VecDeque;
use std::future::Future;
use bytes::Bytes;
use redis_tower_core::Command;
struct MockExecutor {
responses: VecDeque<Frame>,
}
impl MockExecutor {
fn new(frames: Vec<Frame>) -> Self {
Self {
responses: VecDeque::from(frames),
}
}
}
impl RedisExecutor for MockExecutor {
fn execute<Cmd: Command>(
&mut self,
cmd: Cmd,
) -> impl Future<Output = Result<Cmd::Response, RedisError>> + Send {
let frame = self.responses.pop_front().unwrap_or(Frame::Null);
async move { cmd.parse_response(frame) }
}
}
fn ok_frame() -> Frame {
Frame::SimpleString(Bytes::from_static(b"OK"))
}
#[tokio::test]
async fn bloom_add_returns_true() {
let mut mock = MockExecutor::new(vec![Frame::Integer(1)]);
let mut bf = BloomFilter::new(&mut mock, "test:bf");
let result = bf.add("item").await.unwrap();
assert!(result);
}
#[tokio::test]
async fn bloom_madd_returns_vec() {
let mut mock = MockExecutor::new(vec![Frame::Array(Some(vec![
Frame::Integer(1),
Frame::Integer(0),
]))]);
let mut bf = BloomFilter::new(&mut mock, "test:bf");
let result = bf.madd(&["a", "b"]).await.unwrap();
assert_eq!(result, vec![true, false]);
}
#[tokio::test]
async fn bloom_exists_returns_false() {
let mut mock = MockExecutor::new(vec![Frame::Integer(0)]);
let mut bf = BloomFilter::new(&mut mock, "test:bf");
let result = bf.exists("missing").await.unwrap();
assert!(!result);
}
#[tokio::test]
async fn bloom_info_parses() {
let frame = Frame::Array(Some(vec![
Frame::BulkString(Some(Bytes::from("Capacity"))),
Frame::Integer(1000),
Frame::BulkString(Some(Bytes::from("Size"))),
Frame::Integer(2048),
Frame::BulkString(Some(Bytes::from("Number of filters"))),
Frame::Integer(1),
Frame::BulkString(Some(Bytes::from("Number of items inserted"))),
Frame::Integer(0),
Frame::BulkString(Some(Bytes::from("Expansion rate"))),
Frame::Integer(2),
]));
let mut mock = MockExecutor::new(vec![frame]);
let mut bf = BloomFilter::new(&mut mock, "test:bf");
let info = bf.info().await.unwrap();
assert_eq!(info.capacity, 1000);
assert_eq!(info.size, 2048);
assert_eq!(info.num_filters, 1);
assert_eq!(info.num_items_inserted, 0);
assert_eq!(info.expansion_rate, 2);
}
#[tokio::test]
async fn bloom_info_parses_resp3_map() {
let frame = Frame::Map(vec![
(
Frame::SimpleString(Bytes::from_static(b"Capacity")),
Frame::Integer(1000),
),
(
Frame::SimpleString(Bytes::from_static(b"Size")),
Frame::Integer(2048),
),
(
Frame::SimpleString(Bytes::from_static(b"Number of filters")),
Frame::Integer(1),
),
(
Frame::SimpleString(Bytes::from_static(b"Number of items inserted")),
Frame::Integer(4),
),
(
Frame::SimpleString(Bytes::from_static(b"Expansion rate")),
Frame::Integer(2),
),
]);
let mut mock = MockExecutor::new(vec![frame]);
let mut bf = BloomFilter::new(&mut mock, "test:bf");
let info = bf.info().await.unwrap();
assert_eq!(info.capacity, 1000);
assert_eq!(info.size, 2048);
assert_eq!(info.num_filters, 1);
assert_eq!(info.num_items_inserted, 4);
assert_eq!(info.expansion_rate, 2);
}
#[test]
fn info_parser_rejects_odd_resp2_array() {
let frame = Frame::Array(Some(vec![Frame::SimpleString(Bytes::from_static(
b"Capacity",
))]));
let error = parse_flat_kv_frame(frame).unwrap_err();
assert!(error.to_string().contains("even-length"));
}
#[test]
fn info_parser_rejects_duplicate_resp3_fields() {
let frame = Frame::Map(vec![
(
Frame::SimpleString(Bytes::from_static(b"Capacity")),
Frame::Integer(1000),
),
(
Frame::BulkString(Some(Bytes::from_static(b"Capacity"))),
Frame::Integer(2000),
),
]);
let error = parse_flat_kv_frame(frame).unwrap_err();
assert!(error.to_string().contains("duplicate field `Capacity`"));
}
#[test]
fn info_parser_rejects_invalid_utf8_key() {
let frame = Frame::Map(vec![(
Frame::SimpleString(Bytes::from_static(b"\xff")),
Frame::Integer(1),
)]);
let error = parse_flat_kv_frame(frame).unwrap_err();
assert!(error.to_string().contains("valid UTF-8 key"));
}
#[tokio::test]
async fn cuckoo_add_returns_true() {
let mut mock = MockExecutor::new(vec![Frame::Integer(1)]);
let mut cf = CuckooFilter::new(&mut mock, "test:cf");
let result = cf.add("item").await.unwrap();
assert!(result);
}
#[tokio::test]
async fn cuckoo_del_returns_bool() {
let mut mock = MockExecutor::new(vec![Frame::Integer(1)]);
let mut cf = CuckooFilter::new(&mut mock, "test:cf");
let result = cf.del("item").await.unwrap();
assert!(result);
}
#[tokio::test]
async fn cms_init_by_dim_ok() {
let mut mock = MockExecutor::new(vec![ok_frame()]);
let mut cms = CountMinSketch::new(&mut mock, "test:cms");
cms.init_by_dim(100, 5).await.unwrap();
}
#[tokio::test]
async fn cms_incrby_returns_counts() {
let mut mock = MockExecutor::new(vec![Frame::Array(Some(vec![
Frame::Integer(5),
Frame::Integer(3),
]))]);
let mut cms = CountMinSketch::new(&mut mock, "test:cms");
let counts = cms.incrby(&[("foo", 5), ("bar", 3)]).await.unwrap();
assert_eq!(counts, vec![5, 3]);
}
#[tokio::test]
async fn cms_query_returns_counts() {
let mut mock = MockExecutor::new(vec![Frame::Array(Some(vec![
Frame::Integer(10),
Frame::Integer(0),
]))]);
let mut cms = CountMinSketch::new(&mut mock, "test:cms");
let counts = cms.query(&["foo", "bar"]).await.unwrap();
assert_eq!(counts, vec![10, 0]);
}
#[tokio::test]
async fn topk_add_returns_evicted() {
let mut mock = MockExecutor::new(vec![Frame::Array(Some(vec![
Frame::Null,
Frame::BulkString(Some(Bytes::from("evicted-item"))),
]))]);
let mut topk = TopK::new(&mut mock, "test:topk");
let result = topk.add(&["new1", "new2"]).await.unwrap();
assert_eq!(
result,
vec![None, Some(Bytes::from_static(b"evicted-item"))]
);
}
#[tokio::test]
async fn topk_list_returns_items() {
let mut mock = MockExecutor::new(vec![Frame::Array(Some(vec![
Frame::BulkString(Some(Bytes::from("alpha"))),
Frame::BulkString(Some(Bytes::from("beta"))),
]))]);
let mut topk = TopK::new(&mut mock, "test:topk");
let items = topk.list().await.unwrap();
assert_eq!(
items,
vec![Bytes::from_static(b"alpha"), Bytes::from_static(b"beta")]
);
}
#[tokio::test]
async fn tdigest_add_ok() {
let mut mock = MockExecutor::new(vec![ok_frame()]);
let mut td = TDigest::new(&mut mock, "test:td");
td.add(&[1.0, 2.0, 3.0]).await.unwrap();
}
#[tokio::test]
async fn tdigest_quantile_returns_values() {
let mut mock = MockExecutor::new(vec![Frame::Array(Some(vec![
Frame::Double(1.0),
Frame::Double(5.0),
Frame::Double(9.0),
]))]);
let mut td = TDigest::new(&mut mock, "test:td");
let values = td.quantile(&[0.1, 0.5, 0.9]).await.unwrap();
assert_eq!(values, vec![1.0, 5.0, 9.0]);
}
#[tokio::test]
async fn tdigest_info_parses() {
let frame = Frame::Array(Some(vec![
Frame::BulkString(Some(Bytes::from("Compression"))),
Frame::Integer(100),
Frame::BulkString(Some(Bytes::from("Capacity"))),
Frame::Integer(610),
Frame::BulkString(Some(Bytes::from("Merged nodes"))),
Frame::Integer(3),
Frame::BulkString(Some(Bytes::from("Unmerged nodes"))),
Frame::Integer(0),
Frame::BulkString(Some(Bytes::from("Merged weight"))),
Frame::Double(10.0),
Frame::BulkString(Some(Bytes::from("Unmerged weight"))),
Frame::Double(0.0),
Frame::BulkString(Some(Bytes::from("Total compressions"))),
Frame::Integer(1),
Frame::BulkString(Some(Bytes::from("Memory usage"))),
Frame::Integer(9136),
]));
let mut mock = MockExecutor::new(vec![frame]);
let mut td = TDigest::new(&mut mock, "test:td");
let info = td.info().await.unwrap();
assert_eq!(info.compression, 100);
assert_eq!(info.capacity, 610);
assert_eq!(info.merged_nodes, 3);
assert_eq!(info.unmerged_nodes, 0);
assert_eq!(info.merged_weight, 10.0);
assert_eq!(info.unmerged_weight, 0.0);
assert_eq!(info.total_compressions, 1);
assert_eq!(info.memory_usage, 9136);
}
}