Remove Manual Installation + Testing

Author: Behemyth

cppython/plugins/conan/plugin.py

@@ -69,40 +69,7 @@ def information() -> Information:
         """
         return Information()
 
-    def _install_dependencies(self, *, update: bool = False) -> None:
-        """Install/update dependencies using Conan API.
-
-        Args:
-            update: If True, check remotes for newer versions/revisions and install those.
-                   If False, use cached versions when available.
-        """
-        operation = 'update' if update else 'install'
-
-        try:
-            # Setup environment and generate conanfile
-            conan_api, conanfile_path = self._prepare_installation()
-        except Exception as e:
-            raise ProviderInstallationError('conan', f'Failed to prepare {operation} environment: {e}', e) from e
-
-        try:
-            # Load dependency graph
-            deps_graph = self._load_dependency_graph(conan_api, conanfile_path, update)
-        except Exception as e:
-            raise ProviderInstallationError('conan', f'Failed to load dependency graph: {e}', e) from e
-
-        try:
-            # Install dependencies
-            self._install_binaries(conan_api, deps_graph, update)
-        except Exception as e:
-            raise ProviderInstallationError('conan', f'Failed to install binary dependencies: {e}', e) from e
-
-        try:
-            # Generate consumer files
-            self._generate_consumer_files(conan_api, deps_graph)
-        except Exception as e:
-            raise ProviderInstallationError('conan', f'Failed to generate consumer files: {e}', e) from e
-
-    def _prepare_installation(self) -> tuple[ConanAPI, Path]:
+    def _setup_environment(self) -> tuple[ConanAPI, Path]:
         """Prepare the installation environment and generate conanfile.
 
         Returns:
@@ -199,11 +166,11 @@ def _generate_consumer_files(self, conan_api: ConanAPI, deps_graph) -> None:
 
     def install(self) -> None:
         """Installs the provider"""
-        self._install_dependencies(update=False)
+        self._setup_environment()
 
     def update(self) -> None:
         """Updates the provider"""
-        self._install_dependencies(update=True)
+        self._setup_environment()
 
     @staticmethod
     def supported_sync_type(sync_type: type[SyncData]) -> bool:

tests/unit/plugins/conan/test_install.py

@@ -6,12 +6,9 @@
 
 import pytest
 from packaging.requirements import Requirement
-from pytest_mock import MockerFixture
 
 from cppython.plugins.conan.plugin import ConanProvider
-from cppython.plugins.conan.schema import ConanDependency
 from cppython.test.pytest.mixins import ProviderPluginTestMixin
-from cppython.utility.exception import ProviderInstallationError
 
 # Constants for test assertions
 EXPECTED_PROFILE_CALLS = 2
@@ -81,92 +78,3 @@ def test_with_dependencies(
 
         # Verify build path was created
         assert plugin.core_data.cppython_data.build_path.exists()
-
-        # Verify ConanAPI constructor was called
-        conan_setup_mocks['conan_api_constructor'].assert_called_once()
-
-    def test_conan_command_failure(
-        self,
-        plugin: ConanProvider,
-        conan_temp_conanfile: Path,
-        conan_mock_dependencies: list[Requirement],
-        conan_mock_api: Mock,
-        mocker: MockerFixture,
-    ) -> None:
-        """Test install method when conan API operations fail
-
-        Args:
-            plugin: The plugin instance
-            conan_temp_conanfile: Path to temporary conanfile.py
-            conan_mock_dependencies: List of mock dependencies
-            conan_mock_api: Mock ConanAPI instance
-            mocker: Pytest mocker fixture
-        """
-        # Mock builder
-        mock_builder = mocker.Mock()
-        mock_builder.generate_conanfile = mocker.Mock()
-        plugin.builder = mock_builder  # type: ignore[attr-defined]
-
-        # Configure the API mock to fail on graph loading
-        conan_mock_api.graph.load_graph_consumer.side_effect = Exception('Conan API error: package not found')
-
-        # Mock ConanAPI constructor to return our configured mock
-        mock_conan_api_constructor = mocker.patch('cppython.plugins.conan.plugin.ConanAPI', return_value=conan_mock_api)
-
-        # Mock resolve_conan_dependency
-        def mock_resolve(requirement: Requirement) -> ConanDependency:
-            return ConanDependency(name=requirement.name)
-
-        mocker.patch('cppython.plugins.conan.plugin.resolve_conan_dependency', side_effect=mock_resolve)
-
-        # Add a dependency
-        plugin.core_data.cppython_data.dependencies = [conan_mock_dependencies[0]]
-
-        # Execute and verify exception is raised
-        with pytest.raises(
-            ProviderInstallationError,
-            match='Failed to load dependency graph: Conan API error: package not found',
-        ):
-            plugin.install()
-
-        # Verify builder was still called
-        mock_builder.generate_conanfile.assert_called_once()
-
-        # Verify Conan API was attempted
-        mock_conan_api_constructor.assert_called_once()
-
-    def test_with_default_profiles(
-        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 uses pre-resolved profiles from plugin construction
-
-        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
-        """
-        # Setup dependencies
-        plugin.core_data.cppython_data.dependencies = conan_mock_dependencies
-
-        # Execute - should use the profiles resolved during plugin construction
-        plugin.install()
-
-        # Verify that the API was used for installation
-        conan_setup_mocks['conan_api_constructor'].assert_called_once()
-
-        # Verify the rest of the process continued with resolved profiles
-        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()
-
-        # Verify that the resolved profiles were used in the graph loading
-        call_args = conan_mock_api.graph.load_graph_consumer.call_args
-        assert call_args.kwargs['profile_host'] == plugin.data.host_profile
-        assert call_args.kwargs['profile_build'] == plugin.data.build_profile