cleveractors-core/benchmarks/reference_resolver_benchmark.py

"""ASV benchmarks for the ReferenceResolver and version resolution.

Measures performance of:
  - ReferenceResolver.parse() across all three reference formats
  - ReferenceResolver.resolve() for direct ID resolution
  - resolve_version() with concrete and alias versions
  - resolve_version() across varying version list sizes
  - is_concrete_version() and is_version_alias() classifiers
"""

from __future__ import annotations

import asyncio

from cleveractors.registry.resolver import (
    ReferenceResolver,
    is_concrete_version,
    is_version_alias,
    resolve_version,
)

_SMALL_VERSIONS = ["v1.0.0", "v1.1.0", "v1.2.0", "v2.0.0", "v2.1.0"]

_MEDIUM_VERSIONS = [
    f"v{m}.{n}.{p}" for m in range(1, 6) for n in range(10) for p in range(10)
]  # 500 versions

_LARGE_VERSIONS = [
    f"v{m}.{n}.{p}" for m in range(1, 11) for n in range(10) for p in range(10)
]  # 1000 versions


class ParseBenchmark:
    """Benchmark ReferenceResolver.parse() for all reference formats."""

    def setup(self) -> None:
        self.registry_ref = "registry.cleverthis.com:acme/web_search@v1.2.3"
        self.id_ref = "ID:pkg_act_0123456789abcdef0123456789abcdef01234567"
        self.local_ref = "local:path/to/component"
        self.registry_ref_no_version = "registry.cleverthis.com:acme/web_search"

    def time_parse_registry_ref(self) -> None:
        ReferenceResolver.parse(self.registry_ref)

    def time_parse_id_ref(self) -> None:
        ReferenceResolver.parse(self.id_ref)

    def time_parse_local_ref(self) -> None:
        ReferenceResolver.parse(self.local_ref)

    def time_parse_registry_ref_no_version(self) -> None:
        ReferenceResolver.parse(self.registry_ref_no_version)

    def peakmem_parse_registry_ref(self) -> None:
        ReferenceResolver.parse(self.registry_ref)


class ResolveIdBenchmark:
    """Benchmark ReferenceResolver.resolve() for direct ID resolution."""

    def setup(self) -> None:
        self.resolver = ReferenceResolver()
        self.id_ref = "ID:pkg_act_0123456789abcdef0123456789abcdef01234567"

    def time_resolve_id_ref(self) -> None:
        async def _bench() -> None:
            await self.resolver.resolve(self.id_ref)

        asyncio.run(_bench())

    def peakmem_resolve_id_ref(self) -> None:
        async def _bench() -> None:
            await self.resolver.resolve(self.id_ref)

        asyncio.run(_bench())


class ResolveVersionSmallBenchmark:
    """Benchmark resolve_version() against a small version list."""

    params: list[str] = [
        "v1.2.0",  # concrete
        "latest",  # alias
        "v2.x",  # major alias
        "v1.1.x",  # minor alias
    ]

    def setup(self, version: str = "") -> None:
        self.versions = _SMALL_VERSIONS

    def time_resolve_version_small(self, version: str) -> None:
        resolve_version(version, self.versions)

    def peakmem_resolve_version_small(self, version: str) -> None:
        resolve_version(version, self.versions)


class ResolveVersionMediumBenchmark:
    """Benchmark resolve_version() against a medium version list (500)."""

    params: list[str] = [
        "v4.5.5",  # concrete
        "latest",  # alias
        "v3.x",  # major alias
        "v1.9.x",  # minor alias
    ]

    def setup(self, version: str = "") -> None:
        self.versions = _MEDIUM_VERSIONS

    def time_resolve_version_medium(self, version: str) -> None:
        resolve_version(version, self.versions)

    def peakmem_resolve_version_medium(self, version: str) -> None:
        resolve_version(version, self.versions)


class ResolveVersionLargeBenchmark:
    """Benchmark resolve_version() against a large version list (1000)."""

    params: list[str] = [
        "v9.5.5",  # concrete
        "latest",  # alias
        "v5.x",  # major alias
        "v3.9.x",  # minor alias
    ]

    def setup(self, version: str = "") -> None:
        self.versions = _LARGE_VERSIONS

    def time_resolve_version_large(self, version: str) -> None:
        resolve_version(version, self.versions)

    def peakmem_resolve_version_large(self, version: str) -> None:
        resolve_version(version, self.versions)


class ClassificationBenchmark:
    """Benchmark is_concrete_version() and is_version_alias()."""

    params: list[str] = ["v1.2.3", "latest", "v2.x", "v3.1.x", "vx", "x"]

    def time_is_concrete_version(self, version: str) -> None:
        is_concrete_version(version)

    def time_is_version_alias(self, version: str) -> None:
        is_version_alias(version)


class ResolveRegistryBenchmark:
    """Benchmark ReferenceResolver.resolve() for registry references."""

    def setup(self) -> None:
        from cleveractors.registry.types import PackageId, PackageType

        class _MockRegistryClient:
            def __init__(self, package_id: str) -> None:
                self._package_id = package_id

            async def resolve_package(
                self,
                package_type: str,
                namespace: str,
                name: str,
                version: str = "latest",
            ) -> dict[str, str]:
                return {"package_id": self._package_id, "type": package_type}

        self.resolver = ReferenceResolver(
            client=_MockRegistryClient(
                package_id="pkg_act_0123456789abcdef0123456789abcdef01234567"
            )
        )
        self.registry_ref = "registry.example.com:acme/search@v1.0.0"

    def time_resolve_registry_ref(self) -> None:
        async def _bench() -> None:
            await self.resolver.resolve(self.registry_ref)

        asyncio.run(_bench())

    def peakmem_resolve_registry_ref(self) -> None:
        async def _bench() -> None:
            await self.resolver.resolve(self.registry_ref)

        asyncio.run(_bench())