Skip to content

πŸ™Œ OpenHands: AI-Driven Development

feat(enterprise): convert DeviceCodeStore to async (#13136)

Tim O'Farrell7fdb423f99f2
diff --git a/enterprise/server/routes/oauth_device.py b/enterprise/server/routes/oauth_device.py
index a7d126e040..52ee16b570 100644
--- a/enterprise/server/routes/oauth_device.py
+++ b/enterprise/server/routes/oauth_device.py
@@ -7,7 +7,6 @@ from fastapi import APIRouter, Depends, Form, HTTPException, Request, status
from fastapi.responses import JSONResponse
from pydantic import BaseModel
from storage.api_key_store import ApiKeyStore
-from storage.database import session_maker
from storage.device_code_store import DeviceCodeStore
from openhands.core.logger import openhands_logger as logger
@@ -54,7 +53,7 @@ class DeviceTokenErrorResponse(BaseModel):
# ---------------------------------------------------------------------------
oauth_device_router = APIRouter(prefix='/oauth/device')
-device_code_store = DeviceCodeStore(session_maker)
+device_code_store = DeviceCodeStore()
# ---------------------------------------------------------------------------
@@ -90,7 +89,7 @@ async def device_authorization(
) -> DeviceAuthorizationResponse:
"""Start device flow by generating device and user codes."""
try:
- device_code_entry = device_code_store.create_device_code(
+ device_code_entry = await device_code_store.create_device_code(
expires_in=DEVICE_CODE_EXPIRES_IN,
)
@@ -125,7 +124,7 @@ async def device_authorization(
async def device_token(device_code: str = Form(...)):
"""Poll for a token until the user authorizes or the code expires."""
try:
- device_code_entry = device_code_store.get_by_device_code(device_code)
+ device_code_entry = await device_code_store.get_by_device_code(device_code)
if not device_code_entry:
return _oauth_error(
@@ -138,7 +137,9 @@ async def device_token(device_code: str = Form(...)):
is_too_fast, current_interval = device_code_entry.check_rate_limit()
if is_too_fast:
# Update poll time and increase interval
- device_code_store.update_poll_time(device_code, increase_interval=True)
+ await device_code_store.update_poll_time(
+ device_code, increase_interval=True
+ )
logger.warning(
'Client polling too fast, returning slow_down error',
extra={
@@ -154,7 +155,7 @@ async def device_token(device_code: str = Form(...)):
)
# Update poll time for successful rate limit check
- device_code_store.update_poll_time(device_code, increase_interval=False)
+ await device_code_store.update_poll_time(device_code, increase_interval=False)
if device_code_entry.is_expired():
return _oauth_error(
@@ -238,7 +239,7 @@ async def device_verification_authenticated(
)
# Validate device code
- device_code_entry = device_code_store.get_by_user_code(user_code)
+ device_code_entry = await device_code_store.get_by_user_code(user_code)
if not device_code_entry:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
@@ -252,7 +253,7 @@ async def device_verification_authenticated(
)
# First, authorize the device code
- success = device_code_store.authorize_device_code(
+ success = await device_code_store.authorize_device_code(
user_code=user_code,
user_id=user_id,
)
@@ -289,7 +290,7 @@ async def device_verification_authenticated(
# Clean up: revert the device authorization since API key creation failed
# This prevents the device from being in an authorized state without an API key
try:
- device_code_store.deny_device_code(user_code)
+ await device_code_store.deny_device_code(user_code)
logger.info(
'Reverted device authorization due to API key creation failure',
extra={'user_code': user_code, 'user_id': user_id},
diff --git a/enterprise/storage/device_code.py b/enterprise/storage/device_code.py
index 47e18b51bc..b2b4f05b8f 100644
--- a/enterprise/storage/device_code.py
+++ b/enterprise/storage/device_code.py
@@ -47,7 +47,11 @@ class DeviceCode(Base):
def is_expired(self) -> bool:
"""Check if the device code has expired."""
now = datetime.now(timezone.utc)
- return now > self.expires_at
+ # Handle timezone-naive datetime from database by assuming it's UTC
+ expires_at = self.expires_at
+ if expires_at.tzinfo is None:
+ expires_at = expires_at.replace(tzinfo=timezone.utc)
+ return now > expires_at
def is_pending(self) -> bool:
"""Check if the device code is still pending authorization."""
@@ -85,8 +89,13 @@ class DeviceCode(Base):
if self.last_poll_time is None:
return False, self.current_interval
+ # Handle timezone-naive datetime from database by assuming it's UTC
+ last_poll_time = self.last_poll_time
+ if last_poll_time.tzinfo is None:
+ last_poll_time = last_poll_time.replace(tzinfo=timezone.utc)
+
# Calculate time since last poll
- time_since_last_poll = (now - self.last_poll_time).total_seconds()
+ time_since_last_poll = (now - last_poll_time).total_seconds()
# Check if polling too fast
if time_since_last_poll < self.current_interval:
diff --git a/enterprise/storage/device_code_store.py b/enterprise/storage/device_code_store.py
index de2fe29cc4..e37369467f 100644
--- a/enterprise/storage/device_code_store.py
+++ b/enterprise/storage/device_code_store.py
@@ -1,19 +1,20 @@
"""Device code store for OAuth 2.0 Device Flow."""
+from __future__ import annotations
+
import secrets
import string
from datetime import datetime, timedelta, timezone
+from sqlalchemy import select
from sqlalchemy.exc import IntegrityError
+from storage.database import a_session_maker
from storage.device_code import DeviceCode
class DeviceCodeStore:
"""Store for managing OAuth 2.0 device codes."""
- def __init__(self, session_maker):
- self.session_maker = session_maker
-
def generate_user_code(self) -> str:
"""Generate a human-readable user code (8 characters, uppercase letters and digits)."""
# Use a mix of uppercase letters and digits, avoiding confusing characters
@@ -25,7 +26,7 @@ class DeviceCodeStore:
alphabet = string.ascii_letters + string.digits
return ''.join(secrets.choice(alphabet) for _ in range(128))
- def create_device_code(
+ async def create_device_code(
self,
expires_in: int = 600, # 10 minutes default
max_attempts: int = 10,
@@ -58,11 +59,10 @@ class DeviceCodeStore:
)
try:
- with self.session_maker() as session:
+ async with a_session_maker() as session:
session.add(device_code_entry)
- session.commit()
- session.refresh(device_code_entry)
- session.expunge(device_code_entry) # Detach from session cleanly
+ await session.commit()
+ await session.refresh(device_code_entry)
return device_code_entry
except IntegrityError:
# Constraint violation - codes already exist, retry with new codes
@@ -72,25 +72,23 @@ class DeviceCodeStore:
f'Failed to generate unique device codes after {max_attempts} attempts'
)
- def get_by_device_code(self, device_code: str) -> DeviceCode | None:
+ async def get_by_device_code(self, device_code: str) -> DeviceCode | None:
"""Get device code entry by device code."""
- with self.session_maker() as session:
- result = (
- session.query(DeviceCode).filter_by(device_code=device_code).first()
+ async with a_session_maker() as session:
+ result = await session.execute(
+ select(DeviceCode).filter_by(device_code=device_code)
)
- if result:
- session.expunge(result) # Detach from session cleanly
- return result
+ return result.scalars().first()
- def get_by_user_code(self, user_code: str) -> DeviceCode | None:
+ async def get_by_user_code(self, user_code: str) -> DeviceCode | None:
"""Get device code entry by user code."""
- with self.session_maker() as session:
- result = session.query(DeviceCode).filter_by(user_code=user_code).first()
- if result:
- session.expunge(result) # Detach from session cleanly
- return result
+ async with a_session_maker() as session:
+ result = await session.execute(
+ select(DeviceCode).filter_by(user_code=user_code)
+ )
+ return result.scalars().first()
- def authorize_device_code(self, user_code: str, user_id: str) -> bool:
+ async def authorize_device_code(self, user_code: str, user_id: str) -> bool:
"""Authorize a device code.
Args:
@@ -100,10 +98,11 @@ class DeviceCodeStore:
Returns:
True if authorization was successful, False otherwise
"""
- with self.session_maker() as session:
- device_code_entry = (
- session.query(DeviceCode).filter_by(user_code=user_code).first()
+ async with a_session_maker() as session:
+ result = await session.execute(
+ select(DeviceCode).filter_by(user_code=user_code)
)
+ device_code_entry = result.scalars().first()
if not device_code_entry:
return False
@@ -112,11 +111,11 @@ class DeviceCodeStore:
return False
device_code_entry.authorize(user_id)
- session.commit()
+ await session.commit()
return True
- def deny_device_code(self, user_code: str) -> bool:
+ async def deny_device_code(self, user_code: str) -> bool:
"""Deny a device code authorization.
Args:
@@ -125,10 +124,11 @@ class DeviceCodeStore:
Returns:
True if denial was successful, False otherwise
"""
- with self.session_maker() as session:
- device_code_entry = (
- session.query(DeviceCode).filter_by(user_code=user_code).first()
+ async with a_session_maker() as session:
+ result = await session.execute(
+ select(DeviceCode).filter_by(user_code=user_code)
)
+ device_code_entry = result.scalars().first()
if not device_code_entry:
return False
@@ -137,11 +137,11 @@ class DeviceCodeStore:
return False
device_code_entry.deny()
- session.commit()
+ await session.commit()
return True
- def update_poll_time(
+ async def update_poll_time(
self, device_code: str, increase_interval: bool = False
) -> bool:
"""Update the poll time for a device code and optionally increase interval.
@@ -153,15 +153,16 @@ class DeviceCodeStore:
Returns:
True if update was successful, False otherwise
"""
- with self.session_maker() as session:
- device_code_entry = (
- session.query(DeviceCode).filter_by(device_code=device_code).first()
+ async with a_session_maker() as session:
+ result = await session.execute(
+ select(DeviceCode).filter_by(device_code=device_code)
)
+ device_code_entry = result.scalars().first()
if not device_code_entry:
return False
device_code_entry.update_poll_time(increase_interval)
- session.commit()
+ await session.commit()
return True
diff --git a/enterprise/tests/unit/server/routes/test_oauth_device.py b/enterprise/tests/unit/server/routes/test_oauth_device.py
index 2ccba3974f..00b16510ed 100644
--- a/enterprise/tests/unit/server/routes/test_oauth_device.py
+++ b/enterprise/tests/unit/server/routes/test_oauth_device.py
@@ -16,8 +16,15 @@ from storage.device_code import DeviceCode
@pytest.fixture
def mock_device_code_store():
- """Mock device code store."""
- return MagicMock()
+ """Mock device code store with async methods."""
+ mock = MagicMock()
+ mock.create_device_code = AsyncMock()
+ mock.get_by_device_code = AsyncMock()
+ mock.get_by_user_code = AsyncMock()
+ mock.authorize_device_code = AsyncMock()
+ mock.deny_device_code = AsyncMock()
+ mock.update_poll_time = AsyncMock()
+ return mock
@pytest.fixture
@@ -54,7 +61,7 @@ class TestDeviceAuthorization:
expires_at=datetime.now(UTC) + timedelta(minutes=10),
current_interval=5, # Default interval
)
- mock_store.create_device_code.return_value = mock_device
+ mock_store.create_device_code = AsyncMock(return_value=mock_device)
result = await device_authorization(mock_request)
@@ -76,7 +83,7 @@ class TestDeviceAuthorization:
expires_at=datetime.now(UTC) + timedelta(minutes=10),
current_interval=15, # Increased interval from previous rate limiting
)
- mock_store.create_device_code.return_value = mock_device
+ mock_store.create_device_code = AsyncMock(return_value=mock_device)
result = await device_authorization(mock_request)
@@ -113,10 +120,10 @@ class TestDeviceToken:
mock_device.status = status
# Mock rate limiting - return False (not too fast) and default interval
mock_device.check_rate_limit.return_value = (False, 5)
- mock_store.get_by_device_code.return_value = mock_device
- mock_store.update_poll_time.return_value = True
+ mock_store.get_by_device_code = AsyncMock(return_value=mock_device)
+ mock_store.update_poll_time = AsyncMock(return_value=True)
else:
- mock_store.get_by_device_code.return_value = None
+ mock_store.get_by_device_code = AsyncMock(return_value=None)
result = await device_token(device_code=device_code)
@@ -142,8 +149,8 @@ class TestDeviceToken:
)
# Mock rate limiting - return False (not too fast) and default interval
mock_device.check_rate_limit.return_value = (False, 5)
- mock_store.get_by_device_code.return_value = mock_device
- mock_store.update_poll_time.return_value = True
+ mock_store.get_by_device_code = AsyncMock(return_value=mock_device)
+ mock_store.update_poll_time = AsyncMock(return_value=True)
# Mock API key retrieval - use AsyncMock for async method
mock_api_key_store = MagicMock()
@@ -178,7 +185,7 @@ class TestDeviceVerificationAuthenticated:
self, mock_store, mock_api_key_class
):
"""Test verification with invalid device code."""
- mock_store.get_by_user_code.return_value = None
+ mock_store.get_by_user_code = AsyncMock(return_value=None)
with pytest.raises(HTTPException):
await device_verification_authenticated(
@@ -191,7 +198,7 @@ class TestDeviceVerificationAuthenticated:
"""Test verification with already processed device code."""
mock_device = MagicMock()
mock_device.is_pending.return_value = False
- mock_store.get_by_user_code.return_value = mock_device
+ mock_store.get_by_user_code = AsyncMock(return_value=mock_device)
with pytest.raises(HTTPException):
await device_verification_authenticated(
@@ -205,8 +212,8 @@ class TestDeviceVerificationAuthenticated:
# Mock device code
mock_device = MagicMock()
mock_device.is_pending.return_value = True
- mock_store.get_by_user_code.return_value = mock_device
- mock_store.authorize_device_code.return_value = True
+ mock_store.get_by_user_code = AsyncMock(return_value=mock_device)
+ mock_store.authorize_device_code = AsyncMock(return_value=True)
# Mock API key store with async create_api_key
mock_api_key_store = MagicMock()
@@ -250,15 +257,17 @@ class TestDeviceVerificationAuthenticated:
mock_device2.is_pending.return_value = True
# Configure mock store to return appropriate device for each user_code
- def get_by_user_code_side_effect(user_code):
+ async def get_by_user_code_side_effect(user_code):
if user_code == device1_code:
return mock_device1
elif user_code == device2_code:
return mock_device2
return None
- mock_store.get_by_user_code.side_effect = get_by_user_code_side_effect
- mock_store.authorize_device_code.return_value = True
+ mock_store.get_by_user_code = AsyncMock(
+ side_effect=get_by_user_code_side_effect
+ )
+ mock_store.authorize_device_code = AsyncMock(return_value=True)
# Authenticate first device
result1 = await device_verification_authenticated(
@@ -307,8 +316,8 @@ class TestDeviceTokenRateLimiting:
last_poll_time=None, # First poll
current_interval=5,
)
- mock_store.get_by_device_code.return_value = mock_device
- mock_store.update_poll_time.return_value = True
+ mock_store.get_by_device_code = AsyncMock(return_value=mock_device)
+ mock_store.update_poll_time = AsyncMock(return_value=True)
device_code = 'test_device_code'
result = await device_token(device_code=device_code)
@@ -338,8 +347,8 @@ class TestDeviceTokenRateLimiting:
last_poll_time=last_poll,
current_interval=5,
)
- mock_store.get_by_device_code.return_value = mock_device
- mock_store.update_poll_time.return_value = True
+ mock_store.get_by_device_code = AsyncMock(return_value=mock_device)
+ mock_store.update_poll_time = AsyncMock(return_value=True)
device_code = 'test_device_code'
result = await device_token(device_code=device_code)
@@ -369,8 +378,8 @@ class TestDeviceTokenRateLimiting:
last_poll_time=last_poll,
current_interval=5,
)
- mock_store.get_by_device_code.return_value = mock_device
- mock_store.update_poll_time.return_value = True
+ mock_store.get_by_device_code = AsyncMock(return_value=mock_device)
+ mock_store.update_poll_time = AsyncMock(return_value=True)
device_code = 'test_device_code'
result = await device_token(device_code=device_code)
@@ -401,8 +410,8 @@ class TestDeviceTokenRateLimiting:
last_poll_time=last_poll,
current_interval=15, # Already increased from previous slow_down
)
- mock_store.get_by_device_code.return_value = mock_device
- mock_store.update_poll_time.return_value = True
+ mock_store.get_by_device_code = AsyncMock(return_value=mock_device)
+ mock_store.update_poll_time = AsyncMock(return_value=True)
device_code = 'test_device_code'
result = await device_token(device_code=device_code)
@@ -432,8 +441,8 @@ class TestDeviceTokenRateLimiting:
last_poll_time=last_poll,
current_interval=58, # Near maximum of 60
)
- mock_store.get_by_device_code.return_value = mock_device
- mock_store.update_poll_time.return_value = True
+ mock_store.get_by_device_code = AsyncMock(return_value=mock_device)
+ mock_store.update_poll_time = AsyncMock(return_value=True)
device_code = 'test_device_code'
result = await device_token(device_code=device_code)
@@ -459,8 +468,8 @@ class TestDeviceTokenRateLimiting:
last_poll_time=last_poll,
current_interval=5,
)
- mock_store.get_by_device_code.return_value = mock_device
- mock_store.update_poll_time.return_value = True
+ mock_store.get_by_device_code = AsyncMock(return_value=mock_device)
+ mock_store.update_poll_time = AsyncMock(return_value=True)
device_code = 'test_device_code'
result = await device_token(device_code=device_code)
@@ -489,8 +498,10 @@ class TestDeviceVerificationTransactionIntegrity:
# Mock device code
mock_device = MagicMock()
mock_device.is_pending.return_value = True
- mock_store.get_by_user_code.return_value = mock_device
- mock_store.authorize_device_code.return_value = False # Authorization fails
+ mock_store.get_by_user_code = AsyncMock(return_value=mock_device)
+ mock_store.authorize_device_code = AsyncMock(
+ return_value=False
+ ) # Authorization fails
# Mock API key store with async create_api_key
mock_api_key_store = MagicMock()
@@ -521,9 +532,11 @@ class TestDeviceVerificationTransactionIntegrity:
# Mock device code
mock_device = MagicMock()
mock_device.is_pending.return_value = True
- mock_store.get_by_user_code.return_value = mock_device
- mock_store.authorize_device_code.return_value = True # Authorization succeeds
- mock_store.deny_device_code.return_value = True # Cleanup succeeds
+ mock_store.get_by_user_code = AsyncMock(return_value=mock_device)
+ mock_store.authorize_device_code = AsyncMock(
+ return_value=True
+ ) # Authorization succeeds
+ mock_store.deny_device_code = AsyncMock(return_value=True) # Cleanup succeeds
# Mock API key store to fail on creation (async)
mock_api_key_store = MagicMock()
@@ -561,10 +574,12 @@ class TestDeviceVerificationTransactionIntegrity:
# Mock device code
mock_device = MagicMock()
mock_device.is_pending.return_value = True
- mock_store.get_by_user_code.return_value = mock_device
- mock_store.authorize_device_code.return_value = True # Authorization succeeds
- mock_store.deny_device_code.side_effect = Exception(
- 'Cleanup failed'
+ mock_store.get_by_user_code = AsyncMock(return_value=mock_device)
+ mock_store.authorize_device_code = AsyncMock(
+ return_value=True
+ ) # Authorization succeeds
+ mock_store.deny_device_code = AsyncMock(
+ side_effect=Exception('Cleanup failed')
) # Cleanup fails
# Mock API key store to fail on creation (async)
@@ -597,8 +612,11 @@ class TestDeviceVerificationTransactionIntegrity:
# Mock device code
mock_device = MagicMock()
mock_device.is_pending.return_value = True
- mock_store.get_by_user_code.return_value = mock_device
- mock_store.authorize_device_code.return_value = True # Authorization succeeds
+ mock_store.get_by_user_code = AsyncMock(return_value=mock_device)
+ mock_store.authorize_device_code = AsyncMock(
+ return_value=True
+ ) # Authorization succeeds
+ mock_store.deny_device_code = AsyncMock()
# Mock API key store with async create_api_key
mock_api_key_store = MagicMock()
diff --git a/enterprise/tests/unit/storage/test_device_code_store.py b/enterprise/tests/unit/storage/test_device_code_store.py
index 65a58cda8a..e2f7359264 100644
--- a/enterprise/tests/unit/storage/test_device_code_store.py
+++ b/enterprise/tests/unit/storage/test_device_code_store.py
@@ -1,33 +1,17 @@
"""Unit tests for DeviceCodeStore."""
-from unittest.mock import MagicMock
+from unittest.mock import patch
import pytest
-from sqlalchemy.exc import IntegrityError
+from sqlalchemy import select
from storage.device_code import DeviceCode
from storage.device_code_store import DeviceCodeStore
@pytest.fixture
-def mock_session():
- """Mock database session."""
- session = MagicMock()
- return session
-
-
-def mock_session_maker(mock_session):
- """Mock session maker."""
- session_maker = MagicMock()
- session_maker.return_value.__enter__.return_value = mock_session
- session_maker.return_value.__exit__.return_value = None
- return session_maker
-
-
-def device_code_store(mock_session_maker):
+def device_code_store():
"""Create DeviceCodeStore instance."""
- return DeviceCodeStore(mock_session_maker)
+ return DeviceCodeStore()
class TestDeviceCodeStore:
@@ -49,145 +33,257 @@ class TestDeviceCodeStore:
assert len(code) == 128
assert code.isalnum()
- def test_create_device_code_success(self, device_code_store, mock_session):
+ @pytest.mark.asyncio
+ async def test_create_device_code_success(
+ self, device_code_store, async_session_maker
+ ):
"""Test successful device code creation."""
- # Mock successful creation (no IntegrityError)
- mock_device_code = MagicMock(spec=DeviceCode)
- mock_device_code.device_code = 'test-device-code-123'
- mock_device_code.user_code = 'TESTCODE'
-
- # Mock the session to return our mock device code after refresh
- def mock_refresh(obj):
- obj.device_code = mock_device_code.device_code
- obj.user_code = mock_device_code.user_code
-
- mock_session.refresh.side_effect = mock_refresh
-
- result = device_code_store.create_device_code(expires_in=600)
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ result = await device_code_store.create_device_code(expires_in=600)
assert isinstance(result, DeviceCode)
- mock_session.add.assert_called_once()
- mock_session.commit.assert_called_once()
- mock_session.refresh.assert_called_once()
- mock_session.expunge.assert_called_once()
-
- def test_create_device_code_with_retries(
- self, device_code_store, mock_session_maker
+ assert len(result.device_code) == 128
+ assert len(result.user_code) == 8
+
+ # Verify the DeviceCode was created in the database
+ async with async_session_maker() as session:
+ result_db = await session.execute(
+ select(DeviceCode).filter(DeviceCode.device_code == result.device_code)
+ )
+ device_code = result_db.scalars().first()
+ assert device_code is not None
+ assert device_code.user_code == result.user_code
+
+ @pytest.mark.asyncio
+ async def test_create_device_code_with_retries(
+ self, device_code_store, async_session_maker
):
"""Test device code creation with constraint violation retries."""
- mock_session = MagicMock()
- mock_session_maker.return_value.__enter__.return_value = mock_session
- mock_session_maker.return_value.__exit__.return_value = None
+ # First create a device code to cause a collision
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ first_code = await device_code_store.create_device_code(expires_in=600)
+
+ # Patch generate methods to return the same codes on first attempt,
+ # then different codes on second attempt
+ call_count = {'user': 0, 'device': 0}
+ original_generate_user_code = device_code_store.generate_user_code
+ original_generate_device_code = device_code_store.generate_device_code
+
+ def mock_generate_user_code():
+ call_count['user'] += 1
+ if call_count['user'] == 1:
+ return first_code.user_code # Collision
+ return original_generate_user_code()
+
+ def mock_generate_device_code():
+ call_count['device'] += 1
+ if call_count['device'] == 1:
+ return first_code.device_code # Collision
+ return original_generate_device_code()
+
+ device_code_store.generate_user_code = mock_generate_user_code
+ device_code_store.generate_device_code = mock_generate_device_code
+
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ result = await device_code_store.create_device_code(expires_in=600)
- # First attempt fails with IntegrityError, second succeeds
- mock_session.commit.side_effect = [IntegrityError('', '', ''), None]
+ assert isinstance(result, DeviceCode)
+ assert result.device_code != first_code.device_code # Should be different
+ assert call_count['user'] == 2 # Two attempts
- mock_device_code = MagicMock(spec=DeviceCode)
- mock_device_code.device_code = 'test-device-code-456'
- mock_device_code.user_code = 'TESTCD2'
+ @pytest.mark.asyncio
+ async def test_create_device_code_max_attempts_exceeded(
+ self, device_code_store, async_session_maker
+ ):
+ """Test device code creation failure after max attempts."""
+ # First create a device code
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ first_code = await device_code_store.create_device_code(expires_in=600)
+
+ # Always return the same codes to cause repeated collisions
+ device_code_store.generate_user_code = lambda: first_code.user_code
+ device_code_store.generate_device_code = lambda: first_code.device_code
+
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ with pytest.raises(
+ RuntimeError,
+ match='Failed to generate unique device codes after 3 attempts',
+ ):
+ await device_code_store.create_device_code(
+ expires_in=600, max_attempts=3
+ )
+
+ @pytest.mark.asyncio
+ async def test_get_by_device_code(self, device_code_store, async_session_maker):
+ """Test getting device code by device code."""
+ # Create a device code first
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ created = await device_code_store.create_device_code(expires_in=600)
+ result = await device_code_store.get_by_device_code(created.device_code)
+
+ assert result is not None
+ assert result.device_code == created.device_code
+ assert result.user_code == created.user_code
+
+ @pytest.mark.asyncio
+ async def test_get_by_device_code_not_found(
+ self, device_code_store, async_session_maker
+ ):
+ """Test getting non-existent device code."""
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ result = await device_code_store.get_by_device_code('non-existent-code')
+
+ assert result is None
+
+ @pytest.mark.asyncio
+ async def test_get_by_user_code(self, device_code_store, async_session_maker):
+ """Test getting device code by user code."""
+ # Create a device code first
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ created = await device_code_store.create_device_code(expires_in=600)
+ result = await device_code_store.get_by_user_code(created.user_code)
+
+ assert result is not None
+ assert result.device_code == created.device_code
+ assert result.user_code == created.user_code
+
+ @pytest.mark.asyncio
+ async def test_get_by_user_code_not_found(
+ self, device_code_store, async_session_maker
+ ):
+ """Test getting non-existent user code."""
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ result = await device_code_store.get_by_user_code('NOTFOUND')
- def mock_refresh(obj):
- obj.device_code = mock_device_code.device_code
- obj.user_code = mock_device_code.user_code
+ assert result is None
- mock_session.refresh.side_effect = mock_refresh
+ @pytest.mark.asyncio
+ async def test_authorize_device_code_success(
+ self, device_code_store, async_session_maker
+ ):
+ """Test successful device code authorization."""
+ user_id = 'test-user-123'
- store = DeviceCodeStore(mock_session_maker)
- result = store.create_device_code(expires_in=600)
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ created = await device_code_store.create_device_code(expires_in=600)
+ result = await device_code_store.authorize_device_code(
+ created.user_code, user_id
+ )
- assert isinstance(result, DeviceCode)
- assert mock_session.add.call_count == 2 # Two attempts
- assert mock_session.commit.call_count == 2 # Two attempts
+ assert result is True
- def test_create_device_code_max_attempts_exceeded(
- self, device_code_store, mock_session_maker
- ):
- """Test device code creation failure after max attempts."""
- mock_session = MagicMock()
- mock_session_maker.return_value.__enter__.return_value = mock_session
- mock_session_maker.return_value.__exit__.return_value = None
-
- # All attempts fail with IntegrityError
- mock_session.commit.side_effect = IntegrityError('', '', '')
-
- store = DeviceCodeStore(mock_session_maker)
-
- with pytest.raises(
- RuntimeError,
- match='Failed to generate unique device codes after 3 attempts',
- ):
- store.create_device_code(expires_in=600, max_attempts=3)
-
- @pytest.mark.parametrize(
- 'lookup_method,lookup_field',
- [
- ('get_by_device_code', 'device_code'),
- ('get_by_user_code', 'user_code'),
- ],
- )
- def test_lookup_methods(
- self, device_code_store, mock_session, lookup_method, lookup_field
+ # Verify the device code was authorized in the database
+ async with async_session_maker() as session:
+ result_db = await session.execute(
+ select(DeviceCode).filter(DeviceCode.user_code == created.user_code)
+ )
+ device_code = result_db.scalars().first()
+ assert device_code.status == 'authorized'
+ assert device_code.keycloak_user_id == user_id
+
+ @pytest.mark.asyncio
+ async def test_authorize_device_code_not_found(
+ self, device_code_store, async_session_maker
):
- """Test device code lookup methods."""
- test_code = 'test-code-123'
- mock_device_code = MagicMock()
- mock_session.query.return_value.filter_by.return_value.first.return_value = (
- mock_device_code
- )
-
- result = getattr(device_code_store, lookup_method)(test_code)
-
- assert result == mock_device_code
- mock_session.query.assert_called_once_with(DeviceCode)
- mock_session.query.return_value.filter_by.assert_called_once_with(
- **{lookup_field: test_code}
- )
-
- @pytest.mark.parametrize(
- 'device_exists,is_pending,expected_result',
- [
- (True, True, True), # Success case
- (False, True, False), # Device not found
- (True, False, False), # Device not pending
- ],
- )
- def test_authorize_device_code(
- self,
- device_code_store,
- mock_session,
- device_exists,
- is_pending,
- expected_result,
+ """Test authorizing non-existent device code."""
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ result = await device_code_store.authorize_device_code(
+ 'NOTFOUND', 'user-123'
+ )
+
+ assert result is False
+
+ @pytest.mark.asyncio
+ async def test_authorize_device_code_not_pending(
+ self, device_code_store, async_session_maker
):
- """Test device code authorization."""
- user_code = 'ABC12345'
+ """Test authorizing already authorized device code."""
user_id = 'test-user-123'
- if device_exists:
- mock_device = MagicMock()
- mock_device.is_pending.return_value = is_pending
- mock_session.query.return_value.filter_by.return_value.first.return_value = mock_device
- else:
- mock_session.query.return_value.filter_by.return_value.first.return_value = None
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ created = await device_code_store.create_device_code(expires_in=600)
+ # First authorization
+ await device_code_store.authorize_device_code(created.user_code, user_id)
+ # Second authorization should fail
+ result = await device_code_store.authorize_device_code(
+ created.user_code, 'another-user'
+ )
- result = device_code_store.authorize_device_code(user_code, user_id)
+ assert result is False
- assert result == expected_result
- if expected_result:
- mock_device.authorize.assert_called_once_with(user_id)
- mock_session.commit.assert_called_once()
+ @pytest.mark.asyncio
+ async def test_deny_device_code_success(
+ self, device_code_store, async_session_maker
+ ):
+ """Test successful device code denial."""
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ created = await device_code_store.create_device_code(expires_in=600)
+ result = await device_code_store.deny_device_code(created.user_code)
- def test_deny_device_code(self, device_code_store, mock_session):
- """Test device code denial."""
- user_code = 'ABC12345'
- mock_device = MagicMock()
- mock_device.is_pending.return_value = True
- mock_session.query.return_value.filter_by.return_value.first.return_value = (
- mock_device
- )
+ assert result is True
- result = device_code_store.deny_device_code(user_code)
+ # Verify the device code was denied in the database
+ async with async_session_maker() as session:
+ result_db = await session.execute(
+ select(DeviceCode).filter(DeviceCode.user_code == created.user_code)
+ )
+ device_code = result_db.scalars().first()
+ assert device_code.status == 'denied'
+
+ @pytest.mark.asyncio
+ async def test_deny_device_code_not_found(
+ self, device_code_store, async_session_maker
+ ):
+ """Test denying non-existent device code."""
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ result = await device_code_store.deny_device_code('NOTFOUND')
+
+ assert result is False
+
+ @pytest.mark.asyncio
+ async def test_deny_device_code_not_pending(
+ self, device_code_store, async_session_maker
+ ):
+ """Test denying already denied device code."""
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ created = await device_code_store.create_device_code(expires_in=600)
+ # First denial
+ await device_code_store.deny_device_code(created.user_code)
+ # Second denial should fail
+ result = await device_code_store.deny_device_code(created.user_code)
+
+ assert result is False
+
+ @pytest.mark.asyncio
+ async def test_update_poll_time_success(
+ self, device_code_store, async_session_maker
+ ):
+ """Test updating poll time."""
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ created = await device_code_store.create_device_code(expires_in=600)
+ original_interval = created.current_interval
+ result = await device_code_store.update_poll_time(
+ created.device_code, increase_interval=True
+ )
assert result is True
- mock_device.deny.assert_called_once()
- mock_session.commit.assert_called_once()
+
+ # Verify the poll time was updated
+ async with async_session_maker() as session:
+ result_db = await session.execute(
+ select(DeviceCode).filter(DeviceCode.device_code == created.device_code)
+ )
+ device_code = result_db.scalars().first()
+ assert device_code.current_interval > original_interval
+
+ @pytest.mark.asyncio
+ async def test_update_poll_time_not_found(
+ self, device_code_store, async_session_maker
+ ):
+ """Test updating poll time for non-existent device code."""
+ with patch('storage.device_code_store.a_session_maker', async_session_maker):
+ result = await device_code_store.update_poll_time(
+ 'non-existent-code', increase_interval=False
+ )
+
+ assert result is False