Files
mtusi2026lab3/tests/test_lab3_analytics.py
T

271 lines
11 KiB
Python
Executable File

#!/usr/bin/env python3
"""Регрессия аналитики трека 1: успешный RPS отделён от частоты ответов.
Проверяются два дефекта, найденные в разборе серии роста и A/B:
1. Пропускная способность считалась как `requests / duration`, поэтому ответы об
ошибках выглядели выполненной работой. На шаге `abdiag#A` 400 req/s клиент
получил 1978 ответов, из них 853 успешных: старая формула давала 131.87 req/s
вместо 56.87, и это же число шло в вердикт A/B и в потолок.
2. Серия роста — блок why# на одном темпе. Точка, отличающаяся от контроля больше
чем одним ключом бюджета или снятая на другом темпе, исключается с причиной.
Тест детерминированный и оффлайн: сырые сводки k6 подставляются фикстурами в
временный каталог, стенд и Docker не нужны.
Запуск: make test-analytics
python3 -m unittest discover -s tests -p 'test_*.py' -v
"""
from __future__ import annotations
import importlib.util
import json
import sys
import tempfile
import unittest
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
def load_lab3():
"""Загружает драйвер экспериментов как модуль, не запуская CLI."""
path = ROOT / 'scripts' / 'lab3' / 'lab3.py'
spec = importlib.util.spec_from_file_location('lab3', path)
if spec is None or spec.loader is None:
raise SystemExit(f'cannot load {path}')
module = importlib.util.module_from_spec(spec)
sys.modules['lab3'] = module
spec.loader.exec_module(module)
return module
lab3 = load_lab3()
# Дефектный шаг из abdiag#A: 1978 ответов за 15 s, 853 успешных, 1125 ответов 503.
DEGRADED_RATE = 400
DEGRADED_REQUESTS = 1978
DEGRADED_OK = 853
DEGRADED_FAILED = 1125
STEP_SECONDS = 15
DEGRADED_SUCCESSFUL_RPS = 56.87
DEGRADED_ATTEMPTED_RPS = 131.87
def step(
rate: int,
*,
ok: int,
requests: int | None = None,
failed: int = 0,
duration: int = STEP_SECONDS,
p95: float = 10.0,
) -> dict:
total = requests if requests is not None else ok + failed
return {
'rate': rate,
'duration_s': duration,
'requests': total,
'successful_rps': round(ok / duration, 2),
'attempted_rps': round(total / duration, 2),
'failed': failed,
'p95': p95,
'vus_active': 0,
'status': {'ok': ok, 'client_4xx': 0, 'server_5xx': failed, 'other': 0},
}
def summary(label: str, kind: str, steps: list[dict], profile: str = 'spread') -> dict:
return {
'label': label,
'profile': profile,
'mode': 'write',
'kind': kind,
'steps': steps,
'dropped_iterations': 0,
}
class AnalyticsTestCase(unittest.TestCase):
"""Изолирует raw/каталоги вывода: аналитика читает их как глобальные пути."""
def setUp(self) -> None:
self._temporary = tempfile.TemporaryDirectory()
root = Path(self._temporary.name)
self.raw_dir = root / 'raw'
self.raw_dir.mkdir()
self.track1_dir = root / 'track1'
self.track1_dir.mkdir()
self._original = (lab3.RAW_DIR, lab3.TRACK1_DIR, lab3.GRAPH_DIR)
lab3.RAW_DIR = self.raw_dir
lab3.TRACK1_DIR = self.track1_dir
lab3.GRAPH_DIR = self.track1_dir / 'graphs'
def tearDown(self) -> None:
lab3.RAW_DIR, lab3.TRACK1_DIR, lab3.GRAPH_DIR = self._original
self._temporary.cleanup()
def write_raw(
self,
label: str,
payload: dict,
*,
profile: str = 'spread',
mode: str = 'write',
manifest: dict | None = None,
) -> None:
(self.raw_dir / f'{label}.k6.json').write_text(json.dumps(payload, ensure_ascii=False, indent=1))
(self.raw_dir / f'{label}.manifest.json').write_text(
json.dumps(
{'label': label, 'profile': profile, 'mode': mode, 'kind': payload.get('kind'), **(manifest or {})},
ensure_ascii=False,
)
)
def capture_log(self) -> list[str]:
messages: list[str] = []
self._log = lab3.log
lab3.log = messages.append
self.addCleanup(lambda: setattr(lab3, 'log', self._log))
return messages
class SuccessfulThroughputTest(AnalyticsTestCase):
def test_error_answers_are_not_throughput(self) -> None:
label = 'ab#A#rep1'
self.write_raw(
label,
summary(
label,
'ladder',
[
step(
DEGRADED_RATE,
ok=DEGRADED_OK,
requests=DEGRADED_REQUESTS,
failed=DEGRADED_FAILED,
p95=5200.88,
)
],
),
)
series = lab3.summarise_series([label])
row = series['rows'][0]
self.assertEqual(row['successful_rps'], DEGRADED_SUCCESSFUL_RPS)
self.assertEqual(row['attempted_rps'], DEGRADED_ATTEMPTED_RPS)
self.assertEqual(row['successful_min'], DEGRADED_SUCCESSFUL_RPS)
self.assertEqual(row['successful_max'], DEGRADED_SUCCESSFUL_RPS)
# Потолок и сатурация считаются по успешным ответам, а не по всем.
self.assertEqual(series['ceiling_rps'], DEGRADED_SUCCESSFUL_RPS)
self.assertEqual(series['saturation']['rate'], DEGRADED_RATE)
self.assertEqual(series['saturation']['successful_rps'], DEGRADED_SUCCESSFUL_RPS)
class AbVerdictTest(AnalyticsTestCase):
def test_verdict_delta_uses_successful_rps(self) -> None:
for rep in (1, 2, 3):
label = f'ab#A#rep{rep}'
self.write_raw(
label,
summary(
label,
'ladder',
[step(DEGRADED_RATE, ok=DEGRADED_OK, requests=DEGRADED_REQUESTS, failed=DEGRADED_FAILED, p95=5200.88)],
),
)
label_b = f'ab#B#rep{rep}'
self.write_raw(label_b, summary(label_b, 'ladder', [step(DEGRADED_RATE, ok=6000, requests=6000, failed=0, p95=24.4)]))
lab3.report_ab()
verdict = json.loads((self.track1_dir / 'ab-verdict.json').read_text())
entry = next(item for item in verdict['verdicts'] if item['rate'] == DEGRADED_RATE)
expected_change = round((400.0 - DEGRADED_SUCCESSFUL_RPS) / DEGRADED_SUCCESSFUL_RPS * 100, 2)
self.assertEqual(entry['change_percent'], expected_change)
self.assertEqual(entry['a']['successful_rps'], DEGRADED_SUCCESSFUL_RPS)
self.assertEqual(entry['a']['attempted_rps'], DEGRADED_ATTEMPTED_RPS)
self.assertEqual(entry['a']['status_5xx'], DEGRADED_FAILED)
self.assertEqual(entry['b']['successful_rps'], 400.0)
self.assertTrue(entry['confirmed'])
# Потолок стороны тоже успешный, а не «все ответы».
self.assertEqual(verdict['ceiling'], {'A': DEGRADED_SUCCESSFUL_RPS, 'B': 400.0})
summary_md = (self.track1_dir / 'summary-ab.md').read_text()
self.assertIn('успешный RPS', summary_md)
self.assertIn(str(DEGRADED_SUCCESSFUL_RPS), summary_md)
self.assertIn(str(DEGRADED_ATTEMPTED_RPS), summary_md)
class GrowthBlockTest(AnalyticsTestCase):
"""Серия роста — блок why# на одном темпе: несопоставимые точки исключаются."""
COMMON = {
'commit': 'c',
'generator': {'max_vus': '900', 'cpus': '1.5', 'memory': '1024m'},
}
BASE_STAND = {
'API_REPLICAS': '4',
'API_TOTAL_CPUS': '3.0',
'PG_CPUS': '1.5',
'DATABASE_POOL_MAX': '10',
'LB_CPUS': '0.25',
'API_IMAGE': 'img',
}
def write_point(self, label: str, successful: int, stand: dict | None = None, generator: dict | None = None) -> None:
manifest = {
'commit': self.COMMON['commit'],
'generator': {**self.COMMON['generator'], **(generator or {})},
'stand': {**self.BASE_STAND, **(stand or {})},
}
self.write_raw(label, summary(label, 'steady', [step(1500, ok=successful * 60, duration=60)]), manifest=manifest)
def setUp(self) -> None:
super().setUp()
self.write_point('why#n4#rep1', 943)
self.write_point('why#n4-pg3#rep1', 1480, {'PG_CPUS': '3.0'})
self.write_point('why#n4-api6#rep1', 891, {'API_TOTAL_CPUS': '6.0'})
self.write_point('why#n4-pool20#rep1', 853, {'DATABASE_POOL_MAX': '20'})
self.write_point('why#n4-lb1#rep1', 922, {'LB_CPUS': '1.0'}, {'max_vus': '200'})
self.groups = lab3.group_configurations(lab3.raw_labels())
def test_only_comparable_points_are_compared(self) -> None:
lab3.analyse_growth(self.groups)
text = (self.track1_dir / 'summary-growth.md').read_text()
rows = {line.split(' | ')[0].lstrip('| '): line for line in text.splitlines() if line.startswith('| why#')}
self.assertIn('рычаг поднимает потолок', rows['why#n4-pg3'])
self.assertIn('в пределах разброса', rows['why#n4-api6'])
self.assertIn('ухудшает', rows['why#n4-pool20'])
self.assertNotIn('why#n4-lb1', rows)
omitted = text.split('Вне сравнения:')[1]
lb1 = next(line for line in omitted.splitlines() if 'why#n4-lb1' in line)
self.assertIn('max_vus', lb1)
pool5 = next(line for line in omitted.splitlines() if 'why#n4-pool5' in line)
self.assertIn('не снята на этом темпе', pool5)
def test_graph_built_from_same_block(self) -> None:
try:
import matplotlib # noqa: F401
except ImportError:
self.skipTest('matplotlib не установлен: график не строится')
lab3.make_graphs(self.groups)
self.assertTrue((lab3.GRAPH_DIR / 'growth.png').is_file())
class RawSchemaTest(unittest.TestCase):
"""Сырые сводки k6 обязаны быть в текущей схеме: без achieved_rps."""
def test_committed_raw_uses_current_fields(self) -> None:
files = sorted((ROOT / 'evidence' / 'track1' / 'raw').glob('*.k6.json'))
self.assertTrue(files, 'нет сырых сводок k6')
for path in files:
text = path.read_text()
self.assertNotIn('achieved_rps', text, path.name)
for s in json.loads(text).get('steps', []):
self.assertIn('successful_rps', s, path.name)
self.assertIn('attempted_rps', s, path.name)
self.assertLessEqual(s['successful_rps'], s['attempted_rps'], path.name)
if __name__ == '__main__':
unittest.main()