refactor: move run accumulation out of the view model into the domain

The view model was doing two jobs. Alongside presentation state it held what happened during a run — the interval series, the rule that iperf3's omitted warm-up intervals do not count, the retained end summary — and the screen computed mean and peak inline in a widget builder. All of that is the part that has to be correct, and all of it would have been rewritten by anyone replacing the UI. Iperf3Session accumulates a run in the domain layer: samples, totals, errors, whether it was stopped, and the statistics over them. The view model now feeds it events and keeps only a formatted transcript and the repaint schedule; the screen reads every displayed number off the session and derives none. Two details the session now owns rather than leaving to a caller. Omitted intervals are excluded, so a warm-up cannot drag the mean down. And totalRetransmits stays null when no interval reported a count — UDP does not measure retransmits, and "not measured" must not render as zero. The aggregation tests move with the logic, into a pure-Dart test with no widgets or bindings involved. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-26 20:24:44 +09:00
parent 838c883cc0
commit 9485049b57
5 changed files with 283 additions and 87 deletions
@@ -0,0 +1,114 @@
+import 'package:iperf3gui/domain/models/iperf3_event.dart';
+
+/// The accumulated state of one iperf3 run.
+///
+/// Fed the event stream one report at a time, this is the answer to "what
+/// happened during this test" — the interval series, the end totals, any
+/// errors, and the statistics derived from them.
+///
+/// It lives in the domain layer on purpose: it is what has to be *correct*,
+/// independent of how anything chooses to draw it. A different UI, a headless
+/// run or a future export path all consume the same object, and none of them
+/// re-derive a mean or re-decide whether a warm-up interval counts.
+class Iperf3Session {
+  Iperf3Start? _start;
+
+  /// Connection details, once the run has reported them.
+  Iperf3Start? get start => _start;
+
+  final List<Iperf3Interval> _intervals = [];
+
+  /// Throughput samples in arrival order, warm-up intervals excluded.
+  List<Iperf3Interval> get intervals => List.unmodifiable(_intervals);
+
+  Iperf3End? _summary;
+
+  /// Sent/received totals, once the run has finished.
+  Iperf3End? get summary => _summary;
+
+  final List<String> _errors = [];
+
+  /// Errors reported during the run, in order.
+  List<String> get errors => List.unmodifiable(_errors);
+
+  bool _stopped = false;
+
+  /// Whether the run ended because it was asked to stop.
+  bool get stopped => _stopped;
+
+  /// Whether iperf3 reported any error.
+  bool get hasError => _errors.isNotEmpty;
+
+  /// Whether anything at all has been recorded.
+  bool get isEmpty =>
+      _start == null && _intervals.isEmpty && _summary == null && !hasError;
+
+  /// How many throughput samples have been recorded.
+  int get sampleCount => _intervals.length;
+
+  /// Throughput of the most recent sample, or null before the first one.
+  double? get latestBitsPerSecond =>
+      _intervals.isEmpty ? null : _intervals.last.bitsPerSecond;
+
+  /// Mean throughput across the samples, or null before the first one.
+  ///
+  /// This is the mean of the per-interval rates, which is not identical to the
+  /// run's overall rate when intervals differ in length — prefer
+  /// [summary]'s totals for the headline figure once it is available.
+  double? get meanBitsPerSecond {
+    if (_intervals.isEmpty) return null;
+    final total = _intervals.fold<double>(0, (sum, i) => sum + i.bitsPerSecond);
+    return total / _intervals.length;
+  }
+
+  /// Highest sampled throughput, or null before the first sample.
+  double? get peakBitsPerSecond {
+    if (_intervals.isEmpty) return null;
+    return _intervals
+        .map((i) => i.bitsPerSecond)
+        .reduce((a, b) => a > b ? a : b);
+  }
+
+  /// Total bytes across the recorded samples.
+  int get sampledBytes => _intervals.fold<int>(0, (sum, i) => sum + i.bytes);
+
+  /// Total retransmits across the samples, or null if none were reported.
+  ///
+  /// UDP tests report no retransmit counts, so null means "not measured"
+  /// rather than zero.
+  int? get totalRetransmits {
+    final reported =
+        _intervals.map((i) => i.retransmits).whereType<int>().toList();
+    if (reported.isEmpty) return null;
+    return reported.fold<int>(0, (sum, r) => sum + r);
+  }
+
+  /// Record one report.
+  void add(Iperf3Event event) {
+    switch (event) {
+      case Iperf3Start e:
+        _start = e;
+      case Iperf3Interval e:
+        // Warm-up intervals (-O) are marked omitted by iperf3 and must not
+        // drag the statistics down.
+        if (!e.omitted) _intervals.add(e);
+      case Iperf3End e:
+        _summary = e;
+      case Iperf3Error e:
+        _errors.add(e.message);
+      case Iperf3Stopped _:
+        _stopped = true;
+      case Iperf3LogLine _:
+        break;
+    }
+  }
+
+  /// Forget everything, ready for another run.
+  void clear() {
+    _start = null;
+    _intervals.clear();
+    _summary = null;
+    _errors.clear();
+    _stopped = false;
+  }
+}