unifi-core 0.1.0__tar.gz

unifi_core-0.1.0/.gitignore

@@ -0,0 +1,88 @@
+# Environment variables
+.env
+
+# Python
+__pycache__/
+_version.py
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# IDEs and editors
+.idea/
+.vscode/
+*.swp
+*.swo
+*.swn
+*~
+
+# Logs
+*.log
+logs/
+
+# Docker
+.dockerignore
+
+# Cache
+.cache/
+
+# Runtime data
+pids/
+*.pid
+*.seed
+*.pid.lock
+
+# Backup files
+*.bak
+*.backup
+
+# Testing
+.coverage
+
+# Playwright MCP artifacts
+.playwright-mcp/
+
+.DS_Store
+
+aiounifi/*
+aiounifi
+
+.env.template
+claude_config.json
+
+# open-agent-kit: Codebase Intelligence
+.oak/ci/
+.oak/config.*.yaml
+
+# open-agent-kit: Issue raw JSON (local debugging only)
+oak/issue/**/context.json
+
+# open-agent-kit: CI hook configs (local-only, regenerated by oak ci start)
+.claude/settings.local.json
+
+# Specs and plans — captured in Myco vault, not the repo
+docs/superpowers/
+docs/plans/
+docs/specs/
+.superpowers/

unifi_core-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: unifi-core
+Version: 0.1.0
+Summary: UniFi controller connectivity: auth, detection, retry, exceptions
+Requires-Python: >=3.13
+Requires-Dist: aiohttp>=3.8.5
+Requires-Dist: pyyaml>=6.0

unifi_core-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "unifi-core"
+dynamic = ["version"]
+description = "UniFi controller connectivity: auth, detection, retry, exceptions"
+requires-python = ">=3.13"
+dependencies = [
+    "aiohttp>=3.8.5",
+    "pyyaml>=6.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "aioresponses>=0.7.0",
+]
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options.root = "../.."
+raw-options.tag_regex = "^core/v(?P<version>\\d+(?:\\.\\d+)*)(?:\\S*)$"
+raw-options.git_describe_command = ["git", "describe", "--dirty", "--tags", "--long", "--match", "core/v*"]
+raw-options.fallback_version = "0.0.0"
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/unifi_core/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/unifi_core"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

unifi_core-0.1.0/src/unifi_core/__init__.py

@@ -0,0 +1,35 @@
+"""UniFi controller connectivity: auth, detection, retry, exceptions."""
+
+from unifi_core.auth import AuthMethod, LocalAuthProvider, UniFiAuth
+from unifi_core.connection import ConnectionConfig
+from unifi_core.detection import ControllerType, detect_controller_type_by_api_probe, detect_controller_type_pre_login
+from unifi_core.exceptions import (
+    UniFiAuthError,
+    UniFiConnectionError,
+    UniFiError,
+    UniFiPermissionError,
+    UniFiRateLimitError,
+)
+from unifi_core.retry import RetryPolicy, retry_with_backoff
+
+__all__ = [
+    # auth
+    "AuthMethod",
+    "LocalAuthProvider",
+    "UniFiAuth",
+    # connection
+    "ConnectionConfig",
+    # detection
+    "ControllerType",
+    "detect_controller_type_by_api_probe",
+    "detect_controller_type_pre_login",
+    # exceptions
+    "UniFiAuthError",
+    "UniFiConnectionError",
+    "UniFiError",
+    "UniFiPermissionError",
+    "UniFiRateLimitError",
+    # retry
+    "RetryPolicy",
+    "retry_with_backoff",
+]

unifi_core-0.1.0/src/unifi_core/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

unifi_core-0.1.0/src/unifi_core/auth.py

@@ -0,0 +1,73 @@
+"""Dual authentication strategy for UniFi controllers."""
+
+import enum
+import logging
+from typing import Protocol
+
+import aiohttp
+
+from unifi_core.exceptions import UniFiAuthError
+
+logger = logging.getLogger(__name__)
+
+
+class AuthMethod(enum.Enum):
+    LOCAL_ONLY = "local_only"
+    API_KEY_ONLY = "api_key_only"
+    EITHER = "either"
+
+    @classmethod
+    def from_string(cls, value: str | None) -> "AuthMethod":
+        if value is None:
+            return cls.LOCAL_ONLY
+        try:
+            return cls(value)
+        except ValueError:
+            logger.warning("[auth] Unknown auth method '%s', defaulting to local_only", value)
+            return cls.LOCAL_ONLY
+
+
+class LocalAuthProvider(Protocol):
+    """Contract that each app fulfills for local auth."""
+
+    async def get_session(self) -> aiohttp.ClientSession: ...
+
+
+class UniFiAuth:
+    """Dual auth: API key and/or local auth provider."""
+
+    def __init__(self, api_key: str | None = None, local_provider: LocalAuthProvider | None = None):
+        self._api_key = api_key
+        self._local_provider = local_provider
+
+    @property
+    def has_api_key(self) -> bool:
+        return self._api_key is not None and self._api_key != ""
+
+    @property
+    def has_local(self) -> bool:
+        return self._local_provider is not None
+
+    def set_local_provider(self, provider: LocalAuthProvider) -> None:
+        self._local_provider = provider
+
+    async def get_api_key_session(self) -> aiohttp.ClientSession:
+        if not self.has_api_key:
+            raise UniFiAuthError("API key authentication not configured. Set UNIFI_API_KEY environment variable.")
+        return aiohttp.ClientSession(headers={"X-API-Key": self._api_key})
+
+    async def get_local_session(self) -> aiohttp.ClientSession:
+        if not self.has_local:
+            raise UniFiAuthError("Local authentication not configured. Set UNIFI_USERNAME and UNIFI_PASSWORD.")
+        return await self._local_provider.get_session()
+
+    async def get_session(self, method: AuthMethod) -> aiohttp.ClientSession:
+        if method == AuthMethod.API_KEY_ONLY:
+            return await self.get_api_key_session()
+        elif method == AuthMethod.LOCAL_ONLY:
+            return await self.get_local_session()
+        elif method == AuthMethod.EITHER:
+            if self.has_api_key:
+                return await self.get_api_key_session()
+            return await self.get_local_session()
+        raise UniFiAuthError(f"Unknown auth method: {method}")

unifi_core-0.1.0/src/unifi_core/connection.py

@@ -0,0 +1,23 @@
+"""Base async connection primitives for UniFi controllers."""
+
+from dataclasses import dataclass
+
+import aiohttp  # noqa: F401
+
+
+@dataclass
+class ConnectionConfig:
+    host: str
+    port: int = 443
+    verify_ssl: bool = False
+    timeout: float = 30.0
+
+    @property
+    def url_base(self) -> str:
+        return f"https://{self.host}:{self.port}"
+
+    @property
+    def ssl_context(self):
+        if self.verify_ssl:
+            return None
+        return False

unifi_core-0.1.0/src/unifi_core/detection.py

@@ -0,0 +1,87 @@
+"""UniFi controller type detection.
+
+Determines whether the controller is a UniFi OS appliance (UDM, UDR, etc.)
+or a standalone/self-hosted Network Application. This affects API path
+routing: UniFi OS uses /proxy/network/... while standalone uses /api/...
+"""
+
+import enum
+import logging
+
+import aiohttp
+
+logger = logging.getLogger(__name__)
+
+
+class ControllerType(enum.Enum):
+    UNIFI_OS = "proxy"
+    STANDALONE = "direct"
+    AUTO = "auto"
+
+    @classmethod
+    def from_config(cls, value: str) -> "ControllerType":
+        mapping = {"proxy": cls.UNIFI_OS, "direct": cls.STANDALONE, "auto": cls.AUTO}
+        result = mapping.get(value.lower(), cls.AUTO)
+        if value.lower() not in mapping:
+            logger.warning("[detection] Unknown controller type '%s', falling back to auto", value)
+        return result
+
+
+async def detect_controller_type_pre_login(
+    host: str, port: int, verify_ssl: bool = False, timeout: float = 10.0
+) -> ControllerType | None:
+    """Probe the controller before login to detect type.
+
+    Strategy:
+    - GET the base URL without following redirects
+    - UniFi OS returns 200 with x-csrf-token header or HTML
+    - Standalone controllers redirect (301/302) to /manage
+
+    Returns:
+        ControllerType.UNIFI_OS or ControllerType.STANDALONE if detected, None otherwise.
+    """
+    url = f"https://{host}:{port}"
+    ssl_context = None if verify_ssl else False
+    client_timeout = aiohttp.ClientTimeout(total=timeout)
+
+    try:
+        async with aiohttp.ClientSession(timeout=client_timeout) as session:
+            async with session.get(url, ssl=ssl_context, allow_redirects=False) as resp:
+                headers = resp.headers
+                if "x-csrf-token" in headers or resp.status == 200:
+                    return ControllerType.UNIFI_OS
+                if resp.status in (302, 301):
+                    return ControllerType.STANDALONE
+    except Exception as e:
+        logger.debug("[detection] Pre-login probe failed: %s", e)
+
+    return None
+
+
+async def detect_controller_type_by_api_probe(
+    session: aiohttp.ClientSession, host: str, port: int, verify_ssl: bool = False
+) -> ControllerType | None:
+    """Probe API endpoints to detect controller type (requires authenticated session).
+
+    Tries both UniFi OS and standalone API paths for /api/self/sites.
+    Returns the type corresponding to the first path that returns HTTP 200.
+
+    Returns:
+        ControllerType.UNIFI_OS or ControllerType.STANDALONE if detected, None otherwise.
+    """
+    url_base = f"https://{host}:{port}"
+    ssl_context = None if verify_ssl else False
+
+    for path, expected_type in [
+        ("/proxy/network/api/self/sites", ControllerType.UNIFI_OS),
+        ("/api/self/sites", ControllerType.STANDALONE),
+    ]:
+        try:
+            async with session.get(f"{url_base}{path}", ssl=ssl_context) as resp:
+                if resp.status == 200:
+                    logger.info("[detection] Detected %s via %s", expected_type.name, path)
+                    return expected_type
+        except Exception:
+            continue
+
+    return None

unifi_core-0.1.0/src/unifi_core/exceptions.py

@@ -0,0 +1,21 @@
+"""Shared exception hierarchy for UniFi MCP servers."""
+
+
+class UniFiError(Exception):
+    """Base exception for all UniFi errors."""
+
+
+class UniFiAuthError(UniFiError):
+    """Authentication failed."""
+
+
+class UniFiConnectionError(UniFiError):
+    """Connection to controller failed."""
+
+
+class UniFiRateLimitError(UniFiError):
+    """Rate limit exceeded."""
+
+
+class UniFiPermissionError(UniFiError):
+    """Insufficient permissions for operation."""

unifi_core-0.1.0/src/unifi_core/retry.py

@@ -0,0 +1,43 @@
+"""Retry logic with exponential backoff."""
+
+import asyncio
+import logging
+from dataclasses import dataclass
+
+from unifi_core.exceptions import UniFiError
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class RetryPolicy:
+    max_retries: int = 3
+    base_delay: float = 1.0
+    max_delay: float = 30.0
+    backoff_factor: float = 2.0
+    retryable_exceptions: tuple = (UniFiError,)
+
+
+async def retry_with_backoff(operation, policy: RetryPolicy | None = None):
+    """Execute operation with exponential backoff retry."""
+    if policy is None:
+        policy = RetryPolicy()
+
+    last_error = None
+    for attempt in range(policy.max_retries + 1):
+        try:
+            return await operation()
+        except policy.retryable_exceptions as e:
+            last_error = e
+            if attempt < policy.max_retries:
+                delay = min(policy.base_delay * (policy.backoff_factor ** attempt), policy.max_delay)
+                logger.warning(
+                    "[retry] Attempt %d/%d failed: %s. Retrying in %.1fs",
+                    attempt + 1,
+                    policy.max_retries,
+                    e,
+                    delay,
+                )
+                await asyncio.sleep(delay)
+
+    raise last_error

unifi_core-0.1.0/tests/test_auth.py

@@ -0,0 +1,136 @@
+import pytest
+import aiohttp
+from unittest.mock import AsyncMock
+from unifi_core.auth import AuthMethod, UniFiAuth
+from unifi_core.exceptions import UniFiAuthError
+
+
+class TestAuthMethod:
+    def test_enum_values(self):
+        assert AuthMethod.LOCAL_ONLY.value == "local_only"
+        assert AuthMethod.API_KEY_ONLY.value == "api_key_only"
+        assert AuthMethod.EITHER.value == "either"
+
+    def test_from_string_valid(self):
+        assert AuthMethod.from_string("local_only") == AuthMethod.LOCAL_ONLY
+        assert AuthMethod.from_string("api_key_only") == AuthMethod.API_KEY_ONLY
+        assert AuthMethod.from_string("either") == AuthMethod.EITHER
+
+    def test_from_string_none_defaults_to_local(self):
+        assert AuthMethod.from_string(None) == AuthMethod.LOCAL_ONLY
+
+    def test_from_string_unknown_defaults_to_local(self):
+        assert AuthMethod.from_string("unknown") == AuthMethod.LOCAL_ONLY
+        assert AuthMethod.from_string("") == AuthMethod.LOCAL_ONLY
+
+
+class TestUniFiAuthProperties:
+    def test_has_api_key_true(self):
+        auth = UniFiAuth(api_key="test-key")
+        assert auth.has_api_key is True
+
+    def test_has_api_key_false_when_none(self):
+        auth = UniFiAuth(api_key=None)
+        assert auth.has_api_key is False
+
+    def test_has_api_key_false_when_empty(self):
+        auth = UniFiAuth(api_key="")
+        assert auth.has_api_key is False
+
+    def test_has_local_true(self):
+        provider = AsyncMock()
+        auth = UniFiAuth(local_provider=provider)
+        assert auth.has_local is True
+
+    def test_has_local_false_when_none(self):
+        auth = UniFiAuth()
+        assert auth.has_local is False
+
+    def test_set_local_provider(self):
+        auth = UniFiAuth()
+        assert auth.has_local is False
+        provider = AsyncMock()
+        auth.set_local_provider(provider)
+        assert auth.has_local is True
+
+
+class TestUniFiAuthApiKeySession:
+    @pytest.mark.asyncio
+    async def test_get_api_key_session_creates_session_with_header(self):
+        auth = UniFiAuth(api_key="my-api-key")
+        session = await auth.get_api_key_session()
+        try:
+            assert isinstance(session, aiohttp.ClientSession)
+            # Check that the default headers contain the API key
+            assert session.headers.get("X-API-Key") == "my-api-key"
+        finally:
+            await session.close()
+
+    @pytest.mark.asyncio
+    async def test_get_api_key_session_raises_when_not_configured(self):
+        auth = UniFiAuth()
+        with pytest.raises(UniFiAuthError, match="API key authentication not configured"):
+            await auth.get_api_key_session()
+
+
+class TestUniFiAuthLocalSession:
+    @pytest.mark.asyncio
+    async def test_get_local_session_delegates_to_provider(self):
+        mock_session = AsyncMock(spec=aiohttp.ClientSession)
+        provider = AsyncMock()
+        provider.get_session = AsyncMock(return_value=mock_session)
+        auth = UniFiAuth(local_provider=provider)
+        session = await auth.get_local_session()
+        assert session is mock_session
+        provider.get_session.assert_awaited_once()
+
+    @pytest.mark.asyncio
+    async def test_get_local_session_raises_when_not_configured(self):
+        auth = UniFiAuth()
+        with pytest.raises(UniFiAuthError, match="Local authentication not configured"):
+            await auth.get_local_session()
+
+
+class TestUniFiAuthGetSession:
+    @pytest.mark.asyncio
+    async def test_get_session_api_key_only(self):
+        auth = UniFiAuth(api_key="test-key")
+        session = await auth.get_session(AuthMethod.API_KEY_ONLY)
+        try:
+            assert session.headers.get("X-API-Key") == "test-key"
+        finally:
+            await session.close()
+
+    @pytest.mark.asyncio
+    async def test_get_session_local_only(self):
+        mock_session = AsyncMock(spec=aiohttp.ClientSession)
+        provider = AsyncMock()
+        provider.get_session = AsyncMock(return_value=mock_session)
+        auth = UniFiAuth(local_provider=provider)
+        session = await auth.get_session(AuthMethod.LOCAL_ONLY)
+        assert session is mock_session
+
+    @pytest.mark.asyncio
+    async def test_get_session_either_prefers_api_key(self):
+        mock_session = AsyncMock(spec=aiohttp.ClientSession)
+        provider = AsyncMock()
+        provider.get_session = AsyncMock(return_value=mock_session)
+        auth = UniFiAuth(api_key="test-key", local_provider=provider)
+        session = await auth.get_session(AuthMethod.EITHER)
+        try:
+            # Should prefer API key when both are available
+            assert isinstance(session, aiohttp.ClientSession)
+            assert session.headers.get("X-API-Key") == "test-key"
+            provider.get_session.assert_not_awaited()
+        finally:
+            await session.close()
+
+    @pytest.mark.asyncio
+    async def test_get_session_either_falls_back_to_local(self):
+        mock_session = AsyncMock(spec=aiohttp.ClientSession)
+        provider = AsyncMock()
+        provider.get_session = AsyncMock(return_value=mock_session)
+        auth = UniFiAuth(local_provider=provider)
+        session = await auth.get_session(AuthMethod.EITHER)
+        assert session is mock_session
+        provider.get_session.assert_awaited_once()

unifi_core-0.1.0/tests/test_connection.py

@@ -0,0 +1,33 @@
+from unifi_core.connection import ConnectionConfig
+
+
+class TestConnectionConfig:
+    def test_defaults(self):
+        cfg = ConnectionConfig(host="192.168.1.1")
+        assert cfg.host == "192.168.1.1"
+        assert cfg.port == 443
+        assert cfg.verify_ssl is False
+        assert cfg.timeout == 30.0
+
+    def test_custom_values(self):
+        cfg = ConnectionConfig(host="10.0.0.1", port=8443, verify_ssl=True, timeout=60.0)
+        assert cfg.host == "10.0.0.1"
+        assert cfg.port == 8443
+        assert cfg.verify_ssl is True
+        assert cfg.timeout == 60.0
+
+    def test_url_base(self):
+        cfg = ConnectionConfig(host="192.168.1.1")
+        assert cfg.url_base == "https://192.168.1.1:443"
+
+    def test_url_base_custom_port(self):
+        cfg = ConnectionConfig(host="10.0.0.1", port=8443)
+        assert cfg.url_base == "https://10.0.0.1:8443"
+
+    def test_ssl_context_when_verify_false(self):
+        cfg = ConnectionConfig(host="192.168.1.1", verify_ssl=False)
+        assert cfg.ssl_context is False
+
+    def test_ssl_context_when_verify_true(self):
+        cfg = ConnectionConfig(host="192.168.1.1", verify_ssl=True)
+        assert cfg.ssl_context is None

unifi_core-0.1.0/tests/test_detection.py

@@ -0,0 +1,31 @@
+import pytest
+from unifi_core.detection import ControllerType
+
+
+class TestControllerType:
+    def test_enum_values(self):
+        assert ControllerType.UNIFI_OS.value == "proxy"
+        assert ControllerType.STANDALONE.value == "direct"
+        assert ControllerType.AUTO.value == "auto"
+
+    def test_from_config_proxy(self):
+        assert ControllerType.from_config("proxy") == ControllerType.UNIFI_OS
+
+    def test_from_config_direct(self):
+        assert ControllerType.from_config("direct") == ControllerType.STANDALONE
+
+    def test_from_config_auto(self):
+        assert ControllerType.from_config("auto") == ControllerType.AUTO
+
+    def test_from_config_case_insensitive(self):
+        assert ControllerType.from_config("PROXY") == ControllerType.UNIFI_OS
+        assert ControllerType.from_config("Direct") == ControllerType.STANDALONE
+        assert ControllerType.from_config("AUTO") == ControllerType.AUTO
+
+    def test_from_config_unknown_falls_back_to_auto(self):
+        assert ControllerType.from_config("unknown") == ControllerType.AUTO
+        assert ControllerType.from_config("") == ControllerType.AUTO
+
+    def test_enum_members_complete(self):
+        members = set(ControllerType)
+        assert members == {ControllerType.UNIFI_OS, ControllerType.STANDALONE, ControllerType.AUTO}

unifi_core-0.1.0/tests/test_exceptions.py

@@ -0,0 +1,13 @@
+from unifi_core.exceptions import UniFiError, UniFiAuthError, UniFiConnectionError, UniFiRateLimitError, UniFiPermissionError
+
+
+def test_exception_hierarchy():
+    assert issubclass(UniFiAuthError, UniFiError)
+    assert issubclass(UniFiConnectionError, UniFiError)
+    assert issubclass(UniFiRateLimitError, UniFiError)
+    assert issubclass(UniFiPermissionError, UniFiError)
+
+
+def test_exception_message():
+    err = UniFiAuthError("Invalid credentials")
+    assert str(err) == "Invalid credentials"

unifi_core-0.1.0/tests/test_retry.py

@@ -0,0 +1,58 @@
+import pytest
+from unifi_core.retry import RetryPolicy, retry_with_backoff
+from unifi_core.exceptions import UniFiConnectionError
+
+
+@pytest.mark.asyncio
+async def test_retry_succeeds_after_failures():
+    call_count = 0
+
+    async def flaky_operation():
+        nonlocal call_count
+        call_count += 1
+        if call_count < 3:
+            raise UniFiConnectionError("Connection failed")
+        return "success"
+
+    policy = RetryPolicy(max_retries=3, base_delay=0.01)
+    result = await retry_with_backoff(flaky_operation, policy)
+    assert result == "success"
+    assert call_count == 3
+
+
+@pytest.mark.asyncio
+async def test_retry_exhausted_raises():
+    async def always_fails():
+        raise UniFiConnectionError("Connection failed")
+
+    policy = RetryPolicy(max_retries=2, base_delay=0.01)
+    with pytest.raises(UniFiConnectionError):
+        await retry_with_backoff(always_fails, policy)
+
+
+@pytest.mark.asyncio
+async def test_retry_succeeds_on_first_try():
+    async def succeeds():
+        return "ok"
+
+    policy = RetryPolicy(max_retries=3, base_delay=0.01)
+    result = await retry_with_backoff(succeeds, policy)
+    assert result == "ok"
+
+
+@pytest.mark.asyncio
+async def test_retry_non_retryable_exception_not_caught():
+    async def raises_value_error():
+        raise ValueError("not retryable")
+
+    policy = RetryPolicy(max_retries=3, base_delay=0.01)
+    with pytest.raises(ValueError, match="not retryable"):
+        await retry_with_backoff(raises_value_error, policy)
+
+
+def test_retry_policy_defaults():
+    policy = RetryPolicy()
+    assert policy.max_retries == 3
+    assert policy.base_delay == 1.0
+    assert policy.max_delay == 30.0
+    assert policy.backoff_factor == 2.0