From fe3cb94aef0dea87a9f7dbf58addc0a67e905187 Mon Sep 17 00:00:00 2001 From: Huaijin Date: Tue, 13 Oct 2026 07:14:46 +0000 Subject: [PATCH] test(promql): drop redundant and no-op unit tests (#15285) --- src/promql/src/aggregations/avg.rs | 24 -- src/promql/src/aggregations/count.rs | 24 -- src/promql/src/aggregations/extrema.rs | 13 - src/promql/src/aggregations/group.rs | 24 -- src/promql/src/aggregations/max.rs | 24 -- src/promql/src/aggregations/min.rs | 24 -- src/promql/src/aggregations/mod.rs | 49 --- src/promql/src/aggregations/quantile.rs | 16 - src/promql/src/aggregations/stddev.rs | 24 -- src/promql/src/aggregations/stdvar.rs | 24 -- src/promql/src/aggregations/sum.rs | 24 -- src/promql/src/ast/name_visitor.rs | 6 - src/promql/src/ast/rewrite.rs | 47 --- src/promql/src/ast/selector_visitor.rs | 6 - src/promql/src/binary/vector_operations.rs | 358 +----------------- src/promql/src/common.rs | 74 ---- src/promql/src/engine/aggregate.rs | 21 - src/promql/src/engine/call.rs | 155 -------- src/promql/src/engine/mod.rs | 328 +--------------- src/promql/src/engine/selector.rs | 192 +--------- src/promql/src/functions/avg_over_time.rs | 18 - src/promql/src/functions/changes.rs | 12 - src/promql/src/functions/count_over_time.rs | 18 - src/promql/src/functions/deriv.rs | 12 - src/promql/src/functions/extrapolated.rs | 29 -- src/promql/src/functions/holt_winters.rs | 12 - src/promql/src/functions/idelta.rs | 12 - src/promql/src/functions/irate.rs | 12 - src/promql/src/functions/label_join.rs | 54 --- src/promql/src/functions/label_replace.rs | 112 ------ src/promql/src/functions/last_over_time.rs | 18 - src/promql/src/functions/math_operations.rs | 155 -------- src/promql/src/functions/max_over_time.rs | 18 - src/promql/src/functions/min_over_time.rs | 18 - src/promql/src/functions/mod.rs | 13 - src/promql/src/functions/predict_linear.rs | 12 - src/promql/src/functions/present_over_time.rs | 5 - .../src/functions/quantile_over_time.rs | 14 - src/promql/src/functions/stddev_over_time.rs | 11 - src/promql/src/functions/stdvar_over_time.rs | 11 - src/promql/src/functions/sum_over_time.rs | 11 - src/promql/src/series_stream/blocks.rs | 95 ----- 42 files changed, 5 insertions(+), 2124 deletions(-) diff --git a/src/promql/src/aggregations/avg.rs b/src/promql/src/aggregations/avg.rs index 4c5ecf5765..c13cac6d31 100644 --- a/src/promql/src/aggregations/avg.rs +++ b/src/promql/src/aggregations/avg.rs @@ -113,30 +113,6 @@ mod tests { use super::*; use crate::aggregations::eval_aggregate; - #[test] - fn test_avg_value_none_input() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::None, Avg, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_avg_invalid_input_returns_err() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Float(1.0), Avg, &eval_ctx); - assert!(result.is_err()); - } - - #[test] - fn test_avg_empty_matrix_returns_none() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Matrix(vec![]), Avg, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - #[test] fn test_avg_range_function() { let timestamp = 1640995200; // 2022-01-01 00:00:00 UTC diff --git a/src/promql/src/aggregations/count.rs b/src/promql/src/aggregations/count.rs index ef853ea14d..ed6a7eb9e9 100644 --- a/src/promql/src/aggregations/count.rs +++ b/src/promql/src/aggregations/count.rs @@ -82,30 +82,6 @@ mod tests { use super::*; use crate::aggregations::eval_aggregate; - #[test] - fn test_count_value_none_input() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::None, Count, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_count_invalid_input_returns_err() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Float(1.0), Count, &eval_ctx); - assert!(result.is_err()); - } - - #[test] - fn test_count_empty_matrix_returns_none() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Matrix(vec![]), Count, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - #[test] fn test_count_range_function() { let timestamp = 1640995200; // 2022-01-01 00:00:00 UTC diff --git a/src/promql/src/aggregations/extrema.rs b/src/promql/src/aggregations/extrema.rs index 53dc02a938..a167d01739 100644 --- a/src/promql/src/aggregations/extrema.rs +++ b/src/promql/src/aggregations/extrema.rs @@ -78,16 +78,3 @@ impl Accumulate for ExtremaAccumulator { group_series(group_labels, samples) } } - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_min_and_max_have_distinct_accumulator_types() { - assert_ne!( - std::any::TypeId::of::>(), - std::any::TypeId::of::>(), - ); - } -} diff --git a/src/promql/src/aggregations/group.rs b/src/promql/src/aggregations/group.rs index 04272271b3..ea513ed96f 100644 --- a/src/promql/src/aggregations/group.rs +++ b/src/promql/src/aggregations/group.rs @@ -83,30 +83,6 @@ mod tests { use super::*; use crate::aggregations::eval_aggregate; - #[test] - fn test_group_value_none_input() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::None, Group, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_group_invalid_input_returns_err() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Float(1.0), Group, &eval_ctx); - assert!(result.is_err()); - } - - #[test] - fn test_group_empty_matrix_returns_none() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Matrix(vec![]), Group, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - #[test] fn test_group_range_function() { let timestamp = 1640995200; // 2022-01-01 00:00:00 UTC diff --git a/src/promql/src/aggregations/max.rs b/src/promql/src/aggregations/max.rs index 139c947694..5d992f3959 100644 --- a/src/promql/src/aggregations/max.rs +++ b/src/promql/src/aggregations/max.rs @@ -39,30 +39,6 @@ mod tests { use super::*; use crate::aggregations::eval_aggregate; - #[test] - fn test_max_value_none_input() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::None, Max, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_max_invalid_input_returns_err() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Float(1.0), Max, &eval_ctx); - assert!(result.is_err()); - } - - #[test] - fn test_max_empty_matrix_returns_none() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Matrix(vec![]), Max, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - #[test] fn test_max_range_function() { let timestamp = 1640995200; // 2022-01-01 00:00:00 UTC diff --git a/src/promql/src/aggregations/min.rs b/src/promql/src/aggregations/min.rs index 650d44488a..317e7868bf 100644 --- a/src/promql/src/aggregations/min.rs +++ b/src/promql/src/aggregations/min.rs @@ -39,30 +39,6 @@ mod tests { use super::*; use crate::aggregations::eval_aggregate; - #[test] - fn test_min_value_none_input() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::None, Min, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_min_invalid_input_returns_err() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Float(1.0), Min, &eval_ctx); - assert!(result.is_err()); - } - - #[test] - fn test_min_empty_matrix_returns_none() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Matrix(vec![]), Min, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - #[test] fn test_min_range_function() { let timestamp = 1640995200; // 2022-01-01 00:00:00 UTC diff --git a/src/promql/src/aggregations/mod.rs b/src/promql/src/aggregations/mod.rs index 02791f9a2e..abb52a65c7 100644 --- a/src/promql/src/aggregations/mod.rs +++ b/src/promql/src/aggregations/mod.rs @@ -537,14 +537,6 @@ mod tests { use super::*; // Test data helpers - fn create_test_labels() -> Labels { - vec![ - Arc::new(Label::new("instance", "localhost:9090")), - Arc::new(Label::new("job", "prometheus")), - Arc::new(Label::new("__name__", "http_requests_total")), - ] - } - fn labels_to_include( include_labels: &[String], mut actual_labels: Vec>, @@ -562,19 +554,6 @@ mod tests { actual_labels } - #[test] - fn test_labels_to_include() { - let actual_labels = create_test_labels(); - let include_labels = vec!["instance".to_string(), "job".to_string()]; - - let result = labels_to_include(&include_labels, actual_labels.clone()); - - assert_eq!(result.len(), 2); - assert!(result.iter().any(|l| l.name == "instance")); - assert!(result.iter().any(|l| l.name == "job")); - assert!(!result.iter().any(|l| l.name == "__name__")); - } - /// One value of a label-less series, for the scalar accumulators that never read labels. fn push(acc: &mut A, slot: usize, value: f64) { acc.push_series(std::iter::once((slot, value)), Labels::default); @@ -986,34 +965,6 @@ mod tests { assert_eq!(eval_chunked_single_group(&values, Avg), -2.0 / n as f64); } - #[test] - fn test_labels_to_exclude_removes_name_label() { - let actual_labels = create_test_labels(); - let exclude_labels = vec!["instance".to_string()]; - - let result = labels_to_exclude(&exclude_labels, actual_labels.clone()); - - // Should not contain __name__ label (which is NAME_LABEL) - assert!(!result.iter().any(|l| l.name == "__name__")); - } - - #[test] - fn test_labels_to_include_empty_include_list() { - let actual_labels = create_test_labels(); - let result = labels_to_include(&[], actual_labels); - assert_eq!(result.len(), 0); - } - - #[test] - fn test_labels_to_exclude_empty_exclude_list() { - let actual_labels = create_test_labels(); - let result = labels_to_exclude(&[], actual_labels); - // NAME_LABEL (__name__) is always excluded - assert!(!result.iter().any(|l| l.name == "__name__")); - assert!(result.iter().any(|l| l.name == "instance")); - assert!(result.iter().any(|l| l.name == "job")); - } - #[test] fn test_projected_labels_signature_matches_materialized_projection() { use promql_parser::label::Labels as ParserLabels; diff --git a/src/promql/src/aggregations/quantile.rs b/src/promql/src/aggregations/quantile.rs index 72a9855bcc..3ecf5a1530 100644 --- a/src/promql/src/aggregations/quantile.rs +++ b/src/promql/src/aggregations/quantile.rs @@ -246,22 +246,6 @@ mod tests { assert_eq!(result[1].samples[0].value, 30.0); } - #[test] - fn test_quantile_value_none_input() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = quantile(ScalarParam::Const(0.5), &None, Value::None, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_quantile_invalid_input_returns_err() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = quantile(ScalarParam::Const(0.5), &None, Value::Float(1.0), &eval_ctx); - assert!(result.is_err()); - } - #[test] fn test_quantile_out_of_range_phi_is_per_group() { let ts = 1000; diff --git a/src/promql/src/aggregations/stddev.rs b/src/promql/src/aggregations/stddev.rs index ce89419aaa..49b822e8d6 100644 --- a/src/promql/src/aggregations/stddev.rs +++ b/src/promql/src/aggregations/stddev.rs @@ -44,30 +44,6 @@ mod tests { use super::*; use crate::aggregations::eval_aggregate; - #[test] - fn test_stddev_value_none_input() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::None, Stddev, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_stddev_invalid_input_returns_err() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Float(1.0), Stddev, &eval_ctx); - assert!(result.is_err()); - } - - #[test] - fn test_stddev_empty_matrix_returns_none() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Matrix(vec![]), Stddev, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - #[test] fn test_stddev_range_function() { let timestamp = 1640995200; // 2022-01-01 00:00:00 UTC diff --git a/src/promql/src/aggregations/stdvar.rs b/src/promql/src/aggregations/stdvar.rs index 4e2f48bd4b..ef1a4b525f 100644 --- a/src/promql/src/aggregations/stdvar.rs +++ b/src/promql/src/aggregations/stdvar.rs @@ -44,30 +44,6 @@ mod tests { use super::*; use crate::aggregations::eval_aggregate; - #[test] - fn test_stdvar_value_none_input() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::None, Stdvar, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_stdvar_invalid_input_returns_err() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Float(1.0), Stdvar, &eval_ctx); - assert!(result.is_err()); - } - - #[test] - fn test_stdvar_empty_matrix_returns_none() { - let timestamp = 1640995200; - let eval_ctx = EvalContext::new(timestamp, timestamp + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Matrix(vec![]), Stdvar, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - #[test] fn test_stdvar_range_function() { let timestamp = 1640995200; // 2022-01-01 00:00:00 UTC diff --git a/src/promql/src/aggregations/sum.rs b/src/promql/src/aggregations/sum.rs index 1eef1e35bf..93e9f0fa2d 100644 --- a/src/promql/src/aggregations/sum.rs +++ b/src/promql/src/aggregations/sum.rs @@ -148,30 +148,6 @@ mod tests { } } - #[test] - fn test_sum_value_none_input() { - let ts = 1640995200; - let eval_ctx = EvalContext::new(ts, ts + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::None, Sum, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_sum_invalid_input_returns_err() { - let ts = 1640995200; - let eval_ctx = EvalContext::new(ts, ts + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Float(1.0), Sum, &eval_ctx); - assert!(result.is_err()); - } - - #[test] - fn test_sum_empty_matrix_returns_none() { - let ts = 1640995200; - let eval_ctx = EvalContext::new(ts, ts + 1, 1, "test".to_string()); - let result = eval_aggregate(&None, Value::Matrix(vec![]), Sum, &eval_ctx).unwrap(); - assert!(matches!(result, Value::None)); - } - #[test] fn test_sum_range_function() { // Create test matrix data with multiple series and timestamps diff --git a/src/promql/src/ast/name_visitor.rs b/src/promql/src/ast/name_visitor.rs index 1479478a34..5f1e4094b3 100644 --- a/src/promql/src/ast/name_visitor.rs +++ b/src/promql/src/ast/name_visitor.rs @@ -85,12 +85,6 @@ mod tests { assert_eq!(visitor.name.len(), 1); } - #[test] - fn test_name_visitor_new_starts_empty() { - let visitor = MetricNameVisitor::new(); - assert!(visitor.name.is_empty()); - } - #[test] fn test_name_visitor_resolves_name_label_matcher() { let promql = r#"sum(rate({__name__="http_requests_total"}[1m]))"#; diff --git a/src/promql/src/ast/rewrite.rs b/src/promql/src/ast/rewrite.rs index de69e7bd92..7abb97f3d6 100644 --- a/src/promql/src/ast/rewrite.rs +++ b/src/promql/src/ast/rewrite.rs @@ -66,53 +66,6 @@ mod tests { } } - #[test] - fn test_match_placeholder_equal_op() { - let placeholder = get_config().common.dashboard_placeholder.to_string(); - let matcher = create_test_matcher("label", MatchOp::Equal, &placeholder); - assert!(match_placeholder(&matcher, &placeholder)); - - let non_matching_matcher = create_test_matcher("label", MatchOp::Equal, "other_value"); - assert!(!match_placeholder(&non_matching_matcher, &placeholder)); - } - - #[test] - fn test_match_placeholder_not_equal_op() { - let placeholder = get_config().common.dashboard_placeholder.to_string(); - let matcher = create_test_matcher("label", MatchOp::NotEqual, &placeholder); - assert!(match_placeholder(&matcher, &placeholder)); - - let non_matching_matcher = create_test_matcher("label", MatchOp::NotEqual, "other_value"); - assert!(!match_placeholder(&non_matching_matcher, &placeholder)); - } - - #[test] - fn test_match_placeholder_regex_op() { - let placeholder = get_config().common.dashboard_placeholder.to_string(); - let matcher = - create_test_matcher("label", MatchOp::Re(Regex::new("").unwrap()), &placeholder); - assert!(match_placeholder(&matcher, &placeholder)); - - let non_matching_matcher = - create_test_matcher("label", MatchOp::Re(Regex::new("").unwrap()), "other.*"); - assert!(!match_placeholder(&non_matching_matcher, &placeholder)); - } - - #[test] - fn test_match_placeholder_not_regex_op() { - let placeholder = get_config().common.dashboard_placeholder.to_string(); - let matcher = create_test_matcher( - "label", - MatchOp::NotRe(Regex::new("").unwrap()), - &placeholder, - ); - assert!(match_placeholder(&matcher, &placeholder)); - - let non_matching_matcher = - create_test_matcher("label", MatchOp::NotRe(Regex::new("").unwrap()), "other.*"); - assert!(!match_placeholder(&non_matching_matcher, &placeholder)); - } - #[test] fn test_remove_filter_all_removes_placeholder_matchers() { let placeholder = get_config().common.dashboard_placeholder.to_string(); diff --git a/src/promql/src/ast/selector_visitor.rs b/src/promql/src/ast/selector_visitor.rs index 1ce5497e9d..b21a22ad34 100644 --- a/src/promql/src/ast/selector_visitor.rs +++ b/src/promql/src/ast/selector_visitor.rs @@ -89,12 +89,6 @@ mod tests { ); } - #[test] - fn test_selector_visitor_empty() { - let visitor = MetricSelectorVisitor::default(); - assert!(visitor.exprs.is_empty()); - } - #[test] fn test_selector_visitor_non_selector_expr_not_collected() { // Scalar arithmetic has no VectorSelector or MatrixSelector diff --git a/src/promql/src/binary/vector_operations.rs b/src/promql/src/binary/vector_operations.rs index 0bbe3e6d2b..768e60d182 100644 --- a/src/promql/src/binary/vector_operations.rs +++ b/src/promql/src/binary/vector_operations.rs @@ -600,19 +600,10 @@ pub fn vector_bin_op( mod tests { use std::sync::Arc; - use config::meta::promql::value::{Label, Sample, signature}; + use config::meta::promql::value::{Label, Sample}; use super::*; - // Helper function to create test data for matrix operations - fn create_test_matrix_data() -> Vec { - vec![ - create_test_range_value(vec![1.0], vec![("instance", "localhost"), ("job", "node")]), - create_test_range_value(vec![2.0], vec![("instance", "localhost"), ("job", "node")]), - create_test_range_value(vec![3.0], vec![("instance", "remote"), ("job", "api")]), - ] - } - fn create_test_range_value(values: Vec, labels: Vec<(&str, &str)>) -> RangeValue { let labels = labels .into_iter() @@ -634,353 +625,6 @@ mod tests { } } - // Simple tests that don't require complex BinaryExpr construction - #[test] - fn test_range_value_creation() { - let range = create_test_range_value(vec![42.0], vec![("instance", "localhost")]); - assert_eq!(range.samples[0].value, 42.0); - assert_eq!(range.samples[0].timestamp, 1640995200000000i64); - assert_eq!(range.labels.len(), 1); - assert_eq!(range.labels[0].name, "instance"); - assert_eq!(range.labels[0].value, "localhost"); - } - - #[test] - fn test_range_value_with_multiple_labels() { - let range = create_test_range_value( - vec![100.0], - vec![("env", "prod"), ("region", "us-west"), ("service", "api")], - ); - assert_eq!(range.samples[0].value, 100.0); - assert_eq!(range.labels.len(), 3); - - let label_names: Vec<&str> = range.labels.iter().map(|l| l.name.as_str()).collect(); - assert!(label_names.contains(&"env")); - assert!(label_names.contains(&"region")); - assert!(label_names.contains(&"service")); - } - - #[test] - fn test_range_value_empty_labels() { - let range = create_test_range_value(vec![0.0], vec![]); - assert_eq!(range.samples[0].value, 0.0); - assert!(range.labels.is_empty()); - } - - #[test] - fn test_range_value_numeric_values() { - let test_cases = [ - (0.0, "zero"), - (1.0, "positive integer"), - (-1.0, "negative integer"), - (1.234, "positive float"), - (-1.234, "negative float"), - (f64::MAX, "max value"), - (f64::MIN, "min value"), - ]; - - for (value, description) in test_cases { - let range = create_test_range_value(vec![value], vec![("test", description)]); - assert_eq!(range.samples[0].value, value, "Failed for: {description}"); - } - } - - #[test] - fn test_range_value_timestamp_consistency() { - let range1 = create_test_range_value(vec![1.0], vec![("a", "1")]); - let range2 = create_test_range_value(vec![2.0], vec![("b", "2")]); - - // Both should have the same starting timestamp - assert_eq!(range1.samples[0].timestamp, range2.samples[0].timestamp); - assert_eq!(range1.samples[0].timestamp, 1640995200000000i64); - } - - #[test] - fn test_label_creation() { - let labels = vec![ - ("cpu", "0"), - ("mode", "idle"), - ("instance", "localhost:9100"), - ]; - let range = create_test_range_value(vec![75.5], labels.clone()); - - for (i, (expected_name, expected_value)) in labels.iter().enumerate() { - assert_eq!(range.labels[i].name, *expected_name); - assert_eq!(range.labels[i].value, *expected_value); - } - } - - #[test] - fn test_label_modification() { - let mut labels = vec![ - Arc::new(Label::new("env", "prod")), - Arc::new(Label::new("region", "us-west")), - Arc::new(Label::new("service", "api")), - ]; - - // Test label modification - labels[0] = Arc::new(Label::new("env", "staging")); - assert_eq!(labels[0].value, "staging"); - - // Test label filtering (simulate what vector operations do) - let filtered_labels: Vec> = labels - .into_iter() - .filter(|label| label.name != "env") - .collect(); - - assert_eq!(filtered_labels.len(), 2); - assert_eq!(filtered_labels[0].name, "region"); - assert_eq!(filtered_labels[1].name, "service"); - } - - #[test] - fn test_matrix_operations_parallel_processing() { - // Test that we can process matrices in parallel (simulating what the actual functions do) - let matrix = vec![ - create_test_range_value(vec![1.0], vec![("a", "1")]), - create_test_range_value(vec![2.0], vec![("a", "2")]), - create_test_range_value(vec![3.0], vec![("a", "3")]), - create_test_range_value(vec![4.0], vec![("a", "4")]), - create_test_range_value(vec![5.0], vec![("a", "5")]), - ]; - - // Simulate parallel processing by mapping over the matrix - let processed: Vec = matrix - .par_iter() - .map(|range| range.samples[0].value * 2.0) - .collect(); - - assert_eq!(processed.len(), 5); - assert_eq!(processed[0], 2.0); - assert_eq!(processed[1], 4.0); - assert_eq!(processed[2], 6.0); - assert_eq!(processed[3], 8.0); - assert_eq!(processed[4], 10.0); - } - - #[test] - fn test_matrix_operations_error_scenarios() { - // Test scenarios that could lead to errors in matrix operations - - // Test with very large numbers - let large_matrix = [ - create_test_range_value(vec![f64::MAX], vec![("a", "1")]), - create_test_range_value(vec![f64::MIN], vec![("a", "2")]), - ]; - - assert!(large_matrix[0].samples[0].value.is_finite()); - assert!(large_matrix[1].samples[0].value.is_finite()); - - // Test with NaN values - let nan_matrix = [create_test_range_value(vec![f64::NAN], vec![("a", "1")])]; - - // Should handle NaN gracefully - assert!(nan_matrix[0].samples[0].value.is_nan()); - } - - #[test] - fn test_matrix_operations_data_structures() { - // Test RangeValue creation and properties - let value = - create_test_range_value(vec![42.0], vec![("label1", "value1"), ("label2", "value2")]); - assert_eq!(value.samples[0].value, 42.0); - assert_eq!(value.labels.len(), 2); - assert_eq!(value.labels[0].name, "label1"); - assert_eq!(value.labels[0].value, "value1"); - assert_eq!(value.labels[1].name, "label2"); - assert_eq!(value.labels[1].value, "value2"); - } - - #[test] - fn test_matrix_operations_timestamp_consistency() { - let timestamp = 1640995200000000i64; - let value = create_test_range_value(vec![10.0], vec![("test", "value")]); - assert_eq!(value.samples[0].timestamp, timestamp); - } - - #[test] - fn test_matrix_operations_label_handling() { - let value = create_test_range_value(vec![5.0], vec![("a", "1"), ("b", "2"), ("c", "3")]); - assert_eq!(value.labels.len(), 3); - - // Test label ordering and values - let labels = &value.labels; - assert_eq!(labels[0].name, "a"); - assert_eq!(labels[0].value, "1"); - assert_eq!(labels[1].name, "b"); - assert_eq!(labels[1].value, "2"); - assert_eq!(labels[2].name, "c"); - assert_eq!(labels[2].value, "3"); - } - - #[test] - fn test_matrix_operations_empty_labels() { - let value = create_test_range_value(vec![0.0], vec![]); - assert_eq!(value.labels.len(), 0); - assert_eq!(value.samples[0].value, 0.0); - } - - #[test] - fn test_matrix_operations_negative_values() { - let value = create_test_range_value(vec![-15.5], vec![("negative", "test")]); - assert_eq!(value.samples[0].value, -15.5); - assert_eq!(value.labels.len(), 1); - assert_eq!(value.labels[0].name, "negative"); - assert_eq!(value.labels[0].value, "test"); - } - - #[test] - fn test_matrix_operations_large_numbers() { - let value = create_test_range_value(vec![1e15], vec![("large", "number")]); - assert_eq!(value.samples[0].value, 1e15); - assert_eq!(value.labels.len(), 1); - } - - #[test] - fn test_matrix_operations_special_floats() { - let value = create_test_range_value(vec![f64::INFINITY], vec![("inf", "test")]); - assert!(value.samples[0].value.is_infinite()); - assert!(value.samples[0].value.is_sign_positive()); - - let value = create_test_range_value(vec![f64::NEG_INFINITY], vec![("neg_inf", "test")]); - assert!(value.samples[0].value.is_infinite()); - assert!(value.samples[0].value.is_sign_negative()); - - let value = create_test_range_value(vec![f64::NAN], vec![("nan", "test")]); - assert!(value.samples[0].value.is_nan()); - } - - #[test] - fn test_matrix_operations_unicode_labels() { - let value = create_test_range_value( - vec![1.0], - vec![("🚀", "🚀"), ("测试", "测试"), ("🎉", "🎉")], - ); - assert_eq!(value.labels.len(), 3); - assert_eq!(value.labels[0].name, "🚀"); - assert_eq!(value.labels[0].value, "🚀"); - assert_eq!(value.labels[1].name, "测试"); - assert_eq!(value.labels[1].value, "测试"); - assert_eq!(value.labels[2].name, "🎉"); - assert_eq!(value.labels[2].value, "🎉"); - } - - #[test] - fn test_matrix_operations_long_labels() { - let long_name = "a".repeat(1000); - let long_value = "b".repeat(1000); - let value = create_test_range_value(vec![1.0], vec![(&long_name, &long_value)]); - assert_eq!(value.labels.len(), 1); - assert_eq!(value.labels[0].name, long_name); - assert_eq!(value.labels[0].value, long_value); - } - - #[test] - fn test_matrix_operations_duplicate_labels() { - let value = create_test_range_value(vec![1.0], vec![("a", "1"), ("a", "2"), ("a", "3")]); - assert_eq!(value.labels.len(), 3); - // All labels should be preserved even if names are duplicate - assert_eq!(value.labels[0].name, "a"); - assert_eq!(value.labels[0].value, "1"); - assert_eq!(value.labels[1].name, "a"); - assert_eq!(value.labels[1].value, "2"); - assert_eq!(value.labels[2].name, "a"); - assert_eq!(value.labels[2].value, "3"); - } - - #[test] - fn test_matrix_operations_edge_case_values() { - let value = create_test_range_value(vec![f64::EPSILON], vec![("epsilon", "test")]); - assert_eq!(value.samples[0].value, f64::EPSILON); - - let value = - create_test_range_value(vec![f64::MIN_POSITIVE], vec![("min_positive", "test")]); - assert_eq!(value.samples[0].value, f64::MIN_POSITIVE); - - let value = create_test_range_value(vec![f64::MAX], vec![("max", "test")]); - assert_eq!(value.samples[0].value, f64::MAX); - } - - #[test] - fn test_matrix_operations_matrix_data() { - let matrix_data = create_test_matrix_data(); - assert_eq!(matrix_data.len(), 3); - - // Test first element - assert_eq!(matrix_data[0].samples[0].value, 1.0); - assert_eq!(matrix_data[0].labels.len(), 2); - assert_eq!(matrix_data[0].labels[0].name, "instance"); - assert_eq!(matrix_data[0].labels[0].value, "localhost"); - - // Test second element - assert_eq!(matrix_data[1].samples[0].value, 2.0); - assert_eq!(matrix_data[1].labels.len(), 2); - - // Test third element - assert_eq!(matrix_data[2].samples[0].value, 3.0); - assert_eq!(matrix_data[2].labels.len(), 2); - assert_eq!(matrix_data[2].labels[0].name, "instance"); - assert_eq!(matrix_data[2].labels[0].value, "remote"); - } - - #[test] - fn test_matrix_operations_label_signatures() { - let value1 = create_test_range_value(vec![1.0], vec![("a", "1"), ("b", "2")]); - let value2 = create_test_range_value(vec![2.0], vec![("a", "1"), ("b", "2")]); - let value3 = create_test_range_value(vec![3.0], vec![("a", "1"), ("b", "3")]); - - // value1 and value2 should have the same signature (same labels) - let sig1 = signature(&value1.labels); - let sig2 = signature(&value2.labels); - let sig3 = signature(&value3.labels); - - assert_eq!(sig1, sig2); - assert_ne!(sig1, sig3); - assert_ne!(sig2, sig3); - } - - #[test] - fn test_matrix_operations_empty_matrix() { - let empty_matrix: Vec = vec![]; - assert_eq!(empty_matrix.len(), 0); - - // Test that we can create an empty matrix and it doesn't panic - let empty_matrix_with_capacity: Vec = Vec::with_capacity(100); - assert_eq!(empty_matrix_with_capacity.len(), 0); - assert_eq!(empty_matrix_with_capacity.capacity(), 100); - } - - #[test] - fn test_matrix_operations_single_element() { - let single_element = [create_test_range_value( - vec![42.0], - vec![("single", "test")], - )]; - assert_eq!(single_element.len(), 1); - assert_eq!(single_element[0].samples[0].value, 42.0); - assert_eq!(single_element[0].labels.len(), 1); - assert_eq!(single_element[0].labels[0].name, "single"); - assert_eq!(single_element[0].labels[0].value, "test"); - } - - #[test] - fn test_matrix_operations_multiple_samples() { - // Test RangeValue with multiple samples - let value = - create_test_range_value(vec![1.0, 2.0, 3.0, 4.0, 5.0], vec![("metric", "test")]); - assert_eq!(value.samples.len(), 5); - assert_eq!(value.samples[0].value, 1.0); - assert_eq!(value.samples[1].value, 2.0); - assert_eq!(value.samples[2].value, 3.0); - assert_eq!(value.samples[3].value, 4.0); - assert_eq!(value.samples[4].value, 5.0); - - // Check timestamps are incrementing - for i in 1..value.samples.len() { - assert!(value.samples[i].timestamp > value.samples[i - 1].timestamp); - } - } - fn try_eval_bin_op( query: &str, left: Vec, diff --git a/src/promql/src/common.rs b/src/promql/src/common.rs index 04f40da687..93d6be872f 100644 --- a/src/promql/src/common.rs +++ b/src/promql/src/common.rs @@ -186,18 +186,6 @@ mod tests { assert_eq!(quantile(&infinite, 0.75), Some(f64::INFINITY)); } - #[test] - fn test_quantile() { - let data = vec![4.0, 2.0, 1.0, 3.0, 5.0]; - let phi_quantile = 0.5; - let result = quantile(&data, phi_quantile); - let expected = 3.0; - match result { - Some(got) => assert_eq!(got, expected), - None => panic!(), - } - } - #[test] fn test_quantile_comprehensive() { // Test basic quartiles @@ -414,68 +402,6 @@ mod tests { assert_eq!(result, None); } - #[test] - fn test_calculate_trend() { - // Test first iteration (index == 0) - let result = calculate_trend(0, 0.1, 10.0, 12.0, 1.0); - assert_eq!(result, 1.0); - - // Test normal case - let result = calculate_trend(1, 0.1, 10.0, 12.0, 1.0); - // trend_factor * (current_smoothed - previous_smoothed) + (1.0 - trend_factor) * - // previous_trend 0.1 * (12.0 - 10.0) + 0.9 * 1.0 = 0.2 + 0.9 = 1.1 - assert!((result - 1.1).abs() < 1e-10); - - // Test with zero trend factor - let result = calculate_trend(1, 0.0, 10.0, 12.0, 1.0); - assert_eq!(result, 1.0); - - // Test with one trend factor - let result = calculate_trend(1, 1.0, 10.0, 12.0, 1.0); - assert_eq!(result, 2.0); - } - - #[test] - fn test_linear_regression() { - // Test with constant y values - let samples = vec![ - Sample::new(1000, 5.0), - Sample::new(2000, 5.0), - Sample::new(3000, 5.0), - ]; - let result = linear_regression(&samples, 0); - assert!(result.is_some()); - let (slope, intercept) = result.unwrap(); - assert_eq!(slope, 0.0); - assert_eq!(intercept, 5.0); - - // Test with linear relationship - let samples = vec![ - Sample::new(1000, 1.0), - Sample::new(2000, 2.0), - Sample::new(3000, 3.0), - ]; - let result = linear_regression(&samples, 0); - assert!(result.is_some()); - let (slope, intercept) = result.unwrap(); - // Slope should be 1000.0 (y increases by 1 for each 0.001 increase in x) - assert!((slope - 1000.0).abs() < 1e-6); - assert!((intercept - 0.0).abs() < 1e-6); - - // Test with infinite values - let samples = vec![ - Sample::new(1000, f64::INFINITY), - Sample::new(2000, f64::INFINITY), - ]; - let (slope, intercept) = linear_regression(&samples, 0).unwrap(); - assert!(slope.is_nan() && intercept.is_nan()); - - // Test with empty samples - let samples: Vec = vec![]; - let result = linear_regression(&samples, 0); - assert!(result.is_none()); - } - #[test] fn test_kahan_sum_increment() { // Test basic increment diff --git a/src/promql/src/engine/aggregate.rs b/src/promql/src/engine/aggregate.rs index ff4eb5e189..04cca6d253 100644 --- a/src/promql/src/engine/aggregate.rs +++ b/src/promql/src/engine/aggregate.rs @@ -346,27 +346,6 @@ mod tests { ); } - #[test] - fn test_fused_agg_shape_ignores_the_parameter() { - assert_eq!( - shape("topk(3, rate(m[5m]))"), - Some(( - "rate".to_string(), - true, - Some(Some(Duration::from_secs(300))) - )) - ); - assert_eq!( - shape("bottomk by(instance) (2, m{job=\"a\"} offset 1m)"), - Some(("last_over_time".to_string(), false, Some(None))) - ); - assert_eq!( - shape("topk(scalar(m), m)"), - Some(("last_over_time".to_string(), false, Some(None))) - ); - assert_eq!(shape("topk(3, abs(m))"), None); - } - /// `n` series `{instance="", job="api"|"db"}` whose values differ at every step. fn requests(n: usize) -> String { (0..n) diff --git a/src/promql/src/engine/call.rs b/src/promql/src/engine/call.rs index 240e186f10..4b420f305b 100644 --- a/src/promql/src/engine/call.rs +++ b/src/promql/src/engine/call.rs @@ -803,161 +803,6 @@ mod tests { } } - #[tokio::test] - async fn test_call_expr_first_arg() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let args = FunctionArgs { - args: vec![Box::new(PromExpr::NumberLiteral(NumberLiteral { - val: 42.0, - }))], - }; - let result = engine.call_expr_arg(&args, 0).await; - assert!(result.is_ok()); - - if let Ok(Value::Float(val)) = result { - assert_eq!(val, 42.0); - } else { - panic!("Expected Value::Float"); - } - } - - #[tokio::test] - async fn test_call_expr_second_arg() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let args = FunctionArgs { - args: vec![ - Box::new(PromExpr::NumberLiteral(NumberLiteral { val: 10.0 })), - Box::new(PromExpr::NumberLiteral(NumberLiteral { val: 42.0 })), - ], - }; - let result = engine.call_expr_arg(&args, 1).await; - assert!(result.is_ok()); - - if let Ok(Value::Float(val)) = result { - assert_eq!(val, 42.0); - } else { - panic!("Expected Value::Float"); - } - } - - #[tokio::test] - async fn test_call_expr_third_arg() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let args = FunctionArgs { - args: vec![ - Box::new(PromExpr::NumberLiteral(NumberLiteral { val: 10.0 })), - Box::new(PromExpr::NumberLiteral(NumberLiteral { val: 20.0 })), - Box::new(PromExpr::NumberLiteral(NumberLiteral { val: 42.0 })), - ], - }; - let result = engine.call_expr_arg(&args, 2).await; - assert!(result.is_ok()); - - if let Ok(Value::Float(val)) = result { - assert_eq!(val, 42.0); - } else { - panic!("Expected Value::Float"); - } - } - - #[tokio::test] - async fn test_call_expr_fourth_arg() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let args = FunctionArgs { - args: vec![ - Box::new(PromExpr::NumberLiteral(NumberLiteral { val: 10.0 })), - Box::new(PromExpr::NumberLiteral(NumberLiteral { val: 20.0 })), - Box::new(PromExpr::NumberLiteral(NumberLiteral { val: 30.0 })), - Box::new(PromExpr::NumberLiteral(NumberLiteral { val: 42.0 })), - ], - }; - let result = engine.call_expr_arg(&args, 3).await; - assert!(result.is_ok()); - - if let Ok(Value::Float(val)) = result { - assert_eq!(val, 42.0); - } else { - panic!("Expected Value::Float"); - } - } - - #[tokio::test] - async fn test_call_expr_fifth_arg() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let args = FunctionArgs { - args: vec![ - Box::new(PromExpr::NumberLiteral(NumberLiteral { val: 10.0 })), - Box::new(PromExpr::NumberLiteral(NumberLiteral { val: 20.0 })), - Box::new(PromExpr::NumberLiteral(NumberLiteral { val: 30.0 })), - Box::new(PromExpr::NumberLiteral(NumberLiteral { val: 40.0 })), - Box::new(PromExpr::NumberLiteral(NumberLiteral { val: 42.0 })), - ], - }; - let result = engine.call_expr_arg(&args, 4).await; - assert!(result.is_ok()); - - if let Ok(Value::Float(val)) = result { - assert_eq!(val, 42.0); - } else { - panic!("Expected Value::Float"); - } - } - const SECOND: i64 = 1_000_000; const BASE: i64 = 1_640_995_200; diff --git a/src/promql/src/engine/mod.rs b/src/promql/src/engine/mod.rs index 2643298d9a..72c4a2e86b 100644 --- a/src/promql/src/engine/mod.rs +++ b/src/promql/src/engine/mod.rs @@ -226,11 +226,10 @@ pub(crate) mod tests { use std::{sync::Arc, time::Duration}; use promql_parser::{ - label::{MatchOp, Matchers}, + label::Matchers, parser::{ - AggregateExpr, BinaryExpr, Call, EvalStmt, Extension, Function, FunctionArgs, - MatrixSelector, NumberLiteral, Offset, ParenExpr, StringLiteral, SubqueryExpr, - UnaryExpr, VectorSelector, token, value::ValueType, + AggregateExpr, BinaryExpr, EvalStmt, Extension, NumberLiteral, ParenExpr, + StringLiteral, SubqueryExpr, UnaryExpr, token, value::ValueType, }, }; @@ -426,26 +425,6 @@ pub(crate) mod tests { TwoInstanceProvider(ctx, vec![]) } - #[test] - fn test_engine_new() { - // Test basic engine creation with a simple mock - let trace_id = "test_trace"; - let org_id = "test_org"; - let engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - assert_eq!(engine.trace_id, trace_id.to_string()); - assert!(engine.label_selector.is_empty()); - assert!(engine.result_type.is_none()); - } - /// The guard must not fire on a query that merely LOOKS adjacent — `offset` /// is genuinely implemented and must keep working. #[tokio::test] @@ -475,31 +454,6 @@ pub(crate) mod tests { } } - #[tokio::test] - async fn test_exec_expr_number_literal() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let expr = PromExpr::NumberLiteral(NumberLiteral { val: 42.0 }); - let result = engine.exec_expr(&expr).await; - assert!(result.is_ok()); - - if let Ok(Value::Float(val)) = result { - assert_eq!(val, 42.0); - } else { - panic!("Expected Value::Float"); - } - } - #[tokio::test] async fn test_exec_expr_string_literal() { let trace_id = "test_trace"; @@ -626,39 +580,6 @@ pub(crate) mod tests { } } - #[tokio::test] - async fn test_exec_expr_unary_vector() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let sample = Sample::new(1640995200000000i64, 42.0); - let instant = InstantValue { - labels: vec![Arc::new(Label::new("env", "prod"))], - sample, - }; - let _vector = Value::Vector(vec![instant]); - let vector_expr = PromExpr::Extension(Extension { - expr: Arc::new(TestExtension), - }); - - let expr = PromExpr::Unary(UnaryExpr { - expr: Box::new(vector_expr), - }); - - let result = engine.exec_expr(&expr).await; - // This will fail because Extension is not implemented, but we're testing the unary logic - assert!(result.is_err()); - } - #[tokio::test] async fn test_exec_expr_binary_float_float() { let trace_id = "test_trace"; @@ -897,38 +818,6 @@ pub(crate) mod tests { assert_eq!(series[0].samples[0].value, 1.0); } - #[tokio::test] - async fn test_exec_expr_binary_none_none() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let lhs = PromExpr::Extension(Extension { - expr: Arc::new(TestExtension), - }); - let rhs = PromExpr::Extension(Extension { - expr: Arc::new(TestExtension), - }); - let expr = PromExpr::Binary(BinaryExpr { - lhs: Box::new(lhs), - rhs: Box::new(rhs), - op: create_test_token(), - modifier: None, - }); - - let result = engine.exec_expr(&expr).await; - // This will fail because Extension is not implemented, but we're testing the binary logic - assert!(result.is_err()); - } - #[tokio::test] async fn test_exec_expr_subquery() { let trace_id = "test_trace"; @@ -963,108 +852,6 @@ pub(crate) mod tests { ); } - #[tokio::test] - async fn test_exec_expr_subquery_with_offset() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let expr = PromExpr::NumberLiteral(NumberLiteral { val: 42.0 }); - let offset = Some(Offset::Pos(Duration::from_secs(60))); - let subquery_expr = PromExpr::Subquery(SubqueryExpr { - expr: Box::new(expr), - range: Duration::from_secs(300), - offset, - step: None, - at: None, - }); - - let result = engine.exec_expr(&subquery_expr).await; - // Subquery with float input should fail because subquery expects matrix input - assert!(result.is_err()); - assert!( - result - .unwrap_err() - .to_string() - .contains("Unsupported subquery") - ); - } - - #[tokio::test] - async fn test_exec_expr_subquery_vector() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let sample = Sample::new(1640995200000000i64, 42.0); - let _instant = InstantValue { - labels: vec![Arc::new(Label::new("env", "prod"))], - sample, - }; - let vector = PromExpr::Extension(Extension { - expr: Arc::new(TestExtension), - }); - - let subquery_expr = PromExpr::Subquery(SubqueryExpr { - expr: Box::new(vector), - range: Duration::from_secs(300), - offset: None, - step: None, - at: None, - }); - - let result = engine.exec_expr(&subquery_expr).await; - // This will fail because Extension is not implemented, but we're testing the subquery logic - assert!(result.is_err()); - } - - #[tokio::test] - async fn test_exec_expr_subquery_float() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let float_expr = PromExpr::Extension(Extension { - expr: Arc::new(TestExtension), - }); - - let subquery_expr = PromExpr::Subquery(SubqueryExpr { - expr: Box::new(float_expr), - range: Duration::from_secs(300), - offset: None, - step: None, - at: None, - }); - - let result = engine.exec_expr(&subquery_expr).await; - // This will fail because Extension is not implemented, but we're testing the subquery logic - assert!(result.is_err()); - } - #[tokio::test] async fn test_exec_expr_aggregate() { let trace_id = "test_trace"; @@ -1093,34 +880,6 @@ pub(crate) mod tests { assert!(result.is_err()); } - #[tokio::test] - async fn test_exec_expr_call() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let args = FunctionArgs { args: vec![] }; - let func = Function { - name: "time", - arg_types: vec![], - variadic: 0, - experimental: false, - return_type: ValueType::Scalar, - }; - let expr = PromExpr::Call(Call { func, args }); - - let result = engine.exec_expr(&expr).await; - assert!(result.is_ok()); - } - #[tokio::test] async fn test_exec_expr_extension() { let trace_id = "test_trace"; @@ -1149,87 +908,6 @@ pub(crate) mod tests { ); } - #[tokio::test] - async fn test_exec_expr_vector_selector() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let matchers = Matchers { - matchers: vec![promql_parser::label::Matcher { - name: "env".to_string(), - op: MatchOp::Equal, - value: "prod".to_string(), - }], - or_matchers: vec![], - }; - - let selector = VectorSelector { - name: Some("test_metric".to_string()), - matchers, - offset: None, - at: None, - }; - - let expr = PromExpr::VectorSelector(selector); - - let result = engine.exec_expr(&expr).await; - // This will fail because the mock provider doesn't have real data, but we're testing the - // vector selector logic - assert!(result.is_ok()); - } - - #[tokio::test] - async fn test_exec_expr_matrix_selector() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let matchers = Matchers { - matchers: vec![promql_parser::label::Matcher { - name: "env".to_string(), - op: MatchOp::Equal, - value: "prod".to_string(), - }], - or_matchers: vec![], - }; - - let selector = VectorSelector { - name: Some("test_metric".to_string()), - matchers, - offset: None, - at: None, - }; - - let matrix_selector = MatrixSelector { - vs: selector, - range: Duration::from_secs(300), - }; - - let expr = PromExpr::MatrixSelector(matrix_selector); - - let result = engine.exec_expr(&expr).await; - // This will fail because the mock provider doesn't have real data, but we're testing the - // matrix selector logic - assert!(result.is_ok()); - } - #[tokio::test] async fn test_exec() { let trace_id = "test_trace"; diff --git a/src/promql/src/engine/selector.rs b/src/promql/src/engine/selector.rs index c576be46aa..7c13d1653d 100644 --- a/src/promql/src/engine/selector.rs +++ b/src/promql/src/engine/selector.rs @@ -682,7 +682,7 @@ mod tests { use datafusion::{arrow::datatypes::Schema, prelude::SessionContext}; use promql_parser::{ label::{MatchOp, Matchers}, - parser::{Offset, VectorSelector}, + parser::VectorSelector, }; use super::*; @@ -775,158 +775,6 @@ mod tests { assert_eq!(matchers.matchers[0].name, "env"); } - #[tokio::test] - async fn test_eval_vector_selector_basic() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let matchers = Matchers { - matchers: vec![promql_parser::label::Matcher { - name: "env".to_string(), - op: MatchOp::Equal, - value: "prod".to_string(), - }], - or_matchers: vec![], - }; - - let selector = VectorSelector { - name: Some("test_metric".to_string()), - matchers, - offset: None, - at: None, - }; - - let result = engine - .eval_vector_selector(&selector, None, SelectorOutput::Value) - .await; - assert!(result.is_ok()); - let values = result.unwrap(); - assert_eq!(values.len(), 0); // Mock provider returns empty data - } - - #[tokio::test] - async fn test_eval_vector_selector_with_offset() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let matchers = Matchers { - matchers: vec![promql_parser::label::Matcher { - name: "env".to_string(), - op: MatchOp::Equal, - value: "prod".to_string(), - }], - or_matchers: vec![], - }; - - let selector = VectorSelector { - name: Some("test_metric".to_string()), - matchers, - offset: Some(Offset::Pos(Duration::from_secs(60))), - at: None, - }; - - let result = engine - .eval_vector_selector(&selector, None, SelectorOutput::Value) - .await; - assert!(result.is_ok()); - let values = result.unwrap(); - assert_eq!(values.len(), 0); // Mock provider returns empty data - } - - #[tokio::test] - async fn test_eval_vector_selector_with_negative_offset() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let matchers = Matchers { - matchers: vec![promql_parser::label::Matcher { - name: "env".to_string(), - op: MatchOp::Equal, - value: "prod".to_string(), - }], - or_matchers: vec![], - }; - - let selector = VectorSelector { - name: Some("test_metric".to_string()), - matchers, - offset: Some(Offset::Neg(Duration::from_secs(60))), - at: None, - }; - - let result = engine - .eval_vector_selector(&selector, None, SelectorOutput::Value) - .await; - assert!(result.is_ok()); - let values = result.unwrap(); - assert_eq!(values.len(), 0); // Mock provider returns empty data - } - - #[tokio::test] - async fn test_eval_matrix_selector_basic() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let matchers = Matchers { - matchers: vec![promql_parser::label::Matcher { - name: "env".to_string(), - op: MatchOp::Equal, - value: "prod".to_string(), - }], - or_matchers: vec![], - }; - - let selector = VectorSelector { - name: Some("test_metric".to_string()), - matchers, - offset: None, - at: None, - }; - - let result = engine - .eval_matrix_selector(&selector, Duration::from_secs(300), None) - .await; - assert!(result.is_ok()); - let values = result.unwrap(); - assert_eq!(values.len(), 0); // Mock provider returns empty data - } - #[tokio::test] async fn test_eval_vector_selector_without_a_metric_name_is_an_error() { let trace_id = "test_trace"; @@ -1013,44 +861,6 @@ mod tests { ); } - #[tokio::test] - async fn test_eval_matrix_selector_with_offset() { - let trace_id = "test_trace"; - let org_id = "test_org"; - let mut engine = Engine::new( - trace_id, - Arc::new(PromqlContext::new( - create_test_query_ctx(trace_id, org_id, 30), - SimpleMockProvider, - vec![], - )), - create_test_eval_ctx(), - ); - - let matchers = Matchers { - matchers: vec![promql_parser::label::Matcher { - name: "env".to_string(), - op: MatchOp::Equal, - value: "prod".to_string(), - }], - or_matchers: vec![], - }; - - let selector = VectorSelector { - name: Some("test_metric".to_string()), - matchers, - offset: Some(Offset::Pos(Duration::from_secs(120))), - at: None, - }; - - let result = engine - .eval_matrix_selector(&selector, Duration::from_secs(300), None) - .await; - assert!(result.is_ok()); - let values = result.unwrap(); - assert_eq!(values.len(), 0); // Mock provider returns empty data - } - /// Serves one series that carries only an exemplar, as the exemplar loader produces. struct ExemplarProvider; diff --git a/src/promql/src/functions/avg_over_time.rs b/src/promql/src/functions/avg_over_time.rs index 9b61c09c24..314dd1a838 100644 --- a/src/promql/src/functions/avg_over_time.rs +++ b/src/promql/src/functions/avg_over_time.rs @@ -74,24 +74,6 @@ mod tests { avg_over_time(data, &eval_ctx) } - #[test] - fn test_avg_over_time_value_none_input() { - let result = avg_over_time_test_helper(Value::None).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_avg_over_time_invalid_input_returns_err() { - let result = avg_over_time_test_helper(Value::Float(1.0)); - assert!(result.is_err()); - } - - #[test] - fn test_avg_over_time_exec_empty_samples_returns_none() { - let func = AvgOverTimeFunc; - assert!(func.exec(&[], 0, &Duration::ZERO).is_none()); - } - #[test] fn test_avg_over_time_function() { // Create a range value with sample data diff --git a/src/promql/src/functions/changes.rs b/src/promql/src/functions/changes.rs index 3f65ce7bf1..c65c822204 100644 --- a/src/promql/src/functions/changes.rs +++ b/src/promql/src/functions/changes.rs @@ -57,18 +57,6 @@ mod tests { changes(data, &eval_ctx) } - #[test] - fn test_changes_value_none_input() { - let result = changes_test_helper(Value::None).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_changes_invalid_input_returns_err() { - let result = changes_test_helper(Value::Float(1.0)); - assert!(result.is_err()); - } - #[test] fn test_changes_no_changes() { let func = ChangesFunc; diff --git a/src/promql/src/functions/count_over_time.rs b/src/promql/src/functions/count_over_time.rs index 6ff664f428..ee5bb1b213 100644 --- a/src/promql/src/functions/count_over_time.rs +++ b/src/promql/src/functions/count_over_time.rs @@ -52,24 +52,6 @@ mod tests { count_over_time(data, &eval_ctx) } - #[test] - fn test_count_over_time_value_none_input() { - let result = count_over_time_test_helper(Value::None).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_count_over_time_invalid_input_returns_err() { - let result = count_over_time_test_helper(Value::Float(1.0)); - assert!(result.is_err()); - } - - #[test] - fn test_count_over_time_exec_empty_samples_returns_none() { - let func = CountOverTimeFunc; - assert!(func.exec(&[], 0, &Duration::ZERO).is_none()); - } - #[test] fn test_count_over_time_function() { // Create a range value with sample data diff --git a/src/promql/src/functions/deriv.rs b/src/promql/src/functions/deriv.rs index 142626f061..6902c24436 100644 --- a/src/promql/src/functions/deriv.rs +++ b/src/promql/src/functions/deriv.rs @@ -54,18 +54,6 @@ mod tests { deriv(data, &eval_ctx) } - #[test] - fn test_deriv_value_none_input() { - let result = deriv_test_helper(Value::None).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_deriv_invalid_input_returns_err() { - let result = deriv_test_helper(Value::Float(1.0)); - assert!(result.is_err()); - } - #[test] fn test_deriv_exec_fewer_than_two_samples_returns_none() { let func = DerivFunc; diff --git a/src/promql/src/functions/extrapolated.rs b/src/promql/src/functions/extrapolated.rs index e6f0e40d68..e3914b99c3 100644 --- a/src/promql/src/functions/extrapolated.rs +++ b/src/promql/src/functions/extrapolated.rs @@ -44,17 +44,6 @@ impl RangeFunc for ExtrapolationKind { mod rate_tests { use super::*; - #[test] - fn test_rate_name() { - assert_eq!(ExtrapolationKind::Rate.name(), "rate"); - } - - #[test] - fn test_rate_empty_samples() { - let func = ExtrapolationKind::Rate; - assert!(func.exec(&[], 0, &Duration::from_secs(60)).is_none()); - } - #[test] fn test_rate_single_sample() { let func = ExtrapolationKind::Rate; @@ -107,18 +96,6 @@ mod increase_tests { increase(data, &eval_ctx) } - #[test] - fn test_increase_value_none_input() { - let result = increase_test_helper(Value::None).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_increase_invalid_input_returns_err() { - let result = increase_test_helper(Value::Float(1.0)); - assert!(result.is_err()); - } - #[test] fn test_increase_function() { // Create a range value with increasing counter values @@ -218,12 +195,6 @@ mod delta_tests { _ => panic!("Expected Matrix result"), } } - - #[test] - fn test_delta_function_name() { - let func = ExtrapolationKind::Delta; - assert_eq!(func.name(), "delta"); - } } #[cfg(test)] diff --git a/src/promql/src/functions/holt_winters.rs b/src/promql/src/functions/holt_winters.rs index 5a6d441230..5b70b9a04c 100644 --- a/src/promql/src/functions/holt_winters.rs +++ b/src/promql/src/functions/holt_winters.rs @@ -118,18 +118,6 @@ mod tests { ) } - #[test] - fn test_holt_winters_value_none_input() { - let result = holt_winters_test_helper(Value::None, 0.5, 0.3).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_holt_winters_invalid_input_returns_err() { - let result = holt_winters_test_helper(Value::Float(1.0), 0.5, 0.3); - assert!(result.is_err()); - } - #[test] fn test_holt_winters_calculation_fewer_than_two_samples() { assert!(holt_winters_calculation(&[], 0.5, 0.3).is_none()); diff --git a/src/promql/src/functions/idelta.rs b/src/promql/src/functions/idelta.rs index 58263b6e18..ea01a0491f 100644 --- a/src/promql/src/functions/idelta.rs +++ b/src/promql/src/functions/idelta.rs @@ -52,18 +52,6 @@ mod tests { idelta(data, &eval_ctx) } - #[test] - fn test_idelta_value_none_input() { - let result = idelta_test_helper(Value::None).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_idelta_invalid_input_returns_err() { - let result = idelta_test_helper(Value::Float(1.0)); - assert!(result.is_err()); - } - #[test] fn test_idelta_exec_fewer_than_two_samples_returns_none() { let func = IdeltaFunc; diff --git a/src/promql/src/functions/irate.rs b/src/promql/src/functions/irate.rs index 52eab1d0b6..39adac8d84 100644 --- a/src/promql/src/functions/irate.rs +++ b/src/promql/src/functions/irate.rs @@ -62,18 +62,6 @@ mod tests { irate(data, &eval_ctx) } - #[test] - fn test_irate_value_none_input() { - let result = irate_test_helper(Value::None).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_irate_invalid_input_returns_err() { - let result = irate_test_helper(Value::Float(1.0)); - assert!(result.is_err()); - } - #[test] fn test_irate_function() { // Create a range value with increasing counter values diff --git a/src/promql/src/functions/label_join.rs b/src/promql/src/functions/label_join.rs index b5b4bae35f..14593f26d9 100644 --- a/src/promql/src/functions/label_join.rs +++ b/src/promql/src/functions/label_join.rs @@ -180,58 +180,4 @@ mod tests { let result = label_join(Value::Float(1.0), "dst", "-", vec![]); assert!(result.is_err()); } - - #[test] - fn test_label_join_function() { - use config::meta::promql::value::{RangeValue, Sample}; - - let eval_ts = 1000; - - // Create range values with labels - let labels1 = vec![ - Arc::new(Label::new("instance", "server1")), - Arc::new(Label::new("job", "web")), - ]; - - let range_value1 = RangeValue { - labels: labels1, - samples: vec![Sample::new(eval_ts, 42.0)], - exemplars: None, - time_window: None, - }; - - let labels2 = vec![ - Arc::new(Label::new("instance", "server2")), - Arc::new(Label::new("job", "web")), - ]; - - let range_value2 = RangeValue { - labels: labels2, - samples: vec![Sample::new(eval_ts, 43.0)], - exemplars: None, - time_window: None, - }; - - let matrix = Value::Matrix(vec![range_value1, range_value2]); - let source_labels = vec!["instance".to_string(), "job".to_string()]; - let result = label_join(matrix, "combined", "-", source_labels).unwrap(); - - // Should return a matrix with joined labels - match result { - Value::Matrix(m) => { - assert_eq!(m.len(), 2); - // Check that the combined label was added - let combined_label1 = m[0].labels.iter().find(|l| l.name == "combined"); - let combined_label2 = m[1].labels.iter().find(|l| l.name == "combined"); - assert!(combined_label1.is_some()); - assert!(combined_label2.is_some()); - assert_eq!(combined_label1.unwrap().value, "server1-web"); - assert_eq!(combined_label2.unwrap().value, "server2-web"); - // Verify samples are preserved - assert_eq!(m[0].samples[0].value, 42.0); - assert_eq!(m[1].samples[0].value, 43.0); - } - _ => panic!("Expected Matrix result"), - } - } } diff --git a/src/promql/src/functions/label_replace.rs b/src/promql/src/functions/label_replace.rs index 2c0ef0bc1e..cc39da5b9e 100644 --- a/src/promql/src/functions/label_replace.rs +++ b/src/promql/src/functions/label_replace.rs @@ -253,116 +253,4 @@ mod tests { let result = label_replace(Value::Float(1.0), "dst", "$1", "src", ".*"); assert!(result.is_err()); } - - #[test] - fn test_label_replace_function() { - use config::meta::promql::value::{RangeValue, Sample}; - - let eval_ts = 1000; - - // Create range values with labels - let labels = vec![ - Arc::new(Label::new("instance", "server-123.example.com")), - Arc::new(Label::new("job", "web")), - ]; - - let range_value = RangeValue { - labels, - samples: vec![Sample::new(eval_ts, 42.0)], - exemplars: None, - time_window: None, - }; - - let matrix = Value::Matrix(vec![range_value]); - let result = label_replace( - matrix, - "hostname", - "$1", - "instance", - r"server-(\d+)\.example\.com", - ) - .unwrap(); - - // Should return a matrix with replaced label - match result { - Value::Matrix(m) => { - assert_eq!(m.len(), 1); - // Check that the hostname label was added - let hostname_label = m[0].labels.iter().find(|l| l.name == "hostname"); - assert!(hostname_label.is_some()); - assert_eq!(hostname_label.unwrap().value, "123"); - // Verify samples are preserved - assert_eq!(m[0].samples[0].value, 42.0); - } - _ => panic!("Expected Matrix result"), - } - } - - #[test] - fn test_label_replace_empty_replacement_removes_dest_label() { - use config::meta::promql::value::{RangeValue, Sample}; - - let labels = vec![ - Arc::new(Label::new("dst", "old_value")), - Arc::new(Label::new("src", "source_val")), - ]; - let range_value = RangeValue { - labels, - samples: vec![Sample::new(1000, 1.0)], - exemplars: None, - time_window: None, - }; - let matrix = Value::Matrix(vec![range_value]); - let result = label_replace(matrix, "dst", "", "src", ".*").unwrap(); - - match result { - Value::Matrix(m) => { - assert_eq!(m.len(), 1); - // Empty replacement removes dst label - assert!(m[0].labels.iter().all(|l| l.name != "dst")); - } - _ => panic!("Expected Matrix result"), - } - } - - #[test] - fn test_label_replace_no_regex_match_leaves_labels_unchanged() { - use config::meta::promql::value::{RangeValue, Sample}; - - let labels = vec![Arc::new(Label::new("instance", "prod-server"))]; - let range_value = RangeValue { - labels, - samples: vec![Sample::new(1000, 1.0)], - exemplars: None, - time_window: None, - }; - let matrix = Value::Matrix(vec![range_value]); - // Regex won't match "prod-server" - let result = label_replace(matrix, "hostname", "$1", "instance", r"(\d+)").unwrap(); - - match result { - Value::Matrix(m) => { - assert_eq!(m.len(), 1); - // hostname label NOT added since regex didn't match - assert!(m[0].labels.iter().all(|l| l.name != "hostname")); - // instance label preserved - assert!(m[0].labels.iter().any(|l| l.name == "instance")); - } - _ => panic!("Expected Matrix result"), - } - } - - #[test] - fn test_label_replace_invalid_dest_label_returns_err() { - let matrix = Value::Matrix(vec![]); - let result = label_replace(matrix, "123invalid", "$1", "src", ".*"); - assert!(result.is_err()); - } - - #[test] - fn test_label_replace_invalid_regex_returns_err() { - let matrix = Value::Matrix(vec![]); - let result = label_replace(matrix, "dst", "$1", "src", "[invalid"); - assert!(result.is_err()); - } } diff --git a/src/promql/src/functions/last_over_time.rs b/src/promql/src/functions/last_over_time.rs index 31f26119a8..7d8112fd4b 100644 --- a/src/promql/src/functions/last_over_time.rs +++ b/src/promql/src/functions/last_over_time.rs @@ -75,24 +75,6 @@ mod tests { last_over_time(data, &eval_ctx) } - #[test] - fn test_last_over_time_value_none_input() { - let result = last_over_time_test_helper(Value::None).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_last_over_time_invalid_input_returns_err() { - let result = last_over_time_test_helper(Value::Float(1.0)); - assert!(result.is_err()); - } - - #[test] - fn test_last_over_time_exec_empty_samples_returns_none() { - let func = LastOverTimeFunc; - assert!(func.exec(&[], 0, &Duration::ZERO).is_none()); - } - #[test] fn test_last_over_time_function() { // Create a range value with sample data diff --git a/src/promql/src/functions/math_operations.rs b/src/promql/src/functions/math_operations.rs index 5c15b77303..b9c4e2731c 100644 --- a/src/promql/src/functions/math_operations.rs +++ b/src/promql/src/functions/math_operations.rs @@ -223,161 +223,6 @@ mod tests { assert_eq!(apply(sgn, -5.0), -1.0); } - #[test] - fn test_abs() { - let eval_ts = 1000; - let value = create_matrix(eval_ts, vec![-5.0, 3.0]); - let result = abs(value).unwrap(); - - if let Value::Matrix(result_matrix) = result { - assert_eq!(result_matrix.len(), 2); - assert_eq!(result_matrix[0].samples[0].value, 5.0); - assert_eq!(result_matrix[1].samples[0].value, 3.0); - } else { - panic!("Expected Matrix result"); - } - } - - #[test] - fn test_ceil() { - let eval_ts = 1000; - let value = create_matrix(eval_ts, vec![3.2, -3.2]); - let result = ceil(value).unwrap(); - - if let Value::Matrix(result_matrix) = result { - assert_eq!(result_matrix.len(), 2); - assert_eq!(result_matrix[0].samples[0].value, 4.0); - assert_eq!(result_matrix[1].samples[0].value, -3.0); - } else { - panic!("Expected Matrix result"); - } - } - - #[test] - fn test_floor() { - let eval_ts = 1000; - let value = create_matrix(eval_ts, vec![3.2, -3.2]); - let result = floor(value).unwrap(); - - if let Value::Matrix(result_matrix) = result { - assert_eq!(result_matrix.len(), 2); - assert_eq!(result_matrix[0].samples[0].value, 3.0); - assert_eq!(result_matrix[1].samples[0].value, -4.0); - } else { - panic!("Expected Matrix result"); - } - } - - #[test] - fn test_exp() { - let eval_ts = 1000; - let value = create_matrix(eval_ts, vec![0.0, 1.0]); - let result = exp(value).unwrap(); - - if let Value::Matrix(result_matrix) = result { - assert_eq!(result_matrix.len(), 2); - assert_eq!(result_matrix[0].samples[0].value, 1.0); - assert_eq!(result_matrix[1].samples[0].value, std::f64::consts::E); - } else { - panic!("Expected Matrix result"); - } - } - - #[test] - fn test_ln() { - let eval_ts = 1000; - let value = create_matrix(eval_ts, vec![1.0, std::f64::consts::E]); - let result = ln(value).unwrap(); - - if let Value::Matrix(result_matrix) = result { - assert_eq!(result_matrix.len(), 2); - assert_eq!(result_matrix[0].samples[0].value, 0.0); - assert_eq!(result_matrix[1].samples[0].value, 1.0); - } else { - panic!("Expected Matrix result"); - } - } - - #[test] - fn test_log2() { - let eval_ts = 1000; - let value = create_matrix(eval_ts, vec![1.0, 2.0, 4.0]); - let result = log2(value).unwrap(); - - if let Value::Matrix(result_matrix) = result { - assert_eq!(result_matrix.len(), 3); - assert_eq!(result_matrix[0].samples[0].value, 0.0); - assert_eq!(result_matrix[1].samples[0].value, 1.0); - assert_eq!(result_matrix[2].samples[0].value, 2.0); - } else { - panic!("Expected Matrix result"); - } - } - - #[test] - fn test_log10() { - let eval_ts = 1000; - let value = create_matrix(eval_ts, vec![1.0, 10.0, 100.0]); - let result = log10(value).unwrap(); - - if let Value::Matrix(result_matrix) = result { - assert_eq!(result_matrix.len(), 3); - assert_eq!(result_matrix[0].samples[0].value, 0.0); - assert_eq!(result_matrix[1].samples[0].value, 1.0); - assert_eq!(result_matrix[2].samples[0].value, 2.0); - } else { - panic!("Expected Matrix result"); - } - } - - #[test] - fn test_sqrt() { - let eval_ts = 1000; - let value = create_matrix(eval_ts, vec![0.0, 1.0, 4.0]); - let result = sqrt(value).unwrap(); - - if let Value::Matrix(result_matrix) = result { - assert_eq!(result_matrix.len(), 3); - assert_eq!(result_matrix[0].samples[0].value, 0.0); - assert_eq!(result_matrix[1].samples[0].value, 1.0); - assert_eq!(result_matrix[2].samples[0].value, 2.0); - } else { - panic!("Expected Matrix result"); - } - } - - #[test] - fn test_round() { - let eval_ts = 1000; - let value = create_matrix(eval_ts, vec![3.2, 3.5, -3.2]); - let result = round(value, &ScalarParam::Const(1.0)).unwrap(); - - if let Value::Matrix(result_matrix) = result { - assert_eq!(result_matrix.len(), 3); - assert_eq!(result_matrix[0].samples[0].value, 3.0); - assert_eq!(result_matrix[1].samples[0].value, 4.0); - assert_eq!(result_matrix[2].samples[0].value, -3.0); - } else { - panic!("Expected Matrix result"); - } - } - - #[test] - fn test_sgn() { - let eval_ts = 1000; - let value = create_matrix(eval_ts, vec![5.0, -5.0, 0.0]); - let result = sgn(value).unwrap(); - - if let Value::Matrix(result_matrix) = result { - assert_eq!(result_matrix.len(), 3); - assert_eq!(result_matrix[0].samples[0].value, 1.0); - assert_eq!(result_matrix[1].samples[0].value, -1.0); - assert_eq!(result_matrix[2].samples[0].value, 0.0); - } else { - panic!("Expected Matrix result"); - } - } - #[test] fn test_none_value() { let value = Value::None; diff --git a/src/promql/src/functions/max_over_time.rs b/src/promql/src/functions/max_over_time.rs index 8e1d0ec598..c50ffca5b2 100644 --- a/src/promql/src/functions/max_over_time.rs +++ b/src/promql/src/functions/max_over_time.rs @@ -49,24 +49,6 @@ mod tests { max_over_time(data, &eval_ctx) } - #[test] - fn test_max_over_time_value_none_input() { - let result = max_over_time_test_helper(Value::None).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_max_over_time_invalid_input_returns_err() { - let result = max_over_time_test_helper(Value::Float(1.0)); - assert!(result.is_err()); - } - - #[test] - fn test_max_over_time_exec_empty_samples_returns_none() { - let func = MaxOverTimeFunc; - assert!(func.exec(&[], 0, &Duration::ZERO).is_none()); - } - #[test] fn test_max_over_time_function() { // Create a range value with sample data diff --git a/src/promql/src/functions/min_over_time.rs b/src/promql/src/functions/min_over_time.rs index 1ed05ab91a..0b2e2ba2c5 100644 --- a/src/promql/src/functions/min_over_time.rs +++ b/src/promql/src/functions/min_over_time.rs @@ -55,24 +55,6 @@ mod tests { min_over_time(data, &eval_ctx) } - #[test] - fn test_min_over_time_value_none_input() { - let result = min_over_time_test_helper(Value::None).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_min_over_time_invalid_input_returns_err() { - let result = min_over_time_test_helper(Value::Float(1.0)); - assert!(result.is_err()); - } - - #[test] - fn test_min_over_time_exec_empty_samples_returns_none() { - let func = MinOverTimeFunc; - assert!(func.exec(&[], 0, &Duration::ZERO).is_none()); - } - #[test] fn test_min_over_time_function() { // Create a range value with sample data diff --git a/src/promql/src/functions/mod.rs b/src/promql/src/functions/mod.rs index 27aa939a01..b7b38c3d07 100644 --- a/src/promql/src/functions/mod.rs +++ b/src/promql/src/functions/mod.rs @@ -762,19 +762,6 @@ mod tests { } } - #[test] - fn test_func_enum_parsing_known_functions() { - assert_eq!("abs".parse::().unwrap(), Func::Abs); - assert_eq!("rate".parse::().unwrap(), Func::Rate); - assert_eq!("avg_over_time".parse::().unwrap(), Func::AvgOverTime); - assert_eq!( - "histogram_quantile".parse::().unwrap(), - Func::HistogramQuantile - ); - assert_eq!("label_join".parse::().unwrap(), Func::LabelJoin); - assert_eq!("label_replace".parse::().unwrap(), Func::LabelReplace); - } - #[test] fn test_func_enum_unknown_returns_err() { assert!("unknown_function".parse::().is_err()); diff --git a/src/promql/src/functions/predict_linear.rs b/src/promql/src/functions/predict_linear.rs index b93fd84dcf..a8d1666177 100644 --- a/src/promql/src/functions/predict_linear.rs +++ b/src/promql/src/functions/predict_linear.rs @@ -71,18 +71,6 @@ mod tests { predict_linear(data, ScalarParam::Const(duration), &eval_ctx, None) } - #[test] - fn test_predict_linear_value_none_input() { - let result = predict_linear_test_helper(Value::None, 10.0).unwrap(); - assert!(matches!(result, Value::None)); - } - - #[test] - fn test_predict_linear_invalid_input_returns_err() { - let result = predict_linear_test_helper(Value::Float(1.0), 10.0); - assert!(result.is_err()); - } - #[test] fn test_predict_linear_needs_two_samples_to_predict() { let one_sample = RangeValue { diff --git a/src/promql/src/functions/present_over_time.rs b/src/promql/src/functions/present_over_time.rs index 4a0696e517..1c9ed16b7e 100644 --- a/src/promql/src/functions/present_over_time.rs +++ b/src/promql/src/functions/present_over_time.rs @@ -59,11 +59,6 @@ mod tests { assert!(present_over_time(Value::Float(1.0)).is_err()); } - #[test] - fn test_present_over_time_exec_empty_samples_returns_none() { - assert!(PresentOverTimeFunc.exec(&[], 0, &Duration::ZERO).is_none()); - } - #[test] fn test_present_over_time_is_one_regardless_of_sample_values() { let range_value = RangeValue { diff --git a/src/promql/src/functions/quantile_over_time.rs b/src/promql/src/functions/quantile_over_time.rs index fcaee91141..77d666960b 100644 --- a/src/promql/src/functions/quantile_over_time.rs +++ b/src/promql/src/functions/quantile_over_time.rs @@ -71,20 +71,6 @@ mod tests { .collect() } - #[test] - fn test_quantile_over_time_name() { - assert_eq!( - QuantileOverTimeFunc::new(ScalarParam::Const(0.5)).name(), - "quantile_over_time" - ); - } - - #[test] - fn test_quantile_over_time_empty() { - let func = QuantileOverTimeFunc::new(ScalarParam::Const(0.5)); - assert!(func.exec(&[], 0, &Duration::from_secs(1)).is_none()); - } - #[test] fn test_quantile_over_time_median() { let func = QuantileOverTimeFunc::new(ScalarParam::Const(0.5)); diff --git a/src/promql/src/functions/stddev_over_time.rs b/src/promql/src/functions/stddev_over_time.rs index 6e223d1483..b125f0db85 100644 --- a/src/promql/src/functions/stddev_over_time.rs +++ b/src/promql/src/functions/stddev_over_time.rs @@ -47,17 +47,6 @@ mod tests { .collect() } - #[test] - fn test_stddev_over_time_name() { - assert_eq!(StddevOverTimeFunc.name(), "stddev_over_time"); - } - - #[test] - fn test_stddev_over_time_empty() { - let func = StddevOverTimeFunc; - assert!(func.exec(&[], 0, &Duration::from_secs(1)).is_none()); - } - #[test] fn test_stddev_over_time_constant() { let func = StddevOverTimeFunc; diff --git a/src/promql/src/functions/stdvar_over_time.rs b/src/promql/src/functions/stdvar_over_time.rs index 0a0fb2b451..3157451e09 100644 --- a/src/promql/src/functions/stdvar_over_time.rs +++ b/src/promql/src/functions/stdvar_over_time.rs @@ -47,17 +47,6 @@ mod tests { .collect() } - #[test] - fn test_stdvar_over_time_name() { - assert_eq!(StdvarOverTimeFunc.name(), "stdvar_over_time"); - } - - #[test] - fn test_stdvar_over_time_empty() { - let func = StdvarOverTimeFunc; - assert!(func.exec(&[], 0, &Duration::from_secs(1)).is_none()); - } - #[test] fn test_stdvar_over_time_constant() { let func = StdvarOverTimeFunc; diff --git a/src/promql/src/functions/sum_over_time.rs b/src/promql/src/functions/sum_over_time.rs index b868ca8da3..6077725225 100644 --- a/src/promql/src/functions/sum_over_time.rs +++ b/src/promql/src/functions/sum_over_time.rs @@ -53,17 +53,6 @@ mod tests { .collect() } - #[test] - fn test_sum_over_time_name() { - assert_eq!(SumOverTimeFunc.name(), "sum_over_time"); - } - - #[test] - fn test_sum_over_time_empty() { - let func = SumOverTimeFunc; - assert!(func.exec(&[], 0, &Duration::from_secs(1)).is_none()); - } - #[test] fn test_sum_over_time_single() { let func = SumOverTimeFunc; diff --git a/src/promql/src/series_stream/blocks.rs b/src/promql/src/series_stream/blocks.rs index 03c3192199..5d46f92776 100644 --- a/src/promql/src/series_stream/blocks.rs +++ b/src/promql/src/series_stream/blocks.rs @@ -2352,101 +2352,6 @@ mod tests { assert_eq!(fixture.calls.load(Ordering::SeqCst), 0); } - #[tokio::test] - async fn legacy_new_mixed_and_disabled_sources_preserve_same_series_fragments() { - use datafusion::arrow::{array::UInt32Array, ipc::writer::FileWriter}; - let rows = [ - (1, 10, 1.0, Some("x")), - (1, 20, -0.0, Some("x")), - (1, 30, 3.0, Some("x")), - (1, 40, 4.0, Some("x")), - ]; - let legacy_schema = Arc::new(Schema::new(vec![ - Field::new("__oo_midx_row_count", DataType::UInt32, false), - Field::new("group", DataType::Utf8, true), - ])); - let legacy_batch = RecordBatch::try_new( - Arc::clone(&legacy_schema), - vec![ - Arc::new(UInt32Array::from(vec![2])), - Arc::new(StringArray::from(vec!["x"])), - ], - ) - .unwrap(); - let mut legacy = Vec::new(); - let mut writer = FileWriter::try_new(&mut legacy, &legacy_schema).unwrap(); - writer.write(&legacy_batch).unwrap(); - writer.finish().unwrap(); - for legacy_count in [0, 1, 2] { - for enabled in [false, true] { - let mut files = vec![file(&rows[..2]), file(&rows[2..])]; - for source in files.iter_mut().take(legacy_count) { - source.1 = legacy.clone(); - } - let fixture = Fixture::new(&files, false).await; - let source = if enabled { - ScanSource::Blocks(Arc::new(fixture.scan(files.iter().map(|v| v.0.clone())))) - } else { - ScanSource::HashSorted - }; - let ctx = - SessionContext::new_with_config(SessionConfig::new().with_target_partitions(2)); - let table = MemTable::try_new(schema(), vec![vec![batch(&rows)]]) - .unwrap() - .with_sort_order(vec![vec![ - col("__hash__").sort(true, false), - col("_timestamp").sort(true, false), - ]]); - ctx.register_table("m", Arc::new(table)).unwrap(); - let matchers = Matchers::empty(); - let selector = StreamingSelector { - table_name: "m", - matchers: &matchers, - offset: 0, - }; - let result = execute_partitioned( - &ctx, - &source, - &selector, - LabelColumns::grouped(vec!["group".into()]), - 20, - &EvalContext::new(10, 40, 10, "compatibility".into()), - ) - .await; - if enabled && legacy_count > 0 { - assert!(result.is_err()); - assert_eq!(fixture.calls.load(Ordering::SeqCst), 0); - continue; - } - let sources = result.unwrap(); - let mut actual = Vec::new(); - for source in sources { - let mut source = source.await.unwrap(); - assert_eq!( - matches!(&source, SeriesSource::Block(_)), - enabled && legacy_count == 0 - ); - while source.advance().await.unwrap().is_some() { - let mut samples = Vec::new(); - source.consume(&mut samples).await.unwrap(); - actual.extend(samples.iter().map(|s| (s.timestamp, s.value.to_bits()))); - } - } - actual.sort_unstable(); - assert_eq!( - actual, - rows.iter() - .map(|r| (r.1, r.2.to_bits())) - .collect::>() - ); - assert_eq!( - fixture.calls.load(Ordering::SeqCst) > 0, - enabled && legacy_count == 0 - ); - } - } - } - #[tokio::test] async fn schema_evolution_distinguishes_absent_null_and_empty_labels() { let original = batch(&[(1, 10, 1.0, None), (1, 20, 2.0, None)]);