test: Pin Log.progress scoping and no-relabel contracts

- progress_nesting_test: a log emitted inside a progress runner must be
  attributed to the progress scope via the Zone, and a nested progress
  must child under the outer scope.
- progress_relabel_test: progress must never surface the runner's result
  as a scope label (uses a generic recording writer, no terminal rendering).

Author: nielsenko

packages/serverpod_logging/test/progress_nesting_test.dart

@@ -0,0 +1,62 @@
+import 'package:serverpod_logging/serverpod_logging.dart';
+import 'package:test/test.dart';
+
+/// Regression guard for the Zone-based scoping contract of [Log.progress].
+///
+/// The whole point of [Log.progress] is documented as:
+///   "Log calls inside the runner are automatically scoped via the Zone."
+///
+/// A `log.info(...)` emitted from within the runner must be attributed
+/// to the progress scope, not to the enclosing/root scope. This is a pure
+/// framework property and has nothing to do with how (or whether) the scope
+/// is rendered.
+void main() {
+  group('Given Log.progress with a runner that logs', () {
+    late TestLogWriter writer;
+    late Log log;
+
+    setUp(() {
+      writer = TestLogWriter();
+      log = Log(writer);
+    });
+
+    test(
+        'when the runner emits a log entry, '
+        'then that entry is scoped to the progress scope', () async {
+      await log.progress('outer', () async {
+        log.info('inside');
+      });
+      await log.flush();
+
+      final opened = writer.openedScopes.single;
+      expect(opened.label, 'outer');
+
+      final inside = writer.entries.singleWhere((e) => e.message == 'inside');
+      expect(
+        inside.scope.id,
+        opened.id,
+        reason: 'a log emitted inside the runner must reference the '
+            'progress scope, via the Zone',
+      );
+      expect(inside.scope.label, 'outer');
+    });
+
+    test(
+        'when the runner opens a nested progress scope, '
+        'then the inner scope is a child of the outer scope', () async {
+      await log.progress('outer', () async {
+        await log.progress('inner', () async => true);
+      });
+      await log.flush();
+
+      final outer = writer.openedScopes.firstWhere((s) => s.label == 'outer');
+      final inner = writer.openedScopes.firstWhere((s) => s.label == 'inner');
+      expect(
+        inner.parent?.id,
+        outer.id,
+        reason: 'the inner progress scope must nest under the outer one, '
+            'which only works if the runner executes inside the outer Zone',
+      );
+    });
+  });
+}

packages/serverpod_logging/test/progress_relabel_test.dart

@@ -0,0 +1,74 @@
+import 'package:serverpod_logging/serverpod_logging.dart';
+import 'package:test/test.dart';
+
+/// A writer that records every scope label it is ever asked to render,
+/// regardless of which lifecycle hook delivered it.
+///
+/// This is deliberately a *generic* sink (think: a JSON line writer, a DB
+/// writer, an OTEL exporter) - it does not animate spinners or care about
+/// terminals. It exists to pin a framework-level contract:
+///
+///   `Log.progress(label, runner)` describes ONE operation called [label].
+///   The runner's *return value* is data, not a new name for the operation.
+///
+class _LabelRecordingWriter extends LogWriter {
+  final List<String> observedLabels = [];
+
+  @override
+  Future<void> log(LogEntry entry) async {}
+
+  @override
+  Future<void> openScope(LogScope scope) async =>
+      observedLabels.add(scope.label);
+
+  @override
+  Future<void> closeScope(
+    LogScope scope, {
+    required bool success,
+    required Duration duration,
+    Object? error,
+    StackTrace? stackTrace,
+  }) async =>
+      observedLabels.add(scope.label);
+}
+
+void main() {
+  group('Given Log.progress with a plain (non-stream) runner', () {
+    late _LabelRecordingWriter writer;
+    late Log log;
+
+    setUp(() {
+      writer = _LabelRecordingWriter();
+      log = Log(writer);
+    });
+
+    test(
+        'when the runner returns a value, '
+        'then no scope event is labelled with that value', () async {
+      await log.progress<String>('op', () async => 'sentinel-result');
+      await log.flush();
+
+      expect(
+        writer.observedLabels,
+        everyElement('op'),
+        reason: 'progress must not relabel the scope with the runner result; '
+            'the operation is called "op" from start to finish',
+      );
+      expect(
+        writer.observedLabels,
+        isNot(contains('sentinel-result')),
+        reason: 'the runner return value must never surface as a scope label',
+      );
+    });
+
+    test(
+        'when the runner returns true, '
+        'then the scope label stays "op" (not "true")', () async {
+      await log.progress<bool>('op', () async => true);
+      await log.flush();
+
+      expect(writer.observedLabels, everyElement('op'));
+      expect(writer.observedLabels, isNot(contains('true')));
+    });
+  });
+}