Fix integration test failures caused by render overflow errors (#6664)

* Fix integration test failures caused by render overflow errors

Any FlutterError reported during a frame (typically "RenderFlex
overflowed") fails the on-device testWidgets body, which the exit-code
check surfaces as a teardown error on the last test of the module even
though all host-side assertions and goldens pass.

Test harness:
- FletTestApp now captures Flutter test process output and dumps its
  tail when the process exits non-zero, so CI failures show the reason.
- host_test.dart hooks reportTestException to print the exception and
  stack (flutter test otherwise never prints it) and delays tearDownAll
  so end-of-run reports are not lost when the process exits.
- Screenshot captures are hosted in a hidden-scrollbar scrollable
  column, so content taller than the test window scrolls instead of
  overflowing the page; captures and goldens are unaffected.

Tests and examples:
- test_spinkit: render all spinners inside a scrollable column.
- data_table/sortable_and_selectable example: make the page scrollable;
  the table is 2px taller than the default 800x600 window and drew an
  overflow on the first frame.
- Regenerate stale client/pubspec.lock.

CI: temporarily run only the affected tests; restore the full suite
list before merging.

* Restore full macOS integration test matrix

Author: FeodorFitsner

client/pubspec.lock

@@ -430,6 +430,13 @@ packages:
       relative: true
     source: path
     version: "0.1.0"
+  flet_integration_test:
+    dependency: "direct dev"
+    description:
+      path: "../packages/flet_integration_test"
+      relative: true
+    source: path
+    version: "0.86.0"
   flet_lottie:
     dependency: "direct main"
     description:
@@ -1363,13 +1370,13 @@ packages:
     source: hosted
     version: "2.0.4"
   screen_brightness:
-    dependency: transitive
+    dependency: "direct overridden"
     description:
       name: screen_brightness
-      sha256: e0edf92c08889e8f493cde291e7c687db2b4a1471f2371c074070b75d7c7d79b
+      sha256: "5f70754028f169f059fdc61112a19dcbee152f8b293c42c848317854d650cba3"
       url: "https://pub.dev"
     source: hosted
-    version: "2.1.11"
+    version: "2.1.7"
   screen_brightness_android:
     dependency: transitive
     description:
@@ -1387,13 +1394,13 @@ packages:
     source: hosted
     version: "2.1.4"
   screen_brightness_macos:
-    dependency: transitive
+    dependency: "direct overridden"
     description:
       name: screen_brightness_macos
-      sha256: b0957237b842d846a84363b69f229b339a8f91faced55041e245b2ebff7b0142
+      sha256: "278712cf5288db57bd335968cbfb2ec5441028f1ee2fcbdc8d1582d8210a3442"
       url: "https://pub.dev"
     source: hosted
-    version: "2.1.4"
+    version: "2.1.2"
   screen_brightness_ohos:
     dependency: transitive
     description:

packages/flet_integration_test/lib/src/host_test.dart

@@ -25,6 +25,26 @@ void runFletHostTest({
 }) {
   var binding = IntegrationTestWidgetsFlutterBinding.ensureInitialized();
 
+  // With the integration_test binding `flutter test` prints only
+  // "Test failed. See exception logs above." without ever printing the
+  // exception that failed the test (e.g. a render overflow reported during a
+  // frame). Log it here so the failure reason is visible in the test process
+  // output.
+  final prevReportTestException = reportTestException;
+  reportTestException = (details, testDescription) {
+    debugPrint("Test exception ($testDescription): "
+        "${details.exceptionAsString()}\n${details.stack ?? ''}");
+    prevReportTestException(details, testDescription);
+  };
+  debugPrint("Flet host test: exception reporter installed");
+
+  tearDownAll(() async {
+    // Exceptions are reported when the test body completes, moments before
+    // the app process exits; give the device-log relay time to flush them so
+    // they are not lost from the `flutter test` output.
+    await Future.delayed(const Duration(seconds: 2));
+  });
+
   group('end-to-end test', () {
     testWidgets('test app', (tester) async {
       var dir = Directory.current.path;

sdk/python/examples/controls/material/data_table/sortable_and_selectable/main.py

@@ -2,6 +2,7 @@
 
 
 def main(page: ft.Page):
+    page.scroll = ft.ScrollMode.AUTO
     inventory_items = [
         {"id": 1, "name": "Alpha", "qty": 4},
         {"id": 2, "name": "Bravo", "qty": 9},

sdk/python/packages/flet/integration_tests/extensions/spinkit/test_spinkit.py

@@ -138,10 +138,19 @@ async def test_all_controls_render(flet_app: ftt.FletTestApp):
     ]
     flet_app.page.clean()
     flet_app.page.add(
-        ft.Row(
-            wrap=True,
-            key="row",
-            controls=[cls(color=ft.Colors.BLUE, size=40) for cls in controls],
+        # The wrapped row of all spinners is much taller than the test window;
+        # host it in a scrollable column so the page doesn't overflow (an
+        # overflow error fails the Flutter test process).
+        ft.Column(
+            scroll=ft.ScrollMode.AUTO,
+            expand=True,
+            controls=[
+                ft.Row(
+                    wrap=True,
+                    key="row",
+                    controls=[cls(color=ft.Colors.BLUE, size=40) for cls in controls],
+                )
+            ],
         )
     )
     await flet_app.tester.pump(duration=ft.Duration(milliseconds=500))

sdk/python/packages/flet/src/flet/testing/flet_test_app.py

@@ -175,6 +175,8 @@ def __init__(
         self.__assets_dir = assets_dir or "assets"
         self.__tcp_port = tcp_port
         self.__flutter_process: Optional[asyncio.subprocess.Process] = None
+        self.__flutter_output = bytearray()
+        self.__flutter_output_task: Optional[asyncio.Task] = None
         self.__page = None
         self.__tester: Union[Tester, RemoteTester, None] = None
 
@@ -256,15 +258,14 @@ async def main(page: ft.Page):
             print("Started Flet app")
 
         # Stream the Flutter test process output to the console when verbose
-        # (set by `flet test -v`) or when debug logging is on; otherwise hide it.
-        stdout = asyncio.subprocess.DEVNULL
-        stderr = asyncio.subprocess.DEVNULL
-        if (
+        # (set by `flet test -v`) or when debug logging is on; otherwise
+        # capture it into a buffer so it can be dumped if the process fails.
+        verbose = (
             get_bool_env_var("FLET_TEST_VERBOSE")
             or logging.getLogger().getEffectiveLevel() == logging.DEBUG
-        ):
-            stdout = None
-            stderr = None
+        )
+        stdout = None if verbose else asyncio.subprocess.PIPE
+        stderr = None if verbose else asyncio.subprocess.STDOUT
 
         # The resolved Flutter executable (full path, `flutter.bat` on Windows)
         # is passed by `flet test`; fall back to a bare "flutter" on PATH.
@@ -320,6 +321,11 @@ async def main(page: ft.Page):
             stderr=stderr,
         )
 
+        if self.__flutter_process.stdout is not None:
+            self.__flutter_output_task = asyncio.create_task(
+                self.__read_flutter_output(self.__flutter_process.stdout)
+            )
+
         print("Started Flutter test process.")
         print("Waiting for the Flutter app to connect...")
 
@@ -331,11 +337,54 @@ def connected() -> bool:
         while not connected():
             await asyncio.sleep(0.2)
             if self.__flutter_process.returncode is not None:
+                self.__dump_flutter_output()
                 raise RuntimeError(
                     "Flutter process exited early with code "
                     f"{self.__flutter_process.returncode}"
                 )
 
+    async def __read_flutter_output(self, stream: asyncio.StreamReader):
+        # Read in chunks, not lines: the Flet client's debug output includes
+        # very long lines (e.g. screenshot bytes) that overflow StreamReader's
+        # per-line limit. Overlong lines are cut and only the output tail is
+        # kept to bound memory.
+        line = bytearray()
+        truncated = False
+        while True:
+            chunk = await stream.read(65536)
+            if not chunk:
+                break
+            for part in chunk.splitlines(keepends=True):
+                line.extend(part)
+                if line.endswith((b"\n", b"\r")):
+                    self.__append_flutter_output_line(line, truncated)
+                    line.clear()
+                    truncated = False
+                elif len(line) > self.__flutter_output_line_limit:
+                    del line[self.__flutter_output_line_limit :]
+                    truncated = True
+        if line:
+            self.__append_flutter_output_line(line, truncated)
+
+    def __append_flutter_output_line(self, line: bytearray, truncated: bool):
+        if len(line) > self.__flutter_output_line_limit:
+            line = line[: self.__flutter_output_line_limit]
+            truncated = True
+        self.__flutter_output.extend(line.rstrip(b"\r\n"))
+        if truncated:
+            self.__flutter_output.extend(b" ...<truncated>")
+        self.__flutter_output.extend(b"\n")
+        if len(self.__flutter_output) > self.__flutter_output_limit:
+            del self.__flutter_output[: -self.__flutter_output_limit]
+
+    def __dump_flutter_output(self):
+        if not self.__flutter_output:
+            return
+        output = self.__flutter_output.decode(errors="replace")
+        print("---------- Flutter test process output (tail) ----------")
+        print(output)
+        print("---------- End of Flutter test process output ----------")
+
     def __flutter_test_target(self) -> str:
         # In device mode the driver (`integration_test/app_test.dart`) is
         # generated from the template; validate it exists and is non-empty so a
@@ -383,6 +432,12 @@ async def teardown(self):
                     print("Force killing Flutter test process...")
                     self.__flutter_process.kill()
 
+        if self.__flutter_output_task:
+            try:
+                await asyncio.wait_for(self.__flutter_output_task, timeout=5)
+            except asyncio.TimeoutError:
+                self.__flutter_output_task.cancel()
+
         # Stop the RemoteTester socket server (device mode).
         if isinstance(self.__tester, RemoteTester):
             await self.__tester.stop()
@@ -392,6 +447,7 @@ async def teardown(self):
         # `testWidgets` body even though our find/tap assertions passed). Surface
         # that as a test failure — otherwise the run is falsely green.
         if flutter_returncode is not None and flutter_returncode != 0:
+            self.__dump_flutter_output()
             raise RuntimeError(
                 f"Flutter integration test process failed with exit code "
                 f"{flutter_returncode}. See the Flutter test output above."
@@ -420,8 +476,10 @@ async def wrap_page_controls_in_screenshot(
         """
         controls = list(self.page.controls)
         self.page.controls = [
-            scr := ft.Screenshot(
-                ft.Column(controls, margin=margin, intrinsic_width=True)
+            self.__scrollable_screenshot_host(
+                scr := ft.Screenshot(
+                    ft.Column(controls, margin=margin, intrinsic_width=True)
+                )
             )
         ]  # type: ignore
         self.page.update()
@@ -470,7 +528,11 @@ async def assert_control_screenshot(
 
         # add control and take screenshot
         screenshot = ft.Screenshot(control, expand=expand_screenshot)
-        self.page.add(screenshot)
+        self.page.add(
+            screenshot
+            if expand_screenshot
+            else self.__scrollable_screenshot_host(screenshot)
+        )
         await self.__pump_and_settle_with_timeout("assert_control_screenshot-add")
         for _ in range(0, pump_times):
             await self.tester.pump(duration=pump_duration)
@@ -480,6 +542,24 @@ async def assert_control_screenshot(
             similarity_threshold=similarity_threshold,
         )
 
+    def __scrollable_screenshot_host(
+        self, screenshot: ft.Screenshot
+    ) -> Union[ft.Screenshot, ft.Column]:
+        # A scrollable page cannot overflow; an expanded host inside it would
+        # be flex-in-unbounded-height and fail layout instead.
+        if self.page.scroll is not None:
+            return screenshot
+        # Host the screenshot in a scrollable column: content taller than the
+        # window then scrolls instead of overflowing the page (an overflow
+        # error fails the Flutter test process). The child sees the same
+        # unbounded-height constraints as in the page column, so captures are
+        # unaffected.
+        return ft.Column(
+            expand=True,
+            scroll=ft.ScrollMode.HIDDEN,
+            controls=[screenshot],
+        )
+
     async def __pump_and_settle_with_timeout(self, stage: str):
         try:
             await self.tester.pump_and_settle(timeout=self.__pump_and_settle_timeout)
@@ -849,3 +929,5 @@ def _compare_gifs(
             return min(similarities), None
 
     __pump_and_settle_timeout = 10.0
+    __flutter_output_limit = 262144
+    __flutter_output_line_limit = 2048