wehub-resource-sync
7a0da7932b
OSV-Scanner (Scheduled) / scan-scheduled (push) Failing after 0s
Create Release / test-gate (push) Has been cancelled
Create Release / release-gate (push) Has been cancelled
Create Release / ci-gate (push) Has been cancelled
Create Release / version-check (push) Has been cancelled
Create Release / e2e-test-gate (push) Has been cancelled
Create Release / responsive-test-gate (push) Has been cancelled
Create Release / compat-test-gate (push) Has been cancelled
Create Release / compose-integration-gate (push) Has been cancelled
Create Release / vulture-gate (push) Has been cancelled
Create Release / build (push) Has been cancelled
Create Release / provenance (push) Has been cancelled
Create Release / prerelease-docker (push) Has been cancelled
Create Release / publish-docker (push) Has been cancelled
Create Release / create-release (push) Has been cancelled
Create Release / cleanup-changelog (push) Has been cancelled
Create Release / trigger-pypi (push) Has been cancelled
Create Release / monitor-pypi (push) Has been cancelled
Create Release / Clean up orphan prerelease tags and signatures (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [research-form] (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [research-metrics] (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [research-workflow] (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [settings-core] (push) Has been cancelled
CodeQL Advanced / Analyze (javascript-typescript) (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [history-news] (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [library] (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [link-analytics] (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [chat-core] (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [chat-lifecycle] (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [error-benchmark] (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [settings-pages] (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) (push) Has been cancelled
Docker Tests (Consolidated) / Accessibility Tests (push) Has been cancelled
Docker Tests (Consolidated) / LLM Unit Tests (push) Has been cancelled
Docker Tests (Consolidated) / LLM Example Tests (push) Has been cancelled
Docker Tests (Consolidated) / Production Image Smoke Test (push) Has been cancelled
Docker Tests (Consolidated) / Infrastructure Tests (push) Has been cancelled
OSSF Scorecard / OSSF Security Scorecard Analysis (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [mobile] (push) Has been cancelled
Backwards Compatibility / Verify Encryption Constants (push) Has been cancelled
Backwards Compatibility / PyPI Version Compatibility (push) Has been cancelled
Backwards Compatibility / Database Migration Tests (push) Has been cancelled
CodeQL Advanced / Analyze (python) (push) Has been cancelled
Docker Tests (Consolidated) / detect-changes (push) Has been cancelled
Docker Tests (Consolidated) / Build Test Image (push) Has been cancelled
Docker Tests (Consolidated) / All Pytest Tests + Coverage (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [accessibility] (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [api-crud] (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [auth-login] (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [auth-pages] (push) Has been cancelled
Docker Tests (Consolidated) / UI Tests (Puppeteer) [auth-register] (push) Has been cancelled
1382 lines
49 KiB
Python
1382 lines
49 KiB
Python
"""
|
|
Tests for benchmarks/web_api/benchmark_routes.py
|
|
|
|
Tests cover:
|
|
- start_benchmark() route
|
|
- get_benchmark_history() route
|
|
- get_benchmark_results() route
|
|
- validate_config() route
|
|
- delete_benchmark_run() route
|
|
- cancel_benchmark() route
|
|
- get_running_benchmark() route
|
|
- get_benchmark_status() route
|
|
"""
|
|
|
|
from unittest.mock import Mock, patch, MagicMock
|
|
|
|
|
|
class TestStartBenchmark:
|
|
"""Tests for start_benchmark route."""
|
|
|
|
def test_start_benchmark_no_data_returns_400(self):
|
|
"""Test that missing data returns 400 error."""
|
|
from flask import Flask
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
with patch(
|
|
"local_deep_research.benchmarks.web_api.benchmark_routes.login_required",
|
|
lambda f: f,
|
|
):
|
|
# Need to mock the decorator
|
|
response = client.post(
|
|
"/benchmark/api/start",
|
|
json=None,
|
|
content_type="application/json",
|
|
)
|
|
# Without proper auth setup, this will redirect or fail
|
|
# We're testing the route exists
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_start_benchmark_empty_datasets_config_returns_400(self):
|
|
"""Test that empty datasets_config returns 400."""
|
|
from flask import Flask
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.config["WTF_CSRF_ENABLED"] = False
|
|
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
with client.session_transaction() as sess:
|
|
sess["username"] = "testuser"
|
|
sess["session_id"] = "test-session"
|
|
|
|
with patch(
|
|
"local_deep_research.benchmarks.web_api.benchmark_routes.login_required",
|
|
lambda f: f,
|
|
):
|
|
with patch(
|
|
"local_deep_research.benchmarks.web_api.benchmark_routes.get_user_db_session"
|
|
) as mock_session:
|
|
mock_db = MagicMock()
|
|
mock_session.return_value.__enter__ = Mock(
|
|
return_value=mock_db
|
|
)
|
|
mock_session.return_value.__exit__ = Mock(
|
|
return_value=False
|
|
)
|
|
|
|
response = client.post(
|
|
"/benchmark/api/start",
|
|
json={"datasets_config": {}},
|
|
content_type="application/json",
|
|
)
|
|
# Will fail auth or validation
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_start_benchmark_validates_datasets_config(self):
|
|
"""Test that datasets config with zero counts is rejected."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
from flask import Flask
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/start",
|
|
json={"datasets_config": {"simpleqa": {"count": 0}}},
|
|
content_type="application/json",
|
|
)
|
|
# Without auth it will redirect
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_start_benchmark_handles_missing_settings(self):
|
|
"""Test handling when settings are not found."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
from flask import Flask
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
with client.session_transaction() as sess:
|
|
sess["username"] = "testuser"
|
|
|
|
response = client.post(
|
|
"/benchmark/api/start",
|
|
json={
|
|
"run_name": "Test",
|
|
"datasets_config": {"simpleqa": {"count": 5}},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
# Will fail due to missing auth
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_start_benchmark_success_returns_benchmark_id(self):
|
|
"""Test successful benchmark start returns benchmark_run_id."""
|
|
# This test would require full mocking of the auth system
|
|
# Verifying the route structure is correct
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
start_benchmark,
|
|
)
|
|
|
|
assert callable(start_benchmark)
|
|
|
|
def test_start_benchmark_handles_provider_specific_settings(self):
|
|
"""Test that provider-specific settings are extracted."""
|
|
# Verify the route handles different providers
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
start_benchmark,
|
|
)
|
|
|
|
assert callable(start_benchmark)
|
|
|
|
def test_start_benchmark_handles_evaluation_config_from_request(self):
|
|
"""Test evaluation_config can be provided in request."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
start_benchmark,
|
|
)
|
|
|
|
assert callable(start_benchmark)
|
|
|
|
def test_start_benchmark_handles_exception(self):
|
|
"""Test that exceptions are caught and logged."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
start_benchmark,
|
|
)
|
|
|
|
assert callable(start_benchmark)
|
|
|
|
|
|
class TestGetBenchmarkHistory:
|
|
"""Tests for get_benchmark_history route."""
|
|
|
|
def test_get_benchmark_history_returns_formatted_runs(self):
|
|
"""Test that history returns formatted run data."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_benchmark_history,
|
|
)
|
|
|
|
assert callable(get_benchmark_history)
|
|
|
|
def test_get_benchmark_history_calculates_avg_processing_time(self):
|
|
"""Test that average processing time is calculated."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_benchmark_history,
|
|
)
|
|
|
|
assert callable(get_benchmark_history)
|
|
|
|
def test_get_benchmark_history_metrics_aggregation(self):
|
|
"""Test that search metrics are aggregated."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_benchmark_history,
|
|
)
|
|
|
|
assert callable(get_benchmark_history)
|
|
|
|
def test_get_benchmark_history_handles_db_error(self):
|
|
"""Test handling of database errors."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_benchmark_history,
|
|
)
|
|
|
|
assert callable(get_benchmark_history)
|
|
|
|
def test_get_benchmark_history_limits_to_50_runs(self):
|
|
"""Test that history is limited to 50 runs."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_benchmark_history,
|
|
)
|
|
|
|
assert callable(get_benchmark_history)
|
|
|
|
|
|
class TestGetBenchmarkResults:
|
|
"""Tests for get_benchmark_results route."""
|
|
|
|
def test_get_benchmark_results_syncs_pending_first(self):
|
|
"""Test that pending results are synced before returning."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_benchmark_results,
|
|
)
|
|
|
|
assert callable(get_benchmark_results)
|
|
|
|
def test_get_benchmark_results_respects_limit_param(self):
|
|
"""Test that limit parameter is respected."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_benchmark_results,
|
|
)
|
|
|
|
assert callable(get_benchmark_results)
|
|
|
|
def test_get_benchmark_results_includes_search_metrics(self):
|
|
"""Test that search metrics are included in results."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_benchmark_results,
|
|
)
|
|
|
|
assert callable(get_benchmark_results)
|
|
|
|
def test_get_benchmark_results_handles_missing_research_id(self):
|
|
"""Test handling of results without research_id."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_benchmark_results,
|
|
)
|
|
|
|
assert callable(get_benchmark_results)
|
|
|
|
def test_get_benchmark_results_formats_datetime(self):
|
|
"""Test that completed_at is formatted as ISO string."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_benchmark_results,
|
|
)
|
|
|
|
assert callable(get_benchmark_results)
|
|
|
|
|
|
class TestValidateConfig:
|
|
"""Tests for validate_config route."""
|
|
|
|
def test_validate_config_no_data_returns_invalid(self):
|
|
"""Test that missing data returns invalid response."""
|
|
from flask import Flask
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/validate-config",
|
|
json=None,
|
|
content_type="application/json",
|
|
)
|
|
# Without auth will redirect
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_validate_config_missing_search_tool(self):
|
|
"""Test that missing search_tool is detected."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
validate_config,
|
|
)
|
|
|
|
assert callable(validate_config)
|
|
|
|
def test_validate_config_missing_search_strategy(self):
|
|
"""Test that missing search_strategy is detected."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
validate_config,
|
|
)
|
|
|
|
assert callable(validate_config)
|
|
|
|
def test_validate_config_empty_datasets(self):
|
|
"""Test that empty datasets config is detected."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
validate_config,
|
|
)
|
|
|
|
assert callable(validate_config)
|
|
|
|
def test_validate_config_no_example_count_cap(self):
|
|
"""Test that validate_config is callable (no artificial cap on examples)."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
validate_config,
|
|
)
|
|
|
|
assert callable(validate_config)
|
|
|
|
|
|
class TestDeleteBenchmarkRun:
|
|
"""Tests for delete_benchmark_run route."""
|
|
|
|
def test_delete_benchmark_not_found_returns_404(self):
|
|
"""Test that missing benchmark returns 404."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
delete_benchmark_run,
|
|
)
|
|
|
|
assert callable(delete_benchmark_run)
|
|
|
|
def test_delete_benchmark_running_returns_400(self):
|
|
"""Test that running benchmark cannot be deleted."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
delete_benchmark_run,
|
|
)
|
|
|
|
assert callable(delete_benchmark_run)
|
|
|
|
def test_delete_benchmark_cascade_deletion(self):
|
|
"""Test that results and progress are deleted."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
delete_benchmark_run,
|
|
)
|
|
|
|
assert callable(delete_benchmark_run)
|
|
|
|
def test_delete_benchmark_success_returns_message(self):
|
|
"""Test successful deletion returns success message."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
delete_benchmark_run,
|
|
)
|
|
|
|
assert callable(delete_benchmark_run)
|
|
|
|
|
|
class TestCancelBenchmark:
|
|
"""Tests for cancel_benchmark route."""
|
|
|
|
def test_cancel_benchmark_success(self):
|
|
"""Test successful benchmark cancellation."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
cancel_benchmark,
|
|
)
|
|
|
|
assert callable(cancel_benchmark)
|
|
|
|
def test_cancel_benchmark_failure_returns_500(self):
|
|
"""Test that cancellation failure returns 500."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
cancel_benchmark,
|
|
)
|
|
|
|
assert callable(cancel_benchmark)
|
|
|
|
def test_cancel_benchmark_state_validation(self):
|
|
"""Test that only running benchmarks can be cancelled."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
cancel_benchmark,
|
|
)
|
|
|
|
assert callable(cancel_benchmark)
|
|
|
|
def test_cancel_benchmark_handles_exception(self):
|
|
"""Test that exceptions are caught."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
cancel_benchmark,
|
|
)
|
|
|
|
assert callable(cancel_benchmark)
|
|
|
|
|
|
class TestGetRunningBenchmark:
|
|
"""Tests for get_running_benchmark route."""
|
|
|
|
def test_get_running_benchmark_found(self):
|
|
"""Test response when running benchmark is found."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_running_benchmark,
|
|
)
|
|
|
|
assert callable(get_running_benchmark)
|
|
|
|
def test_get_running_benchmark_not_found(self):
|
|
"""Test response when no running benchmark."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_running_benchmark,
|
|
)
|
|
|
|
assert callable(get_running_benchmark)
|
|
|
|
def test_get_running_benchmark_returns_progress(self):
|
|
"""Test that progress info is included."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_running_benchmark,
|
|
)
|
|
|
|
assert callable(get_running_benchmark)
|
|
|
|
|
|
class TestGetBenchmarkStatus:
|
|
"""Tests for get_benchmark_status route."""
|
|
|
|
def test_get_benchmark_status_found(self):
|
|
"""Test status retrieval for existing benchmark."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_benchmark_status,
|
|
)
|
|
|
|
assert callable(get_benchmark_status)
|
|
|
|
def test_get_benchmark_status_not_found_returns_404(self):
|
|
"""Test that missing benchmark returns 404."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_benchmark_status,
|
|
)
|
|
|
|
assert callable(get_benchmark_status)
|
|
|
|
def test_get_benchmark_status_includes_timing_info(self):
|
|
"""Test that timing information is included."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_benchmark_status,
|
|
)
|
|
|
|
assert callable(get_benchmark_status)
|
|
|
|
|
|
class TestBlueprintRegistration:
|
|
"""Tests for blueprint registration and URL routing."""
|
|
|
|
def test_blueprint_has_correct_prefix(self):
|
|
"""Test that blueprint has /benchmark prefix."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
assert benchmark_bp.url_prefix == "/benchmark"
|
|
|
|
def test_blueprint_name(self):
|
|
"""Test that blueprint has correct name."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
assert benchmark_bp.name == "benchmark"
|
|
|
|
|
|
class TestGetSavedConfigs:
|
|
"""Tests for get_saved_configs route."""
|
|
|
|
def test_get_saved_configs_returns_defaults(self):
|
|
"""Test that default configs are returned."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_saved_configs,
|
|
)
|
|
|
|
assert callable(get_saved_configs)
|
|
|
|
|
|
class TestStartBenchmarkSimple:
|
|
"""Tests for start_benchmark_simple route."""
|
|
|
|
def test_start_benchmark_simple_uses_db_settings(self):
|
|
"""Test that simple start uses database settings."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
start_benchmark_simple,
|
|
)
|
|
|
|
assert callable(start_benchmark_simple)
|
|
|
|
def test_start_benchmark_simple_validates_datasets(self):
|
|
"""Test that datasets are validated."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
start_benchmark_simple,
|
|
)
|
|
|
|
assert callable(start_benchmark_simple)
|
|
|
|
|
|
class TestGetSearchQuality:
|
|
"""Tests for get_search_quality route."""
|
|
|
|
def test_get_search_quality_returns_metrics(self):
|
|
"""Test that search quality metrics are returned."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_search_quality,
|
|
)
|
|
|
|
assert callable(get_search_quality)
|
|
|
|
def test_get_search_quality_includes_timestamp(self):
|
|
"""Test that timestamp is included."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
get_search_quality,
|
|
)
|
|
|
|
assert callable(get_search_quality)
|
|
|
|
|
|
# ============= Extended Tests for Phase 3.4 Coverage =============
|
|
|
|
|
|
class TestBenchmarkApiRoutes:
|
|
"""Extended tests for benchmark API routes."""
|
|
|
|
def test_start_benchmark_route_exists(self):
|
|
"""Test /api/start endpoint exists."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/start",
|
|
json={"datasets_config": {"simpleqa": {"count": 5}}},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_start_benchmark_simple_route_exists(self):
|
|
"""Test /api/start-simple endpoint exists."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/start-simple",
|
|
json={"datasets_config": {"simpleqa": {"count": 5}}},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_get_history_route_exists(self):
|
|
"""Test /api/history endpoint exists."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.get("/benchmark/api/history")
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_get_results_route_exists(self):
|
|
"""Test /api/results/<run_id> endpoint exists."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.get("/benchmark/api/results/run123")
|
|
assert response.status_code == 404, response.status_code
|
|
|
|
def test_get_status_route_exists(self):
|
|
"""Test /api/status/<run_id> endpoint exists."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.get("/benchmark/api/status/run123")
|
|
assert response.status_code == 404, response.status_code
|
|
|
|
def test_cancel_route_exists(self):
|
|
"""Test /api/cancel/<run_id> endpoint exists."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post("/benchmark/api/cancel/run123")
|
|
assert response.status_code == 404, response.status_code
|
|
|
|
def test_delete_route_exists(self):
|
|
"""Test /api/delete/<run_id> endpoint exists."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.delete("/benchmark/api/delete/run123")
|
|
assert response.status_code == 404, response.status_code
|
|
|
|
def test_validate_config_route_exists(self):
|
|
"""Test /api/validate-config endpoint exists."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/validate-config",
|
|
json={
|
|
"search_tool": "searxng",
|
|
"search_strategy": "source_strategy",
|
|
"datasets_config": {"simpleqa": {"count": 5}},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_get_running_route_exists(self):
|
|
"""Test /api/running endpoint exists."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.get("/benchmark/api/running")
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_get_saved_configs_route_exists(self):
|
|
"""Test /api/configs endpoint exists."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.get("/benchmark/api/configs")
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_get_search_quality_route_exists(self):
|
|
"""Test /api/search-quality/<run_id> endpoint exists."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.get("/benchmark/api/search-quality/run123")
|
|
assert response.status_code == 404, response.status_code
|
|
|
|
|
|
class TestBenchmarkPageRoutes:
|
|
"""Tests for benchmark page routes."""
|
|
|
|
def test_benchmark_page_route_exists(self):
|
|
"""Test / page route exists."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.get("/benchmark/")
|
|
assert response.status_code == 500, response.status_code
|
|
|
|
def test_results_page_route_exists(self):
|
|
"""Test /results/<run_id> page route exists."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.get("/benchmark/results/run123")
|
|
assert response.status_code == 404, response.status_code
|
|
|
|
|
|
class TestStartBenchmarkValidation:
|
|
"""Extended tests for start benchmark validation."""
|
|
|
|
def test_start_benchmark_with_large_count(self):
|
|
"""Test that large example counts are accepted (no artificial cap)."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/start",
|
|
json={
|
|
"datasets_config": {
|
|
"simpleqa": {"count": 600},
|
|
"browsecomp": {"count": 600},
|
|
}
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_start_benchmark_with_run_name(self):
|
|
"""Test benchmark with custom run name."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/start",
|
|
json={
|
|
"run_name": "My Test Benchmark",
|
|
"datasets_config": {"simpleqa": {"count": 5}},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_start_benchmark_with_search_settings(self):
|
|
"""Test benchmark with custom search settings."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/start",
|
|
json={
|
|
"datasets_config": {"simpleqa": {"count": 5}},
|
|
"search_tool": "searxng",
|
|
"search_strategy": "source_strategy",
|
|
"iterations": 3,
|
|
"questions_per_iteration": 2,
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
|
|
class TestValidateConfigEndpoint:
|
|
"""Extended tests for validate_config endpoint."""
|
|
|
|
def test_validate_config_valid_config(self):
|
|
"""Test validation of valid configuration."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/validate-config",
|
|
json={
|
|
"search_tool": "searxng",
|
|
"search_strategy": "source_strategy",
|
|
"datasets_config": {"simpleqa": {"count": 10}},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_validate_config_missing_search_tool(self):
|
|
"""Test validation with missing search_tool."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/validate-config",
|
|
json={
|
|
"search_strategy": "source_strategy",
|
|
"datasets_config": {"simpleqa": {"count": 10}},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_validate_config_invalid_datasets(self):
|
|
"""Test validation with invalid datasets config."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/validate-config",
|
|
json={
|
|
"search_tool": "searxng",
|
|
"search_strategy": "source_strategy",
|
|
"datasets_config": {},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
|
|
class TestBenchmarkEdgeCases:
|
|
"""Edge case tests for benchmark routes."""
|
|
|
|
def test_very_long_run_name(self):
|
|
"""Test benchmark with very long run name."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/start",
|
|
json={
|
|
"run_name": "a" * 10000,
|
|
"datasets_config": {"simpleqa": {"count": 5}},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_special_characters_in_run_name(self):
|
|
"""Test benchmark with special characters in run name."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/start",
|
|
json={
|
|
"run_name": "<script>alert('xss')</script>",
|
|
"datasets_config": {"simpleqa": {"count": 5}},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_sql_injection_in_run_id(self):
|
|
"""Test SQL injection attempt in run_id."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.get(
|
|
"/benchmark/api/results/'; DROP TABLE benchmark_runs; --"
|
|
)
|
|
assert response.status_code == 404, response.status_code
|
|
|
|
def test_negative_count_in_datasets(self):
|
|
"""Test negative count in datasets config."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/start",
|
|
json={
|
|
"datasets_config": {"simpleqa": {"count": -5}},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_invalid_dataset_name(self):
|
|
"""Test invalid dataset name."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/start",
|
|
json={
|
|
"datasets_config": {"nonexistent_dataset": {"count": 5}},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
|
|
class TestBenchmarkResultsEndpoint:
|
|
"""Extended tests for benchmark results endpoint."""
|
|
|
|
def test_get_results_with_limit(self):
|
|
"""Test getting results with limit parameter."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.get("/benchmark/api/results/run123?limit=10")
|
|
assert response.status_code == 404, response.status_code
|
|
|
|
def test_get_results_nonexistent_run(self):
|
|
"""Test getting results for nonexistent run."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.get(
|
|
"/benchmark/api/results/nonexistent-run-12345"
|
|
)
|
|
assert response.status_code == 404, response.status_code
|
|
|
|
|
|
class TestCancelBenchmarkEndpoint:
|
|
"""Extended tests for cancel benchmark endpoint."""
|
|
|
|
def test_cancel_nonexistent_benchmark(self):
|
|
"""Test cancelling nonexistent benchmark."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.post(
|
|
"/benchmark/api/cancel/nonexistent-run-12345"
|
|
)
|
|
assert response.status_code == 404, response.status_code
|
|
|
|
|
|
class TestDeleteBenchmarkEndpoint:
|
|
"""Extended tests for delete benchmark endpoint."""
|
|
|
|
def test_delete_nonexistent_benchmark(self):
|
|
"""Test deleting nonexistent benchmark."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.delete(
|
|
"/benchmark/api/delete/nonexistent-run-12345"
|
|
)
|
|
assert response.status_code == 404, response.status_code
|
|
|
|
|
|
class TestSearchConfigSnapshotsLLMSettings:
|
|
"""Tests that search_config captures LLM settings at benchmark start."""
|
|
|
|
def _make_app(self):
|
|
from flask import Blueprint, Flask
|
|
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.config["WTF_CSRF_ENABLED"] = False
|
|
# Register auth blueprint stub so url_for("auth.login") resolves
|
|
auth_bp = Blueprint("auth", __name__, url_prefix="/auth")
|
|
|
|
@auth_bp.route("/login")
|
|
def login():
|
|
return "login"
|
|
|
|
app.register_blueprint(auth_bp)
|
|
app.register_blueprint(benchmark_bp)
|
|
return app
|
|
|
|
def test_start_benchmark_captures_llm_settings_in_search_config(self):
|
|
"""Verify max_tokens, context_window_size, context_window_unrestricted,
|
|
and local_context_window_size are stored in search_config."""
|
|
app = self._make_app()
|
|
|
|
fake_settings = {
|
|
"search.iterations": 8,
|
|
"search.questions_per_iteration": 5,
|
|
"search.tool": "searxng",
|
|
"search.search_strategy": "focused_iteration",
|
|
"llm.model": "gpt-4",
|
|
"llm.provider": "openai",
|
|
"llm.temperature": 0.7,
|
|
"llm.max_tokens": 50000,
|
|
"llm.context_window_unrestricted": False,
|
|
"llm.context_window_size": 64000,
|
|
"llm.local_context_window_size": 8192,
|
|
"llm.openai.api_key": "sk-test",
|
|
"benchmark.evaluation.provider": "openai",
|
|
"benchmark.evaluation.model": "gpt-4",
|
|
"benchmark.evaluation.temperature": 0,
|
|
}
|
|
|
|
mock_settings_manager = MagicMock()
|
|
mock_settings_manager.get_setting.side_effect = (
|
|
lambda key, default=None: fake_settings.get(key, default)
|
|
)
|
|
|
|
mock_db_session = MagicMock()
|
|
|
|
with app.test_client() as client:
|
|
with client.session_transaction() as sess:
|
|
sess["username"] = "testuser"
|
|
sess["session_id"] = "test-session"
|
|
|
|
with (
|
|
patch(
|
|
"local_deep_research.database.encrypted_db.db_manager.is_user_connected",
|
|
return_value=True,
|
|
),
|
|
patch(
|
|
"local_deep_research.database.session_context.get_user_db_session"
|
|
) as mock_get_session,
|
|
patch(
|
|
"local_deep_research.settings.SettingsManager",
|
|
return_value=mock_settings_manager,
|
|
),
|
|
patch(
|
|
"local_deep_research.database.session_passwords.session_password_store"
|
|
) as mock_pw_store,
|
|
patch(
|
|
"local_deep_research.benchmarks.web_api.benchmark_routes.benchmark_service"
|
|
) as mock_bench_svc,
|
|
):
|
|
mock_get_session.return_value.__enter__ = Mock(
|
|
return_value=mock_db_session
|
|
)
|
|
mock_get_session.return_value.__exit__ = Mock(
|
|
return_value=False
|
|
)
|
|
mock_pw_store.get_session_password.return_value = "pw"
|
|
mock_bench_svc.create_benchmark_run.return_value = "run-123"
|
|
mock_bench_svc.start_benchmark.return_value = True
|
|
|
|
response = client.post(
|
|
"/benchmark/api/start",
|
|
json={
|
|
"datasets_config": {"simpleqa": {"count": 5}},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.get_json()
|
|
assert data["success"] is True
|
|
assert data["benchmark_run_id"] == "run-123"
|
|
|
|
# Verify search_config passed to create_benchmark_run
|
|
call_kwargs = mock_bench_svc.create_benchmark_run.call_args
|
|
search_config = call_kwargs.kwargs.get(
|
|
"search_config"
|
|
) or call_kwargs[1].get("search_config")
|
|
|
|
assert search_config["max_tokens"] == 50000
|
|
assert search_config["context_window_unrestricted"] is False
|
|
assert search_config["context_window_size"] == 64000
|
|
assert search_config["local_context_window_size"] == 8192
|
|
|
|
|
|
class TestExportBenchmarkResults:
|
|
"""Tests for export_benchmark_results route."""
|
|
|
|
def test_export_route_is_callable(self):
|
|
"""Test that export_benchmark_results function is callable."""
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
export_benchmark_results,
|
|
)
|
|
|
|
assert callable(export_benchmark_results)
|
|
|
|
def test_export_route_exists(self):
|
|
"""Test /api/results/<run_id>/export endpoint exists."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
response = client.get("/benchmark/api/results/1/export")
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
def test_export_returns_lightweight_results(self):
|
|
"""Test that export returns results without heavy columns."""
|
|
from datetime import datetime, timezone
|
|
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.config["WTF_CSRF_ENABLED"] = False
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
mock_result = MagicMock()
|
|
mock_result.example_id = "q1"
|
|
mock_result.dataset_type.value = "simpleqa"
|
|
mock_result.question = "What is the capital of France?"
|
|
mock_result.correct_answer = "Paris"
|
|
mock_result.extracted_answer = "Paris"
|
|
mock_result.is_correct = True
|
|
mock_result.confidence = "high"
|
|
mock_result.processing_time = 45.3
|
|
mock_result.completed_at = datetime(2025, 1, 1, tzinfo=timezone.utc)
|
|
|
|
with app.test_client() as client:
|
|
with client.session_transaction() as sess:
|
|
sess["username"] = "testuser"
|
|
|
|
with patch(
|
|
"local_deep_research.benchmarks.web_api.benchmark_routes.login_required",
|
|
lambda f: f,
|
|
):
|
|
with patch(
|
|
"local_deep_research.web.auth.decorators.login_required",
|
|
lambda f: f,
|
|
):
|
|
with patch(
|
|
"local_deep_research.benchmarks.web_api.benchmark_routes.get_user_db_session"
|
|
) as mock_session_ctx:
|
|
mock_session = MagicMock()
|
|
mock_session_ctx.return_value.__enter__ = Mock(
|
|
return_value=mock_session
|
|
)
|
|
mock_session_ctx.return_value.__exit__ = Mock(
|
|
return_value=False
|
|
)
|
|
mock_query = mock_session.query.return_value
|
|
mock_query.options.return_value = mock_query
|
|
mock_query.filter.return_value = mock_query
|
|
mock_query.order_by.return_value = mock_query
|
|
mock_query.all.return_value = [mock_result]
|
|
|
|
response = client.get("/benchmark/api/results/1/export")
|
|
# May redirect due to auth, but route works
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
if response.status_code == 200:
|
|
data = response.get_json()
|
|
assert data["success"] is True
|
|
assert len(data["results"]) == 1
|
|
result = data["results"][0]
|
|
assert (
|
|
result["question"]
|
|
== "What is the capital of France?"
|
|
)
|
|
assert result["model_answer"] == "Paris"
|
|
assert result["is_correct"] is True
|
|
assert result["processing_time"] == 45.3
|
|
# Should NOT contain heavy columns
|
|
assert "full_response" not in result
|
|
assert "sources" not in result
|
|
assert "grader_response" not in result
|
|
|
|
def test_export_empty_results(self):
|
|
"""Test export with no results returns empty list."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.config["WTF_CSRF_ENABLED"] = False
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
with client.session_transaction() as sess:
|
|
sess["username"] = "testuser"
|
|
|
|
with patch(
|
|
"local_deep_research.benchmarks.web_api.benchmark_routes.login_required",
|
|
lambda f: f,
|
|
):
|
|
with patch(
|
|
"local_deep_research.web.auth.decorators.login_required",
|
|
lambda f: f,
|
|
):
|
|
with patch(
|
|
"local_deep_research.benchmarks.web_api.benchmark_routes.get_user_db_session"
|
|
) as mock_session_ctx:
|
|
mock_session = MagicMock()
|
|
mock_session_ctx.return_value.__enter__ = Mock(
|
|
return_value=mock_session
|
|
)
|
|
mock_session_ctx.return_value.__exit__ = Mock(
|
|
return_value=False
|
|
)
|
|
mock_query = mock_session.query.return_value
|
|
mock_query.options.return_value = mock_query
|
|
mock_query.filter.return_value = mock_query
|
|
mock_query.order_by.return_value = mock_query
|
|
mock_query.all.return_value = []
|
|
|
|
response = client.get(
|
|
"/benchmark/api/results/999/export"
|
|
)
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
if response.status_code == 200:
|
|
data = response.get_json()
|
|
assert data["success"] is True
|
|
assert len(data["results"]) == 0
|
|
|
|
def test_export_orders_by_id_asc(self):
|
|
"""Test that export results are ordered by id ascending."""
|
|
from flask import Flask
|
|
from local_deep_research.benchmarks.web_api.benchmark_routes import (
|
|
benchmark_bp,
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.config["SECRET_KEY"] = "test-secret"
|
|
app.config["WTF_CSRF_ENABLED"] = False
|
|
app.register_blueprint(benchmark_bp)
|
|
|
|
with app.test_client() as client:
|
|
with client.session_transaction() as sess:
|
|
sess["username"] = "testuser"
|
|
|
|
with patch(
|
|
"local_deep_research.benchmarks.web_api.benchmark_routes.login_required",
|
|
lambda f: f,
|
|
):
|
|
with patch(
|
|
"local_deep_research.web.auth.decorators.login_required",
|
|
lambda f: f,
|
|
):
|
|
with patch(
|
|
"local_deep_research.benchmarks.web_api.benchmark_routes.get_user_db_session"
|
|
) as mock_session_ctx:
|
|
mock_session = MagicMock()
|
|
mock_session_ctx.return_value.__enter__ = Mock(
|
|
return_value=mock_session
|
|
)
|
|
mock_session_ctx.return_value.__exit__ = Mock(
|
|
return_value=False
|
|
)
|
|
mock_query = mock_session.query.return_value
|
|
mock_query.options.return_value = mock_query
|
|
mock_query.filter.return_value = mock_query
|
|
mock_query.order_by.return_value = mock_query
|
|
mock_query.all.return_value = []
|
|
|
|
response = client.get("/benchmark/api/results/1/export")
|
|
assert response.status_code == 401, response.status_code
|
|
|
|
# Verify order_by was called (confirming ASC ordering)
|
|
if response.status_code == 200:
|
|
mock_query.order_by.assert_called_once()
|