328 lines
8.5 KiB
Python
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) |