intermediate version

Author: amhellmund

src/tests/cpp_dev/conan/__init__.py

@@ -22,7 +22,7 @@
 from cpp_dev.dependency.conan.utils import conan_env
 
 from .utils.env import ConanTestEnv, create_conan_env
-from .utils.server import ConanServer, launch_conan_server
+from .utils.server import ConanServer, launch_conan_test_server
 
 MockType = MagicMock | AsyncMock
 
@@ -69,7 +69,7 @@ class ConanTestEnvironment:
 
 @pytest.fixture
 def conan_test_environment(tmp_path: Path, unused_http_port: int) -> Generator[ConanTestEnvironment]:
-    with launch_conan_server(tmp_path / "server", unused_http_port) as server:
+    with launch_conan_test_server(tmp_path / "server", unused_http_port) as server:
         with create_conan_env(tmp_path / "conan", server.http_port) as conan:
             conan.create_and_upload_package(ConanPackageReference("dep/1.0.0@official/cppdev"), [])
             conan.create_and_upload_package(ConanPackageReference("cpd1/1.0.0@official/cppdev"), [])

src/tests/cpp_dev/dependency/conan/test_command_wrapper.py

@@ -0,0 +1,45 @@
+# Copyright (c) 2024 Andi Hellmund. All rights reserved.
+
+# This work is licensed under the terms of the BSD-3-Clause license.
+# For a copy, see <https://opensource.org/license/bsd-3-clause>.
+
+from collections.abc import Generator
+from dataclasses import dataclass
+from pathlib import Path
+
+import pytest
+
+from cpp_dev.common.version import SemanticVersion
+from cpp_dev.dependency.conan.provider import ConanDependencyProvider
+from cpp_dev.dependency.conan.types import ConanPackageReference
+from tests.cpp_dev.dependency.conan.utils.env import (ConanTestEnv,
+                                                      create_conan_env)
+from tests.cpp_dev.dependency.conan.utils.server import (
+    ConanServer, launch_conan_test_server)
+
+
+@dataclass
+class ConanTestEnvironment:
+    server: ConanServer
+    conan: ConanTestEnv
+
+
+@pytest.fixture
+def conan_test_environment(tmp_path: Path, unused_http_port: int) -> Generator[ConanTestEnvironment]:
+    with launch_conan_test_server(tmp_path / "server", unused_http_port) as conan_server:
+        with create_conan_env(tmp_path / "conan", conan_server.http_port) as conan_env:
+            conan_env.create_and_upload_package(ConanPackageReference("cpd/1.0.0@official/cppdev"), [])
+            conan_env.create_and_upload_package(ConanPackageReference("cpd/2.0.0@custom/cppdev"), [])
+            conan_env.create_and_upload_package(ConanPackageReference("cpd/3.0.0@official/cppdev"), [])
+            yield ConanTestEnvironment(
+                server=conan_server,
+                conan=conan_env
+            )
+
+
+def test_get_available_versions(conan_test_environment: ConanTestEnvironment) -> None:
+    provider = ConanDependencyProvider(conan_test_environment.conan.conan_dir)
+    assert provider.fetch_versions("official", "cpd") == [
+        SemanticVersion("3.0.0"),
+        SemanticVersion("1.0.0"),
+    ]

src/tests/cpp_dev/dependency/conan/test_provider.py

@@ -4,53 +4,86 @@
 # For a copy, see <https://opensource.org/license/bsd-3-clause>.
 
 import json
-from collections.abc import Generator
+from collections.abc import Generator, Mapping
 from contextlib import contextmanager
+from dataclasses import dataclass
 from pathlib import Path
 from textwrap import dedent
 
+from cpp_dev.common.types import CppStandard
 from cpp_dev.common.utils import ensure_dir_exists
 from cpp_dev.dependency.conan.command_wrapper import conan_create, conan_upload
 from cpp_dev.dependency.conan.setup import CONAN_REMOTE, initialize_conan
 from cpp_dev.dependency.conan.types import ConanPackageReference
 from cpp_dev.dependency.conan.utils import conan_env
+from tests.cpp_dev.dependency.conan.utils.server import (
+    ConanServer, launch_conan_test_server)
 
 ###############################################################################
 # Public API                                                                ###
 ###############################################################################
 
+FileSpec = Mapping[Path, str]
+
+@dataclass
+class ConanTestPackage:
+    ref: ConanPackageReference
+    dependencies: list[ConanPackageReference]
+    cpp_standard: CppStandard
+    bin_files: FileSpec | None = None
+    lib_files: FileSpec | None = None
+    include_files: FileSpec | None = None
+
+
 class ConanTestEnv:
     """A Conan environment for testing."""
 
-    def __init__(self, conan_dir: Path, profile: str) -> None:
-        self._conan_dir = conan_dir
-        self._package_dir = conan_dir / ".conan_test_env"
+    def __init__(self, conan_home_dir: Path, profile: str, server: ConanServer) -> None:
+        self._conan_home_dir = conan_home_dir
+        self._package_dir =  conan_home_dir / ".conan_package_creation"
         ensure_dir_exists(self._package_dir)
         self._profile = profile
+        self._server = server
 
-    def create_and_upload_package(self, ref: ConanPackageReference, dependencies: list[ConanPackageReference]) -> None:
+    def create_and_upload_packages(self, packages: list[ConanTestPackage]) -> None:
         """Create and upload a Conan package for testing."""
-        _create_and_upload_conan_package(self._package_dir, ref, dependencies, self._profile)
+        for package in packages:
+            _create_and_upload_conan_package(self._package_dir, package, self._profile)
 
     @property
-    def conan_dir(self) -> Path:
+    def conan_home_dir(self) -> Path:
         """Return the base directory of the Conan environment."""
-        return self._conan_dir
+        return self._conan_home_dir
 
     @property
     def profile(self) -> str:
         """Return the profile used for testing."""
         return self._profile
+    
+    @property
+    def server(self) -> ConanServer:
+        """Return the server used for testing."""
+        return self._server
 
 
 @contextmanager
-def create_conan_env(conan_dir: Path, server_http_port: int) -> Generator[ConanTestEnv]:
+def create_conan_test_env(base_dir: Path, server_http_port: int, packages: list[ConanTestPackage]) -> Generator[ConanTestEnv]:
     """Create a Conan environment for testing."""
-    ensure_dir_exists(conan_dir)
-    source_config_path, profile = _create_conan_source_config(conan_dir, server_http_port)
-    initialize_conan(conan_dir, source_config_path)
-    with conan_env(conan_dir):
-        yield ConanTestEnv(conan_dir, profile)
+    
+    # create the home for the conan server
+    conan_server_dir = base_dir / "server"
+    ensure_dir_exists(conan_server_dir)
+    with launch_conan_test_server(conan_server_dir, server_http_port) as server:
+        # create the home for the conan client
+        conan_home_dir = base_dir / "conan_home"
+        ensure_dir_exists(conan_home_dir)
+        source_config_path, profile = _create_conan_source_config(conan_home_dir, server_http_port)
+        initialize_conan(conan_home_dir, source_config_path)
+
+        with conan_env(conan_home_dir):
+            conan_test_env = ConanTestEnv(conan_home_dir, profile, server)
+            conan_test_env.create_and_upload_packages(packages)
+            yield conan_test_env
 
 
 ###############################################################################
@@ -101,13 +134,13 @@ def _create_conan_source_config(conan_dir: Path, server_http_port: int) -> tuple
     return source_config_path, PROFILE_NAME
 
 
-def _create_and_upload_conan_package(base_dir: Path, ref: ConanPackageReference, dependencies: list[ConanPackageReference], profile: str) -> None:
-    package_dir = base_dir / f"{ref.name}_{ref.version}"
+def _create_and_upload_conan_package(base_dir: Path, package: ConanTestPackage, profile: str) -> None:
+    package_dir = base_dir / f"{package.ref.name}_{package.ref.version}"
     ensure_dir_exists(package_dir)
 
     conanfile_path = package_dir / "conanfile.py"
 
-    requirements = ",".join([f"\"{dep}\"" for dep in dependencies])
+    requirements = ",".join([f"\"{dep}\"" for dep in package.dependencies])
     conanfile_path.write_text(dedent(
         """
         from conan import ConanFile
@@ -120,11 +153,11 @@ class TestConan(ConanFile):
 
             {requirements}
         """.format(
-            name=ref.name,
-            user=ref.user,
-            version=ref.version,
-            requirements=f"requires = {requirements}" if dependencies else ""
+            name=package.ref.name,
+            user=package.ref.user,
+            version=package.ref.version,
+            requirements=f"requires = {requirements}" if package.dependencies else ""
         )
     ))
     conan_create(package_dir, profile)
-    conan_upload(ref, CONAN_REMOTE)
+    conan_upload(package.ref, CONAN_REMOTE)

src/tests/cpp_dev/dependency/conan/utils/env.py

@@ -32,8 +32,8 @@ def compose_url(self) -> str:
         return f"http://{self.hostname}:{self.http_port}"
 
 @contextmanager
-def launch_conan_server(server_dir: Path, http_port: int) -> Generator[ConanServer]:
-    """Launch a Conan server."""
+def launch_conan_test_server(server_dir: Path, http_port: int) -> Generator[ConanServer]:
+    """Launch a Conan server for testing."""
     connection_params = _create_conan_server_config(server_dir, http_port)
     process = _launch_conan_server(server_dir)
     _wait_for_server_start(connection_params)

src/tests/cpp_dev/dependency/conan/utils/server.py

@@ -8,15 +8,25 @@
 from cpp_dev.dependency.conan.command_wrapper import conan_list
 from cpp_dev.dependency.conan.setup import CONAN_REMOTE
 from cpp_dev.dependency.conan.types import ConanPackageReference
+from tests.cpp_dev.dependency.conan.utils.server import \
+    launch_conan_test_server
 
-from .env import create_conan_env
-from .server import launch_conan_server
+from .env import ConanTestPackage, create_conan_test_env
 
+TEST_PACKAGES = [
+    ConanTestPackage(
+        ref=ConanPackageReference("dep/1.0.0@official/cppdev"),
+        dependencies=[],
+        cpp_standard="c++17",
+    ),
+    ConanTestPackage(
+        ref=ConanPackageReference("test/1.0.0@official/cppdev"),
+        dependencies=[ConanPackageReference("dep/1.0.0@official/cppdev")],
+        cpp_standard="c++17",
+    ),
+]
 
 def test_create_conan_env(tmp_path: Path, unused_http_port: int) -> None:
-    with launch_conan_server(tmp_path / "server", unused_http_port) as conan_server:
-        with create_conan_env(tmp_path / "conan", conan_server.http_port) as conan_env:
-            conan_env.create_and_upload_package(ConanPackageReference("dep/1.0.0@official/cppdev"), [])
-            conan_env.create_and_upload_package(ConanPackageReference("test/1.0.0@official/cppdev"), [ConanPackageReference("dep/1.0.0@official/cppdev")])
-            result = conan_list(CONAN_REMOTE, "test")
-            assert "test/1.0.0@official/cppdev" in result
+    with create_conan_test_env(tmp_path, unused_http_port, TEST_PACKAGES) as conan_env:
+        result = conan_list(CONAN_REMOTE, "test")
+        assert ConanPackageReference("test/1.0.0@official/cppdev") in result

src/tests/cpp_dev/dependency/conan/utils/test_env.py

@@ -7,10 +7,10 @@
 
 import requests
 
-from .server import launch_conan_server
+from .server import launch_conan_test_server
 
 
 def test_launch_conan_server(tmp_path: Path, unused_http_port: int) -> None:
-    with launch_conan_server(tmp_path / "server", unused_http_port) as conan_server:
+    with launch_conan_test_server(tmp_path / "server", unused_http_port) as conan_server:
         response = requests.get(conan_server.compose_url() + "/v1/ping", timeout=2)
         assert response.status_code == 200