Testing

Author: Behemyth

cppython/plugins/conan/plugin.py

@@ -69,21 +69,59 @@ def information() -> Information:
         """
         return Information()
 
-    def install(self) -> None:
-        """Installs the provider"""
+    def _install_dependencies(self, *, update: bool = False) -> None:
+        """Common implementation for installing/updating dependencies.
+
+        Args:
+            update: If True, check remotes for newer versions/revisions and install those.
+                   If False, use cached versions when available.
+        """
         resolved_dependencies = [resolve_conan_dependency(req) for req in self.core_data.cppython_data.dependencies]
 
         self.builder.generate_conanfile(self.core_data.project_data.project_root, resolved_dependencies)
 
         self.core_data.cppython_data.build_path.mkdir(parents=True, exist_ok=True)
 
-    def update(self) -> None:
-        """Updates the provider"""
-        resolved_dependencies = [resolve_conan_dependency(req) for req in self.core_data.cppython_data.dependencies]
+        # Install/update dependencies using Conan API
+        project_root = self.core_data.project_data.project_root
+        conanfile_path = project_root / 'conanfile.py'
 
-        self.builder.generate_conanfile(self.core_data.project_data.project_root, resolved_dependencies)
+        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,
+            )
+
+            # Install dependencies
+            conan_api.install.install_binaries(deps_graph=deps_graph, remotes=conan_api.remotes.list())
 
-        self.core_data.cppython_data.build_path.mkdir(parents=True, exist_ok=True)
+    def install(self) -> None:
+        """Installs the provider"""
+        self._install_dependencies(update=False)
+
+    def update(self) -> None:
+        """Updates the provider"""
+        self._install_dependencies(update=True)
 
     @staticmethod
     def supported_sync_type(sync_type: type[SyncData]) -> bool:
@@ -148,7 +186,10 @@ def publish(self) -> None:
         )
 
         # Step 2: Get default profiles
-        profile_host, profile_build = conan_api.profiles.get_profiles_from_args([])
+        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])
 
         # Step 3: Build dependency graph for the package
         deps_graph = conan_api.graph.load_graph_consumer(

examples/conan_cmake/simple/pdm.lock

@@ -0,0 +1,165 @@
+"""Shared fixtures for Conan plugin tests"""
+
+from pathlib import Path
+from unittest.mock import Mock
+
+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
+
+
+@pytest.fixture(name='conan_mock_api')
+def fixture_conan_mock_api(mocker: MockerFixture) -> Mock:
+    """Creates a mock ConanAPI instance for install/update operations
+
+    Args:
+        mocker: Pytest mocker fixture
+
+    Returns:
+        Mock ConanAPI instance
+    """
+    mock_api = mocker.Mock()
+
+    # Mock graph module
+    mock_deps_graph = mocker.Mock()
+    mock_api.graph.load_graph_consumer = mocker.Mock(return_value=mock_deps_graph)
+
+    # Mock install module
+    mock_api.install.install_binaries = mocker.Mock()
+
+    # Mock remotes module
+    mock_remote = mocker.Mock()
+    mock_remote.name = 'conancenter'
+    mock_api.remotes.list = mocker.Mock(return_value=[mock_remote])
+
+    # Mock profiles module
+    mock_profile_host = mocker.Mock()
+    mock_profile_build = mocker.Mock()
+    mock_api.profiles.get_default_host = mocker.Mock(return_value='/path/to/default/host')
+    mock_api.profiles.get_default_build = mocker.Mock(return_value='/path/to/default/build')
+    mock_api.profiles.get_profile = mocker.Mock(
+        side_effect=lambda paths: mock_profile_host if 'host' in paths[0] else mock_profile_build
+    )
+
+    return mock_api
+
+
+@pytest.fixture(name='conan_mock_api_publish')
+def fixture_conan_mock_api_publish(mocker: MockerFixture) -> Mock:
+    """Creates a mock ConanAPI instance for publish operations
+
+    Args:
+        mocker: Pytest mocker fixture
+
+    Returns:
+        Mock ConanAPI instance configured for publish operations
+    """
+    mock_api = mocker.Mock()
+
+    # Mock export module - export returns a tuple (ref, conanfile)
+    mock_ref = mocker.Mock()
+    mock_ref.name = 'test_package'
+    mock_conanfile = mocker.Mock()
+    mock_api.export.export = mocker.Mock(return_value=(mock_ref, mock_conanfile))
+
+    # Mock graph module
+    mock_api.graph.load_graph_consumer = mocker.Mock()
+    mock_api.graph.analyze_binaries = mocker.Mock()
+
+    # Mock install module
+    mock_api.install.install_binaries = mocker.Mock()
+
+    # Mock list module
+    mock_select_result = mocker.Mock()
+    mock_select_result.recipes = ['some_package/1.0@user/channel']
+    mock_api.list.select = mocker.Mock(return_value=mock_select_result)
+
+    # Mock remotes module
+    mock_remote = mocker.Mock()
+    mock_remote.name = 'origin'
+    mock_api.remotes.list = mocker.Mock(return_value=[mock_remote])
+
+    # Mock upload module
+    mock_api.upload.upload_full = mocker.Mock()
+
+    # Mock profiles module
+    mock_profile = mocker.Mock()
+    mock_api.profiles.get_default_host = mocker.Mock(return_value='/path/to/default/host')
+    mock_api.profiles.get_default_build = mocker.Mock(return_value='/path/to/default/build')
+    mock_api.profiles.get_profile = mocker.Mock(return_value=mock_profile)
+
+    return mock_api
+
+
+@pytest.fixture(name='conan_temp_conanfile')
+def fixture_conan_temp_conanfile(plugin: ConanProvider) -> Path:
+    """Creates a temporary conanfile.py for testing
+
+    Args:
+        plugin: The plugin instance
+
+    Returns:
+        Path to the created conanfile.py
+    """
+    project_root = plugin.core_data.project_data.project_root
+    conanfile_path = project_root / 'conanfile.py'
+    conanfile_path.write_text(
+        'from conan import ConanFile\n\nclass TestConan(ConanFile):\n    name = "test_package"\n    version = "1.0"\n'
+    )
+    return conanfile_path
+
+
+@pytest.fixture(name='conan_mock_dependencies')
+def fixture_conan_mock_dependencies() -> list[Requirement]:
+    """Creates mock dependencies for testing
+
+    Returns:
+        List of mock requirements
+    """
+    return [
+        Requirement('boost>=1.70.0'),
+        Requirement('zlib>=1.2.11'),
+    ]
+
+
+@pytest.fixture(name='conan_setup_mocks')
+def fixture_conan_setup_mocks(
+    plugin: ConanProvider,
+    conan_mock_api: Mock,
+    mocker: MockerFixture,
+) -> dict[str, Mock]:
+    """Sets up all mocks for testing install/update operations
+
+    Args:
+        plugin: The plugin instance
+        conan_mock_api: Mock ConanAPI instance
+        mocker: Pytest mocker fixture
+
+    Returns:
+        Dictionary containing all mocks
+    """
+    # Mock builder
+    mock_builder = mocker.Mock()
+    mock_builder.generate_conanfile = mocker.Mock()
+    # Set the builder attribute on the plugin
+    plugin.builder = mock_builder  # type: ignore[attr-defined]
+
+    # Mock ConanAPI constructor
+    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, version_ge=None)
+
+    mock_resolve_conan_dependency = mocker.patch(
+        'cppython.plugins.conan.plugin.resolve_conan_dependency', side_effect=mock_resolve
+    )
+
+    return {
+        'builder': mock_builder,
+        'conan_api_constructor': mock_conan_api_constructor,
+        'resolve_conan_dependency': mock_resolve_conan_dependency,
+    }

tests/fixtures/conan.py

@@ -6,9 +6,14 @@
 
 import subprocess
 from pathlib import Path
+from tomllib import loads
 
 from typer.testing import CliRunner
 
+from cppython.console.schema import ConsoleInterface
+from cppython.core.schema import ProjectConfiguration
+from cppython.project import Project
+
 pytest_plugins = ['tests.fixtures.example']
 
 
@@ -18,10 +23,22 @@ class TestConanCMake:
     @staticmethod
     def test_simple(example_runner: CliRunner) -> None:
         """Simple project"""
-        # By nature of running the test, we require PDM to develop the project and so it will be installed
-        result = subprocess.run(['pdm', 'install'], capture_output=True, text=True, check=False)
+        # Create project configuration
+        project_root = Path.cwd()
+        project_configuration = ProjectConfiguration(project_root=project_root, version=None)
+
+        # Create console interface
+        interface = ConsoleInterface()
+
+        # Load pyproject.toml data
+        pyproject_path = project_root / 'pyproject.toml'
+        pyproject_data = loads(pyproject_path.read_text(encoding='utf-8'))
+
+        # Create and use the project directly
+        project = Project(project_configuration, interface, pyproject_data)
 
-        assert result.returncode == 0, f'PDM install failed: {result.stderr}'
+        # Call install directly to get structured results
+        project.install()
 
         # Run the CMake configuration command
         result = subprocess.run(['cmake', '--preset=default'], capture_output=True, text=True, check=False)