104 lines
5.1 KiB
Python
104 lines
5.1 KiB
Python
import csv
|
|
import unittest
|
|
from pathlib import Path
|
|
from unittest.mock import patch
|
|
import json
|
|
|
|
|
|
def classify(text, mode):
|
|
from src.llm_service import classify as run
|
|
|
|
return run(text, mode)
|
|
|
|
|
|
class ClassificationTests(unittest.TestCase):
|
|
def test_demo_sample_cases(self):
|
|
path = Path(__file__).resolve().parents[1] / "samples/sample_leads.csv"
|
|
with path.open(encoding="utf-8-sig", newline="") as sample:
|
|
for row in csv.DictReader(sample):
|
|
with self.subTest(text=row["text"]):
|
|
if row["expected_category"] == "invalid":
|
|
with self.assertRaises(ValueError):
|
|
classify(row["text"], "DEMO")
|
|
continue
|
|
result = classify(row["text"], "DEMO")
|
|
self.assertEqual(result.category, row["expected_category"])
|
|
self.assertEqual(result.needs_review, row["needs_review"] == "true")
|
|
self.assertTrue(result.reason.strip())
|
|
if result.category != "spam":
|
|
self.assertTrue(result.draft_reply.strip())
|
|
else:
|
|
self.assertEqual(result.draft_reply, "")
|
|
self.assertEqual((result.input_tokens, result.output_tokens, result.cached_tokens), (0, 0, 0))
|
|
self.assertEqual(result, classify(row["text"], "DEMO"))
|
|
|
|
def test_invalid_inputs(self):
|
|
for text in (None, " ", "я" * 4001, "a\x00b", "a\uffff", "\udc00"):
|
|
with self.subTest(text=repr(text)[:20]), self.assertRaises(ValueError):
|
|
classify(text, "DEMO")
|
|
with self.assertRaises(ValueError):
|
|
classify("Здравствуйте", "typo")
|
|
self.assertTrue(classify("я" * 4000, "DEMO").category)
|
|
|
|
def test_real_requires_key(self):
|
|
with patch.dict("os.environ", {"OPENAI_API_KEY": ""}), self.assertRaisesRegex(ValueError, "OPENAI_API_KEY"):
|
|
classify("Нужен счёт", "REAL AI")
|
|
|
|
def run_with_response(self, content, status=200):
|
|
"""Run the installed OpenAI parser with a local HTTP transport."""
|
|
import httpx
|
|
from openai import OpenAI
|
|
|
|
def serve(request):
|
|
body = json.loads(request.content)
|
|
self.assertEqual(body["input"], [{"role": "user", "content": "Сломалась плита"}])
|
|
self.assertTrue(body["text"]["format"]["strict"])
|
|
payload = {
|
|
"id": "resp_test", "created_at": 1, "object": "response",
|
|
"status": "completed", "model": "provider-model",
|
|
"output": [{"id": "msg_test", "type": "message", "status": "completed",
|
|
"role": "assistant", "content": [content]}],
|
|
"usage": {"input_tokens": 120, "output_tokens": 31, "total_tokens": 151,
|
|
"input_tokens_details": {"cached_tokens": 64},
|
|
"output_tokens_details": {"reasoning_tokens": 0}},
|
|
}
|
|
if status != 200:
|
|
payload = {"error": {"message": "private-request-detail", "type": "invalid_request_error"}}
|
|
return httpx.Response(status, json=payload)
|
|
|
|
def client(**settings):
|
|
return OpenAI(**settings, http_client=httpx.Client(transport=httpx.MockTransport(serve)))
|
|
|
|
with patch.dict("os.environ", {"OPENAI_API_KEY": "unit-test"}), patch("src.llm_service.OpenAI", client):
|
|
return classify("Сломалась плита", "REAL AI")
|
|
|
|
def test_real_parses_result_and_provider_usage(self):
|
|
data = dict(category="normal", reason="Нужен ремонт плиты.", draft_reply="Уточните модель, пожалуйста.",
|
|
needs_review=False)
|
|
content = {"type": "output_text", "text": json.dumps(data), "annotations": []}
|
|
output = self.run_with_response(content)
|
|
self.assertEqual((output.model, output.input_tokens, output.output_tokens, output.cached_tokens),
|
|
("provider-model", 120, 31, 64))
|
|
self.assertEqual(output.reason, "Нужен ремонт плиты.")
|
|
self.assertTrue(output.needs_review)
|
|
|
|
def test_real_rejects_refusal_and_invalid_schema(self):
|
|
responses = [
|
|
{"type": "refusal", "refusal": "Отклонено"},
|
|
{"type": "output_text", "text": '{"category": "unknown"}', "annotations": []},
|
|
]
|
|
for content in responses:
|
|
with self.subTest(content=content), self.assertRaisesRegex(ValueError, "ответ"):
|
|
self.run_with_response(content)
|
|
|
|
def test_real_hides_provider_error_detail(self):
|
|
with self.assertRaisesRegex(ValueError, "401") as caught:
|
|
self.run_with_response(None, status=401)
|
|
self.assertNotIn("private-request-detail", str(caught.exception))
|
|
|
|
def test_unavailable_service_stops_after_one_retry(self):
|
|
with patch("openai._base_client.time.sleep") as delay:
|
|
with self.assertRaisesRegex(ValueError, "503"):
|
|
self.run_with_response(None, status=503)
|
|
delay.assert_called_once()
|