Clean up clippy warnings across the crate

Address every lint clippy reports under `--all-targets`:

- `inconsistent_digit_grouping` in a frequency test (regroup the
  literal at the standard 3-digit boundary).
- `excessive_precision` in current/energy formatting tests (truncate
  the f32 literals to a representable mantissa; the formatter still
  rounds to the asserted output).
- `useless_vec` in two `bounds` test fixtures (use array literals).
- `redundant_closure` in a `logical_meter_handle` test helper (pass
  the function reference directly).
- `clone_on_copy` on `Option<Timestamp>` and a stray `into_iter()` in
  `test_utils`'s mock telemetry stream.
- `collapsible_if` in `receive_electrical_component_telemetry_stream`
  (fold the two guards into a single let-chain, edition 2024).
- `type_complexity` on `MockComponent::metrics` (factor out a
  `MockMetricRow` typedef).

`cargo fmt --check` was already clean, no formatting changes.

Signed-off-by: Sahas Subramanian <sahas.subramanian@proton.me>

Author: shsms

src/bounds.rs

@@ -380,8 +380,8 @@ mod tests {
     /// single endpoint merge into one.
     #[test]
     fn squash_merges_touching_endpoints() {
-        let a = vec![Bounds::new(Some(1.0), Some(5.0))];
-        let b = vec![Bounds::new(Some(5.0), Some(10.0))];
+        let a = [Bounds::new(Some(1.0), Some(5.0))];
+        let b = [Bounds::new(Some(5.0), Some(10.0))];
         // `intersect_bounds_sets` runs the pairwise intersect through squash.
         let result = intersect_bounds_sets(
             &[Bounds::new(Some(0.0), Some(20.0))],

src/client/test_utils.rs

@@ -54,16 +54,21 @@ pub struct MockMicrogridApiClient {
     clock: TokioSyncedClock,
 }
 
+/// One row per emitted telemetry frame: `(power, reactive_power, voltage,
+/// current)`. Each field is independently optional so individual metrics
+/// can be omitted from a frame.
+pub type MockMetricRow = (
+    Option<Power>,
+    Option<ReactivePower>,
+    Option<Voltage>,
+    Option<Current>,
+);
+
 #[derive(Default, Debug, Clone)]
 pub struct MockComponent {
     pub component: ElectricalComponent,
     pub children: Vec<MockComponent>,
-    pub metrics: Vec<(
-        Option<Power>,
-        Option<ReactivePower>,
-        Option<Voltage>,
-        Option<Current>,
-    )>,
+    pub metrics: Vec<MockMetricRow>,
     /// Overrides the state code reported in each telemetry sample. `None`
     /// defaults to `Ready`.
     state_code: Option<ElectricalComponentStateCode>,
@@ -173,7 +178,7 @@ impl MockComponent {
         if self.component.category == ElectricalComponentCategory::Unspecified as i32 {
             panic!("Cannot add children to a hidden load component");
         }
-        self.children.extend(children.into_iter());
+        self.children.extend(children);
         self
     }
 
@@ -356,134 +361,134 @@ impl MicrogridApiClient for MockMicrogridApiClient {
             .find(|c| c.component.id == comp_id)
             .cloned();
 
-        if let Some(component) = component {
-            if !component.metrics.is_empty() {
-                let metrics = component.metrics.clone();
-                let state_code = component
-                    .state_code
-                    .unwrap_or(ElectricalComponentStateCode::Ready);
-                let silence_after_metrics = component.silence_after_metrics;
-                let clock = self.clock.clone();
-                tokio::spawn(async move {
-                    let dur = std::time::Duration::from_millis(200);
-                    let mut interval = tokio::time::interval(dur);
-                    let offset = chrono::TimeDelta::from_std(dur).unwrap_or_default();
-
-                    for metrics in metrics.iter() {
-                        interval.tick().await;
-                        // `tokio::time::interval`'s first tick fires
-                        // immediately, so `clock.wall_now()` is still the
-                        // anchor here. Add one interval so the first sample
-                        // is timestamped at `anchor + dur`, matching the
-                        // resampler's first interval boundary.
-                        let wall = clock.wall_now() + offset;
-                        let sys_delta =
-                            wall.signed_duration_since(chrono::DateTime::<chrono::Utc>::UNIX_EPOCH);
-                        let next_ts = SystemTime::UNIX_EPOCH
-                            + std::time::Duration::from_nanos(
-                                sys_delta.num_nanoseconds().unwrap_or(0).max(0) as u64,
-                            );
-                        let duration_since_epoch =
-                            next_ts.duration_since(SystemTime::UNIX_EPOCH).unwrap();
-                        let ts = Some(protobuf::Timestamp {
-                            seconds: duration_since_epoch.as_secs() as i64,
-                            nanos: duration_since_epoch.subsec_nanos() as i32,
-                        });
-                        let mut metric_samples = vec![];
-                        if let Some(power) = metrics.0 {
-                            metric_samples.push(MetricSample {
-                                sample_time: ts.clone(),
-                                metric: Metric::AcPowerActive as i32,
-                                value: Some(MetricValueVariant {
-                                    metric_value_variant: Some(
-                                        metric_value_variant::MetricValueVariant::SimpleMetric(
-                                            SimpleMetricValue {
-                                                value: power.as_watts(),
-                                            },
-                                        ),
+        if let Some(component) = component
+            && !component.metrics.is_empty()
+        {
+            let metrics = component.metrics.clone();
+            let state_code = component
+                .state_code
+                .unwrap_or(ElectricalComponentStateCode::Ready);
+            let silence_after_metrics = component.silence_after_metrics;
+            let clock = self.clock.clone();
+            tokio::spawn(async move {
+                let dur = std::time::Duration::from_millis(200);
+                let mut interval = tokio::time::interval(dur);
+                let offset = chrono::TimeDelta::from_std(dur).unwrap_or_default();
+
+                for metrics in metrics.iter() {
+                    interval.tick().await;
+                    // `tokio::time::interval`'s first tick fires
+                    // immediately, so `clock.wall_now()` is still the
+                    // anchor here. Add one interval so the first sample
+                    // is timestamped at `anchor + dur`, matching the
+                    // resampler's first interval boundary.
+                    let wall = clock.wall_now() + offset;
+                    let sys_delta =
+                        wall.signed_duration_since(chrono::DateTime::<chrono::Utc>::UNIX_EPOCH);
+                    let next_ts = SystemTime::UNIX_EPOCH
+                        + std::time::Duration::from_nanos(
+                            sys_delta.num_nanoseconds().unwrap_or(0).max(0) as u64,
+                        );
+                    let duration_since_epoch =
+                        next_ts.duration_since(SystemTime::UNIX_EPOCH).unwrap();
+                    let ts = Some(protobuf::Timestamp {
+                        seconds: duration_since_epoch.as_secs() as i64,
+                        nanos: duration_since_epoch.subsec_nanos() as i32,
+                    });
+                    let mut metric_samples = vec![];
+                    if let Some(power) = metrics.0 {
+                        metric_samples.push(MetricSample {
+                            sample_time: ts,
+                            metric: Metric::AcPowerActive as i32,
+                            value: Some(MetricValueVariant {
+                                metric_value_variant: Some(
+                                    metric_value_variant::MetricValueVariant::SimpleMetric(
+                                        SimpleMetricValue {
+                                            value: power.as_watts(),
+                                        },
                                     ),
-                                }),
-                                bounds: vec![],
-                                connection: None,
-                            });
-                        }
-                        if let Some(reactive_power) = metrics.1 {
-                            metric_samples.push(MetricSample {
-                                sample_time: ts.clone(),
-                                metric: Metric::AcPowerReactive as i32,
-                                value: Some(MetricValueVariant {
-                                    metric_value_variant: Some(
-                                        metric_value_variant::MetricValueVariant::SimpleMetric(
-                                            SimpleMetricValue {
-                                                value: reactive_power.as_volt_amperes_reactive(),
-                                            },
-                                        ),
+                                ),
+                            }),
+                            bounds: vec![],
+                            connection: None,
+                        });
+                    }
+                    if let Some(reactive_power) = metrics.1 {
+                        metric_samples.push(MetricSample {
+                            sample_time: ts,
+                            metric: Metric::AcPowerReactive as i32,
+                            value: Some(MetricValueVariant {
+                                metric_value_variant: Some(
+                                    metric_value_variant::MetricValueVariant::SimpleMetric(
+                                        SimpleMetricValue {
+                                            value: reactive_power.as_volt_amperes_reactive(),
+                                        },
                                     ),
-                                }),
-                                bounds: vec![],
-                                connection: None,
-                            });
-                        }
-                        if let Some(voltage) = metrics.2 {
-                            metric_samples.push(MetricSample {
-                                sample_time: ts.clone(),
-                                metric: Metric::AcVoltage as i32,
-                                value: Some(MetricValueVariant {
-                                    metric_value_variant: Some(
-                                        metric_value_variant::MetricValueVariant::SimpleMetric(
-                                            SimpleMetricValue {
-                                                value: voltage.as_volts(),
-                                            },
-                                        ),
+                                ),
+                            }),
+                            bounds: vec![],
+                            connection: None,
+                        });
+                    }
+                    if let Some(voltage) = metrics.2 {
+                        metric_samples.push(MetricSample {
+                            sample_time: ts,
+                            metric: Metric::AcVoltage as i32,
+                            value: Some(MetricValueVariant {
+                                metric_value_variant: Some(
+                                    metric_value_variant::MetricValueVariant::SimpleMetric(
+                                        SimpleMetricValue {
+                                            value: voltage.as_volts(),
+                                        },
                                     ),
-                                }),
-                                bounds: vec![],
-                                connection: None,
-                            });
-                        }
-                        if let Some(current) = metrics.3 {
-                            metric_samples.push(MetricSample {
-                                sample_time: ts.clone(),
-                                metric: Metric::AcCurrent as i32,
-                                value: Some(MetricValueVariant {
-                                    metric_value_variant: Some(
-                                        metric_value_variant::MetricValueVariant::SimpleMetric(
-                                            SimpleMetricValue {
-                                                value: current.as_amperes(),
-                                            },
-                                        ),
+                                ),
+                            }),
+                            bounds: vec![],
+                            connection: None,
+                        });
+                    }
+                    if let Some(current) = metrics.3 {
+                        metric_samples.push(MetricSample {
+                            sample_time: ts,
+                            metric: Metric::AcCurrent as i32,
+                            value: Some(MetricValueVariant {
+                                metric_value_variant: Some(
+                                    metric_value_variant::MetricValueVariant::SimpleMetric(
+                                        SimpleMetricValue {
+                                            value: current.as_amperes(),
+                                        },
                                     ),
-                                }),
-                                bounds: vec![],
-                                connection: None,
-                            });
-                        }
-
-                        let resp = ReceiveElectricalComponentTelemetryStreamResponse {
-                            telemetry: Some(ElectricalComponentTelemetry {
-                                electrical_component_id: comp_id,
-                                metric_samples,
-                                // TODO: support sending errors
-                                state_snapshots: vec![ElectricalComponentStateSnapshot {
-                                    origin_time: ts,
-                                    states: vec![state_code as i32],
-                                    warnings: vec![],
-                                    errors: vec![],
-                                }],
+                                ),
                             }),
-                        };
-                        if tx.send(Ok(resp)).await.is_err() {
-                            break;
-                        }
+                            bounds: vec![],
+                            connection: None,
+                        });
                     }
-                    if silence_after_metrics {
-                        // Hold the sender open indefinitely so the client
-                        // actor doesn't see the stream end and reconnect.
-                        let _keep_open = tx;
-                        std::future::pending::<()>().await;
+
+                    let resp = ReceiveElectricalComponentTelemetryStreamResponse {
+                        telemetry: Some(ElectricalComponentTelemetry {
+                            electrical_component_id: comp_id,
+                            metric_samples,
+                            // TODO: support sending errors
+                            state_snapshots: vec![ElectricalComponentStateSnapshot {
+                                origin_time: ts,
+                                states: vec![state_code as i32],
+                                warnings: vec![],
+                                errors: vec![],
+                            }],
+                        }),
+                    };
+                    if tx.send(Ok(resp)).await.is_err() {
+                        break;
                     }
-                });
-            }
+                }
+                if silence_after_metrics {
+                    // Hold the sender open indefinitely so the client
+                    // actor doesn't see the stream end and reconnect.
+                    let _keep_open = tx;
+                    std::future::pending::<()>().await;
+                }
+            });
         }
 
         let stream = tokio_stream::wrappers::ReceiverStream::new(rx);

src/logical_meter/logical_meter_handle.rs

@@ -567,7 +567,7 @@ mod tests {
     ) {
         let values = samples
             .iter()
-            .map(|res| res.value().map(|v| extractor(v)))
+            .map(|res| res.value().map(&extractor))
             .collect::<Vec<_>>();
 
         samples.as_slice().windows(2).for_each(|w| {

src/quantity/current.rs

@@ -82,8 +82,8 @@ mod tests {
         assert_eq!(s(-0.001558), "-1.558 mA");
         assert_eq!(p(-0.001558, 1), "-1.6 mA");
 
-        assert_eq!(s(-2030.04487), "-2030.045 A");
-        assert_eq!(p(-2030.04487, 1), "-2030 A");
-        assert_eq!(p(-2030.04487, 2), "-2030.04 A");
+        assert_eq!(s(-2030.0449), "-2030.045 A");
+        assert_eq!(p(-2030.0449, 1), "-2030 A");
+        assert_eq!(p(-2030.0449, 2), "-2030.04 A");
     }
 }

src/quantity/energy.rs

@@ -107,8 +107,8 @@ mod tests {
         assert_eq!(s(0.0015508), "1.551 mWh");
         assert_eq!(p(0.0015508, 5), "1.5508 mWh");
 
-        assert_eq!(s(1030.04487), "1.03 kWh");
-        assert_eq!(p(1030.04487, 1), "1 kWh");
+        assert_eq!(s(1030.0449), "1.03 kWh");
+        assert_eq!(p(1030.0449, 1), "1 kWh");
 
         assert_eq!(s(2_030_022.0), "2.03 MWh");
         assert_eq!(s(2_030_022_123.0), "2.03 GWh");
@@ -117,8 +117,8 @@ mod tests {
         assert_eq!(s(-1.558), "-1.558 Wh");
         assert_eq!(p(-1.558, 1), "-1.6 Wh");
 
-        assert_eq!(s(-1030.04487), "-1.03 kWh");
-        assert_eq!(p(-1030.04487, 1), "-1 kWh");
+        assert_eq!(s(-1030.0449), "-1.03 kWh");
+        assert_eq!(p(-1030.0449, 1), "-1 kWh");
 
         assert_eq!(s(-2_030_022.0), "-2.03 MWh");
         assert_eq!(p(-2_030_022.0, 1), "-2 MWh");

src/quantity/frequency.rs

@@ -33,7 +33,7 @@ mod tests {
         let freq_2 = Frequency::from_megahertz(0.0012);
         assert_f32_eq(freq_2.as_hertz(), 1200.0);
 
-        let freq_2 = Frequency::from_gigahertz(0.000_0012);
+        let freq_2 = Frequency::from_gigahertz(0.000_001_2);
         assert_f32_eq(freq_2.as_hertz(), 1200.0);
 
         assert!(freq_1 < freq_2);