forked from mtusi2026/mtusi2026lab4
168 lines
8.0 KiB
Python
168 lines
8.0 KiB
Python
"""Real PostgreSQL + private S3 integration; synthetic images only."""
|
|
import hashlib
|
|
import io
|
|
import struct
|
|
import uuid
|
|
import zlib
|
|
from PIL import Image
|
|
from psycopg import sql
|
|
from test_api import client, user, login
|
|
|
|
|
|
def image_bytes(kind='PNG'):
|
|
stream = io.BytesIO()
|
|
Image.new('RGB',(320,200),(45,110,190)).save(stream,format=kind)
|
|
return stream.getvalue()
|
|
|
|
|
|
def actors(c):
|
|
a,ab=user(c)
|
|
b,bb=user(c)
|
|
e,eb=user(c)
|
|
ah,_=login(c,ab)
|
|
bh,_=login(c,bb)
|
|
eh,_=login(c,eb)
|
|
chat=c.post('/api/v1/chats',headers=ah,json={'title':'Файлы','member_ids':[a['id'],b['id']]}).json()
|
|
return ah,bh,eh,chat
|
|
|
|
|
|
def upload(c,headers,chat,raw=None,mime='image/png',filename='Фото.png'):
|
|
raw=image_bytes() if raw is None else raw
|
|
return c.post('/api/v1/chats/'+chat['id']+'/attachments',params={'filename':filename},content=raw,
|
|
headers={**headers,'Content-Type':mime})
|
|
|
|
|
|
def test_original_png_jpeg_and_message(client):
|
|
ah,bh,eh,chat=actors(client)
|
|
for kind,mime in [('PNG','image/png'),('JPEG','image/jpeg')]:
|
|
raw=image_bytes(kind)
|
|
r=upload(client,ah,chat,raw,mime)
|
|
assert r.status_code==201
|
|
att=r.json()
|
|
assert att['status']=='ready' and att['variants']==[] and att['error_code'] is None
|
|
assert att['sha256']==hashlib.sha256(raw).hexdigest() and att['size_bytes']==len(raw)
|
|
assert 'object_key' not in att and 'bucket' not in att
|
|
path='/api/v1/attachments/'+att['id']
|
|
assert client.get(path,headers=bh).json()==att
|
|
content=client.get(path+'/content',headers=bh)
|
|
assert content.status_code==200 and content.content==raw
|
|
assert content.headers['Content-Type']==mime
|
|
for suffix in ['', '/content']:
|
|
assert client.get(path+suffix,headers=eh).status_code==404
|
|
assert client.get(path+'/content?variant=thumbnail',headers=bh).status_code==400
|
|
response=client.post('/api/v1/chats/'+chat['id']+'/messages',headers={**ah,'Idempotency-Key':uuid.uuid4().hex},
|
|
json={'text':'','attachment_ids':[att['id']]})
|
|
assert response.status_code==201
|
|
assert response.json()['attachment_ids']==[att['id']]
|
|
|
|
|
|
def test_invalid_media_corruption_limits_and_filename(client):
|
|
ah,_,_,chat=actors(client)
|
|
cases=[(b'not an image','image/png',415),(image_bytes(),'image/jpeg',415),
|
|
(image_bytes('JPEG'),'image/png',415),(image_bytes()[:40],'image/png',415),
|
|
(image_bytes(),'text/plain',415),(b'x'*(10485760+1),'image/png',413)]
|
|
for raw,mime,expected in cases:
|
|
response=upload(client,ah,chat,raw,mime)
|
|
assert response.status_code==expected
|
|
assert response.json()['error']['request_id']==response.headers['X-Request-Id']
|
|
# Valid PNG header advertises >40Mp; reject before attempting decompression.
|
|
header=struct.pack('!IIBBBBB',10001,4000,8,2,0,0,0)
|
|
chunk=lambda tag,data: struct.pack('!I',len(data))+tag+data+struct.pack('!I',zlib.crc32(tag+data)&0xffffffff)
|
|
bomb=b'\x89PNG\r\n\x1a\n'+chunk(b'IHDR',header)+chunk(b'IDAT',zlib.compress(b''))+chunk(b'IEND',b'')
|
|
assert upload(client,ah,chat,bomb).status_code==413
|
|
for filename in ['../x.png','a\\b.png','bad\x00.png','bad\x1f.png','bad\x7f.png',' ','x'*256]:
|
|
assert upload(client,ah,chat,filename=filename).status_code==400
|
|
|
|
|
|
def test_foreign_attachment_binding_and_normalized_replay(client):
|
|
ah,bh,eh,chat=actors(client)
|
|
att=upload(client,ah,chat).json()
|
|
other=client.post('/api/v1/chats',headers=bh,json={'title':'Другой чат','member_ids':[chat['member_ids'][0],chat['member_ids'][1]]}).json()
|
|
path='/api/v1/chats/'+other['id']+'/messages'
|
|
for aid in [att['id'],str(uuid.uuid4())]:
|
|
response=client.post(path,headers={**bh,'Idempotency-Key':uuid.uuid4().hex},json={'text':'test','attachment_ids':[aid]})
|
|
assert response.status_code==404
|
|
assert upload(client,eh,chat).status_code==404
|
|
h={**ah,'Idempotency-Key':uuid.uuid4().hex}
|
|
path='/api/v1/chats/'+chat['id']+'/messages'
|
|
first=client.post(path,headers=h,json={'text':'same'})
|
|
replay=client.post(path,headers=h,json={'attachment_ids':[],'text':'same'})
|
|
assert first.status_code==replay.status_code==201 and first.json()==replay.json()
|
|
conflict=client.post(path,headers=h,json={'text':'same','attachment_ids':[att['id']]})
|
|
assert conflict.status_code==409
|
|
duplicates=client.post(path,headers={**ah,'Idempotency-Key':uuid.uuid4().hex},json={'text':'','attachment_ids':[att['id'],att['id']]})
|
|
assert duplicates.status_code==400
|
|
|
|
|
|
def test_compensate_s3_when_metadata_insert_fails(client):
|
|
ah,_,_,chat=actors(client)
|
|
db=client.app.state.db
|
|
store=client.app.state.storage
|
|
before={item['Key'] for page in store.pages() for item in page.get('Contents',[])}
|
|
function='fail_attachment_'+uuid.uuid4().hex
|
|
trigger='fail_attachment_'+uuid.uuid4().hex
|
|
filename='fault_'+uuid.uuid4().hex+'.png'
|
|
with db.pool.connection() as conn:
|
|
conn.execute(sql.SQL("CREATE FUNCTION {}() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN IF NEW.filename={} THEN RAISE EXCEPTION 'synthetic metadata failure'; END IF; RETURN NEW; END $$").format(sql.Identifier(function),sql.Literal(filename)))
|
|
conn.execute(sql.SQL('CREATE TRIGGER {} BEFORE INSERT ON attachments FOR EACH ROW EXECUTE FUNCTION {}()').format(sql.Identifier(trigger),sql.Identifier(function)))
|
|
try:
|
|
response=upload(client,ah,chat,filename=filename)
|
|
assert response.status_code==503
|
|
with db.pool.connection() as conn:
|
|
assert conn.execute('SELECT count(*) AS n FROM attachments WHERE filename=%s',(filename,)).fetchone()['n']==0
|
|
after={item['Key'] for page in store.pages() for item in page.get('Contents',[])}
|
|
assert after==before
|
|
finally:
|
|
with db.pool.connection() as conn:
|
|
conn.execute(sql.SQL('DROP TRIGGER IF EXISTS {} ON attachments').format(sql.Identifier(trigger)))
|
|
conn.execute(sql.SQL('DROP FUNCTION IF EXISTS {}()').format(sql.Identifier(function)))
|
|
|
|
|
|
def test_compensation_preserves_committed_object(client):
|
|
from messenger.attachments import compensate
|
|
ah,_,_,chat=actors(client)
|
|
att=upload(client,ah,chat).json()
|
|
with client.app.state.db.pool.connection() as conn:
|
|
key=conn.execute('SELECT object_key FROM attachments WHERE id=%s',(att['id'],)).fetchone()['object_key']
|
|
# A retry after an unknown COMMIT result must never delete an already tracked object.
|
|
compensate(client.app.state.db,client.app.state.storage,key)
|
|
content=client.get('/api/v1/attachments/'+att['id']+'/content',headers=ah)
|
|
assert content.status_code==200 and content.content==image_bytes()
|
|
|
|
|
|
def test_stream_close_even_if_headers_cannot_be_sent(client):
|
|
import asyncio
|
|
import pytest
|
|
from messenger.attachments import ObjectResponse
|
|
ah,_,_,chat=actors(client)
|
|
att=upload(client,ah,chat).json()
|
|
with client.app.state.db.pool.connection() as conn:
|
|
key=conn.execute('SELECT object_key FROM attachments WHERE id=%s',(att['id'],)).fetchone()['object_key']
|
|
store=client.app.state.storage
|
|
opened=store.get(key)
|
|
response=ObjectResponse(opened,media_type='image/png')
|
|
async def fail_send(message):
|
|
raise OSError('synthetic disconnected transport')
|
|
async def receive():
|
|
return {'type':'http.disconnect'}
|
|
with pytest.raises(Exception):
|
|
asyncio.run(response({'type':'http','asgi':{'spec_version':'2.4'}},receive,fail_send))
|
|
assert opened.closed
|
|
acquired=0
|
|
try:
|
|
for _ in range(8):
|
|
assert store.gate.acquire(blocking=False)
|
|
acquired+=1
|
|
finally:
|
|
for _ in range(acquired):
|
|
store.gate.release()
|
|
|
|
|
|
def test_chunked_upload_is_limited_without_content_length(client):
|
|
ah,_,_,chat=actors(client)
|
|
chunks=iter([b'x'*1048576]*10+[b'x'])
|
|
response=client.post('/api/v1/chats/'+chat['id']+'/attachments?filename=chunked.png',
|
|
content=chunks,headers={**ah,'Content-Type':'image/png'})
|
|
assert response.status_code==413
|
|
assert response.json()['error']['code']=='payload_too_large'
|