fix(test): pass serious_python native-build env to flet test

flet test spawns its own 'flutter test integration_test' (via FletTestApp)
instead of going through _run_flutter_command, so it never received the
serious_python build-time env that flet build sets. Most critically
SERIOUS_PYTHON_APP was unset, which makes the Android packageApp Gradle task
early-return and leave a stale app.zip (old-Python main.pyc) in the APK,
crashing the embedded runtime with 'ImportError: bad magic number'.

Extract the serious_python native-build env into a shared
_serious_python_build_env() and use it from both _run_flutter_command and
flet test's _flutter_path_env, so the two paths bundle an identical app and
can't drift. Adds SERIOUS_PYTHON_APP, SERIOUS_PYTHON_ANDROID_EXTRACT_PACKAGES
and SP_NATIVE_SET to the test env (and _TEST_ENV_KEYS).

Author: FeodorFitsner

sdk/python/packages/flet-cli/src/flet_cli/commands/build_base.py

@@ -2479,6 +2479,60 @@ def run_flutter(self):
 
         self._run_flutter_command()
 
+    def _serious_python_build_env(self) -> dict:
+        """
+        serious_python environment for the platform NATIVE build (the Gradle /
+        CMake / podspec steps run by `flutter build`).
+
+        These tell the native build where the `package` step staged the app and
+        site-packages and which embedded Python runtime to bundle. `flet build`
+        applies them via `_run_flutter_command`; `flet test` applies the SAME set
+        to the `flutter test` it spawns (see test.py `_flutter_path_env`) so both
+        bundle an identical app. In particular, without `SERIOUS_PYTHON_APP` the
+        Android `packageApp` Gradle task early-returns and a stale `app.zip` (e.g.
+        an old-Python `main.pyc`) survives in the APK — `ImportError: bad magic
+        number`. Built defensively so it is safe to call before the full build
+        pipeline has populated every attribute.
+        """
+
+        env: dict = {}
+        python_release = getattr(self, "python_release", None)
+        if python_release is not None:
+            # Only the short version is passed; serious_python derives the rest
+            # from its committed manifest snapshot.
+            env["SERIOUS_PYTHON_VERSION"] = python_release.short
+
+        build_dir = getattr(self, "build_dir", None)
+        package_platform = getattr(self, "package_platform", None)
+        if build_dir is not None and package_platform != "Emscripten":
+            env["SERIOUS_PYTHON_SITE_PACKAGES"] = str(build_dir / "site-packages")
+            # app staging dir: read by the platform native build (CMake / podspec
+            # / Android Gradle) at `flutter build` time to place the unpacked app
+            # into the bundle.
+            env["SERIOUS_PYTHON_APP"] = str(build_dir / "python-app")
+
+        # Swift Package Manager (darwin): export the cache-bust key the package
+        # step computed so the plugin's Package.swift re-resolves when the staged
+        # native set changes (SwiftPM caches its graph on manifest text + env).
+        if (
+            build_dir is not None
+            and package_platform in ("iOS", "Darwin")
+            and self._darwin_spm_active()
+        ):
+            spm_key_file = build_dir / ".serious_python_spm_key"
+            if spm_key_file.exists():
+                env["SP_NATIVE_SET"] = spm_key_file.read_text().strip()
+
+        # Path-hungry packages to ship extracted to disk: consumed by the
+        # serious_python_android Gradle split during `flutter build`.
+        if package_platform == "Android" and getattr(
+            self, "android_extract_packages", None
+        ):
+            env["SERIOUS_PYTHON_ANDROID_EXTRACT_PACKAGES"] = ",".join(
+                self.android_extract_packages
+            )
+        return env
+
     def _run_flutter_command(self):
         """
         Build final Flutter CLI command, configure environment, and run it.
@@ -2500,36 +2554,10 @@ def _run_flutter_command(self):
             ]
         )
 
-        # Only the short version is passed; serious_python derives the rest
-        # from its committed manifest snapshot.
-        build_env = {
-            "SERIOUS_PYTHON_VERSION": self.python_release.short,
-        }
-
-        # site-packages variable
-        if self.package_platform != "Emscripten":
-            build_env["SERIOUS_PYTHON_SITE_PACKAGES"] = str(
-                self.build_dir / "site-packages"
-            )
-            # app staging dir: read by the platform native build (CMake /
-            # podspec / Android Gradle) at `flutter build` time to place the
-            # unpacked app into the bundle.
-            build_env["SERIOUS_PYTHON_APP"] = str(self.build_dir / "python-app")
-
-        # Swift Package Manager (darwin): export the cache-bust key the package
-        # step computed so the plugin's Package.swift re-resolves when the staged
-        # native set changes (SwiftPM caches its graph on manifest text + env).
-        if self._darwin_spm_active():
-            spm_key_file = self.build_dir / ".serious_python_spm_key"
-            if spm_key_file.exists():
-                build_env["SP_NATIVE_SET"] = spm_key_file.read_text().strip()
-
-        # Path-hungry packages to ship extracted to disk: consumed by the
-        # serious_python_android Gradle split during `flutter build`.
-        if self.package_platform == "Android" and self.android_extract_packages:
-            build_env["SERIOUS_PYTHON_ANDROID_EXTRACT_PACKAGES"] = ",".join(
-                self.android_extract_packages
-            )
+        # serious_python env for the native build, shared verbatim with `flet
+        # test` (which spawns its own `flutter test`) so both bundle an identical
+        # app — see `_serious_python_build_env`.
+        build_env = self._serious_python_build_env()
 
         if self.package_platform == "Emscripten" and not self.template_data["no_wasm"]:
             build_args.append("--wasm")

sdk/python/packages/flet-cli/src/flet_cli/commands/test.py

@@ -50,17 +50,23 @@ def _provision_steps(cmd: "BaseBuildCommand") -> Path:
 
 # Env vars set by `flet test` (and `provision_test_host`) for the pytest
 # subprocess. `flutter test integration_test` (spawned by FletTestApp) runs the
-# platform's native build, whose serious_python build phase bundles
-# site-packages into the app from SERIOUS_PYTHON_SITE_PACKAGES — without it the
-# embedded Python can't import its dependencies (e.g. ModuleNotFoundError:
-# certifi). `flet build`/`flet debug` set the same vars for their flutter build
-# (see build_base.py `_run_flutter_command`).
+# platform's native build, whose serious_python build phase bundles the staged
+# app + site-packages — without these vars the embedded Python can't import its
+# dependencies (e.g. ModuleNotFoundError: certifi) and, on Android, the
+# `packageApp` Gradle task no-ops so a stale `app.zip` (old-Python `main.pyc`)
+# survives in the APK (ImportError: bad magic number). `flet build`/`flet debug`
+# set the SAME serious_python vars for their flutter build via
+# `_serious_python_build_env` (build_base.py `_run_flutter_command`); we reuse it
+# here so the two paths can't drift.
 _TEST_ENV_KEYS = (
     "PATH",
     "FLET_TEST_DISABLE_FVM",
     "FLET_TEST_FLUTTER_EXE",
     "SERIOUS_PYTHON_VERSION",
     "SERIOUS_PYTHON_SITE_PACKAGES",
+    "SERIOUS_PYTHON_APP",
+    "SERIOUS_PYTHON_ANDROID_EXTRACT_PACKAGES",
+    "SP_NATIVE_SET",
     "SERIOUS_PYTHON_FLUTTER_PACKAGES",
 )
 
@@ -81,13 +87,10 @@ def _flutter_path_env(cmd: "BaseBuildCommand") -> dict:
         # on Windows can't resolve a bare "flutter" (no PATHEXT lookup).
         env["FLET_TEST_FLUTTER_EXE"] = str(cmd.flutter_exe)
     env["FLET_TEST_DISABLE_FVM"] = "1"
-    if getattr(cmd, "python_release", None) is not None:
-        env["SERIOUS_PYTHON_VERSION"] = cmd.python_release.short
-    if (
-        getattr(cmd, "build_dir", None) is not None
-        and getattr(cmd, "package_platform", None) != "Emscripten"
-    ):
-        env["SERIOUS_PYTHON_SITE_PACKAGES"] = str(cmd.build_dir / "site-packages")
+    # Same serious_python env `flet build` hands its native build, so the app
+    # `flutter test` builds is bundled identically (incl. SERIOUS_PYTHON_APP →
+    # a fresh app.zip with a matching-Python main.pyc).
+    env.update(cmd._serious_python_build_env())
     if getattr(cmd, "flutter_packages_temp_dir", None) is not None:
         env["SERIOUS_PYTHON_FLUTTER_PACKAGES"] = str(cmd.flutter_packages_temp_dir)
     return env