π 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.pyindex 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, statusfrom fastapi.responses import JSONResponsefrom pydantic import BaseModelfrom storage.api_key_store import ApiKeyStore-from storage.database import session_makerfrom storage.device_code_store import DeviceCodeStorefrom 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 keytry:- 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.pyindex 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_atdef 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 fastif time_since_last_poll < self.current_interval:diff --git a/enterprise/storage/device_code_store.py b/enterprise/storage/device_code_store.pyindex 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 secretsimport stringfrom datetime import datetime, timedelta, timezone+from sqlalchemy import selectfrom sqlalchemy.exc import IntegrityError+from storage.database import a_session_makerfrom storage.device_code import DeviceCodeclass 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.digitsreturn ''.join(secrets.choice(alphabet) for _ in range(128))- def create_device_code(+ async def create_device_code(self,expires_in: int = 600, # 10 minutes defaultmax_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_entryexcept 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 Falsedevice_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 Falsedevice_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 Falsedevice_code_entry.update_poll_time(increase_interval)- session.commit()+ await session.commit()return Truediff --git a/enterprise/tests/unit/server/routes/test_oauth_device.py b/enterprise/tests/unit/server/routes/test_oauth_device.pyindex 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.fixturedef 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 intervalmock_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 intervalmock_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 methodmock_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 codemock_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_keymock_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_device1elif user_code == device2_code:return mock_device2return 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 deviceresult1 = await device_verification_authenticated(@@ -307,8 +316,8 @@ class TestDeviceTokenRateLimiting:last_poll_time=None, # First pollcurrent_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 codemock_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_keymock_api_key_store = MagicMock()@@ -521,9 +532,11 @@ class TestDeviceVerificationTransactionIntegrity:# Mock device codemock_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 codemock_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 codemock_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_keymock_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.pyindex 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 patchimport pytest-from sqlalchemy.exc import IntegrityError+from sqlalchemy import selectfrom storage.device_code import DeviceCodefrom 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) == 128assert 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