forked from mtusi2026/mtusi2026lab5
104 lines
5.2 KiB
Python
104 lines
5.2 KiB
Python
from collections import Counter
|
|
|
|
import images
|
|
from common import api_containers, call, check, new_chat, new_key, new_user, run_tests, send, upload
|
|
|
|
|
|
def test_requests_spread_over_replicas():
|
|
alice = new_user("alice")
|
|
replies = [call("GET", "/api/v1/users/me", 200, token=alice["token"]) for _ in range(20)]
|
|
served = Counter(reply.instance for reply in replies)
|
|
print(f"20 x GET /users/me with one token -> replicas: {dict(served)}")
|
|
check(all(reply.json["id"] == alice["id"] for reply in replies), "another user returned")
|
|
check(len(served) >= 2, "all requests went to one replica: balancing does not work")
|
|
print("PASS: one session works on every replica, no second login (sessions are shared in Redis)")
|
|
|
|
|
|
def test_write_on_one_read_on_other():
|
|
alice, bob = new_user("alice"), new_user("bob")
|
|
chat = new_chat(alice, bob)
|
|
sent = send(alice, chat["id"], "written on one replica")
|
|
readers = set()
|
|
for _ in range(6):
|
|
reply = call("GET", f"/api/v1/chats/{chat['id']}/messages", 200, token=bob["token"])
|
|
check(sent.json in reply.json["items"], "confirmed message is not visible on another replica")
|
|
readers.add(reply.instance)
|
|
print(f"message written by {sent.instance}; read back by {sorted(readers)}")
|
|
check(readers - {sent.instance}, "no read went to another replica")
|
|
print("PASS: a message written via one replica is read right away via another (shared PostgreSQL)")
|
|
|
|
|
|
def test_logout_seen_by_all_replicas():
|
|
user = new_user("logout")
|
|
out = call("DELETE", "/api/v1/auth/sessions/current", 204, token=user["token"])
|
|
after = [call("GET", "/api/v1/users/me", 401, token=user["token"]).instance for _ in range(10)]
|
|
print(f"logout on {out.instance}; old token then rejected by {sorted(set(after))}")
|
|
check(len(set(after)) >= 2, "only one replica answered")
|
|
print("PASS: logout on one replica revokes the session on all of them")
|
|
|
|
|
|
def test_idempotent_retry_on_other_replica():
|
|
alice, bob = new_user("alice"), new_user("bob")
|
|
chat = new_chat(alice, bob)
|
|
key = new_key()
|
|
first = send(alice, chat["id"], "retry me", key=key)
|
|
for _ in range(10): # round robin: следующий запрос уйдёт на другую реплику
|
|
retry = send(alice, chat["id"], "retry me", key=key)
|
|
if retry.instance != first.instance:
|
|
break
|
|
print(f"first POST on {first.instance} -> 201 {first.json['id']}; "
|
|
f"same key on {retry.instance} -> {retry.status} {retry.json['id']}")
|
|
check(retry.instance != first.instance, "retry never reached another replica")
|
|
check(retry.json == first.json, "retry on another replica returned a different message")
|
|
items = call("GET", f"/api/v1/chats/{chat['id']}/messages", 200, token=bob["token"]).json["items"]
|
|
check([m["text"] for m in items].count("retry me") == 1, "retry created a duplicate")
|
|
print("PASS: Idempotency-Key is shared: a retry through another replica returns the same message")
|
|
|
|
|
|
def test_attachment_on_other_replica():
|
|
alice, bob = new_user("alice"), new_user("bob")
|
|
chat = new_chat(alice, bob)
|
|
data = images.sample_png()
|
|
sent = upload(alice, chat["id"], data)
|
|
readers = set()
|
|
for _ in range(6):
|
|
reply = call("GET", f"/api/v1/attachments/{sent.json['id']}/content", 200, token=bob["token"])
|
|
check(reply.data == data, "another replica returned different bytes")
|
|
readers.add(reply.instance)
|
|
print(f"file uploaded via {sent.instance}; downloaded byte for byte via {sorted(readers)}")
|
|
check(readers - {sent.instance}, "no download went to another replica")
|
|
print("PASS: a file uploaded through one replica is downloaded through another (shared S3, nothing local)")
|
|
|
|
|
|
def test_instance_header_everywhere():
|
|
containers = api_containers()
|
|
alice, eve = new_user("alice"), new_user("eve")
|
|
chat = new_chat(alice)
|
|
replies = [
|
|
call("GET", "/health/live", 200),
|
|
call("GET", "/health/ready", 200),
|
|
send(alice, chat["id"], "hello"),
|
|
call("POST", f"/api/v1/chats/{chat['id']}/messages", 400, token=alice["token"], body={"text": "no key"}),
|
|
call("GET", "/api/v1/users/me", 401),
|
|
call("GET", f"/api/v1/chats/{chat['id']}", 404, token=eve["token"]),
|
|
call("POST", "/api/v1/users", 409,
|
|
body={"username": alice["username"], "display_name": "x", "password": alice["password"]}),
|
|
]
|
|
for reply in replies: # call() уже проверил, что заголовок есть; здесь — что это настоящий контейнер
|
|
check(any(container.startswith(reply.instance) for container in containers),
|
|
f"X-Instance-Id {reply.instance} is not a running api container")
|
|
print(f"statuses {[r.status for r in replies]}: every answer has X-Instance-Id of a running container "
|
|
f"{sorted({r.instance for r in replies})}; api containers: {[c[:12] for c in containers]}")
|
|
print("PASS: X-Instance-Id is in every response and points to a real container")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
run_tests([
|
|
test_requests_spread_over_replicas,
|
|
test_write_on_one_read_on_other,
|
|
test_logout_seen_by_all_replicas,
|
|
test_idempotent_retry_on_other_replica,
|
|
test_attachment_on_other_replica,
|
|
test_instance_header_everywhere,
|
|
])
|