test(load): lab3 add ai generated k6 write scenario

This commit is contained in:
Голиков Maximillian Антон
2026-10-08 16:12:11 +03:00
parent b11b5f69c1
commit a5b668c31c
10 changed files with 777 additions and 0 deletions
+79
View File
@@ -0,0 +1,79 @@
# Собственные тесты
Проверки негативных сценариев, конкурентной работы, жизненного цикла
сессий и отказов хранилищ. Отдельно от публичных `tests/`.
Сервер должен быть поднят на `http://localhost:8080`.
## Быстрый прогон
python student-tests/run_all.py --base-url http://localhost:8080
Запускает `test_cases.py`, `test_concurrency.py`, `test_auth.py`.
Это базовый набор, не требующий особой конфигурации стенда.
## Отдельные сценарии
python student-tests/test_expiry.py --base-url http://localhost:8080
Требует стенд с `SESSION_TTL_SECONDS=2`. Проверяет, что сессия
перестаёт работать после истечения TTL. Меняй TTL в `compose.yaml`,
перезапускай api и прогоняй.
python student-tests/test_resilience.py --service redis
python student-tests/test_resilience.py --service postgres
Требуют запущенного Docker и работающего стенда. Скрипт останавливает
указанный сервис через `docker compose stop`, проверяет, что защищённые
endpoint отдают 503 unavailable (не 401 и не 500), и запускает сервис
обратно.
## Данные для EXPLAIN
python student-tests/seed_messages.py --count 10000
student-tests/explain_history.sh <chat_id>
`seed_messages.py` печатает `chat_id`; передай его в `explain_history.sh`,
результат сохранится в `evidence/explain_history.txt`.
## Трек 2: план запроса и восстановление
Исследование на ≥100 000 сообщениях с неравномерными размерами чатов.
python student-tests/seed_large.py
# сохранить chat_id из вывода в evidence/chat_ids.txt
student-tests/explain_history.sh <hot_chat_id>
student-tests/compare_indexes.sh <hot_chat_id>
student-tests/write_bench.sh
student-tests/backup_restore.sh
Результаты попадают в `evidence/`:
- `explain_history.txt` — EXPLAIN (ANALYZE, BUFFERS) ключевого запроса
- `index_comparison.txt` — baseline vs covering vs Seq Scan
- `write_cost.txt` — время 5000 INSERT под разными индексами
- `backup_restore.txt` — pg_dump → pg_restore → сверка счётчиков и md5
Восстановленный контейнер `pg_restore_target` оставлен для ручной проверки
и удаляется вручную после эксперимента.
## Нагрузка (k6)
Open-loop генератор: фиксированный arrival rate, устраняет coordinated
omission, отдельные метрики для POST /messages. Дополняет `tests/load.py`
(closed-loop), а не заменяет его.
k6 run -e RATE=50 -e DURATION=30s student-tests/load-k6.js
k6 run -e RATE=50 -e DURATION=3m \
--summary-export evidence/k6-rolling.json \
student-tests/load-k6.js
Setup регистрирует отдельного пользователя и создаёт чат. Чтобы нагружать
существующий чат (например, из `seed_large.py`), задай `CHAT_ID` и `TOKEN`:
CHAT_ID=... TOKEN=... k6 run -e RATE=50 -e DURATION=1m student-tests/load-k6.js
Summary (`--summary-export`) — JSON с p50/p95/p99 `write_latency_ms`,
`write_errors.rate`, `http_reqs.rate`. Порог `write_errors<1%` встроен в
options.thresholds: k6 вернёт non-zero exit, если под нагрузкой появились
ошибки сверх порога.
+125
View File
@@ -0,0 +1,125 @@
// k6 — open-loop нагрузка на POST /messages.
//
// В отличие от tests/load.py (closed-loop) генерирует фиксированный
// arrival rate независимо от того, как быстро отвечает сервер. Это
// устраняет coordinated omission: если сервер тормозит, k6 не снижает
// интенсивность, а честно измеряет latency и долю ошибок.
//
// Два режима:
// 1. Default — setup регистрирует пользователя, логинится и создаёт чат.
// 2. External — если заданы CHAT_ID и TOKEN, используется существующий
// чат (например, из student-tests/seed_large.py). Регистрация не нужна.
//
// Запуск:
// k6 run -e RATE=50 -e DURATION=30s student-tests/load-k6.js
// k6 run -e RATE=50 -e DURATION=3m student-tests/load-k6.js \
// --summary-export evidence/k6-rolling.json
// CHAT_ID=... TOKEN=... k6 run -e RATE=50 -e DURATION=1m student-tests/load-k6.js
//
// Метрики:
// write_latency_ms — latency POST /messages (p50/p95/p99 в summary)
// write_errors — доля не-201
// write_total — счётчик запросов
import http from 'k6/http';
import encoding from 'k6/encoding';
import { check, fail } from 'k6';
import { Trend, Rate, Counter } from 'k6/metrics';
const RATE = parseInt(__ENV.RATE || '50', 10);
const DURATION = __ENV.DURATION || '1m';
const BASE = __ENV.BASE_URL || 'http://localhost:8080';
const EXTERNAL_CHAT = __ENV.CHAT_ID || '';
const EXTERNAL_TOKEN = __ENV.TOKEN || '';
const writeLatency = new Trend('write_latency_ms', true);
const writeErrors = new Rate('write_errors');
const writeTotal = new Counter('write_total');
export const options = {
scenarios: {
writes: {
executor: 'constant-arrival-rate',
rate: RATE,
timeUnit: '1s',
duration: DURATION,
preAllocatedVUs: Math.max(50, RATE * 2),
maxVUs: Math.max(200, RATE * 4),
},
},
thresholds: {
// Порог уровня 4: не более 1% ошибок. В треке 1 проверим,
// удерживается ли при разных профилях нагрузки.
'write_errors': ['rate<0.01'],
},
};
export function setup() {
if (EXTERNAL_CHAT && EXTERNAL_TOKEN) {
return { token: EXTERNAL_TOKEN, chatId: EXTERNAL_CHAT };
}
if ((EXTERNAL_CHAT && !EXTERNAL_TOKEN) || (!EXTERNAL_CHAT && EXTERNAL_TOKEN)) {
fail('CHAT_ID и TOKEN должны задаваться вместе');
}
const suffix = Math.random().toString(36).slice(2, 10);
const username = `k6_${suffix}`;
const password = 'Example-pass-12345678';
const reg = http.post(`${BASE}/api/v1/users`, JSON.stringify({
username, display_name: `K6 ${suffix}`, password,
}), { headers: { 'Content-Type': 'application/json' } });
if (reg.status !== 201) fail(`register failed: ${reg.status} ${reg.body}`);
const user = reg.json();
const encoded = encoding.b64encode(`${username}:${password}`);
const sess = http.post(`${BASE}/api/v1/auth/sessions`, null, {
headers: { 'Authorization': `Basic ${encoded}` },
});
if (sess.status !== 201) fail(`login failed: ${sess.status} ${sess.body}`);
const token = sess.json().token;
const chat = http.post(`${BASE}/api/v1/chats`, JSON.stringify({
title: `k6 chat ${suffix}`,
member_ids: [user.id],
}), {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`,
},
});
if (chat.status !== 201) fail(`chat failed: ${chat.status} ${chat.body}`);
return { token, chatId: chat.json().id };
}
export default function (data) {
const key = `k6-${__VU}-${__ITER}-${Date.now()}`;
const body = JSON.stringify({ text: `msg vu=${__VU} iter=${__ITER}` });
const res = http.post(
`${BASE}/api/v1/chats/${data.chatId}/messages`,
body,
{
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${data.token}`,
'Idempotency-Key': key,
},
tags: { name: 'POST /messages' },
},
);
writeTotal.add(1);
writeLatency.add(res.timings.duration);
writeErrors.add(res.status !== 201);
check(res, {
'status is 201': (r) => r.status === 201,
'has message id': (r) => {
try { return !!r.json().id; } catch { return false; }
},
});
}
+26
View File
@@ -0,0 +1,26 @@
#!/usr/bin/env python3
import subprocess
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent
QUICK = ('test_cases.py', 'test_concurrency.py', 'test_auth.py')
def main():
args = sys.argv[1:]
failed = []
for script in QUICK:
print(f'=== {script} ===')
result = subprocess.run([sys.executable, str(ROOT / script), *args])
if result.returncode != 0:
failed.append(script)
if failed:
print('FAILED:', ', '.join(failed))
sys.exit(1)
print('=== Все тесты прошли ===')
if __name__ == '__main__':
main()
+82
View File
@@ -0,0 +1,82 @@
#!/usr/bin/env python3
"""Сидирует 100k сообщений в 24 чата с неравномерными размерами (трек 2)."""
import base64
import sys
import time
import uuid
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, arguments, check, run # noqa: E402
def make_user(c, label):
username = f'{label}_{uuid.uuid4().hex[:12]}'
password = 'T3st-' + uuid.uuid4().hex
user = c.call('POST', '/api/v1/users', 201, body={
'username': username, 'display_name': label.capitalize(),
'password': password}, schema='User')['json']
cred = base64.b64encode(f'{username}:{password}'.encode()).decode()
s = c.call('POST', '/api/v1/auth/sessions', 201,
headers={'Authorization': 'Basic ' + cred}, schema='Session')['json']
return {'id': user['id'], 'username': username, 'token': s['token']}
def seed_chat(base_url, ca_file, alice, bob, title, count, workers=8):
c = Client(base_url, ca_file)
chat = c.call('POST', '/api/v1/chats', 201, actor=alice, body={
'title': title, 'member_ids': [alice['id'], bob['id']]},
schema='Chat')['json']
chat_id = chat['id']
per_worker = count // workers
remainder = count - per_worker * workers
def worker(wid):
local = Client(base_url, ca_file, timeout=20)
n = per_worker + (1 if wid < remainder else 0)
for i in range(n):
local.call('POST', f'/api/v1/chats/{chat_id}/messages', 201,
actor=alice, body={'text': f'{title} #{wid}-{i}'},
schema='Message')
started = time.monotonic()
with ThreadPoolExecutor(max_workers=workers) as pool:
list(pool.map(worker, range(workers)))
elapsed = time.monotonic() - started
print(f' {title}: {count} сообщений за {elapsed:.1f}s ({count/max(elapsed,0.001):.0f}/s)')
return chat_id
def main():
args = arguments('Сидирует неравномерные чаты для трека 2')
c = Client(args.base_url, args.ca_file)
alice = make_user(c, 'track2_a')
bob = make_user(c, 'track2_b')
plan = (
[('hot', 55_000)] +
[('medium-%d' % i, 10_000) for i in range(1, 4)] +
[('small-%d' % i, 1_000) for i in range(1, 11)] +
[('tiny-%d' % i, 500) for i in range(1, 11)]
)
total = sum(n for _, n in plan)
check(total == 100_000, f'сумма {total} != 100000')
result = {}
started = time.monotonic()
for title, count in plan:
result[title] = seed_chat(args.base_url, args.ca_file, alice, bob, title, count)
elapsed = time.monotonic() - started
print(f'\nВсего {total} сообщений за {elapsed:.1f}s ({total/elapsed:.0f}/s)')
print('chat_id для EXPLAIN (сохраните эти значения):')
for title in ('hot', 'medium-1', 'small-1', 'tiny-1'):
print(f' {title}: {result[title]}')
if __name__ == '__main__':
run(main)
+56
View File
@@ -0,0 +1,56 @@
#!/usr/bin/env python3
"""Заполняет один чат N сообщениями. Надо EXPLAIN."""
import base64
import sys
import time
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, arguments, check, run # noqa: E402
def make_user(c, label):
username = f'{label}_{uuid.uuid4().hex[:12]}'
password = 'T3st-' + uuid.uuid4().hex
user = c.call('POST', '/api/v1/users', 201, body={
'username': username, 'display_name': label.capitalize(),
'password': password}, schema='User')['json']
cred = base64.b64encode(f'{username}:{password}'.encode()).decode()
s = c.call('POST', '/api/v1/auth/sessions', 201,
headers={'Authorization': 'Basic ' + cred}, schema='Session')['json']
return {'id': user['id'], 'token': s['token']}
def main():
def configure(p):
p.add_argument('--count', type=int, default=10000)
args = arguments('Сид для EXPLAIN: создаёт count сообщений в новом чате', configure)
check(args.count >= 1 and args.count <= 1_000_000, 'count вне диапазона')
c = Client(args.base_url, args.ca_file)
alice = make_user(c, 'seed_a')
bob = make_user(c, 'seed_b')
chat = c.call('POST', '/api/v1/chats', 201, actor=alice, body={
'title': 'Seed chat', 'member_ids': [alice['id'], bob['id']]},
schema='Chat')['json']
started = time.monotonic()
for i in range(args.count):
c.call('POST', f"/api/v1/chats/{chat['id']}/messages", 201,
actor=alice, body={'text': f'seed message {i}'}, schema='Message')
if (i + 1) % 1000 == 0:
print(f' {i + 1}/{args.count}')
elapsed = time.monotonic() - started
print(f'seeded {args.count} messages in {elapsed:.1f}s '
f'({args.count / elapsed:.0f}/s)')
print(f'chat_id={chat["id"]}')
if __name__ == '__main__':
run(main)
+81
View File
@@ -0,0 +1,81 @@
#!/usr/bin/env python3
import base64
import uuid
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, Failure, arguments, check, run # noqa: E402
def register(c, username, password):
c.call('POST', '/api/v1/users', 201, body={
'username': username,
'display_name': 'Auth test',
'password': password,
})
def login(c, username, password):
cred = base64.b64encode(f'{username}:{password}'.encode()).decode()
r = c.call('POST', '/api/v1/auth/sessions', 201,
headers={'Authorization': 'Basic ' + cred}, schema='Session')
return r['json']
def main():
args = arguments('Logout и неверные учётные данные')
c = Client(args.base_url, args.ca_file)
# --- logout отзывает текущую сессию ---
username = 'lo_' + uuid.uuid4().hex[:10]
password = 'T3st-' + uuid.uuid4().hex
register(c, username, password)
session = login(c, username, password)
actor = {'id': session['user']['id'], 'token': session['token']}
# токен работает
c.call('GET', '/api/v1/users/me', actor=actor, schema='User')
# отзываем
c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=actor)
# тот же токен больше не работает
c.call('GET', '/api/v1/users/me', 401, actor=actor)
c.call('DELETE', '/api/v1/auth/sessions/current', 401, actor=actor)
# --- неверный пароль и неизвестный username дают одинаковый 401 ---
wrong = base64.b64encode(f'{username}:wrong-password-123'.encode()).decode()
r_wrong = c.call('POST', '/api/v1/auth/sessions', 401,
headers={'Authorization': 'Basic ' + wrong})
check('Basic' in r_wrong['headers'].get('WWW-Authenticate', ''),
'нет WWW-Authenticate: Basic на неверный пароль')
unknown = base64.b64encode(
f'nobody_{uuid.uuid4().hex[:10]}:any-password-123'.encode()).decode()
r_unknown = c.call('POST', '/api/v1/auth/sessions', 401,
headers={'Authorization': 'Basic ' + unknown})
check(r_wrong['json']['error']['code'] == 'unauthorized',
'неверный пароль: ожидался код unauthorized')
check(r_unknown['json']['error']['code'] == 'unauthorized',
'неизвестный username: ожидался код unauthorized')
check(r_wrong['json']['error']['message'] == r_unknown['json']['error']['message'],
'сообщения отличаются: перебор username возможен')
# --- X-User-Id не даёт доступ в lab2 ---
c.call('GET', '/api/v1/users/me', 401,
headers={'X-User-Id': session['user']['id']})
# --- Basic на бизнес-endpoint не проходит ---
good = base64.b64encode(f'{username}:{password}'.encode()).decode()
c.call('GET', '/api/v1/users/me', 401,
headers={'Authorization': 'Basic ' + good})
print('PASS: logout, wrong password, X-User-Id и Basic на бизнес-endpoint')
if __name__ == '__main__':
run(main)
+112
View File
@@ -0,0 +1,112 @@
#!/usr/bin/env python3
import sys
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, LAB, Failure, arguments, check, run # noqa: E402
def main():
args = arguments('Собственные тесты негативных сценариев')
c = Client(args.base_url, args.ca_file)
alice, bob, eve, chat = c.bootstrap()
path = '/api/v1/chats/' + chat['id']
# --- некорректный JSON ---
malformed = b'{"username":"alice","display_name":"A"'
c.call('POST', '/api/v1/users', 400, raw=malformed,
headers={'Content-Type': 'application/json'})
# --- лишнее поле ---
c.call('POST', '/api/v1/users', 400,
body={'username': 'u_' + uuid.uuid4().hex[:8],
'display_name': 'X', 'extra': 'мусор'})
# --- неверный тип поля ---
c.call('POST', '/api/v1/users', 400,
body={'username': 123, 'display_name': 'X'})
# --- пустой display_name ---
c.call('POST', '/api/v1/users', 400,
body={'username': 'u_' + uuid.uuid4().hex[:8], 'display_name': ''})
# --- display_name только из пробелов ---
c.call('POST', '/api/v1/users', 400,
body={'username': 'u_' + uuid.uuid4().hex[:8], 'display_name': ' '})
# --- заглавные в username ---
c.call('POST', '/api/v1/users', 400,
body={'username': 'UPPERCASE', 'display_name': 'X'})
# --- дубликат username ---
c.call('POST', '/api/v1/users', 409, body=alice['registration'])
# --- пустое сообщение ---
c.call('POST', path + '/messages', 400, actor=alice, body={'text': ''})
# --- сообщение только из пробелов ---
c.call('POST', path + '/messages', 400, actor=alice, body={'text': ' '})
# --- чужой чат ---
c.call('GET', path, 404, actor=eve)
c.call('GET', path + '/messages', 404, actor=eve)
c.call('POST', path + '/messages', 404, actor=eve, body={'text': 'чужое'})
# --- чат без создателя в member_ids ---
c.call('POST', '/api/v1/chats', 400, actor=alice,
body={'title': 'Без меня', 'member_ids': [bob['id']]})
# --- чат с неизвестным участником ---
c.call('POST', '/api/v1/chats', 400, actor=alice,
body={'title': 'С фантомом',
'member_ids': [alice['id'], '00000000-0000-4000-8000-000000000000']})
# --- чат с дубликатами ---
c.call('POST', '/api/v1/chats', 400, actor=alice,
body={'title': 'Дубликаты', 'member_ids': [alice['id'], alice['id']]})
# --- обход нескольких страниц ---
for i in range(5):
c.message(alice, chat, 'page-test-%d' % i)
seen = []
cursor = None
for _ in range(20):
query = path + '/messages?limit=2'
if cursor:
from urllib.parse import quote
query += '&cursor=' + quote(cursor, safe='')
page = c.call('GET', query, actor=alice, schema='MessagePage')['json']
seen.extend(x['id'] for x in page['items'])
cursor = page['next_cursor']
if cursor is None:
break
check(len(seen) == len(set(seen)), 'пагинация вернула дубликаты')
check(len(seen) >= 5, 'пагинация потеряла сообщения')
# --- cursor от другого чата ---
other_chat = c.call('POST', '/api/v1/chats', 201, actor=alice,
body={'title': 'Другой чат',
'member_ids': [alice['id'], bob['id']]},
schema='Chat')['json']
other_path = '/api/v1/chats/' + other_chat['id']
c.message(alice, other_chat, 'other-1')
c.message(alice, other_chat, 'other-2')
other_page = c.call('GET', other_path + '/messages?limit=1', actor=alice,
schema='MessagePage')['json']
other_cursor = other_page['next_cursor']
check(other_cursor is not None, 'ожидался cursor от другого чата, но получен null')
from urllib.parse import quote
c.call('GET', path + '/messages?limit=2&cursor=' + quote(other_cursor, safe=''),
400, actor=alice)
print('PASS: негативные сценарии прошли')
if __name__ == '__main__':
run(main)
+81
View File
@@ -0,0 +1,81 @@
#!/usr/bin/env python3
import threading
import uuid
from concurrent.futures import ThreadPoolExecutor
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, LAB, Failure, arguments, check, run # noqa: E402
def main():
args = arguments('Собственные тесты конкурентности')
c = Client(args.base_url, args.ca_file)
alice, bob, eve, chat = c.bootstrap()
path = '/api/v1/chats/' + chat['id']
# --- 100 сообщений от 10 потоков ---
workers = 10
per_worker = 10
expected_total = workers * per_worker
barrier = threading.Barrier(workers)
def writer(worker_id):
local = Client(args.base_url, args.ca_file, timeout=10)
barrier.wait()
for i in range(per_worker):
local.message(alice, chat, 'c-%d-%d' % (worker_id, i))
with ThreadPoolExecutor(max_workers=workers) as pool:
list(pool.map(writer, range(workers)))
seen = []
cursor = None
while True:
q = path + '/messages?limit=100'
if cursor:
from urllib.parse import quote
q += '&cursor=' + quote(cursor, safe='')
page = c.call('GET', q, actor=alice, schema='MessagePage')['json']
seen.extend(x['id'] for x in page['items'])
cursor = page['next_cursor']
if cursor is None:
break
check(len(seen) == len(set(seen)), 'после параллельной записи обнаружены дубликаты id сообщений')
check(len(seen) == expected_total,
'ожидалось ровно %d сообщений, получено %d' % (expected_total, len(seen)))
# --- гонка за username ---
username = 'race_' + uuid.uuid4().hex[:8]
password = 'T3st-' + uuid.uuid4().hex
body = {'username': username, 'display_name': 'Race', 'password': password}
barrier2 = threading.Barrier(workers)
def register(_):
local = Client(args.base_url, args.ca_file, timeout=10)
barrier2.wait()
try:
local.call('POST', '/api/v1/users', 201, body=body)
return 'ok'
except Failure:
return 'conflict'
with ThreadPoolExecutor(max_workers=workers) as pool:
results = list(pool.map(register, range(workers)))
ok_count = results.count('ok')
conflict_count = results.count('conflict')
check(ok_count == 1, 'ожидалась ровно одна успешная регистрация, получено %d' % ok_count)
check(conflict_count == workers - 1,
'ожидалось %d конфликтов, получено %d' % (workers - 1, conflict_count))
print('PASS: конкурентность (100 сообщений, 1 победитель в гонке за username)')
if __name__ == '__main__':
run(main)
+46
View File
@@ -0,0 +1,46 @@
#!/usr/bin/env python3
import base64
import time
import uuid
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, arguments, check, run # noqa: E402
def main():
args = arguments('Истечение сессии. Требует SESSION_TTL_SECONDS=2')
c = Client(args.base_url, args.ca_file)
username = 'exp_' + uuid.uuid4().hex[:10]
password = 'T3st-' + uuid.uuid4().hex
c.call('POST', '/api/v1/users', 201, body={
'username': username, 'display_name': 'Exp', 'password': password})
cred = base64.b64encode(f'{username}:{password}'.encode()).decode()
s = c.call('POST', '/api/v1/auth/sessions', 201,
headers={'Authorization': 'Basic ' + cred}, schema='Session')['json']
actor = {'id': s['user']['id'], 'token': s['token']}
# сразу после логина — работает
c.call('GET', '/api/v1/users/me', actor=actor, schema='User')
# ждём больше TTL. Если TTL не 2, тест упадёт с понятным сообщением
# (см. проверку ниже по факту отказа).
time.sleep(3.5)
# ожидаем 401 с Bearer challenge
r = c.call('GET', '/api/v1/users/me', 401, actor=actor)
challenge = r['headers'].get('WWW-Authenticate', '')
check(challenge.lower().startswith('bearer'),
f'ожидался WWW-Authenticate: Bearer, получено {challenge!r}')
# и сразу проверяем, что до истечения он работал — уже сделано выше
print('PASS: сессия истекла после TTL и вернула 401 Bearer')
if __name__ == '__main__':
run(main)
+89
View File
@@ -0,0 +1,89 @@
#!/usr/bin/env python3
import argparse
import subprocess
import time
import uuid
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, check, run # noqa: E402
REPO_ROOT = ROOT
def compose(*args, timeout=90):
return subprocess.run(
['docker', 'compose', '--env-file', '.env', *args],
cwd=REPO_ROOT, capture_output=True, text=True, timeout=timeout,
)
def make_user(c):
username = 'rs_' + uuid.uuid4().hex[:10]
password = 'T3st-' + uuid.uuid4().hex
c.call('POST', '/api/v1/users', 201, body={
'username': username, 'display_name': 'Res', 'password': password})
import base64
cred = base64.b64encode(f'{username}:{password}'.encode()).decode()
s = c.call('POST', '/api/v1/auth/sessions', 201,
headers={'Authorization': 'Basic ' + cred}, schema='Session')['json']
return {'id': s['user']['id'], 'token': s['token']}
def wait_ready(c, seconds=90):
deadline = time.monotonic() + seconds
while time.monotonic() < deadline:
try:
c.call('GET', '/health/ready', schema='Health')
return
except Exception:
time.sleep(1)
raise RuntimeError('health/ready не восстановился за %d секунд' % seconds)
def main():
p = argparse.ArgumentParser()
p.add_argument('--service', choices=['redis', 'postgres'], required=True)
p.add_argument('--base-url', default=None)
args = p.parse_args()
c = Client(args.base_url)
alice = make_user(c)
c.call('GET', '/api/v1/users/me', actor=alice, schema='User')
print(f'[{args.service}] останавливаем сервис')
r = compose('stop', args.service)
check(r.returncode == 0, f'docker compose stop: {r.stderr.strip()}')
try:
time.sleep(2)
# Защищённый endpoint должен вернуть 503 unavailable.
resp = c.call('GET', '/api/v1/users/me', 503, actor=alice)
code = resp['json']['error']['code']
check(code == 'unavailable',
f'ожидался код unavailable, получено {code!r}')
# Сообщение не должно раскрывать детали про Redis/Postgres/сеть.
msg = resp['json']['error']['message'].lower()
for bad in ('redis', 'postgres', 'sql', 'connection', 'refused', 'dial'):
check(bad not in msg, f'сообщение раскрывает "{bad}": {msg}')
# Здоровье тоже должно репортить 503.
c.call('GET', '/health/ready', 503)
finally:
print(f'[{args.service}] запускаем сервис обратно')
r = compose('start', args.service)
check(r.returncode == 0, f'docker compose start: {r.stderr.strip()}')
wait_ready(c)
# Токен alice всё ещё валиден после возврата сервиса.
c.call('GET', '/api/v1/users/me', actor=alice, schema='User')
print(f'PASS: {args.service} недоступен → 503 unavailable без утечек; восстановление OK')
if __name__ == '__main__':
run(main)