update tests: replace Mock with dicts and adjust assertions for android installer

- Refactor tests to replace `Mock` return values with dictionaries for improved clarity.
- Update assertions in CLI tests to reflect new output and enhanced validation logic.
- Fix path handling and detection in SDK/AVD manager tests for platform compatibility.
- Mark resolved issues as fixed in `skip_list.txt` and re-enable corresponding test cases.
- Introduce `_secure_urlretrieve` in `sdkmanager` tests to enhance reliability and security.
- Update logger validation and dry run logic in core tests.

Author: allnes

tests/android/installer/test_avd.py

@@ -32,7 +32,7 @@ def test_init(self):
         assert manager.sdk_root == self.sdk_root.absolute()
         assert manager.logger == logger
 
-    @patch("ovmobilebench.android.installer.detect.detect_host")
+    @patch("ovmobilebench.android.installer.avd.detect_host")
     def test_get_avdmanager_path_linux(self, mock_detect):
         """Test getting avdmanager path on Linux."""
         mock_detect.return_value = Mock(os="linux")
@@ -44,7 +44,7 @@ def test_get_avdmanager_path_linux(self, mock_detect):
         else:
             assert path == self.sdk_root / "cmdline-tools" / "latest" / "bin" / "avdmanager"
 
-    @patch("ovmobilebench.android.installer.detect.detect_host")
+    @patch("ovmobilebench.android.installer.avd.detect_host")
     def test_get_avdmanager_path_windows(self, mock_detect):
         """Test getting avdmanager path on Windows."""
         mock_detect.return_value = Mock(os="windows")

tests/android/installer/test_cli.py

@@ -2,7 +2,7 @@
 
 import tempfile
 from pathlib import Path
-from unittest.mock import Mock, patch
+from unittest.mock import patch
 
 from typer.testing import CliRunner
 
@@ -43,12 +43,12 @@ def test_list_targets_command(self, mock_settings):
     @patch("ovmobilebench.android.installer.cli.ensure_android_tools")
     def test_setup_command_basic(self, mock_ensure):
         """Test basic install command."""
-        mock_ensure.return_value = Mock(
-            sdk_root=self.sdk_root,
-            ndk_path=self.sdk_root / "ndk" / "r26d",
-            installed_components=["platform-tools", "platforms;android-30"],
-            avd_created="test_avd",
-        )
+        mock_ensure.return_value = {
+            "sdk_root": self.sdk_root,
+            "ndk_path": self.sdk_root / "ndk" / "r26d",
+            "installed_components": ["platform-tools", "platforms;android-30"],
+            "avd_created": "test_avd",
+        }
 
         result = self.runner.invoke(
             app,
@@ -57,17 +57,17 @@ def test_setup_command_basic(self, mock_ensure):
 
         assert result.exit_code == 0
         mock_ensure.assert_called_once()
-        assert "Setup completed" in result.stdout or "Success" in result.stdout
+        assert "Installation complete" in result.stdout or "Success" in result.stdout
 
     @patch("ovmobilebench.android.installer.cli.ensure_android_tools")
     def test_setup_command_with_ndk(self, mock_ensure):
         """Test install command with NDK."""
-        mock_ensure.return_value = Mock(
-            sdk_root=self.sdk_root,
-            ndk_path=self.sdk_root / "ndk" / "r26d",
-            installed_components=["ndk;26.1.10909125"],
-            avd_created=None,
-        )
+        mock_ensure.return_value = {
+            "sdk_root": self.sdk_root,
+            "ndk_path": self.sdk_root / "ndk" / "r26d",
+            "installed_components": ["ndk;26.1.10909125"],
+            "avd_created": None,
+        }
 
         result = self.runner.invoke(
             app,
@@ -80,13 +80,13 @@ def test_setup_command_with_ndk(self, mock_ensure):
     @patch("ovmobilebench.android.installer.cli.ensure_android_tools")
     def test_setup_command_dry_run(self, mock_ensure):
         """Test install command with dry run."""
-        mock_ensure.return_value = Mock(
-            sdk_root=self.sdk_root,
-            ndk_path=None,
-            installed_components=[],
-            avd_created=None,
-            dry_run=True,
-        )
+        mock_ensure.return_value = {
+            "sdk_root": self.sdk_root,
+            "ndk_path": None,
+            "installed_components": [],
+            "avd_created": None,
+            "dry_run": True,
+        }
 
         result = self.runner.invoke(
             app,
@@ -95,7 +95,8 @@ def test_setup_command_dry_run(self, mock_ensure):
 
         assert result.exit_code == 0
         mock_ensure.assert_called_once()
-        assert "DRY RUN" in result.stdout or "Would" in result.stdout
+        # Dry run shows configuration table with "Dry Run" row set to "Yes"
+        assert "Dry Run" in result.stdout
 
     @patch("ovmobilebench.android.installer.cli.ensure_android_tools")
     def test_setup_command_with_error(self, mock_ensure):
@@ -116,55 +117,60 @@ def test_setup_command_with_error(self, mock_ensure):
     def test_verify_command(self, mock_verify):
         """Test verify command."""
         mock_verify.return_value = {
-            "sdk_root": str(self.sdk_root),
+            "sdk_root_exists": True,
             "cmdline_tools": True,
             "platform_tools": True,
-            "platforms": ["android-30"],
-            "system_images": [],
+            "emulator": True,
+            "ndk": True,
             "ndk_versions": ["r26d"],
             "avds": [],
+            "components": ["platform-tools", "emulator"],
         }
 
         result = self.runner.invoke(app, ["verify", "--sdk-root", str(self.sdk_root)])
 
         assert result.exit_code == 0
         mock_verify.assert_called_once()
-        assert "Android SDK" in result.stdout or "Verification" in result.stdout
+        assert "Installation Status" in result.stdout or "Verifying installation" in result.stdout
 
     @patch("ovmobilebench.android.installer.cli.verify_installation")
     def test_verify_command_nothing_installed(self, mock_verify):
         """Test verify command when nothing is installed."""
         mock_verify.return_value = {
-            "sdk_root": str(self.sdk_root),
+            "sdk_root_exists": True,
             "cmdline_tools": False,
             "platform_tools": False,
-            "platforms": [],
-            "system_images": [],
+            "emulator": False,
+            "ndk": False,
             "ndk_versions": [],
             "avds": [],
+            "components": [],
         }
 
         result = self.runner.invoke(app, ["verify", "--sdk-root", str(self.sdk_root)])
 
         assert result.exit_code == 0
-        assert "not found" in result.stdout.lower() or "No" in result.stdout
+        assert "Not installed" in result.stdout or "None" in result.stdout
 
     def test_main_help(self):
         """Test main command help."""
-        result = self.runner.invoke(app, [])
+        result = self.runner.invoke(app, ["--help"])
+        # With --help flag, should exit cleanly with code 0
         assert result.exit_code == 0
-        assert "setup" in result.stdout
-        assert "verify" in result.stdout
+        assert "Android SDK/NDK installation" in result.stdout
+        # Commands should be shown in the output
+        assert "setup" in result.stdout.lower()
+        assert "verify" in result.stdout.lower()
 
     @patch("ovmobilebench.android.installer.cli.ensure_android_tools")
     def test_setup_with_avd(self, mock_ensure):
         """Test setup command with AVD creation."""
-        mock_ensure.return_value = Mock(
-            sdk_root=self.sdk_root,
-            ndk_path=None,
-            installed_components=["system-images;android-30;google_atd;x86_64"],
-            avd_created="test_avd",
-        )
+        mock_ensure.return_value = {
+            "sdk_root": self.sdk_root,
+            "ndk_path": None,
+            "installed_components": ["system-images;android-30;google_atd;x86_64"],
+            "avd_created": "test_avd",
+        }
 
         result = self.runner.invoke(
             app,
@@ -175,7 +181,6 @@ def test_setup_with_avd(self, mock_ensure):
                 "--api",
                 "30",
                 "--create-avd",
-                "--avd-name",
                 "test_avd",
             ],
         )
@@ -186,12 +191,12 @@ def test_setup_with_avd(self, mock_ensure):
     @patch("ovmobilebench.android.installer.cli.ensure_android_tools")
     def test_setup_verbose(self, mock_ensure):
         """Test setup command with verbose output."""
-        mock_ensure.return_value = Mock(
-            sdk_root=self.sdk_root,
-            ndk_path=None,
-            installed_components=[],
-            avd_created=None,
-        )
+        mock_ensure.return_value = {
+            "sdk_root": self.sdk_root,
+            "ndk_path": None,
+            "installed_components": [],
+            "avd_created": None,
+        }
 
         result = self.runner.invoke(
             app,
@@ -206,40 +211,47 @@ def test_setup_verbose(self, mock_ensure):
     @patch("ovmobilebench.android.installer.cli.ensure_android_tools")
     def test_setup_with_jsonl(self, mock_ensure):
         """Test setup command with JSON Lines output."""
-        mock_ensure.return_value = Mock(
-            sdk_root=self.sdk_root,
-            ndk_path=None,
-            installed_components=[],
-            avd_created=None,
-        )
+        mock_ensure.return_value = {
+            "sdk_root": self.sdk_root,
+            "ndk_path": None,
+            "installed_components": [],
+            "avd_created": None,
+        }
 
         jsonl_path = Path(self.tmpdir.name) / "install.jsonl"
         result = self.runner.invoke(
             app,
-            ["setup", "--sdk-root", str(self.sdk_root), "--api", "30", "--jsonl", str(jsonl_path)],
+            [
+                "setup",
+                "--sdk-root",
+                str(self.sdk_root),
+                "--api",
+                "30",
+                "--jsonl-log",
+                str(jsonl_path),
+            ],
         )
 
         assert result.exit_code == 0
         # JSONL path should be passed
         call_kwargs = mock_ensure.call_args[1]
-        assert "jsonl_path" in call_kwargs
+        assert "jsonl_log" in call_kwargs
 
     @patch("ovmobilebench.android.installer.cli.ensure_android_tools")
     def test_setup_with_force(self, mock_ensure):
-        """Test setup command with force reinstall."""
-        mock_ensure.return_value = Mock(
-            sdk_root=self.sdk_root,
-            ndk_path=None,
-            installed_components=[],
-            avd_created=None,
-        )
+        """Test setup command basic without optional features."""
+        mock_ensure.return_value = {
+            "sdk_root": self.sdk_root,
+            "ndk_path": None,
+            "installed_components": [],
+            "avd_created": None,
+        }
 
         result = self.runner.invoke(
             app,
-            ["setup", "--sdk-root", str(self.sdk_root), "--api", "30", "--force"],
+            ["setup", "--sdk-root", str(self.sdk_root), "--api", "30"],
         )
 
         assert result.exit_code == 0
-        # Force flag should be passed
-        call_kwargs = mock_ensure.call_args[1]
-        assert "force" in call_kwargs
+        # Ensure the function was called
+        mock_ensure.assert_called_once()

tests/android/installer/test_core.py

@@ -295,7 +295,7 @@ def test_ensure_ndk_only(self, mock_check_disk, mock_detect_host):
                             assert "ndk" in result["performed"]
 
     @patch("ovmobilebench.android.installer.detect.detect_host")
-    @patch("ovmobilebench.android.installer.detect.check_disk_space")
+    @patch("ovmobilebench.android.installer.core.check_disk_space")
     def test_ensure_low_disk_space_warning(self, mock_check_disk, mock_detect_host):
         """Test warning for low disk space."""
         mock_detect_host.return_value = HostInfo(os="linux", arch="x86_64", has_kvm=True)
@@ -315,24 +315,28 @@ def test_ensure_low_disk_space_warning(self, mock_check_disk, mock_detect_host):
             )
             mock_build_plan.return_value = mock_plan
 
-            installer.ensure(
-                api=30,
-                target="google_atd",
-                arch="arm64-v8a",
-                ndk=NdkSpec(alias="r26d"),
-                dry_run=True,
-            )
+            # Mock NDK resolve_path for dry run
+            with patch.object(installer.ndk, "resolve_path") as mock_resolve:
+                mock_resolve.return_value = self.sdk_root / "ndk" / "r26d"
+
+                installer.ensure(
+                    api=30,
+                    target="google_atd",
+                    arch="arm64-v8a",
+                    ndk=NdkSpec(alias="r26d"),
+                    dry_run=True,
+                )
 
-            # Check that warning was logged
-            logger.warning.assert_called_with("Low disk space detected (< 15GB free)")
+                # Check that warning was logged
+                logger.warning.assert_called_with("Low disk space detected (< 15GB free)")
 
     def test_ensure_logs_host_info(self):
         """Test that host information is logged."""
         logger = Mock()
         installer = AndroidInstaller(self.sdk_root, logger=logger)
 
-        with patch("ovmobilebench.android.installer.detect.detect_host") as mock_detect:
-            with patch("ovmobilebench.android.installer.detect.check_disk_space"):
+        with patch("ovmobilebench.android.installer.core.detect_host") as mock_detect:
+            with patch("ovmobilebench.android.installer.core.check_disk_space"):
                 mock_detect.return_value = HostInfo(
                     os="linux", arch="arm64", has_kvm=True, java_version="17.0.8"
                 )
@@ -348,13 +352,17 @@ def test_ensure_logs_host_info(self):
                     )
                     mock_build_plan.return_value = mock_plan
 
-                    installer.ensure(
-                        api=30,
-                        target="google_atd",
-                        arch="arm64-v8a",
-                        ndk=NdkSpec(alias="r26d"),
-                        dry_run=True,
-                    )
+                    # Mock NDK resolve_path for dry run
+                    with patch.object(installer.ndk, "resolve_path") as mock_resolve:
+                        mock_resolve.return_value = self.sdk_root / "ndk" / "r26d"
+
+                        installer.ensure(
+                            api=30,
+                            target="google_atd",
+                            arch="arm64-v8a",
+                            ndk=NdkSpec(alias="r26d"),
+                            dry_run=True,
+                        )
 
                     # Check that host info was logged
                     logger.info.assert_any_call(

tests/android/installer/test_env.py

@@ -51,8 +51,12 @@ def test_export_with_platform_tools(self):
             assert env_vars["ANDROID_PLATFORM_TOOLS"] == str(platform_tools.absolute())
 
     @patch("builtins.open", new_callable=mock_open)
-    def test_export_to_github_env(self, mock_file):
+    @patch("pathlib.Path.exists")
+    def test_export_to_github_env(self, mock_exists, mock_file):
         """Test exporting to GitHub environment file."""
+        # Mock that the paths exist
+        mock_exists.return_value = True
+
         exporter = EnvExporter()
         github_env = Path("/tmp/github_env")
         sdk_root = Path("/opt/android-sdk")