Add Install Tests w/ Logging Traces

Author: Behemyth

cppython/plugins/conan/plugin.py

@@ -5,6 +5,8 @@
 installation, and synchronization with other tools.
 """
 
+import logging
+import subprocess
 from pathlib import Path
 from typing import Any
 
@@ -70,51 +72,73 @@ def information() -> Information:
         return Information()
 
     def _install_dependencies(self, *, update: bool = False) -> None:
-        """Common implementation for installing/updating dependencies.
+        """Install/update dependencies using conan CLI command.
 
         Args:
             update: If True, check remotes for newer versions/revisions and install those.
                    If False, use cached versions when available.
         """
         try:
+            logger = logging.getLogger('cppython.conan')
+            logger.debug('Starting dependency installation/update (update=%s)', update)
+
             resolved_dependencies = [resolve_conan_dependency(req) for req in self.core_data.cppython_data.dependencies]
+            logger.debug(
+                'Resolved %d dependencies: %s', len(resolved_dependencies), [str(dep) for dep in resolved_dependencies]
+            )
 
+            # Generate conanfile.py
             self.builder.generate_conanfile(self.core_data.project_data.project_root, resolved_dependencies)
+            logger.debug('Generated conanfile.py at %s', self.core_data.project_data.project_root)
 
+            # Ensure build directory exists
             self.core_data.cppython_data.build_path.mkdir(parents=True, exist_ok=True)
+            logger.debug('Created build path: %s', self.core_data.cppython_data.build_path)
 
-            # Install/update dependencies using Conan API
+            # Build conan install command
             project_root = self.core_data.project_data.project_root
             conanfile_path = project_root / 'conanfile.py'
 
-            if conanfile_path.exists():
-                # Initialize Conan API
-                conan_api = ConanAPI()
-
-                # Get default profiles
-                profile_host_path = conan_api.profiles.get_default_host()
-                profile_build_path = conan_api.profiles.get_default_build()
-                profile_host = conan_api.profiles.get_profile([profile_host_path])
-                profile_build = conan_api.profiles.get_profile([profile_build_path])
-
-                # Build dependency graph for the package
-                deps_graph = conan_api.graph.load_graph_consumer(
-                    path=str(conanfile_path),
-                    name=None,
-                    version=None,
-                    user=None,
-                    channel=None,
-                    profile_host=profile_host,
-                    profile_build=profile_build,
-                    lockfile=None,
-                    remotes=conan_api.remotes.list(),
-                    update=update,
-                    check_updates=update,
-                    is_build_require=False,
-                )
+            if not conanfile_path.exists():
+                raise ProviderInstallationError('conan', 'Generated conanfile.py not found')
+
+            # Prepare conan install command
+            cmd = [
+                'conan',
+                'install',
+                str(conanfile_path),
+                '--output-folder',
+                str(self.core_data.cppython_data.build_path),
+                '--build',
+                'missing',
+            ]
+
+            if update:
+                cmd.extend(['--update'])
+
+            logger.debug('Running conan command: %s', ' '.join(cmd))
 
-                # Install dependencies
-                conan_api.install.install_binaries(deps_graph=deps_graph, remotes=conan_api.remotes.list())
+            # Execute conan install command
+            result = subprocess.run(cmd, cwd=str(project_root), capture_output=True, text=True, check=False)
+
+            # Log output for debugging
+            if result.stdout:
+                logger.debug('Conan stdout:\n%s', result.stdout)
+            if result.stderr:
+                logger.debug('Conan stderr:\n%s', result.stderr)
+
+            # Check for success
+            if result.returncode != 0:
+                error_msg = f'Conan install failed with return code {result.returncode}'
+                if result.stderr:
+                    error_msg += f': {result.stderr}'
+                raise ProviderInstallationError('conan', error_msg)
+
+            logger.debug('Successfully installed dependencies using conan CLI')
+
+        except subprocess.SubprocessError as e:
+            operation = 'update' if update else 'install'
+            raise ProviderInstallationError('conan', f'Failed to {operation} dependencies: {e}', e) from e
         except Exception as e:
             operation = 'update' if update else 'install'
             error_msg = str(e)

examples/conan_cmake/simple/pyproject.toml

@@ -18,7 +18,7 @@ provider-name = "conan"
 
 install-path = "install"
 
-dependencies = ["fmt>=11.0.1"]
+dependencies = ["fmt>=11.2.0"]
 
 [tool.cppython.generator]
 

tests/integration/examples/test_conan_cmake.py

@@ -25,7 +25,7 @@ def test_simple(example_runner: CliRunner) -> None:
         """Simple project"""
         # Create project configuration
         project_root = Path.cwd()
-        project_configuration = ProjectConfiguration(project_root=project_root, version=None)
+        project_configuration = ProjectConfiguration(project_root=project_root, version=None, verbosity=2, debug=True)
 
         # Create console interface
         interface = ConsoleInterface()

tests/unit/plugins/conan/test_install.py

@@ -6,9 +6,11 @@
 
 import pytest
 from packaging.requirements import Requirement
+from pytest_mock import MockerFixture
 
 from cppython.plugins.conan.plugin import ConanProvider
 from cppython.test.pytest.mixins import ProviderPluginTestMixin
+from cppython.utility.exception import ProviderInstallationError
 
 # Use shared fixtures
 pytest_plugins = ['tests.fixtures.conan']
@@ -44,21 +46,27 @@ def fixture_plugin_type() -> type[ConanProvider]:
 
     def test_install_with_dependencies(
         self,
+        mocker: MockerFixture,
         plugin: ConanProvider,
-        conan_mock_api: Mock,
         conan_temp_conanfile: Path,
         conan_mock_dependencies: list[Requirement],
         conan_setup_mocks: dict[str, Mock],
     ) -> None:
         """Test install method with dependencies and existing conanfile
 
         Args:
+            mocker: Pytest mocker fixture
             plugin: The plugin instance
-            conan_mock_api: Mock ConanAPI instance
             conan_temp_conanfile: Path to temporary conanfile.py
             conan_mock_dependencies: List of mock dependencies
             conan_setup_mocks: Dictionary containing all mocks
         """
+        # Setup subprocess mock to return success
+        mock_subprocess = mocker.patch('cppython.plugins.conan.plugin.subprocess.run')
+        mock_subprocess.return_value.returncode = 0
+        mock_subprocess.return_value.stdout = 'Install completed successfully'
+        mock_subprocess.return_value.stderr = ''
+
         # Setup dependencies
         plugin.core_data.cppython_data.dependencies = conan_mock_dependencies
 
@@ -79,124 +87,55 @@ def test_install_with_dependencies(
         # Verify build path was created
         assert plugin.core_data.cppython_data.build_path.exists()
 
-        # Verify Conan API calls
-        conan_mock_api.profiles.get_default_host.assert_called_once()
-        conan_mock_api.profiles.get_default_build.assert_called_once()
-        conan_mock_api.profiles.get_profile.assert_called()
-        conan_mock_api.graph.load_graph_consumer.assert_called_once()
-        conan_mock_api.install.install_binaries.assert_called_once()
-
-        # Verify graph consumer call arguments
-        load_graph_args = conan_mock_api.graph.load_graph_consumer.call_args
-        assert load_graph_args[1]['path'] == str(conan_temp_conanfile)
-        assert load_graph_args[1]['update'] is False
-        assert load_graph_args[1]['check_updates'] is False
-
-    def test_install_without_conanfile(
-        self,
-        plugin: ConanProvider,
-        conan_mock_api: Mock,
-        conan_mock_dependencies: list[Requirement],
-        conan_setup_mocks: dict[str, Mock],
-    ) -> None:
-        """Test install method when conanfile.py doesn't exist
-
-        Args:
-            plugin: The plugin instance
-            conan_mock_api: Mock ConanAPI instance
-            conan_mock_dependencies: List of mock dependencies
-            conan_setup_mocks: Dictionary containing all mocks
-        """
-        # Setup dependencies
-        plugin.core_data.cppython_data.dependencies = [conan_mock_dependencies[0]]
-
-        # Execute
-        plugin.install()
-
-        # Verify builder was called
-        conan_setup_mocks['builder'].generate_conanfile.assert_called_once()
-
-        # Verify build path was created
-        assert plugin.core_data.cppython_data.build_path.exists()
-
-        # Verify Conan API calls were NOT made (no conanfile.py)
-        conan_mock_api.profiles.get_default_host.assert_not_called()
-        conan_mock_api.profiles.get_default_build.assert_not_called()
-        conan_mock_api.profiles.get_profile.assert_not_called()
-        conan_mock_api.graph.load_graph_consumer.assert_not_called()
-        conan_mock_api.install.install_binaries.assert_not_called()
-
-    def test_install_no_dependencies(
-        self,
-        plugin: ConanProvider,
-        conan_mock_api: Mock,
-        conan_temp_conanfile: Path,
-        conan_setup_mocks: dict[str, Mock],
-    ) -> None:
-        """Test install method with no dependencies
+        # Verify subprocess was called with correct command
+        mock_subprocess.assert_called_once()
+        call_args = mock_subprocess.call_args
+        cmd = call_args[0][0]
 
-        Args:
-            plugin: The plugin instance
-            conan_mock_api: Mock ConanAPI instance
-            conan_temp_conanfile: Path to temporary conanfile.py
-            conan_setup_mocks: Dictionary containing all mocks
-        """
-        # No dependencies
-        plugin.core_data.cppython_data.dependencies = []
-
-        # Execute
-        plugin.install()
-
-        # Verify builder was called with empty dependencies
-        conan_setup_mocks['builder'].generate_conanfile.assert_called_once()
-        assert len(conan_setup_mocks['builder'].generate_conanfile.call_args[0][1]) == 0
-
-        # Verify dependency resolution was not called
-        conan_setup_mocks['resolve_conan_dependency'].assert_not_called()
-
-        # Verify build path was created
-        assert plugin.core_data.cppython_data.build_path.exists()
+        # Check command structure
+        assert cmd[0] == 'conan'
+        assert cmd[1] == 'install'
+        assert cmd[2] == str(conan_temp_conanfile)
+        assert '--output-folder' in cmd
+        assert '--build' in cmd
+        assert 'missing' in cmd
+        assert '--update' not in cmd  # install mode, not update
 
-        # Verify Conan API calls were still made (conanfile.py exists)
-        conan_mock_api.profiles.get_default_host.assert_called_once()
-        conan_mock_api.profiles.get_default_build.assert_called_once()
-        conan_mock_api.profiles.get_profile.assert_called()
-        conan_mock_api.graph.load_graph_consumer.assert_called_once()
-        conan_mock_api.install.install_binaries.assert_called_once()
+        # Check working directory
+        assert call_args[1]['cwd'] == str(plugin.core_data.project_data.project_root)
 
-    def test_install_conan_api_failure(
+    def test_install_conan_command_failure(
         self,
+        mocker: MockerFixture,
         plugin: ConanProvider,
-        conan_mock_api: Mock,
         conan_temp_conanfile: Path,
         conan_mock_dependencies: list[Requirement],
         conan_setup_mocks: dict[str, Mock],
     ) -> None:
-        """Test install method when Conan API calls fail
+        """Test install method when conan command fails
 
         Args:
+            mocker: Pytest mocker fixture
             plugin: The plugin instance
-            conan_mock_api: Mock ConanAPI instance
             conan_temp_conanfile: Path to temporary conanfile.py
             conan_mock_dependencies: List of mock dependencies
             conan_setup_mocks: Dictionary containing all mocks
         """
-        # Make API call fail
-        conan_mock_api.graph.load_graph_consumer.side_effect = Exception('Conan graph load failed')
+        # Make subprocess return failure
+        mock_subprocess = mocker.patch('cppython.plugins.conan.plugin.subprocess.run')
+        mock_subprocess.return_value.returncode = 1
+        mock_subprocess.return_value.stdout = ''
+        mock_subprocess.return_value.stderr = 'Conan install failed: package not found'
 
         # Add a dependency
         plugin.core_data.cppython_data.dependencies = [conan_mock_dependencies[0]]
 
         # Execute and verify exception is raised
-        with pytest.raises(Exception, match='Conan graph load failed'):
+        with pytest.raises(ProviderInstallationError, match='Conan install failed with return code 1'):
             plugin.install()
 
         # Verify builder was still called
         conan_setup_mocks['builder'].generate_conanfile.assert_called_once()
 
-        # Verify API was called up to the point of failure
-        conan_mock_api.profiles.get_default_host.assert_called_once()
-        conan_mock_api.profiles.get_default_build.assert_called_once()
-        conan_mock_api.profiles.get_profile.assert_called()
-        conan_mock_api.graph.load_graph_consumer.assert_called_once()
-        conan_mock_api.install.install_binaries.assert_not_called()
+        # Verify subprocess was called
+        mock_subprocess.assert_called_once()