zapret-kvn/tests/test_service_check.py
loop-uh e8ad0b1911
Some checks failed
Windows project source guards / test (push) Failing after 8m21s
Gemini в проверке сервисов: узел, который открывает сайт, но не пускает из своей страны
В каталог «Через этот узел» добавлен Gemini. Сайт gemini.google.com проверяется как остальные (время до первого байта), а регион отдельным одним запросом к generativelanguage.googleapis.com/v1beta/models: статус 400, 403 или 451 вместе с текстом «user location is not supported» значит, что из страны узла сервис не работает; обычный 403 без этого текста (нужен ключ) значит, что регион поддерживается. Так же устроена проверка Gemini на Android.

Новый вердикт «region» (в строке карточки отмечается как «не открывается», в подробностях словами: нужен узел в другой стране) приоритетнее оценки скорости, но не прячет узел, который не открывает сайт совсем. Запрос региона делается только если сайт открылся, поэтому сбой узла не выдаётся за блок по стране; ошибка самого запроса вердикт не меняет.

Тесты: test_service_check с 22 до 39 (вывод по региону, разбор ответа, сбои и отмена, порядок запросов), весь набор 1985 тестов без падений.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-04 11:04:24 -05:00

458 lines
18 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""Проверка сервисов через узел: вывод по времени до первого байта и серия запросов по одному соединению."""
from __future__ import annotations
import unittest
from xray_fluent.network import service_check as sc
YOUTUBE = sc.SERVICES[0]
DISCORD = sc.SERVICES[1]
def _run(host: str, *times: float, failed: bool = False, reason: str = "") -> sc.EndpointRun:
return sc.EndpointRun(host, tuple(times), failed=failed, reason=reason)
class JudgeTests(unittest.TestCase):
def test_fast_answers_are_ok(self) -> None:
verdict = sc.judge(YOUTUBE, [_run("www.youtube.com", 90, 80, 85, 95), _run("i.ytimg.com", 60, 70, 65, 62)])
self.assertEqual(verdict.code, sc.CODE_OK)
self.assertIn("быстрые", verdict.text)
def test_one_long_wait_among_fast_ones_is_a_pause(self) -> None:
verdict = sc.judge(YOUTUBE, [_run("www.youtube.com", 90, 80, 2900, 95)])
self.assertEqual(verdict.code, sc.CODE_PAUSE)
self.assertIn("2.9 с", verdict.text)
def test_every_request_slow_is_slow_not_a_pause(self) -> None:
verdict = sc.judge(YOUTUBE, [_run("www.youtube.com", 3100, 3000, 2900, 3200)])
self.assertEqual(verdict.code, sc.CODE_SLOW)
def test_a_name_that_does_not_open_makes_the_service_partial(self) -> None:
verdict = sc.judge(DISCORD, [_run("discord.com", 100, 90), _run("gateway.discord.gg", failed=True, reason="timeout")])
self.assertEqual(verdict.code, sc.CODE_PARTIAL)
self.assertIn("gateway.discord.gg", verdict.text)
def test_nothing_opens_is_blocked_with_the_reason(self) -> None:
verdict = sc.judge(DISCORD, [_run("discord.com", failed=True, reason="ConnectionResetError")])
self.assertEqual(verdict.code, sc.CODE_BLOCKED)
self.assertIn("ConnectionResetError", verdict.text)
def test_no_runs_is_unknown(self) -> None:
self.assertEqual(sc.judge(YOUTUBE, []).code, sc.CODE_UNKNOWN)
def test_one_slow_answer_without_enough_samples_is_not_a_pause(self) -> None:
self.assertEqual(sc.judge(YOUTUBE, [_run("www.youtube.com", 90, 2900)]).code, sc.CODE_OK)
GEMINI = next(spec for spec in sc.SERVICES if spec.key == "gemini")
_GEMINI_BLOCK_BODY = b'{"error": {"code": 400, "message": "User location is not supported for the API use.", "status": "FAILED_PRECONDITION"}}'
class GeoJudgeTests(unittest.TestCase):
OPEN = [_run("gemini.google.com", 120, 110, 115, 118)]
def test_service_that_opens_but_refuses_the_region_is_region_not_ok(self) -> None:
verdict = sc.judge(GEMINI, self.OPEN, [sc.GeoRun("generativelanguage.googleapis.com", blocked=True, status=400)])
self.assertEqual(verdict.code, sc.CODE_REGION)
self.assertIn("400", verdict.text)
self.assertIn("generativelanguage.googleapis.com", verdict.text)
self.assertAlmostEqual(verdict.ttfb_median_ms, 116.5)
def test_a_supported_region_or_an_unknown_answer_leaves_the_speed_verdict(self) -> None:
for geo in (sc.GeoRun("g", status=403), sc.GeoRun("g", failed=True, reason="timeout")):
with self.subTest(geo=geo):
self.assertEqual(sc.judge(GEMINI, self.OPEN, [geo]).code, sc.CODE_OK)
def test_region_block_does_not_hide_a_node_that_opens_nothing(self) -> None:
verdict = sc.judge(GEMINI, [_run("gemini.google.com", failed=True, reason="timeout")], [sc.GeoRun("g", blocked=True, status=400)])
self.assertEqual(verdict.code, sc.CODE_BLOCKED)
def test_region_block_wins_over_a_slow_or_partial_service(self) -> None:
slow = [_run("gemini.google.com", 3100, 3000, 2900, 3200)]
self.assertEqual(sc.judge(GEMINI, slow, [sc.GeoRun("g", blocked=True, status=400)]).code, sc.CODE_REGION)
def test_judge_without_geo_runs_is_unchanged(self) -> None:
self.assertEqual(sc.judge(GEMINI, self.OPEN).code, sc.CODE_OK)
class _GeoResponse:
def __init__(self, status: int, body: bytes) -> None:
self.status, self.body = status, body
def read(self, _size: int) -> bytes:
return self.body
class _GeoConnection:
def __init__(self, status: int = 200, body: bytes = b"", *, fail: Exception | None = None) -> None:
self.status, self.body, self.fail = status, body, fail
self.requests: list[tuple[str, str]] = []
self.closed = False
def request(self, method, path, headers=None) -> None:
self.requests.append((method, path))
if self.fail is not None:
raise self.fail
def getresponse(self) -> _GeoResponse:
return _GeoResponse(self.status, self.body)
def close(self) -> None:
self.closed = True
class ProbeGeoTests(unittest.TestCase):
RULE = GEMINI.geo[0]
def _probe(self, connection: _GeoConnection, **kwargs) -> sc.GeoRun:
return sc.probe_geo("127.0.0.1", 1, self.RULE, connect=lambda *_a: connection, **kwargs)
def test_status_and_text_together_mean_blocked(self) -> None:
connection = _GeoConnection(400, _GEMINI_BLOCK_BODY)
run = self._probe(connection)
self.assertTrue(run.blocked)
self.assertEqual(run.status, 400)
self.assertEqual(connection.requests, [("GET", "/v1beta/models")])
self.assertTrue(connection.closed)
def test_403_without_the_region_text_means_the_region_is_supported(self) -> None:
run = self._probe(_GeoConnection(403, b'{"error": {"message": "Method doesn\'t allow unregistered callers."}}'))
self.assertFalse(run.blocked)
self.assertEqual(run.status, 403)
def test_the_region_text_with_a_status_outside_the_rule_is_not_a_block(self) -> None:
self.assertFalse(self._probe(_GeoConnection(200, _GEMINI_BLOCK_BODY)).blocked)
def test_text_is_matched_without_regard_to_case(self) -> None:
self.assertTrue(self._probe(_GeoConnection(403, b"USER LOCATION IS NOT SUPPORTED")).blocked)
def test_network_failure_is_unknown_not_blocked(self) -> None:
run = self._probe(_GeoConnection(fail=ConnectionResetError("reset")))
self.assertTrue(run.failed)
self.assertFalse(run.blocked)
self.assertEqual(run.reason, "ConnectionResetError")
def test_proxy_that_refuses_the_tunnel_is_unknown_not_blocked(self) -> None:
def refuse(*_a):
raise OSError("proxy refused")
run = sc.probe_geo("127.0.0.1", 1, self.RULE, connect=refuse)
self.assertTrue(run.failed)
self.assertFalse(run.blocked)
def test_cancelled_check_makes_no_request(self) -> None:
connection = _GeoConnection(400, _GEMINI_BLOCK_BODY)
run = self._probe(connection, cancelled=lambda: True)
self.assertTrue(run.failed)
self.assertEqual(connection.requests, [])
class GeoCheckTests(unittest.TestCase):
@staticmethod
def _open(_h, _p, host, path, cancelled):
return _run(host, 120, 110, 115, 118)
def test_gemini_is_in_the_catalog_with_a_region_rule(self) -> None:
self.assertEqual(GEMINI.title, "Gemini")
self.assertEqual(len(GEMINI.geo), 1)
self.assertEqual(GEMINI.geo[0].host, "generativelanguage.googleapis.com")
self.assertIn(400, GEMINI.geo[0].statuses)
def test_check_service_reports_region_when_the_site_opens_and_the_api_refuses(self) -> None:
def geo(_h, _p, rule, cancelled):
return sc.GeoRun(rule.host, blocked=True, status=400)
verdict = sc.check_service("127.0.0.1", 1, GEMINI, probe=self._open, geo_probe=geo)
self.assertEqual(verdict.code, sc.CODE_REGION)
def test_region_is_not_asked_when_the_site_does_not_open(self) -> None:
calls: list[str] = []
def closed(_h, _p, host, path, cancelled):
return _run(host, failed=True, reason="timeout")
def geo(_h, _p, rule, cancelled):
calls.append(rule.host)
return sc.GeoRun(rule.host)
verdict = sc.check_service("127.0.0.1", 1, GEMINI, probe=closed, geo_probe=geo)
self.assertEqual(verdict.code, sc.CODE_BLOCKED)
self.assertEqual(calls, [])
def test_services_without_a_region_rule_never_ask(self) -> None:
calls: list[str] = []
def geo(_h, _p, rule, cancelled):
calls.append(rule.host)
return sc.GeoRun(rule.host)
verdict = sc.check_service("127.0.0.1", 1, YOUTUBE, probe=self._open, geo_probe=geo)
self.assertEqual(verdict.code, sc.CODE_OK)
self.assertEqual(calls, [])
def test_summary_marks_a_region_block_like_a_blocked_service(self) -> None:
verdicts = {"youtube": sc.ServiceVerdict("youtube", sc.CODE_OK), "gemini": {"code": "region"}}
self.assertEqual(sc.summary_text(verdicts), "✓ YouTube ✗ Gemini")
class _Response:
def __init__(self, will_close: bool = False) -> None:
self.will_close = will_close
def read(self, _size: int) -> bytes:
return b"x"
class _Connection:
"""Подставное соединение: каждый ответ «приходит» за заданное время по подставным часам."""
def __init__(self, clock: "_Clock", delays: list[float], *, fail_after: int | None = None, will_close: bool = False) -> None:
self.clock, self.delays, self.fail_after, self.will_close = clock, list(delays), fail_after, will_close
self.requests = 0
self.closed = False
def request(self, method, path, headers=None) -> None:
if self.fail_after is not None and self.requests >= self.fail_after:
raise ConnectionResetError("reset")
self.requests += 1
def getresponse(self) -> _Response:
self.clock.now += self.delays.pop(0) / 1000
return _Response(self.will_close)
def close(self) -> None:
self.closed = True
class _Clock:
def __init__(self) -> None:
self.now = 0.0
def __call__(self) -> float:
return self.now
class ProbeTests(unittest.TestCase):
def test_first_request_with_the_handshake_is_not_counted(self) -> None:
clock = _Clock()
connection = _Connection(clock, [800, 90, 80, 85, 95])
run = sc.probe_endpoint("127.0.0.1", 1, "www.youtube.com", "/", connect=lambda *_a: connection, clock=clock)
self.assertEqual([round(value) for value in run.ttfb_ms], [90, 80, 85, 95])
self.assertTrue(connection.closed)
self.assertFalse(run.failed)
def test_connection_that_closes_after_the_answer_gives_one_measurement(self) -> None:
clock = _Clock()
connection = _Connection(clock, [300], will_close=True)
run = sc.probe_endpoint("127.0.0.1", 1, "x.com", "/", connect=lambda *_a: connection, clock=clock)
self.assertEqual([round(value) for value in run.ttfb_ms], [300])
self.assertEqual(connection.requests, 1)
def test_reset_on_the_first_request_is_a_failure_with_its_name(self) -> None:
clock = _Clock()
connection = _Connection(clock, [], fail_after=0)
run = sc.probe_endpoint("127.0.0.1", 1, "x.com", "/", connect=lambda *_a: connection, clock=clock)
self.assertTrue(run.failed)
self.assertEqual((run.ttfb_ms, run.reason), ((), "ConnectionResetError"))
def test_reset_in_the_middle_keeps_what_was_measured(self) -> None:
clock = _Clock()
connection = _Connection(clock, [500, 90, 95], fail_after=3)
run = sc.probe_endpoint("127.0.0.1", 1, "x.com", "/", connect=lambda *_a: connection, clock=clock)
self.assertTrue(run.failed)
self.assertEqual([round(value) for value in run.ttfb_ms], [90, 95])
def test_proxy_that_refuses_the_tunnel_is_a_failure(self) -> None:
def refuse(*_args):
raise ConnectionRefusedError("no proxy")
run = sc.probe_endpoint("127.0.0.1", 1, "x.com", "/", connect=refuse)
self.assertTrue(run.failed)
def test_stop_ends_the_series(self) -> None:
clock = _Clock()
connection = _Connection(clock, [300, 90, 90, 90, 90])
run = sc.probe_endpoint("127.0.0.1", 1, "x.com", "/", connect=lambda *_a: connection, clock=clock, cancelled=lambda: True)
self.assertEqual(connection.requests, 0)
self.assertEqual(run.ttfb_ms, ())
class CheckAllTests(unittest.TestCase):
def test_every_service_of_the_catalog_gets_a_verdict(self) -> None:
def probe(_h, _p, host, path, cancelled):
return _run(host, 80, 90, 85, 88) if host != "gateway.discord.gg" else _run(host, failed=True, reason="timeout")
def no_geo(_h, _p, rule, cancelled):
return sc.GeoRun(rule.host, status=403)
verdicts = sc.check_all("127.0.0.1", 1, probe=probe, geo_probe=no_geo)
self.assertEqual(set(verdicts), {spec.key for spec in sc.SERVICES})
self.assertEqual(verdicts["youtube"].code, sc.CODE_OK)
self.assertEqual(verdicts["discord"].code, sc.CODE_PARTIAL)
def test_summary_line_names_every_service_with_a_mark(self) -> None:
verdicts = {
"youtube": sc.ServiceVerdict("youtube", sc.CODE_OK),
"discord": sc.ServiceVerdict("discord", sc.CODE_BLOCKED),
"telegram": {"code": "pause"},
}
self.assertEqual(sc.summary_text(verdicts), "✓ YouTube ✗ Discord ⚠ Telegram")
def test_catalog_is_free_of_duplicates(self) -> None:
self.assertEqual(len({spec.key for spec in sc.SERVICES}), len(sc.SERVICES))
self.assertTrue(all(spec.endpoints for spec in sc.SERVICES))
class NodeStorageTests(unittest.TestCase):
def test_services_survive_saving_and_old_nodes_load_without_them(self) -> None:
from xray_fluent.profiles.models import Node
node = Node(name="n", services={"youtube": {"code": "ok", "text": "быстро"}}, services_checked_at="2026-10-20T12:00:00+00:00")
restored = Node.from_dict(node.to_dict())
self.assertEqual(restored.services, node.services)
self.assertEqual(restored.services_checked_at, node.services_checked_at)
old = {key: value for key, value in node.to_dict().items() if not key.startswith("services")}
self.assertEqual(Node.from_dict(old).services, {})
class DetailTextTests(unittest.TestCase):
def test_card_lists_marks_and_words_only_for_problems(self) -> None:
from xray_fluent.profiles.models import Node
from xray_fluent.ui.node_detail_widget import NodeDetailWidget
node = Node(
name="n",
services={
"youtube": {"code": "ok", "text": "быстро"},
"discord": {"code": "pause", "text": "ответы идут с паузами"},
},
services_checked_at="2026-10-20T12:00:00+00:00",
)
text = NodeDetailWidget._services_text(_Format(), node)
self.assertIn("✓ YouTube ⚠ Discord", text)
self.assertIn("Discord: ответы идут с паузами", text)
self.assertNotIn("YouTube: быстро", text)
self.assertEqual(NodeDetailWidget._services_text(_Format(), Node(name="n")), "")
class WorkerAndControllerTests(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
from PyQt6.QtWidgets import QApplication
cls.app = QApplication.instance() or QApplication([])
def _worker(self, **kwargs):
from xray_fluent.network.speed_test_worker import SpeedTestWorker
return SpeedTestWorker([], "xray.exe", **kwargs)
def test_worker_emits_the_verdicts_only_when_asked(self) -> None:
from unittest.mock import patch
from xray_fluent.profiles.models import Node
verdicts = {"youtube": sc.ServiceVerdict("youtube", sc.CODE_OK, "быстро")}
node = Node(name="n")
for asked, expected in ((True, [(node.id, {"youtube": verdicts["youtube"].as_dict()})]), (False, [])):
worker = self._worker(check_services=asked)
got: list = []
worker.services.connect(lambda node_id, data: got.append((node_id, data)))
with patch.object(sc, "check_all", return_value=verdicts) as check:
worker._check_node_services(node, 4321)
self.assertEqual(got, expected)
self.assertEqual(check.call_count, 1 if asked else 0)
def test_failed_check_does_not_break_the_speed_result(self) -> None:
from unittest.mock import patch
from xray_fluent.profiles.models import Node
worker = self._worker(check_services=True)
with patch.object(sc, "check_all", side_effect=RuntimeError("boom")):
worker._check_node_services(Node(name="n"), 4321)
def test_stop_skips_the_check(self) -> None:
from unittest.mock import patch
from xray_fluent.profiles.models import Node
worker = self._worker(check_services=True)
worker._cancelled = True
with patch.object(sc, "check_all") as check:
worker._check_node_services(Node(name="n"), 4321)
check.assert_not_called()
def test_controller_stores_verdicts_in_the_node_and_refreshes_the_list(self) -> None:
from types import SimpleNamespace
from xray_fluent.application import worker_service
from xray_fluent.profiles.models import Node
node = Node(name="n", speed_mbps=3.0, is_alive=True)
emitted: list = []
worker = object()
controller = SimpleNamespace(
sender=lambda: worker,
_speed_worker=worker,
_get_node_by_id=lambda node_id: node if node_id == node.id else None,
speed_updated=SimpleNamespace(emit=lambda *args: emitted.append(args)),
)
worker_service.on_services_result(controller, node.id, {"youtube": {"code": "ok", "text": "быстро"}, "bad": "x"})
self.assertEqual(set(node.services), {"youtube"})
self.assertTrue(node.services_checked_at)
self.assertEqual(emitted, [(node.id, 3.0, True)])
# Чужой сигнал (не от текущего теста) игнорируется.
controller.sender = lambda: object()
worker_service.on_services_result(controller, node.id, {"x": {"code": "ok"}})
self.assertEqual(set(node.services), {"youtube"})
class _Format:
@staticmethod
def _format_ts(value: str) -> str:
return value[:10]
if __name__ == "__main__":
unittest.main()