Add Profile Tests

Author: Behemyth

cppython/plugins/conan/plugin.py

@@ -109,27 +109,7 @@ def _install_dependencies(self, *, update: bool = False) -> None:
             logger.debug('Available remotes: %s', [remote.name for remote in all_remotes])
 
             # Get default profiles, handle case when no default profile exists
-            try:
-                profile_host_path = conan_api.profiles.get_default_host()
-                profile_build_path = conan_api.profiles.get_default_build()
-
-                # Ensure we have valid profile paths
-                if profile_host_path is None:
-                    # Create a minimal default profile with basic settings if none exists
-                    profile_host = conan_api.profiles.detect()
-                else:
-                    profile_host = conan_api.profiles.get_profile([profile_host_path])
-
-                if profile_build_path is None:
-                    # Create a minimal default profile with basic settings if none exists
-                    profile_build = conan_api.profiles.detect()
-                else:
-                    profile_build = conan_api.profiles.get_profile([profile_build_path])
-
-            except Exception:
-                # If profile operations fail, create minimal default profiles with basic settings
-                profile_host = conan_api.profiles.detect()
-                profile_build = conan_api.profiles.detect()
+            profile_host, profile_build = self._resolve_profiles(conan_api)
 
             logger.debug('Using profiles: host=%s, build=%s', profile_host, profile_build)
 
@@ -267,27 +247,7 @@ def publish(self) -> None:
         )
 
         # Step 2: Get default profiles, handle case when no default profile exists
-        try:
-            profile_host_path = conan_api.profiles.get_default_host()
-            profile_build_path = conan_api.profiles.get_default_build()
-
-            # Ensure we have valid profile paths
-            if profile_host_path is None:
-                # Create a minimal default profile with basic settings if none exists
-                profile_host = conan_api.profiles.detect()
-            else:
-                profile_host = conan_api.profiles.get_profile([profile_host_path])
-
-            if profile_build_path is None:
-                # Create a minimal default profile with basic settings if none exists
-                profile_build = conan_api.profiles.detect()
-            else:
-                profile_build = conan_api.profiles.get_profile([profile_build_path])
-
-        except Exception:
-            # If profile operations fail, create minimal default profiles with basic settings
-            profile_host = conan_api.profiles.detect()
-            profile_build = conan_api.profiles.detect()
+        profile_host, profile_build = self._resolve_profiles(conan_api)
 
         # Step 3: Build dependency graph for the package
         deps_graph = conan_api.graph.load_graph_consumer(
@@ -339,3 +299,40 @@ def publish(self) -> None:
                 )
             else:
                 raise ProviderInstallationError('conan', 'No packages found to upload')
+
+    def _resolve_profiles(self, conan_api) -> tuple:
+        """Resolve host and build profiles with fallback to detect().
+
+        Args:
+            conan_api: The Conan API instance
+
+        Returns:
+            Tuple of (profile_host, profile_build)
+        """
+        try:
+            profile_host_path = conan_api.profiles.get_default_host()
+            profile_build_path = conan_api.profiles.get_default_build()
+
+            # Resolve host profile
+            if profile_host_path is None:
+                profile_host = conan_api.profiles.detect()
+            else:
+                profile_host = conan_api.profiles.get_profile([profile_host_path])
+                if profile_host is None:
+                    profile_host = conan_api.profiles.detect()
+
+            # Resolve build profile
+            if profile_build_path is None:
+                profile_build = conan_api.profiles.detect()
+            else:
+                profile_build = conan_api.profiles.get_profile([profile_build_path])
+                if profile_build is None:
+                    profile_build = conan_api.profiles.detect()
+
+            return profile_host, profile_build
+
+        except Exception:
+            # If profile operations fail, create minimal default profiles with basic settings
+            profile_host = conan_api.profiles.detect()
+            profile_build = conan_api.profiles.detect()
+            return profile_host, profile_build

tests/unit/plugins/conan/test_install.py

@@ -13,12 +13,15 @@
 from cppython.test.pytest.mixins import ProviderPluginTestMixin
 from cppython.utility.exception import ProviderInstallationError
 
+# Constants for test assertions
+EXPECTED_PROFILE_CALLS = 2
+EXPECTED_GET_PROFILE_CALLS = 2
+
 # Use shared fixtures
 pytest_plugins = ['tests.fixtures.conan']
 
 # Constants for test verification
 EXPECTED_DEPENDENCY_COUNT = 2
-EXPECTED_PROFILE_CALLS = 2
 
 
 class TestConanInstall(ProviderPluginTestMixin[ConanProvider]):
@@ -255,3 +258,47 @@ def test_install_with_second_profile_exception_fallback(
         conan_mock_api.graph.load_graph_consumer.assert_called_once()
         conan_mock_api.install.install_binaries.assert_called_once()
         conan_mock_api.install.install_consumer.assert_called_once()
+
+    def test_install_with_get_profile_returning_none_fallback(
+        self,
+        plugin: ConanProvider,
+        conan_temp_conanfile: Path,
+        conan_mock_dependencies: list[Requirement],
+        conan_setup_mocks: dict[str, Mock],
+        conan_mock_api: Mock,
+    ) -> None:
+        """Test install method when get_profile returns None (profile file corrupted/invalid)
+
+        Args:
+            plugin: The plugin instance
+            conan_temp_conanfile: Path to temporary conanfile.py
+            conan_mock_dependencies: List of mock dependencies
+            conan_setup_mocks: Dictionary containing all mocks
+            conan_mock_api: Mock ConanAPI instance
+        """
+        # Configure profiles to exist but get_profile returns None (corrupted/invalid profile)
+        conan_mock_api.profiles.get_default_host.return_value = '/path/to/host/profile'
+        conan_mock_api.profiles.get_default_build.return_value = '/path/to/build/profile'
+        conan_mock_api.profiles.get_profile.return_value = None  # Profile file exists but is corrupted
+
+        # Setup dependencies
+        plugin.core_data.cppython_data.dependencies = conan_mock_dependencies
+
+        # Execute - should not throw an exception despite get_profile returning None
+        plugin.install()
+
+        # Verify that despite get_profile returning None, the fallback was used
+        conan_setup_mocks['conan_api_constructor'].assert_called_once()
+        conan_mock_api.profiles.get_default_host.assert_called_once()
+        conan_mock_api.profiles.get_default_build.assert_called_once()
+
+        # Should call get_profile twice (once for host, once for build)
+        assert conan_mock_api.profiles.get_profile.call_count == EXPECTED_GET_PROFILE_CALLS
+
+        # Verify fallback profile creation was called (should be called twice for detect)
+        assert conan_mock_api.profiles.detect.call_count >= EXPECTED_PROFILE_CALLS
+
+        # Verify the rest of the process continued
+        conan_mock_api.graph.load_graph_consumer.assert_called_once()
+        conan_mock_api.install.install_binaries.assert_called_once()
+        conan_mock_api.install.install_consumer.assert_called_once()

tests/unit/plugins/conan/test_publish.py

@@ -1,5 +1,6 @@
 """Unit tests for the conan plugin publish functionality"""
 
+from pathlib import Path
 from typing import Any
 from unittest.mock import MagicMock, Mock
 
@@ -13,6 +14,9 @@
 # Use shared fixtures
 pytest_plugins = ['tests.fixtures.conan']
 
+# Constants for test assertions
+EXPECTED_PROFILE_CALLS = 2
+
 
 class TestConanPublish(ProviderPluginTestMixin[ConanProvider]):
     """Tests for the Conan provider publish functionality"""
@@ -282,3 +286,50 @@ def test_publish_list_pattern_creation(
 
         # Verify ListPattern was created with correct reference pattern
         mock_list_pattern.assert_called_once_with(f'{ref.name}/*', package_id='*', only_recipe=False)
+
+    def test_publish_with_get_profile_returning_none_fallback(
+        self,
+        plugin: ConanProvider,
+        conan_temp_conanfile: Path,
+        conan_mock_api_publish: Mock,
+        mocker: MockerFixture,
+    ) -> None:
+        """Test publish method when get_profile returns None (profile file corrupted/invalid)
+
+        Args:
+            plugin: The plugin instance
+            conan_temp_conanfile: Path to temporary conanfile.py
+            conan_mock_api_publish: Mock ConanAPI instance configured for publish
+            mocker: Pytest mocker fixture
+        """
+        # Set plugin to local mode to avoid remote upload complications
+        plugin.data = plugin.data.__class__(
+            remotes=[],
+        )
+
+        # Configure profiles to exist but get_profile returns None (corrupted/invalid profile)
+        conan_mock_api_publish.profiles.get_default_host.return_value = '/path/to/host/profile'
+        conan_mock_api_publish.profiles.get_default_build.return_value = '/path/to/build/profile'
+        conan_mock_api_publish.profiles.get_profile.return_value = None  # Profile file exists but is corrupted
+
+        # Mock ConanAPI constructor to return our configured mock
+        mock_conan_api_constructor = mocker.patch(
+            'cppython.plugins.conan.plugin.ConanAPI', return_value=conan_mock_api_publish
+        )
+
+        # Execute - should not throw an exception despite get_profile returning None
+        plugin.publish()
+
+        # Verify that despite get_profile returning None, the fallback was used
+        mock_conan_api_constructor.assert_called_once()
+        conan_mock_api_publish.profiles.get_default_host.assert_called_once()
+        conan_mock_api_publish.profiles.get_default_build.assert_called_once()
+
+        # Should call get_profile twice (once for host, once for build)
+        assert conan_mock_api_publish.profiles.get_profile.call_count == EXPECTED_PROFILE_CALLS
+
+        # Verify fallback profile creation was called (should be called twice for detect)
+        assert conan_mock_api_publish.profiles.detect.call_count >= EXPECTED_PROFILE_CALLS
+
+        # Verify the rest of the process continued
+        conan_mock_api_publish.export.export.assert_called_once()