379 lines
12 KiB
Python
379 lines
12 KiB
Python
"""Integration tests for analysis session endpoints."""
|
|
|
|
import pytest
|
|
|
|
|
|
@pytest.mark.integration
|
|
class TestAnalysisIntegration:
|
|
"""Integration tests for analysis session management."""
|
|
|
|
def test_create_session_success(self, client, auth_headers, clean_test_sessions):
|
|
"""Test creating analysis session with real DB API."""
|
|
session_data = {
|
|
"environment": "ift",
|
|
"api_mode": "bench",
|
|
"request": [
|
|
{"body": "Test question 1", "with_docs": True},
|
|
{"body": "Test question 2", "with_docs": False}
|
|
],
|
|
"response": {
|
|
"answers": [
|
|
{"answer": "Test answer 1", "docs": []},
|
|
{"answer": "Test answer 2", "docs": []}
|
|
]
|
|
},
|
|
"annotations": {
|
|
"duration_ms": 1234,
|
|
"model": "test-model",
|
|
"test_run": True
|
|
}
|
|
}
|
|
|
|
response = client.post(
|
|
"/api/v1/analysis/sessions",
|
|
json=session_data,
|
|
headers=auth_headers
|
|
)
|
|
|
|
assert response.status_code == 201
|
|
|
|
data = response.json()
|
|
assert "session_id" in data
|
|
assert "user_id" in data
|
|
assert data["environment"] == "ift"
|
|
assert data["api_mode"] == "bench"
|
|
assert len(data["request"]) == 2
|
|
assert "created_at" in data
|
|
assert "updated_at" in data
|
|
|
|
def test_get_sessions_list(self, client, auth_headers, clean_test_sessions):
|
|
"""Test getting list of sessions."""
|
|
# Create test sessions
|
|
for env in ["ift", "psi", "prod"]:
|
|
session_data = {
|
|
"environment": env,
|
|
"api_mode": "bench",
|
|
"request": [{"body": f"Question for {env}"}],
|
|
"response": {"answer": f"Answer for {env}"},
|
|
"annotations": {}
|
|
}
|
|
client.post(
|
|
"/api/v1/analysis/sessions",
|
|
json=session_data,
|
|
headers=auth_headers
|
|
)
|
|
|
|
# Get all sessions
|
|
response = client.get("/api/v1/analysis/sessions", headers=auth_headers)
|
|
|
|
assert response.status_code == 200
|
|
|
|
data = response.json()
|
|
assert "sessions" in data
|
|
assert "total" in data
|
|
assert data["total"] >= 3
|
|
assert len(data["sessions"]) >= 3
|
|
|
|
# Verify session structure
|
|
for session in data["sessions"]:
|
|
assert "session_id" in session
|
|
assert "environment" in session
|
|
assert "created_at" in session
|
|
assert session["environment"] in ["ift", "psi", "prod"]
|
|
|
|
def test_get_sessions_with_filter(self, client, auth_headers, clean_test_sessions):
|
|
"""Test filtering sessions by environment."""
|
|
# Create sessions for different environments
|
|
for env in ["ift", "psi"]:
|
|
for i in range(2):
|
|
session_data = {
|
|
"environment": env,
|
|
"api_mode": "bench",
|
|
"request": [{"body": f"Question {i}"}],
|
|
"response": {},
|
|
"annotations": {}
|
|
}
|
|
client.post(
|
|
"/api/v1/analysis/sessions",
|
|
json=session_data,
|
|
headers=auth_headers
|
|
)
|
|
|
|
# Filter by IFT
|
|
response = client.get(
|
|
"/api/v1/analysis/sessions?environment=ift",
|
|
headers=auth_headers
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
|
|
data = response.json()
|
|
assert data["total"] >= 2
|
|
|
|
# All returned sessions should be IFT
|
|
for session in data["sessions"]:
|
|
assert session["environment"] == "ift"
|
|
|
|
def test_get_sessions_pagination(self, client, auth_headers, clean_test_sessions):
|
|
"""Test session pagination."""
|
|
# Create 5 test sessions
|
|
for i in range(5):
|
|
session_data = {
|
|
"environment": "ift",
|
|
"api_mode": "bench",
|
|
"request": [{"body": f"Question {i}"}],
|
|
"response": {},
|
|
"annotations": {}
|
|
}
|
|
client.post(
|
|
"/api/v1/analysis/sessions",
|
|
json=session_data,
|
|
headers=auth_headers
|
|
)
|
|
|
|
# Get first 3
|
|
response = client.get(
|
|
"/api/v1/analysis/sessions?limit=3&offset=0",
|
|
headers=auth_headers
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert len(data["sessions"]) <= 3
|
|
|
|
# Get next 3
|
|
response = client.get(
|
|
"/api/v1/analysis/sessions?limit=3&offset=3",
|
|
headers=auth_headers
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
|
|
def test_get_session_by_id(self, client, auth_headers, clean_test_sessions):
|
|
"""Test getting specific session by ID."""
|
|
# Create session
|
|
session_data = {
|
|
"environment": "psi",
|
|
"api_mode": "backend",
|
|
"request": [
|
|
{"body": "Detailed question", "with_docs": True}
|
|
],
|
|
"response": {
|
|
"answer": "Detailed answer",
|
|
"confidence": 0.95
|
|
},
|
|
"annotations": {
|
|
"duration_ms": 5678,
|
|
"tokens_used": 1234
|
|
}
|
|
}
|
|
|
|
create_response = client.post(
|
|
"/api/v1/analysis/sessions",
|
|
json=session_data,
|
|
headers=auth_headers
|
|
)
|
|
|
|
assert create_response.status_code == 201
|
|
session_id = create_response.json()["session_id"]
|
|
|
|
# Get session by ID
|
|
get_response = client.get(
|
|
f"/api/v1/analysis/sessions/{session_id}",
|
|
headers=auth_headers
|
|
)
|
|
|
|
assert get_response.status_code == 200
|
|
|
|
data = get_response.json()
|
|
assert data["session_id"] == session_id
|
|
assert data["environment"] == "psi"
|
|
assert data["api_mode"] == "backend"
|
|
assert data["request"][0]["body"] == "Detailed question"
|
|
assert data["response"]["answer"] == "Detailed answer"
|
|
assert data["annotations"]["duration_ms"] == 5678
|
|
|
|
def test_delete_session(self, client, auth_headers, clean_test_sessions):
|
|
"""Test deleting a session."""
|
|
# Create session
|
|
session_data = {
|
|
"environment": "prod",
|
|
"api_mode": "bench",
|
|
"request": [{"body": "To be deleted"}],
|
|
"response": {},
|
|
"annotations": {}
|
|
}
|
|
|
|
create_response = client.post(
|
|
"/api/v1/analysis/sessions",
|
|
json=session_data,
|
|
headers=auth_headers
|
|
)
|
|
|
|
assert create_response.status_code == 201
|
|
session_id = create_response.json()["session_id"]
|
|
|
|
# Delete session
|
|
delete_response = client.delete(
|
|
f"/api/v1/analysis/sessions/{session_id}",
|
|
headers=auth_headers
|
|
)
|
|
|
|
assert delete_response.status_code == 204
|
|
|
|
# Verify deletion
|
|
get_response = client.get(
|
|
f"/api/v1/analysis/sessions/{session_id}",
|
|
headers=auth_headers
|
|
)
|
|
|
|
assert get_response.status_code == 404
|
|
|
|
def test_delete_nonexistent_session(self, client, auth_headers):
|
|
"""Test deleting non-existent session."""
|
|
fake_session_id = "00000000-0000-0000-0000-000000000000"
|
|
|
|
response = client.delete(
|
|
f"/api/v1/analysis/sessions/{fake_session_id}",
|
|
headers=auth_headers
|
|
)
|
|
|
|
assert response.status_code == 404
|
|
|
|
def test_create_session_invalid_environment(self, client, auth_headers):
|
|
"""Test creating session with invalid environment."""
|
|
session_data = {
|
|
"environment": "invalid", # Invalid
|
|
"api_mode": "bench",
|
|
"request": [],
|
|
"response": {},
|
|
"annotations": {}
|
|
}
|
|
|
|
response = client.post(
|
|
"/api/v1/analysis/sessions",
|
|
json=session_data,
|
|
headers=auth_headers
|
|
)
|
|
|
|
# Should fail validation (either FastAPI or DB API)
|
|
assert response.status_code in [400, 422]
|
|
|
|
def test_sessions_require_authentication(self, client):
|
|
"""Test that session endpoints require authentication."""
|
|
# Create without auth
|
|
response = client.post(
|
|
"/api/v1/analysis/sessions",
|
|
json={"environment": "ift", "api_mode": "bench", "request": [], "response": {}, "annotations": {}}
|
|
)
|
|
assert response.status_code == 401
|
|
|
|
# List without auth
|
|
response = client.get("/api/v1/analysis/sessions")
|
|
assert response.status_code == 401
|
|
|
|
# Get by ID without auth
|
|
response = client.get("/api/v1/analysis/sessions/some-id")
|
|
assert response.status_code == 401
|
|
|
|
# Delete without auth
|
|
response = client.delete("/api/v1/analysis/sessions/some-id")
|
|
assert response.status_code == 401
|
|
|
|
def test_create_multiple_sessions_same_user(self, client, auth_headers, clean_test_sessions):
|
|
"""Test creating multiple sessions for same user."""
|
|
session_ids = []
|
|
|
|
for i in range(3):
|
|
session_data = {
|
|
"environment": "ift",
|
|
"api_mode": "bench",
|
|
"request": [{"body": f"Question {i}"}],
|
|
"response": {"answer": f"Answer {i}"},
|
|
"annotations": {"iteration": i}
|
|
}
|
|
|
|
response = client.post(
|
|
"/api/v1/analysis/sessions",
|
|
json=session_data,
|
|
headers=auth_headers
|
|
)
|
|
|
|
assert response.status_code == 201
|
|
session_ids.append(response.json()["session_id"])
|
|
|
|
# Verify all sessions exist
|
|
list_response = client.get("/api/v1/analysis/sessions", headers=auth_headers)
|
|
assert list_response.status_code == 200
|
|
assert list_response.json()["total"] >= 3
|
|
|
|
# Verify each session is unique
|
|
assert len(set(session_ids)) == 3
|
|
|
|
def test_session_data_integrity(self, client, auth_headers, clean_test_sessions):
|
|
"""Test that session data is stored and retrieved without corruption."""
|
|
complex_data = {
|
|
"environment": "psi",
|
|
"api_mode": "backend",
|
|
"request": [
|
|
{
|
|
"body": "Complex question with special chars: Привет! 你好 こんにちは",
|
|
"with_docs": True,
|
|
"metadata": {
|
|
"source": "test",
|
|
"priority": 1,
|
|
"tags": ["integration", "test", "unicode"]
|
|
}
|
|
}
|
|
],
|
|
"response": {
|
|
"answer": "Complex answer with nested data",
|
|
"confidence": 0.98,
|
|
"sources": [
|
|
{"doc_id": "doc1", "relevance": 0.95},
|
|
{"doc_id": "doc2", "relevance": 0.87}
|
|
],
|
|
"metadata": {
|
|
"model": "gpt-4",
|
|
"temperature": 0.7,
|
|
"tokens": {"prompt": 100, "completion": 200}
|
|
}
|
|
},
|
|
"annotations": {
|
|
"test_type": "integration",
|
|
"special_chars": "!@#$%^&*()",
|
|
"unicode": "Тест 测试 テスト",
|
|
"nested": {
|
|
"level1": {
|
|
"level2": {
|
|
"value": "deep nested value"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# Create session
|
|
create_response = client.post(
|
|
"/api/v1/analysis/sessions",
|
|
json=complex_data,
|
|
headers=auth_headers
|
|
)
|
|
|
|
assert create_response.status_code == 201
|
|
session_id = create_response.json()["session_id"]
|
|
|
|
# Retrieve and verify
|
|
get_response = client.get(
|
|
f"/api/v1/analysis/sessions/{session_id}",
|
|
headers=auth_headers
|
|
)
|
|
|
|
assert get_response.status_code == 200
|
|
retrieved_data = get_response.json()
|
|
|
|
# Verify complex data integrity
|
|
assert "Привет" in retrieved_data["request"][0]["body"]
|
|
assert retrieved_data["response"]["sources"][0]["doc_id"] == "doc1"
|
|
assert retrieved_data["annotations"]["nested"]["level1"]["level2"]["value"] == "deep nested value"
|