forked from mtusi2026/mtusi2026lab2
Подтверждённые сообщения и действующие сессии переживают перезапуск, история читается по индексу, копия восстанавливается в новый том.
216 lines
8.7 KiB
Python
216 lines
8.7 KiB
Python
import subprocess
|
|
import threading
|
|
import unittest
|
|
import uuid
|
|
from urllib.parse import quote
|
|
|
|
from api import basic, bearer, request
|
|
|
|
|
|
def psql(sql):
|
|
result = subprocess.run(
|
|
[
|
|
'docker', 'exec', '-i', 'mtusi-lab2-postgres',
|
|
'psql', '-U', 'messenger', '-d', 'messenger', '-v', 'ON_ERROR_STOP=1', '-tAc', sql,
|
|
],
|
|
check=True,
|
|
capture_output=True,
|
|
text=True,
|
|
)
|
|
return result.stdout.strip()
|
|
|
|
|
|
def register(username, password, display_name='Студент'):
|
|
status, headers, payload = request('POST', '/api/v1/users', body={
|
|
'username': username,
|
|
'display_name': display_name,
|
|
'password': password,
|
|
})
|
|
return status, headers, payload
|
|
|
|
|
|
class ApiTests(unittest.TestCase):
|
|
def test_lab1_edges_still_hold(self):
|
|
status, headers, payload = request(
|
|
'POST', '/api/v1/users',
|
|
body={'username': 'not a user', 'display_name': 'Имя', 'password': 'long-enough-pass'},
|
|
headers={'Content-Type': 'application/jsonx'},
|
|
)
|
|
self.assertEqual(status, 415)
|
|
self.assertEqual(payload['error']['code'], 'unsupported_media_type')
|
|
self.assertTrue(headers['X-Request-Id'])
|
|
|
|
username = 'edge_' + uuid.uuid4().hex[:8]
|
|
password = 'edge-password-1'
|
|
status, _, user = register(username, password)
|
|
self.assertEqual(status, 201)
|
|
self.assertNotIn('password', user)
|
|
self.assertNotIn('password_hash', user)
|
|
status, _, session = request('POST', '/api/v1/auth/sessions', headers=basic(username, password))
|
|
self.assertEqual(status, 201)
|
|
token = session['token']
|
|
auth = bearer(token)
|
|
|
|
status, _, chat = request('POST', '/api/v1/chats', headers=auth, body={
|
|
'title': 'края',
|
|
'member_ids': [user['id']],
|
|
})
|
|
self.assertEqual(status, 201)
|
|
path = '/api/v1/chats/' + chat['id'] + '/messages'
|
|
status, _, _ = request('GET', path + '?limit=999999999', headers=auth)
|
|
self.assertEqual(status, 400)
|
|
status, _, _ = request('GET', path + '?cursor=@@@', headers=auth)
|
|
self.assertEqual(status, 400)
|
|
status, _, _ = request('POST', '/api/v1/users', body={
|
|
'username': username,
|
|
'display_name': 'Имя',
|
|
'password': 'long-enough-pass',
|
|
'extra': 1,
|
|
})
|
|
self.assertEqual(status, 400)
|
|
|
|
def test_password_hash_is_argon2id_and_quotes_stay_data(self):
|
|
username = 'hash_' + uuid.uuid4().hex[:8]
|
|
password = 'hash-password-1'
|
|
display = "a'; drop table users;--"
|
|
status, _, user = register(username, password, display)
|
|
self.assertEqual(status, 201)
|
|
stored_name = psql("SELECT display_name FROM users WHERE username = '%s'" % username)
|
|
self.assertEqual(stored_name, display)
|
|
prefix = psql("SELECT left(password_hash, 9) FROM users WHERE username = '%s'" % username)
|
|
self.assertEqual(prefix, '$argon2id')
|
|
leaked = psql(
|
|
"SELECT position('%s' in password_hash) FROM users WHERE username = '%s'" % (password, username)
|
|
)
|
|
self.assertEqual(leaked, '0')
|
|
self.assertEqual(psql("SELECT to_regclass('public.users')"), 'users')
|
|
status, headers, _ = request(
|
|
'POST', '/api/v1/auth/sessions',
|
|
headers=basic(username, 'wrong-password'),
|
|
)
|
|
self.assertEqual(status, 401)
|
|
self.assertTrue(headers['WWW-Authenticate'].lower().startswith('basic'))
|
|
|
|
def test_colon_in_password_and_logout(self):
|
|
username = 'colon_' + uuid.uuid4().hex[:8]
|
|
password = 'left:right:pass'
|
|
status, _, user = register(username, password)
|
|
self.assertEqual(status, 201)
|
|
status, _, session = request('POST', '/api/v1/auth/sessions', headers=basic(username, password))
|
|
self.assertEqual(status, 201)
|
|
auth = bearer(session['token'])
|
|
status, _, me = request('GET', '/api/v1/users/me', headers=auth)
|
|
self.assertEqual(status, 200)
|
|
self.assertEqual(me['id'], user['id'])
|
|
status, _, me = request(
|
|
'GET', '/api/v1/users/me',
|
|
headers={**auth, 'X-User-Id': str(uuid.uuid4())},
|
|
)
|
|
self.assertEqual(me['id'], user['id'])
|
|
status, headers, _ = request('GET', '/api/v1/users/me', headers={'X-User-Id': user['id']})
|
|
self.assertEqual(status, 401)
|
|
self.assertTrue(headers['WWW-Authenticate'].lower().startswith('bearer'))
|
|
status, headers, _ = request('GET', '/api/v1/users/me', headers=basic(username, password))
|
|
self.assertEqual(status, 401)
|
|
self.assertTrue(headers['WWW-Authenticate'].lower().startswith('bearer'))
|
|
status, _, raw = request('DELETE', '/api/v1/auth/sessions/current', headers=auth)
|
|
self.assertEqual(status, 204)
|
|
self.assertIsNone(raw)
|
|
status, _, _ = request('GET', '/api/v1/users/me', headers=auth)
|
|
self.assertEqual(status, 401)
|
|
status, _, _ = request('DELETE', '/api/v1/auth/sessions/current', headers=auth)
|
|
self.assertEqual(status, 401)
|
|
|
|
def test_duplicate_username_race(self):
|
|
username = 'race_' + uuid.uuid4().hex[:8]
|
|
password = 'race-password-1'
|
|
barrier = threading.Barrier(8)
|
|
results = []
|
|
lock = threading.Lock()
|
|
|
|
def once():
|
|
barrier.wait()
|
|
status, _, _ = register(username, password)
|
|
with lock:
|
|
results.append(status)
|
|
|
|
threads = [threading.Thread(target=once) for _ in range(8)]
|
|
for thread in threads:
|
|
thread.start()
|
|
for thread in threads:
|
|
thread.join()
|
|
self.assertEqual(results.count(201), 1, results)
|
|
self.assertEqual(results.count(409), 7, results)
|
|
self.assertEqual(psql("SELECT count(*) FROM users WHERE username = '%s'" % username), '1')
|
|
|
|
def test_chat_create_rolls_back(self):
|
|
username = 'roll_' + uuid.uuid4().hex[:8]
|
|
password = 'roll-password-1'
|
|
status, _, user = register(username, password)
|
|
self.assertEqual(status, 201)
|
|
status, _, session = request('POST', '/api/v1/auth/sessions', headers=basic(username, password))
|
|
auth = bearer(session['token'])
|
|
title = 'rollback_' + uuid.uuid4().hex[:10]
|
|
missing = str(uuid.uuid4())
|
|
before = psql('SELECT count(*) FROM chats')
|
|
status, _, _ = request('POST', '/api/v1/chats', headers=auth, body={
|
|
'title': title,
|
|
'member_ids': [user['id'], missing],
|
|
})
|
|
self.assertEqual(status, 400)
|
|
self.assertEqual(psql("SELECT count(*) FROM chats WHERE title = '%s'" % title), '0')
|
|
self.assertEqual(psql('SELECT count(*) FROM chats'), before)
|
|
|
|
def test_read_after_write_and_pages(self):
|
|
username = 'page_' + uuid.uuid4().hex[:8]
|
|
password = 'page-password-1'
|
|
status, _, user = register(username, password)
|
|
status, _, session = request('POST', '/api/v1/auth/sessions', headers=basic(username, password))
|
|
auth = bearer(session['token'])
|
|
status, _, chat = request('POST', '/api/v1/chats', headers=auth, body={
|
|
'title': 'страницы',
|
|
'member_ids': [user['id']],
|
|
})
|
|
sent = []
|
|
for text in ('раз', 'два', 'три'):
|
|
status, _, message = request(
|
|
'POST', '/api/v1/chats/%s/messages' % chat['id'],
|
|
headers=auth,
|
|
body={'text': text},
|
|
)
|
|
self.assertEqual(status, 201)
|
|
sent.append(message)
|
|
status, _, page = request(
|
|
'GET', '/api/v1/chats/%s/messages?limit=2' % chat['id'],
|
|
headers=auth,
|
|
)
|
|
self.assertEqual(page['items'], sent[:2])
|
|
self.assertIsNotNone(page['next_cursor'])
|
|
status, _, rest = request(
|
|
'GET', '/api/v1/chats/%s/messages?limit=2&cursor=%s' % (
|
|
chat['id'], quote(page['next_cursor'], safe=''),
|
|
),
|
|
headers=auth,
|
|
)
|
|
self.assertEqual(rest['items'], sent[2:])
|
|
self.assertIsNone(rest['next_cursor'])
|
|
|
|
def test_migrations_do_not_duplicate(self):
|
|
before = psql('SELECT count(*) FROM users')
|
|
versions = psql('SELECT count(*) FROM schema_migrations')
|
|
self.assertEqual(versions, '1')
|
|
out = subprocess.check_output(
|
|
[
|
|
'docker', 'exec', 'mtusi-lab2-api', 'python', '-c',
|
|
"import sys; sys.path.insert(0, '/app/src'); import db; print(len(db.apply_migrations()))",
|
|
],
|
|
text=True,
|
|
)
|
|
self.assertEqual(out.strip(), '0')
|
|
self.assertEqual(psql('SELECT count(*) FROM users'), before)
|
|
self.assertEqual(psql("SELECT version FROM schema_migrations"), '001_init.sql')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|