copilot-swe-agent[bot]
7fe25474bb
E) Wizard DB persistence + worker sync
- app/api/dropbox.py: save-settings persists to DB (primary); .env write
is now best-effort (no 500 on missing file); notify_settings_updated()
called; update-settings already done in previous commit
- app/api/google_drive.py: update-settings + save-settings both persist
to DB and call notify_settings_updated(); .env write remains best-effort
- app/api/onedrive.py: save-settings + update-settings persist to DB +
notify; test-token auto-refresh path persists rotated token via
SessionLocal + notifies; .env write is best-effort throughout
- app/views/wizard.py: setup-wizard POST calls notify_settings_updated()
when settings are saved; GET pre-fills fields from DB > ENV > default
with a source badge; new GET /setup/undo-skip route removes skip marker
F) ENV Exporter
- app/utils/settings_service.py: get_settings_for_export(db, source)
supports source=db (DB-only) and source=effective (full runtime config)
- app/api/settings.py: GET /api/settings/export-env admin-only endpoint
returns downloadable .env file; source= query param selects scope
- frontend/templates/settings.html: Export .env dropdown (DB / effective)
+ Setup Wizard button added alongside existing Audit Log button
G) Setup Wizard improvements
- frontend/templates/setup_wizard.html: inputs pre-filled with
current_value; DB/ENV/DEFAULT source badges; undo-skip messaging
- app/views/wizard.py: passes setup_skipped flag to template
Tests
- tests/test_wizard_db_persist.py: 28 tests across 7 classes covering
wizard DB persistence, undo-skip, ENV exporter service + endpoint
- tests/test_api_dropbox.py: updated two tests to match new best-effort
.env behavior (was: assert 500; now: assert 200)
- tests/test_api_onedrive_comprehensive.py: same for two OneDrive tests;
fixed settings singleton pollution by adding @patch("app.api.*.settings")
to all new wizard tests that call save/update endpoints
Co-authored-by: christianlouis <361235+christianlouis@users.noreply.github.com>
730 lines
26 KiB
Python
730 lines
26 KiB
Python
"""
|
|
Comprehensive unit tests for app/api/onedrive.py
|
|
|
|
Tests all API endpoints with success and error cases, proper mocking, and edge cases.
|
|
Target: Bring coverage from 10.51% to 70%+
|
|
"""
|
|
|
|
from datetime import timedelta
|
|
from unittest.mock import Mock, mock_open, patch
|
|
|
|
import pytest
|
|
from fastapi import HTTPException
|
|
from fastapi.testclient import TestClient
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestExchangeOneDriveToken:
|
|
"""Tests for POST /onedrive/exchange-token endpoint."""
|
|
|
|
@patch("app.api.onedrive.exchange_oauth_token")
|
|
def test_exchange_token_success(self, mock_exchange, client: TestClient):
|
|
"""Test successful token exchange."""
|
|
mock_exchange.return_value = {
|
|
"refresh_token": "test_refresh_token",
|
|
"access_token": "test_access_token",
|
|
"expires_in": 3600,
|
|
}
|
|
|
|
response = client.post(
|
|
"/api/onedrive/exchange-token",
|
|
data={
|
|
"client_id": "test_client_id",
|
|
"client_secret": "test_client_secret",
|
|
"redirect_uri": "http://localhost/callback",
|
|
"code": "test_auth_code",
|
|
"tenant_id": "common",
|
|
},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert "refresh_token" in data
|
|
assert data["refresh_token"] == "test_refresh_token"
|
|
assert data["expires_in"] == 3600
|
|
assert mock_exchange.called
|
|
|
|
@patch("app.api.onedrive.exchange_oauth_token")
|
|
def test_exchange_token_with_tenant_id(self, mock_exchange, client: TestClient):
|
|
"""Test token exchange with specific tenant ID."""
|
|
mock_exchange.return_value = {
|
|
"refresh_token": "test_refresh_token",
|
|
"access_token": "test_access_token",
|
|
"expires_in": 3600,
|
|
}
|
|
|
|
response = client.post(
|
|
"/api/onedrive/exchange-token",
|
|
data={
|
|
"client_id": "test_client_id",
|
|
"client_secret": "test_client_secret",
|
|
"redirect_uri": "http://localhost/callback",
|
|
"code": "test_auth_code",
|
|
"tenant_id": "specific-tenant-id",
|
|
},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
# Verify the token URL uses the correct tenant
|
|
call_args = mock_exchange.call_args
|
|
assert "specific-tenant-id" in call_args[1]["token_url"]
|
|
|
|
@patch("app.api.onedrive.exchange_oauth_token")
|
|
def test_exchange_token_error(self, mock_exchange, client: TestClient):
|
|
"""Test token exchange with error from OAuth provider."""
|
|
mock_exchange.side_effect = HTTPException(
|
|
status_code=400, detail="Invalid authorization code"
|
|
)
|
|
|
|
response = client.post(
|
|
"/api/onedrive/exchange-token",
|
|
data={
|
|
"client_id": "test_client_id",
|
|
"client_secret": "test_client_secret",
|
|
"redirect_uri": "http://localhost/callback",
|
|
"code": "invalid_code",
|
|
"tenant_id": "common",
|
|
},
|
|
)
|
|
|
|
assert response.status_code == 400
|
|
|
|
def test_exchange_token_missing_required_fields(self, client: TestClient):
|
|
"""Test token exchange without required fields."""
|
|
response = client.post(
|
|
"/api/onedrive/exchange-token",
|
|
data={
|
|
"client_id": "test_client_id"
|
|
# Missing other required fields
|
|
},
|
|
)
|
|
|
|
assert response.status_code == 422 # Validation error
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestTestOneDriveToken:
|
|
"""Tests for GET /onedrive/test-token endpoint."""
|
|
|
|
@patch("requests.post")
|
|
@patch("requests.get")
|
|
@patch("app.config.settings")
|
|
def test_test_token_success(
|
|
self, mock_settings, mock_get, mock_post, client: TestClient
|
|
):
|
|
"""Test successful token validation with properly mocked responses."""
|
|
# Configure settings with property mocking
|
|
type(mock_settings).onedrive_refresh_token = "test_refresh_token"
|
|
type(mock_settings).onedrive_client_id = "test_client_id"
|
|
type(mock_settings).onedrive_client_secret = "test_client_secret"
|
|
type(mock_settings).onedrive_tenant_id = "common"
|
|
type(mock_settings).http_request_timeout = 30
|
|
|
|
# Mock token refresh response
|
|
mock_post_response = Mock()
|
|
mock_post_response.status_code = 200
|
|
mock_post_response.json.return_value = {
|
|
"access_token": "test_access_token",
|
|
"expires_in": 3600,
|
|
}
|
|
mock_post.return_value = mock_post_response
|
|
|
|
# Mock user info response
|
|
mock_get_response = Mock()
|
|
mock_get_response.status_code = 200
|
|
mock_get_response.json.return_value = {
|
|
"displayName": "Test User",
|
|
"userPrincipalName": "test@example.com",
|
|
}
|
|
mock_get.return_value = mock_get_response
|
|
|
|
response = client.get("/api/onedrive/test-token")
|
|
|
|
# Accept both success and error due to complex mock interactions
|
|
# The important part is testing the endpoint doesn't crash
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert "status" in data
|
|
|
|
@patch("app.config.settings")
|
|
def test_test_token_not_configured(self, mock_settings, client: TestClient):
|
|
"""Test when OneDrive credentials are not configured."""
|
|
mock_settings.onedrive_refresh_token = None
|
|
mock_settings.onedrive_client_id = None
|
|
mock_settings.onedrive_client_secret = None
|
|
|
|
response = client.get("/api/onedrive/test-token")
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["status"] == "error"
|
|
assert "not fully configured" in data["message"].lower()
|
|
|
|
@patch("requests.post")
|
|
@patch("app.config.settings")
|
|
def test_test_token_refresh_failed(
|
|
self, mock_settings, mock_post, client: TestClient
|
|
):
|
|
"""Test when token refresh fails."""
|
|
type(mock_settings).onedrive_refresh_token = "invalid_token"
|
|
type(mock_settings).onedrive_client_id = "test_client_id"
|
|
type(mock_settings).onedrive_client_secret = "test_client_secret"
|
|
type(mock_settings).onedrive_tenant_id = "common"
|
|
type(mock_settings).http_request_timeout = 30
|
|
|
|
# Mock failed refresh
|
|
mock_post_response = Mock()
|
|
mock_post_response.status_code = 400
|
|
mock_post_response.text = "Invalid refresh token"
|
|
mock_post.return_value = mock_post_response
|
|
|
|
response = client.get("/api/onedrive/test-token")
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["status"] == "error"
|
|
# May or may not have needs_reauth depending on mock behavior
|
|
# assert data.get("needs_reauth") is True
|
|
|
|
@patch("requests.post")
|
|
@patch("requests.get")
|
|
@patch("app.config.settings")
|
|
def test_test_token_new_refresh_token_issued(
|
|
self, mock_settings, mock_get, mock_post, client: TestClient
|
|
):
|
|
"""Test when Microsoft issues a new refresh token."""
|
|
type(mock_settings).onedrive_refresh_token = "old_refresh_token"
|
|
type(mock_settings).onedrive_client_id = "test_client_id"
|
|
type(mock_settings).onedrive_client_secret = "test_client_secret"
|
|
type(mock_settings).onedrive_tenant_id = "common"
|
|
type(mock_settings).http_request_timeout = 30
|
|
|
|
# Mock token refresh with new refresh token
|
|
mock_post_response = Mock()
|
|
mock_post_response.status_code = 200
|
|
mock_post_response.json.return_value = {
|
|
"access_token": "test_access_token",
|
|
"refresh_token": "new_refresh_token", # New token
|
|
"expires_in": 3600,
|
|
}
|
|
mock_post.return_value = mock_post_response
|
|
|
|
# Mock user info
|
|
mock_get_response = Mock()
|
|
mock_get_response.status_code = 200
|
|
mock_get_response.json.return_value = {
|
|
"displayName": "Test User",
|
|
"userPrincipalName": "test@example.com",
|
|
}
|
|
mock_get.return_value = mock_get_response
|
|
|
|
with patch("os.path.exists", return_value=False):
|
|
response = client.get("/api/onedrive/test-token")
|
|
|
|
assert response.status_code == 200
|
|
# Just verify request completed, token updates are hard to test with mocks
|
|
|
|
@patch("requests.post")
|
|
@patch("requests.get")
|
|
@patch(
|
|
"builtins.open",
|
|
new_callable=mock_open,
|
|
read_data="ONEDRIVE_REFRESH_TOKEN=old_token\n",
|
|
)
|
|
@patch("os.path.exists")
|
|
@patch("os.path.dirname")
|
|
@patch("app.config.settings")
|
|
def test_test_token_updates_env_file(
|
|
self,
|
|
mock_settings,
|
|
mock_dirname,
|
|
mock_exists,
|
|
mock_file,
|
|
mock_get,
|
|
mock_post,
|
|
client: TestClient,
|
|
):
|
|
"""Test that new refresh token is saved to .env file."""
|
|
mock_settings.onedrive_refresh_token = "old_token"
|
|
mock_settings.onedrive_client_id = "test_client_id"
|
|
mock_settings.onedrive_client_secret = "test_client_secret"
|
|
mock_settings.onedrive_tenant_id = "common"
|
|
mock_settings.http_request_timeout = 30
|
|
mock_exists.return_value = True
|
|
mock_dirname.return_value = "/app"
|
|
|
|
# Mock token refresh with new token
|
|
mock_post_response = Mock()
|
|
mock_post_response.status_code = 200
|
|
mock_post_response.json.return_value = {
|
|
"access_token": "test_access_token",
|
|
"refresh_token": "new_token",
|
|
"expires_in": 3600,
|
|
}
|
|
mock_post.return_value = mock_post_response
|
|
|
|
# Mock user info
|
|
mock_get_response = Mock()
|
|
mock_get_response.status_code = 200
|
|
mock_get_response.json.return_value = {
|
|
"displayName": "Test User",
|
|
"userPrincipalName": "test@example.com",
|
|
}
|
|
mock_get.return_value = mock_get_response
|
|
|
|
response = client.get("/api/onedrive/test-token")
|
|
assert response.status_code == 200
|
|
|
|
@patch("requests.post")
|
|
@patch("requests.get")
|
|
@patch("app.config.settings")
|
|
def test_test_token_user_info_failed(
|
|
self, mock_settings, mock_get, mock_post, client: TestClient
|
|
):
|
|
"""Test when user info request fails."""
|
|
mock_settings.onedrive_refresh_token = "test_token"
|
|
mock_settings.onedrive_client_id = "test_client_id"
|
|
mock_settings.onedrive_client_secret = "test_client_secret"
|
|
mock_settings.onedrive_tenant_id = "common"
|
|
mock_settings.http_request_timeout = 30
|
|
|
|
# Mock successful refresh
|
|
mock_post_response = Mock()
|
|
mock_post_response.status_code = 200
|
|
mock_post_response.json.return_value = {
|
|
"access_token": "test_access_token",
|
|
"expires_in": 3600,
|
|
}
|
|
mock_post.return_value = mock_post_response
|
|
|
|
# Mock failed user info
|
|
mock_get_response = Mock()
|
|
mock_get_response.status_code = 401
|
|
mock_get_response.text = "Unauthorized"
|
|
mock_get.return_value = mock_get_response
|
|
|
|
response = client.get("/api/onedrive/test-token")
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["status"] == "error"
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestFormatTimeRemaining:
|
|
"""Tests for format_time_remaining helper function."""
|
|
|
|
def test_format_expired_time(self):
|
|
"""Test formatting of expired time."""
|
|
from app.api.onedrive import format_time_remaining
|
|
|
|
expired = timedelta(seconds=-100)
|
|
result = format_time_remaining(expired)
|
|
assert result == "Expired"
|
|
|
|
def test_format_days_and_hours(self):
|
|
"""Test formatting with days and hours."""
|
|
from app.api.onedrive import format_time_remaining
|
|
|
|
time_left = timedelta(days=2, hours=5, minutes=30)
|
|
result = format_time_remaining(time_left)
|
|
assert "2 days" in result
|
|
assert "5 hours" in result
|
|
|
|
def test_format_hours_only(self):
|
|
"""Test formatting with hours only."""
|
|
from app.api.onedrive import format_time_remaining
|
|
|
|
time_left = timedelta(hours=5)
|
|
result = format_time_remaining(time_left)
|
|
assert "5 hours" in result
|
|
|
|
def test_format_minutes_only(self):
|
|
"""Test formatting with minutes only."""
|
|
from app.api.onedrive import format_time_remaining
|
|
|
|
time_left = timedelta(minutes=45)
|
|
result = format_time_remaining(time_left)
|
|
assert "45 minutes" in result
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestSaveOneDriveSettings:
|
|
"""Tests for POST /onedrive/save-settings endpoint."""
|
|
|
|
@patch("builtins.open", new_callable=mock_open, read_data="# Existing config\n")
|
|
@patch("os.path.exists")
|
|
@patch("os.path.dirname")
|
|
@patch("app.config.settings")
|
|
def test_save_settings_success(
|
|
self, mock_settings, mock_dirname, mock_exists, mock_file, client: TestClient
|
|
):
|
|
"""Test successful save to .env file."""
|
|
mock_exists.return_value = True
|
|
mock_dirname.return_value = "/app"
|
|
|
|
response = client.post(
|
|
"/api/onedrive/save-settings",
|
|
data={
|
|
"refresh_token": "new_refresh_token",
|
|
"client_id": "new_client_id",
|
|
"client_secret": "new_client_secret",
|
|
"tenant_id": "common",
|
|
"folder_path": "/Documents",
|
|
},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["status"] == "success"
|
|
|
|
@patch("os.path.exists")
|
|
@patch("os.path.dirname")
|
|
def test_save_settings_env_file_not_found(
|
|
self, mock_dirname, mock_exists, client: TestClient
|
|
):
|
|
"""Test that missing .env file is non-fatal — DB write still succeeds."""
|
|
mock_exists.return_value = False
|
|
mock_dirname.return_value = "/app"
|
|
|
|
response = client.post(
|
|
"/api/onedrive/save-settings",
|
|
data={"refresh_token": "token", "tenant_id": "common"},
|
|
)
|
|
|
|
# .env write is best-effort; endpoint should still succeed via DB write
|
|
assert response.status_code == 200
|
|
assert response.json()["status"] == "success"
|
|
|
|
@patch(
|
|
"builtins.open",
|
|
new_callable=mock_open,
|
|
read_data="ONEDRIVE_REFRESH_TOKEN=old_token\n",
|
|
)
|
|
@patch("os.path.exists")
|
|
@patch("os.path.dirname")
|
|
@patch("app.config.settings")
|
|
def test_save_settings_updates_existing_lines(
|
|
self, mock_settings, mock_dirname, mock_exists, mock_file, client: TestClient
|
|
):
|
|
"""Test that existing settings are updated."""
|
|
mock_exists.return_value = True
|
|
mock_dirname.return_value = "/app"
|
|
|
|
response = client.post(
|
|
"/api/onedrive/save-settings",
|
|
data={"refresh_token": "updated_token", "tenant_id": "common"},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
|
|
@patch(
|
|
"builtins.open",
|
|
new_callable=mock_open,
|
|
read_data="# ONEDRIVE_CLIENT_ID=commented\n",
|
|
)
|
|
@patch("os.path.exists")
|
|
@patch("os.path.dirname")
|
|
@patch("app.config.settings")
|
|
def test_save_settings_uncomments_lines(
|
|
self, mock_settings, mock_dirname, mock_exists, mock_file, client: TestClient
|
|
):
|
|
"""Test that commented settings are uncommented."""
|
|
mock_exists.return_value = True
|
|
mock_dirname.return_value = "/app"
|
|
|
|
response = client.post(
|
|
"/api/onedrive/save-settings",
|
|
data={
|
|
"refresh_token": "token",
|
|
"client_id": "new_client_id",
|
|
"tenant_id": "common",
|
|
},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
|
|
@patch("builtins.open", new_callable=mock_open, read_data="OTHER_SETTING=value\n")
|
|
@patch("os.path.exists")
|
|
@patch("os.path.dirname")
|
|
@patch("app.config.settings")
|
|
def test_save_settings_adds_new_lines(
|
|
self, mock_settings, mock_dirname, mock_exists, mock_file, client: TestClient
|
|
):
|
|
"""Test that new settings are added if not present."""
|
|
mock_exists.return_value = True
|
|
mock_dirname.return_value = "/app"
|
|
|
|
response = client.post(
|
|
"/api/onedrive/save-settings",
|
|
data={
|
|
"refresh_token": "new_token",
|
|
"folder_path": "/New/Path",
|
|
"tenant_id": "common",
|
|
},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
|
|
def test_save_settings_missing_required_field(self, client: TestClient):
|
|
"""Test save without required refresh_token."""
|
|
response = client.post(
|
|
"/api/onedrive/save-settings", data={"tenant_id": "common"}
|
|
)
|
|
|
|
assert response.status_code == 422 # Validation error
|
|
|
|
@patch("os.path.exists")
|
|
@patch("os.path.dirname")
|
|
def test_save_settings_exception_handling(
|
|
self, mock_dirname, mock_exists, client: TestClient
|
|
):
|
|
"""Test that exceptions in .env write are non-fatal — DB write still succeeds."""
|
|
mock_exists.side_effect = Exception("Unexpected error")
|
|
|
|
response = client.post(
|
|
"/api/onedrive/save-settings",
|
|
data={"refresh_token": "token", "tenant_id": "common"},
|
|
)
|
|
|
|
# .env write exception is caught; endpoint succeeds via DB write
|
|
assert response.status_code == 200
|
|
assert response.json()["status"] == "success"
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestUpdateOneDriveSettings:
|
|
"""Tests for POST /onedrive/update-settings endpoint."""
|
|
|
|
@patch("app.tasks.upload_to_onedrive.get_onedrive_token")
|
|
@patch("app.config.settings")
|
|
def test_update_settings_success(
|
|
self, mock_settings, mock_get_token, client: TestClient
|
|
):
|
|
"""Test successful settings update in memory."""
|
|
mock_get_token.return_value = "test_token"
|
|
|
|
response = client.post(
|
|
"/api/onedrive/update-settings",
|
|
data={
|
|
"refresh_token": "new_refresh_token",
|
|
"client_id": "new_client_id",
|
|
"client_secret": "new_client_secret",
|
|
"tenant_id": "common",
|
|
"folder_path": "/Documents",
|
|
},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["status"] == "success"
|
|
|
|
@patch("app.tasks.upload_to_onedrive.get_onedrive_token")
|
|
@patch("app.config.settings")
|
|
def test_update_settings_minimal(
|
|
self, mock_settings, mock_get_token, client: TestClient
|
|
):
|
|
"""Test update with only required fields."""
|
|
mock_get_token.return_value = "test_token"
|
|
|
|
response = client.post(
|
|
"/api/onedrive/update-settings",
|
|
data={"refresh_token": "new_token", "tenant_id": "common"},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
|
|
@patch("app.tasks.upload_to_onedrive.get_onedrive_token")
|
|
@patch("app.config.settings")
|
|
def test_update_settings_token_test_fails(
|
|
self, mock_settings, mock_get_token, client: TestClient
|
|
):
|
|
"""Test update when token test fails."""
|
|
mock_get_token.side_effect = Exception("Token invalid")
|
|
|
|
response = client.post(
|
|
"/api/onedrive/update-settings",
|
|
data={"refresh_token": "bad_token", "tenant_id": "common"},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["status"] == "warning"
|
|
assert "token test failed" in data["message"].lower()
|
|
|
|
def test_update_settings_missing_required_field(self, client: TestClient):
|
|
"""Test update without required refresh_token."""
|
|
response = client.post(
|
|
"/api/onedrive/update-settings", data={"tenant_id": "common"}
|
|
)
|
|
|
|
assert response.status_code == 422
|
|
|
|
@patch("app.config.settings")
|
|
def test_update_settings_exception_handling(
|
|
self, mock_settings, client: TestClient
|
|
):
|
|
"""Test exception handling in update settings."""
|
|
mock_settings.onedrive_refresh_token = None
|
|
|
|
with patch(
|
|
"app.tasks.upload_to_onedrive.get_onedrive_token",
|
|
side_effect=Exception("Fatal error"),
|
|
):
|
|
response = client.post(
|
|
"/api/onedrive/update-settings",
|
|
data={"refresh_token": "token", "tenant_id": "common"},
|
|
)
|
|
|
|
# Should still update settings even if test fails
|
|
assert response.status_code == 200
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestGetOneDriveFullConfig:
|
|
"""Tests for GET /onedrive/get-full-config endpoint."""
|
|
|
|
@patch("app.config.settings")
|
|
def test_get_full_config_success(self, mock_settings, client: TestClient):
|
|
"""Test successful config retrieval."""
|
|
type(mock_settings).onedrive_client_id = "test_client_id"
|
|
type(mock_settings).onedrive_client_secret = "test_client_secret"
|
|
type(mock_settings).onedrive_tenant_id = "test_tenant"
|
|
type(mock_settings).onedrive_refresh_token = "test_token"
|
|
type(mock_settings).onedrive_folder_path = "/Documents/Upload"
|
|
|
|
response = client.get("/api/onedrive/get-full-config")
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["status"] == "success"
|
|
assert "config" in data
|
|
assert "env_format" in data
|
|
# Config values may vary due to settings mock behavior
|
|
|
|
@patch("app.config.settings")
|
|
def test_get_full_config_with_defaults(self, mock_settings, client: TestClient):
|
|
"""Test config retrieval with default values."""
|
|
type(mock_settings).onedrive_client_id = None
|
|
type(mock_settings).onedrive_client_secret = None
|
|
type(mock_settings).onedrive_tenant_id = None
|
|
type(mock_settings).onedrive_refresh_token = None
|
|
type(mock_settings).onedrive_folder_path = None
|
|
|
|
response = client.get("/api/onedrive/get-full-config")
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
# Just verify it returns data, defaults may vary
|
|
assert "status" in data
|
|
|
|
@patch("app.config.settings")
|
|
def test_get_full_config_exception_handling(
|
|
self, mock_settings, client: TestClient
|
|
):
|
|
"""Test exception handling in get full config."""
|
|
# Even with exception, endpoint catches it
|
|
response = client.get("/api/onedrive/get-full-config")
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
# May return success or error depending on settings access
|
|
assert "status" in data
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestOneDriveIntegration:
|
|
"""Integration tests for OneDrive endpoints."""
|
|
|
|
@patch("app.config.settings")
|
|
def test_full_oauth_flow(self, mock_settings, client: TestClient):
|
|
"""Test complete OAuth flow: exchange token, update settings, test token."""
|
|
# Step 1: Exchange token
|
|
with patch("app.api.onedrive.exchange_oauth_token") as mock_exchange:
|
|
mock_exchange.return_value = {
|
|
"refresh_token": "new_refresh_token",
|
|
"access_token": "new_access_token",
|
|
"expires_in": 3600,
|
|
}
|
|
|
|
response = client.post(
|
|
"/api/onedrive/exchange-token",
|
|
data={
|
|
"client_id": "test_client_id",
|
|
"client_secret": "test_client_secret",
|
|
"redirect_uri": "http://localhost/callback",
|
|
"code": "auth_code",
|
|
"tenant_id": "common",
|
|
},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
token_data = response.json()
|
|
|
|
# Step 2: Update settings
|
|
with patch("app.tasks.upload_to_onedrive.get_onedrive_token"):
|
|
response = client.post(
|
|
"/api/onedrive/update-settings",
|
|
data={
|
|
"refresh_token": token_data["refresh_token"],
|
|
"tenant_id": "common",
|
|
},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
|
|
@patch("requests.post")
|
|
@patch("requests.get")
|
|
@patch("app.config.settings")
|
|
def test_token_refresh_rotation(
|
|
self, mock_settings, mock_get, mock_post, client: TestClient
|
|
):
|
|
"""Test token refresh with automatic rotation."""
|
|
type(mock_settings).onedrive_refresh_token = "old_token"
|
|
type(mock_settings).onedrive_client_id = "test_client_id"
|
|
type(mock_settings).onedrive_client_secret = "test_client_secret"
|
|
type(mock_settings).onedrive_tenant_id = "common"
|
|
type(mock_settings).http_request_timeout = 30
|
|
|
|
# First call returns new refresh token
|
|
mock_post_response = Mock()
|
|
mock_post_response.status_code = 200
|
|
mock_post_response.json.return_value = {
|
|
"access_token": "access1",
|
|
"refresh_token": "new_token",
|
|
"expires_in": 3600,
|
|
}
|
|
mock_post.return_value = mock_post_response
|
|
|
|
mock_get_response = Mock()
|
|
mock_get_response.status_code = 200
|
|
mock_get_response.json.return_value = {
|
|
"displayName": "Test User",
|
|
"userPrincipalName": "test@example.com",
|
|
}
|
|
mock_get.return_value = mock_get_response
|
|
|
|
with patch("os.path.exists", return_value=False):
|
|
response = client.get("/api/onedrive/test-token")
|
|
|
|
assert response.status_code == 200
|
|
# Token rotation tested, exact behavior depends on settings mock
|
|
|
|
@patch("app.config.settings")
|
|
def test_config_export_and_import(self, mock_settings, client: TestClient):
|
|
"""Test exporting and importing configuration."""
|
|
# Set up configuration
|
|
type(mock_settings).onedrive_client_id = "test_client_id"
|
|
type(mock_settings).onedrive_client_secret = "test_secret"
|
|
type(mock_settings).onedrive_tenant_id = "test_tenant"
|
|
type(mock_settings).onedrive_refresh_token = "test_token"
|
|
type(mock_settings).onedrive_folder_path = "/Test"
|
|
|
|
# Export config
|
|
response = client.get("/api/onedrive/get-full-config")
|
|
assert response.status_code == 200
|
|
config_data = response.json()
|
|
|
|
# Verify env format is present (exact values may vary)
|
|
assert "env_format" in config_data
|