Files
mtusi2026lab2/tests/lab2_checks.py
T

328 lines
8.5 KiB
Python

from __future__ import annotations
import base64
import json
import os
import subprocess
import unittest
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from threading import Barrier
from urllib.error import HTTPError
from urllib.request import Request, urlopen
from uuid import uuid4
BASE_URL = os.getenv(
"BASE_URL",
"http://localhost:18081",
).rstrip("/")
PROJECT_DIR = Path(__file__).resolve().parent.parent
PASSWORD = "Synthetic-test-password-123"
class Lab2Checks(unittest.TestCase):
def request(
self,
method,
path,
payload=None,
token=None,
headers=None,
):
request_headers = dict(headers or {})
data = None
if payload is not None:
data = json.dumps(
payload,
ensure_ascii=False,
).encode("utf-8")
request_headers["Content-Type"] = "application/json"
if token is not None:
request_headers["Authorization"] = f"Bearer {token}"
request = Request(
BASE_URL + path,
data=data,
headers=request_headers,
method=method,
)
try:
response = urlopen(request, timeout=20)
except HTTPError as exc:
response = exc
with response:
status = response.code
response_headers = response.headers
raw = response.read()
request_id = response_headers.get("X-Request-Id")
self.assertTrue(request_id, "Missing X-Request-Id")
body = json.loads(raw.decode("utf-8")) if raw else None
if status >= 400:
self.assertIsInstance(body, dict)
self.assertEqual(set(body), {"error"})
self.assertEqual(
set(body["error"]),
{"code", "message", "request_id"},
)
self.assertEqual(
body["error"]["request_id"],
request_id,
)
return status, body, response_headers
def create_user(self, password=PASSWORD):
username = "u_" + uuid4().hex[:20]
status, user, _ = self.request(
"POST",
"/api/v1/users",
{
"username": username,
"display_name": "Тестовый пользователь",
"password": password,
},
)
self.assertEqual(status, 201)
self.assertEqual(
set(user),
{"id", "username", "display_name", "created_at"},
)
return username, user
def login(self, username, password=PASSWORD):
credentials = base64.b64encode(
f"{username}:{password}".encode("utf-8")
).decode("ascii")
return self.request(
"POST",
"/api/v1/auth/sessions",
headers={"Authorization": f"Basic {credentials}"},
)
def create_logged_in_user(self):
username, user = self.create_user()
status, session, _ = self.login(username)
self.assertEqual(status, 201)
return user, session["token"]
def database_counts(self):
result = subprocess.run(
[
"docker",
"compose",
"--env-file",
".env",
"exec",
"-T",
"postgres",
"psql",
"-U",
"messenger",
"-d",
"messenger",
"-At",
"-v",
"ON_ERROR_STOP=1",
"-c",
(
"SELECT "
"(SELECT count(*) FROM chats), "
"(SELECT count(*) FROM chat_members);"
),
],
cwd=PROJECT_DIR,
check=True,
capture_output=True,
text=True,
timeout=15,
)
return tuple(
int(value)
for value in result.stdout.strip().split("|")
)
def test_wrong_password(self):
username, _ = self.create_user()
status, body, headers = self.login(
username,
"Definitely-wrong-password-123",
)
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
self.assertEqual(
headers.get("WWW-Authenticate"),
'Basic realm="messenger", charset="UTF-8"',
)
unknown_username = "missing_" + uuid4().hex[:16]
other_status, other_body, _ = self.login(
unknown_username,
"Definitely-wrong-password-123",
)
self.assertEqual(other_status, 401)
self.assertEqual(
body["error"]["message"],
other_body["error"]["message"],
)
def test_logout(self):
_, token = self.create_logged_in_user()
status, _, _ = self.request(
"GET",
"/api/v1/users/me",
token=token,
)
self.assertEqual(status, 200)
status, body, _ = self.request(
"DELETE",
"/api/v1/auth/sessions/current",
token=token,
)
self.assertEqual(status, 204)
self.assertIsNone(body)
status, _, headers = self.request(
"GET",
"/api/v1/users/me",
token=token,
)
self.assertEqual(status, 401)
self.assertEqual(
headers.get("WWW-Authenticate"),
'Bearer realm="messenger"',
)
status, _, _ = self.request(
"DELETE",
"/api/v1/auth/sessions/current",
token=token,
)
self.assertEqual(status, 401)
def test_x_user_id_does_not_authenticate_or_change_user(self):
first_user, token = self.create_logged_in_user()
_, second_user = self.create_user()
status, _, _ = self.request(
"GET",
"/api/v1/users/me",
headers={"X-User-Id": second_user["id"]},
)
self.assertEqual(status, 401)
status, body, _ = self.request(
"GET",
"/api/v1/users/me",
token=token,
headers={"X-User-Id": second_user["id"]},
)
self.assertEqual(status, 200)
self.assertEqual(body["id"], first_user["id"])
def test_unicode_password_with_colons(self):
password = "Учебный:пароль:длинный-123"
username, _ = self.create_user(password=password)
status, _, _ = self.login(username, password=password)
self.assertEqual(status, 201)
def test_concurrent_username_registration(self):
workers = 4
barrier = Barrier(workers)
username = "race_" + uuid4().hex[:20]
payload = {
"username": username,
"display_name": "Конкурентная регистрация",
"password": PASSWORD,
}
def register(_):
barrier.wait(timeout=10)
status, _, _ = self.request(
"POST",
"/api/v1/users",
payload,
)
return status
with ThreadPoolExecutor(max_workers=workers) as executor:
statuses = list(executor.map(register, range(workers)))
self.assertEqual(
sorted(statuses),
[201, 409, 409, 409],
)
status, _, _ = self.login(username)
self.assertEqual(status, 201)
def test_chat_creation_rollback(self):
user, token = self.create_logged_in_user()
before = self.database_counts()
status, body, _ = self.request(
"POST",
"/api/v1/chats",
{
"title": "Этот чат должен откатиться",
"member_ids": [
user["id"],
str(uuid4()),
],
},
token=token,
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
after = self.database_counts()
self.assertEqual(
before,
after,
"Failed chat creation left database rows",
)
status, _, _ = self.request(
"POST",
"/api/v1/chats",
{
"title": "Создание после rollback",
"member_ids": [user["id"]],
},
token=token,
)
self.assertEqual(status, 201)
if __name__ == "__main__":
unittest.main(verbosity=2)