Cargo fmt and clippy. Move ES DSL tests into test submodule.

Kolleida · Kolleida · commit b8a66c89ee09 · 2026-03-23T18:02:59.000-04:00
diff --git a/asap-common/dependencies/rs/elastic_dsl_utilities/src/parsing.rs b/asap-common/dependencies/rs/elastic_dsl_utilities/src/parsing.rs
@@ -22,9 +22,11 @@ pub fn extract_metric_aggs(aggs: &Value) -> Option<Vec<MetricAggregation>> {
         let body_obj = agg_body.as_object()?;
         let mut found = None;
         for (key, inner) in body_obj {
-            if let Some(agg_type) = MetricAggType::from_str(key) {
+            if let Some(agg_type) = MetricAggType::from_json_str(key) {
                 let field = inner.get("field")?.as_str()?.to_owned();
-                let kwargs_map = inner.as_object()?.iter()
+                let kwargs_map = inner
+                    .as_object()?
+                    .iter()
                     .filter(|(k, _)| *k != "field")
                     .map(|(k, v)| (k.clone(), v.clone()))
                     .collect();
@@ -165,7 +167,9 @@ pub fn extract_label_filters(query: &Value) -> Option<(Vec<LabelFilter>, Option<
 /// - `{"range": ...}` -> `(label_filters=[], time_range=Some(...))`
 /// - `{"bool": {"filter": ...}}` -> label filters + optional time range
 /// - `None`/`null` query is represented by caller as `(vec![], None)`.
-pub fn extract_predicates_from_query(query: &Value) -> Option<(Vec<LabelFilter>, Option<TimeRange>)> {
+pub fn extract_predicates_from_query(
+    query: &Value,
+) -> Option<(Vec<LabelFilter>, Option<TimeRange>)> {
     if query.is_null() {
         return Some((Vec::new(), None));
     }
@@ -211,9 +215,7 @@ pub fn extract_predicates_from_query(query: &Value) -> Option<(Vec<LabelFilter>,
 ///   }
 /// }
 /// ```
-pub fn extract_group_by_agg(
-    aggs: &Value,
-) -> Option<(String, GroupBySpec, Vec<MetricAggregation>)> {
+pub fn extract_group_by_agg(aggs: &Value) -> Option<(String, GroupBySpec, Vec<MetricAggregation>)> {
     let obj = aggs.as_object()?;
     // There must be exactly one top-level aggregation entry.
     if obj.len() != 1 {
@@ -262,15 +264,27 @@ mod tests {
         });
         let result = extract_metric_aggs(&aggs).unwrap();
         assert_eq!(result.len(), 3);
-        let avg = result.iter().find(|a| a.result_name == "avg_latency").unwrap();
+        let avg = result
+            .iter()
+            .find(|a| a.result_name == "avg_latency")
+            .unwrap();
         assert_eq!(avg.agg_type, MetricAggType::Avg);
         assert_eq!(avg.field, "latency_ms");
-        let p95 = result.iter().find(|a| a.result_name == "p95_latency").unwrap();
+        let p95 = result
+            .iter()
+            .find(|a| a.result_name == "p95_latency")
+            .unwrap();
         assert_eq!(p95.agg_type, MetricAggType::Percentiles);
         assert_eq!(p95.field, "latency_ms");
-        assert_eq!(p95.params.as_ref().unwrap().get("percents").unwrap(), &json!([95]));
+        assert_eq!(
+            p95.params.as_ref().unwrap().get("percents").unwrap(),
+            &json!([95])
+        );
 
-        let avg = result.iter().find(|a| a.result_name == "avg_latency").unwrap();
+        let avg = result
+            .iter()
+            .find(|a| a.result_name == "avg_latency")
+            .unwrap();
         assert!(avg.params.is_none());
     }
 
@@ -374,7 +388,12 @@ mod tests {
         });
         let (name, group_by, metric_aggs) = extract_group_by_agg(&aggs).unwrap();
         assert_eq!(name, "by_service");
-        assert_eq!(group_by, GroupBySpec::Terms { field: "service".to_string() });
+        assert_eq!(
+            group_by,
+            GroupBySpec::Terms {
+                field: "service".to_string()
+            }
+        );
         assert_eq!(metric_aggs.len(), 1);
         assert_eq!(metric_aggs[0].agg_type, MetricAggType::Avg);
     }
diff --git a/asap-common/dependencies/rs/elastic_dsl_utilities/src/pattern.rs b/asap-common/dependencies/rs/elastic_dsl_utilities/src/pattern.rs
@@ -1,9 +1,7 @@
 use serde_json::Value;
 
 use crate::{
-    parsing::{
-        extract_group_by_agg, extract_metric_aggs, extract_predicates_from_query,
-    },
+    parsing::{extract_group_by_agg, extract_metric_aggs, extract_predicates_from_query},
     types::EsDslQueryPattern,
 };
 
@@ -28,7 +26,6 @@ pub fn classify(value: &Value) -> EsDslQueryPattern {
         }
         _ => return EsDslQueryPattern::Unknown,
     }
-        
 
     let aggs = value.get("aggs").unwrap_or(&Value::Null);
     let query = value.get("query");
@@ -198,8 +195,20 @@ mod tests {
                 aggregations,
             } => {
                 assert_eq!(label_filters.len(), 2);
-                assert_eq!(label_filters[0], LabelFilter { field: "service".into(), value: "frontend".into() });
-                assert_eq!(label_filters[1], LabelFilter { field: "env".into(), value: "staging".into() });
+                assert_eq!(
+                    label_filters[0],
+                    LabelFilter {
+                        field: "service".into(),
+                        value: "frontend".into()
+                    }
+                );
+                assert_eq!(
+                    label_filters[1],
+                    LabelFilter {
+                        field: "env".into(),
+                        value: "staging".into()
+                    }
+                );
                 assert!(time_range.is_some());
                 assert_eq!(aggregations.len(), 1);
             }
@@ -257,7 +266,12 @@ mod tests {
                 aggregations,
             } => {
                 assert_eq!(grouped_result_name, "grouped_result");
-                assert_eq!(group_by, GroupBySpec::Terms { field: "service".into() });
+                assert_eq!(
+                    group_by,
+                    GroupBySpec::Terms {
+                        field: "service".into()
+                    }
+                );
                 assert_eq!(label_filters[0].field, "service");
                 assert_eq!(label_filters[0].value, "frontend");
                 assert_eq!(label_filters[1].field, "env");
@@ -312,7 +326,13 @@ mod tests {
                         fields: vec!["service".into(), "region".into()]
                     }
                 );
-                assert_eq!(label_filters[0], LabelFilter { field: "env".into(), value: "staging".into() });
+                assert_eq!(
+                    label_filters[0],
+                    LabelFilter {
+                        field: "env".into(),
+                        value: "staging".into()
+                    }
+                );
                 assert!(time_range.is_none());
                 assert_eq!(aggregations.len(), 1);
             }
@@ -370,7 +390,10 @@ mod tests {
     fn test_parse_and_classify_roundtrip() {
         let json = r#"{"size":0,"aggs":{"avg_cpu":{"avg":{"field":"cpu_usage"}}}}"#;
         let result = parse_and_classify(json).unwrap();
-        assert!(matches!(result, EsDslQueryPattern::SimpleAggregation { .. }));
+        assert!(matches!(
+            result,
+            EsDslQueryPattern::SimpleAggregation { .. }
+        ));
     }
 
     #[test]
diff --git a/asap-common/dependencies/rs/elastic_dsl_utilities/src/types.rs b/asap-common/dependencies/rs/elastic_dsl_utilities/src/types.rs
@@ -21,7 +21,7 @@ pub enum MetricAggType {
 
 impl MetricAggType {
     /// Returns the JSON key name for this aggregation type.
-    pub fn as_str(&self) -> &'static str {
+    pub fn as_json_str(&self) -> &'static str {
         match self {
             MetricAggType::Avg => "avg",
             MetricAggType::Min => "min",
@@ -32,7 +32,7 @@ impl MetricAggType {
     }
 
     /// Try to parse from a string key.
-    pub fn from_str(s: &str) -> Option<Self> {
+    pub fn from_json_str(s: &str) -> Option<Self> {
         match s {
             "avg" => Some(MetricAggType::Avg),
             "min" => Some(MetricAggType::Min),
@@ -198,9 +198,6 @@ pub enum EsDslQueryPattern {
 }
 
 impl EsDslQueryPattern {
-    /// Classify the given ES DSL query into one of the above patterns, extracting
-    /// the relevant components for routing to sketch fast-paths.
-    
     pub fn get_time_range(&self) -> Option<&TimeRange> {
         match self {
             EsDslQueryPattern::SimpleAggregation { time_range, .. } => time_range.as_ref(),
diff --git a/asap-query-engine/src/engines/simple_engine.rs b/asap-query-engine/src/engines/simple_engine.rs
@@ -1488,7 +1488,10 @@ impl SimpleEngine {
         time: f64,
     ) -> Option<(KeyByLabelNames, QueryResult)> {
         let context = self.build_query_execution_context_elastic(query, time)?;
-        debug!("Built execution context for ElasticSearch query {:?}", context);
+        debug!(
+            "Built execution context for ElasticSearch query {:?}",
+            context
+        );
         // Execute complete query pipeline
         let results = self
             .execute_query_pipeline(&context, false) // SQL: topk disabled
@@ -1584,7 +1587,7 @@ impl SimpleEngine {
         // By default, we only include grouping labels in the output for ES DSL.
 
         // Take first aggregation by default since current engine doesn't support multiple aggregations in a single query.
-        let aggregation = query_pattern.get_metric_aggs()?.first()?.clone(); 
+        let aggregation = query_pattern.get_metric_aggs()?.first()?.clone();
 
         // By default, we only include grouping labels in the output for ES DSL.
         let mut query_output_labels = match query_pattern.get_groupby_spec() {
@@ -1624,7 +1627,8 @@ impl SimpleEngine {
                             .and_then(|arr| arr.first())
                             .and_then(|v| v.as_f64());
                         // ES percentiles are specified as values between 0 and 100, but we want to convert to 0-1 range for our internal representation.
-                        query_kwargs.insert("quantile".to_string(), (quantile? / 100.0).to_string());
+                        query_kwargs
+                            .insert("quantile".to_string(), (quantile? / 100.0).to_string());
                     }
                 }
             }
@@ -1639,9 +1643,13 @@ impl SimpleEngine {
         Some((metric, metadata))
     }
 
-    pub fn resolve_query_time_range_elastic(&self, query_time: u64, query_pattern: EsDslQueryPattern) -> QueryTimestamps {
-        // Resolves the actual start and end timestamps into milliseconds for an ElasticSearch query 
-        // based on the provided query_time and the time range specified in the ES DSL query pattern (if any). 
+    pub fn resolve_query_time_range_elastic(
+        &self,
+        query_time: u64,
+        query_pattern: EsDslQueryPattern,
+    ) -> QueryTimestamps {
+        // Resolves the actual start and end timestamps into milliseconds for an ElasticSearch query
+        // based on the provided query_time and the time range specified in the ES DSL query pattern (if any).
         // If no time range is specified, default to entire history up to query_time.
 
         let mut start_timestamp: u64 = 0;
diff --git a/asap-query-engine/src/tests/elastic_dsl_query_tests.rs b/asap-query-engine/src/tests/elastic_dsl_query_tests.rs
diff --git a/asap-query-engine/src/tests/mod.rs b/asap-query-engine/src/tests/mod.rs
