a166b6d37f
- Add conditional request support (If-None-Match, If-Modified-Since) returning 304 Not Modified - Add caching headers: Cache-Control (immutable), Last-Modified - Add 416 Range Not Satisfiable response for invalid range requests - Add download completion logging with bytes transferred and throughput - Add client disconnect handling during streaming downloads - Add comprehensive streaming download tests
536 lines
21 KiB
Python
536 lines
21 KiB
Python
"""
|
|
Integration tests for streaming download functionality.
|
|
|
|
Tests cover:
|
|
- HTTP Range requests (partial downloads, resume)
|
|
- Conditional requests (If-None-Match, If-Modified-Since)
|
|
- Caching headers (Cache-Control, Last-Modified, Accept-Ranges)
|
|
- Large file streaming
|
|
- Download modes (proxy, redirect, presigned)
|
|
"""
|
|
|
|
import pytest
|
|
import io
|
|
import time
|
|
from email.utils import formatdate
|
|
from tests.factories import (
|
|
compute_sha256,
|
|
upload_test_file,
|
|
)
|
|
from tests.conftest import (
|
|
SIZE_1KB,
|
|
SIZE_100KB,
|
|
SIZE_1MB,
|
|
)
|
|
|
|
|
|
class TestRangeRequests:
|
|
"""Tests for HTTP Range request support (partial downloads)."""
|
|
|
|
@pytest.mark.integration
|
|
def test_range_request_first_bytes(self, integration_client, test_package):
|
|
"""Test range request for first N bytes."""
|
|
project, package = test_package
|
|
content = b"0123456789" * 100 # 1000 bytes
|
|
upload_test_file(integration_client, project, package, content, tag="range-test")
|
|
|
|
# Request first 10 bytes
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/range-test",
|
|
params={"mode": "proxy"},
|
|
headers={"Range": "bytes=0-9"},
|
|
)
|
|
assert response.status_code == 206 # Partial Content
|
|
assert response.content == b"0123456789"
|
|
assert "Content-Range" in response.headers
|
|
assert response.headers["Content-Range"].startswith("bytes 0-9/")
|
|
|
|
@pytest.mark.integration
|
|
def test_range_request_middle_bytes(self, integration_client, test_package):
|
|
"""Test range request for bytes in the middle."""
|
|
project, package = test_package
|
|
content = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
upload_test_file(integration_client, project, package, content, tag="range-mid")
|
|
|
|
# Request bytes 10-19 (KLMNOPQRST)
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/range-mid",
|
|
params={"mode": "proxy"},
|
|
headers={"Range": "bytes=10-19"},
|
|
)
|
|
assert response.status_code == 206
|
|
assert response.content == b"KLMNOPQRST"
|
|
|
|
@pytest.mark.integration
|
|
def test_range_request_suffix_bytes(self, integration_client, test_package):
|
|
"""Test range request for last N bytes (suffix range)."""
|
|
project, package = test_package
|
|
content = b"0123456789ABCDEF" # 16 bytes
|
|
upload_test_file(integration_client, project, package, content, tag="range-suffix")
|
|
|
|
# Request last 4 bytes
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/range-suffix",
|
|
params={"mode": "proxy"},
|
|
headers={"Range": "bytes=-4"},
|
|
)
|
|
assert response.status_code == 206
|
|
assert response.content == b"CDEF"
|
|
|
|
@pytest.mark.integration
|
|
def test_range_request_open_ended(self, integration_client, test_package):
|
|
"""Test range request from offset to end."""
|
|
project, package = test_package
|
|
content = b"0123456789"
|
|
upload_test_file(integration_client, project, package, content, tag="range-open")
|
|
|
|
# Request from byte 5 to end
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/range-open",
|
|
params={"mode": "proxy"},
|
|
headers={"Range": "bytes=5-"},
|
|
)
|
|
assert response.status_code == 206
|
|
assert response.content == b"56789"
|
|
|
|
@pytest.mark.integration
|
|
def test_range_request_includes_accept_ranges_header(
|
|
self, integration_client, test_package
|
|
):
|
|
"""Test that range requests include Accept-Ranges header."""
|
|
project, package = test_package
|
|
content = b"test content"
|
|
upload_test_file(integration_client, project, package, content, tag="accept-ranges")
|
|
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/accept-ranges",
|
|
params={"mode": "proxy"},
|
|
headers={"Range": "bytes=0-4"},
|
|
)
|
|
assert response.status_code == 206
|
|
assert response.headers.get("Accept-Ranges") == "bytes"
|
|
|
|
@pytest.mark.integration
|
|
def test_full_download_advertises_accept_ranges(
|
|
self, integration_client, test_package
|
|
):
|
|
"""Test that full downloads advertise range support."""
|
|
project, package = test_package
|
|
content = b"test content"
|
|
upload_test_file(integration_client, project, package, content, tag="full-accept")
|
|
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/full-accept",
|
|
params={"mode": "proxy"},
|
|
)
|
|
assert response.status_code == 200
|
|
assert response.headers.get("Accept-Ranges") == "bytes"
|
|
|
|
|
|
class TestConditionalRequests:
|
|
"""Tests for conditional request handling (304 Not Modified)."""
|
|
|
|
@pytest.mark.integration
|
|
def test_if_none_match_returns_304(self, integration_client, test_package):
|
|
"""Test If-None-Match with matching ETag returns 304."""
|
|
project, package = test_package
|
|
content = b"conditional request test content"
|
|
expected_hash = compute_sha256(content)
|
|
upload_test_file(integration_client, project, package, content, tag="cond-etag")
|
|
|
|
# Request with matching ETag
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/cond-etag",
|
|
params={"mode": "proxy"},
|
|
headers={"If-None-Match": f'"{expected_hash}"'},
|
|
)
|
|
assert response.status_code == 304
|
|
assert response.content == b"" # No body for 304
|
|
|
|
@pytest.mark.integration
|
|
def test_if_none_match_without_quotes(self, integration_client, test_package):
|
|
"""Test If-None-Match works with or without quotes."""
|
|
project, package = test_package
|
|
content = b"etag no quotes test"
|
|
expected_hash = compute_sha256(content)
|
|
upload_test_file(integration_client, project, package, content, tag="cond-noquote")
|
|
|
|
# Request with ETag without quotes
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/cond-noquote",
|
|
params={"mode": "proxy"},
|
|
headers={"If-None-Match": expected_hash},
|
|
)
|
|
assert response.status_code == 304
|
|
|
|
@pytest.mark.integration
|
|
def test_if_none_match_mismatch_returns_200(self, integration_client, test_package):
|
|
"""Test If-None-Match with non-matching ETag returns 200."""
|
|
project, package = test_package
|
|
content = b"etag mismatch test"
|
|
upload_test_file(integration_client, project, package, content, tag="cond-mismatch")
|
|
|
|
# Request with different ETag
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/cond-mismatch",
|
|
params={"mode": "proxy"},
|
|
headers={"If-None-Match": '"different-etag-value"'},
|
|
)
|
|
assert response.status_code == 200
|
|
assert response.content == content
|
|
|
|
@pytest.mark.integration
|
|
def test_if_modified_since_returns_304(self, integration_client, test_package):
|
|
"""Test If-Modified-Since with future date returns 304."""
|
|
project, package = test_package
|
|
content = b"modified since test"
|
|
upload_test_file(integration_client, project, package, content, tag="cond-modified")
|
|
|
|
# Request with future date (artifact was definitely created before this)
|
|
future_date = formatdate(time.time() + 86400, usegmt=True) # Tomorrow
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/cond-modified",
|
|
params={"mode": "proxy"},
|
|
headers={"If-Modified-Since": future_date},
|
|
)
|
|
assert response.status_code == 304
|
|
|
|
@pytest.mark.integration
|
|
def test_if_modified_since_old_date_returns_200(
|
|
self, integration_client, test_package
|
|
):
|
|
"""Test If-Modified-Since with old date returns 200."""
|
|
project, package = test_package
|
|
content = b"old date test"
|
|
upload_test_file(integration_client, project, package, content, tag="cond-old")
|
|
|
|
# Request with old date (2020-01-01)
|
|
old_date = "Wed, 01 Jan 2020 00:00:00 GMT"
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/cond-old",
|
|
params={"mode": "proxy"},
|
|
headers={"If-Modified-Since": old_date},
|
|
)
|
|
assert response.status_code == 200
|
|
assert response.content == content
|
|
|
|
@pytest.mark.integration
|
|
def test_304_includes_etag(self, integration_client, test_package):
|
|
"""Test 304 response includes ETag header."""
|
|
project, package = test_package
|
|
content = b"304 etag test"
|
|
expected_hash = compute_sha256(content)
|
|
upload_test_file(integration_client, project, package, content, tag="304-etag")
|
|
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/304-etag",
|
|
params={"mode": "proxy"},
|
|
headers={"If-None-Match": f'"{expected_hash}"'},
|
|
)
|
|
assert response.status_code == 304
|
|
assert response.headers.get("ETag") == f'"{expected_hash}"'
|
|
|
|
@pytest.mark.integration
|
|
def test_304_includes_cache_control(self, integration_client, test_package):
|
|
"""Test 304 response includes Cache-Control header."""
|
|
project, package = test_package
|
|
content = b"304 cache test"
|
|
expected_hash = compute_sha256(content)
|
|
upload_test_file(integration_client, project, package, content, tag="304-cache")
|
|
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/304-cache",
|
|
params={"mode": "proxy"},
|
|
headers={"If-None-Match": f'"{expected_hash}"'},
|
|
)
|
|
assert response.status_code == 304
|
|
assert "immutable" in response.headers.get("Cache-Control", "")
|
|
|
|
|
|
class TestCachingHeaders:
|
|
"""Tests for caching headers on download responses."""
|
|
|
|
@pytest.mark.integration
|
|
def test_download_includes_cache_control(self, integration_client, test_package):
|
|
"""Test download response includes Cache-Control header."""
|
|
project, package = test_package
|
|
content = b"cache control test"
|
|
upload_test_file(integration_client, project, package, content, tag="cache-ctl")
|
|
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/cache-ctl",
|
|
params={"mode": "proxy"},
|
|
)
|
|
assert response.status_code == 200
|
|
cache_control = response.headers.get("Cache-Control", "")
|
|
assert "public" in cache_control
|
|
assert "immutable" in cache_control
|
|
assert "max-age" in cache_control
|
|
|
|
@pytest.mark.integration
|
|
def test_download_includes_last_modified(self, integration_client, test_package):
|
|
"""Test download response includes Last-Modified header."""
|
|
project, package = test_package
|
|
content = b"last modified test"
|
|
upload_test_file(integration_client, project, package, content, tag="last-mod")
|
|
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/last-mod",
|
|
params={"mode": "proxy"},
|
|
)
|
|
assert response.status_code == 200
|
|
assert "Last-Modified" in response.headers
|
|
# Should be in RFC 7231 format
|
|
last_modified = response.headers["Last-Modified"]
|
|
assert "GMT" in last_modified
|
|
|
|
@pytest.mark.integration
|
|
def test_download_includes_etag(self, integration_client, test_package):
|
|
"""Test download response includes ETag header."""
|
|
project, package = test_package
|
|
content = b"etag header test"
|
|
expected_hash = compute_sha256(content)
|
|
upload_test_file(integration_client, project, package, content, tag="etag-hdr")
|
|
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/etag-hdr",
|
|
params={"mode": "proxy"},
|
|
)
|
|
assert response.status_code == 200
|
|
assert response.headers.get("ETag") == f'"{expected_hash}"'
|
|
|
|
|
|
class TestDownloadResume:
|
|
"""Tests for download resume functionality using range requests."""
|
|
|
|
@pytest.mark.integration
|
|
def test_resume_download_after_partial(self, integration_client, test_package):
|
|
"""Test resuming download from where it left off."""
|
|
project, package = test_package
|
|
content = b"ABCDEFGHIJ" * 100 # 1000 bytes
|
|
upload_test_file(integration_client, project, package, content, tag="resume-test")
|
|
|
|
# Simulate partial download (first 500 bytes)
|
|
response1 = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/resume-test",
|
|
params={"mode": "proxy"},
|
|
headers={"Range": "bytes=0-499"},
|
|
)
|
|
assert response1.status_code == 206
|
|
first_half = response1.content
|
|
assert len(first_half) == 500
|
|
|
|
# Resume from byte 500
|
|
response2 = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/resume-test",
|
|
params={"mode": "proxy"},
|
|
headers={"Range": "bytes=500-"},
|
|
)
|
|
assert response2.status_code == 206
|
|
second_half = response2.content
|
|
assert len(second_half) == 500
|
|
|
|
# Combine and verify
|
|
combined = first_half + second_half
|
|
assert combined == content
|
|
|
|
@pytest.mark.integration
|
|
def test_resume_with_etag_verification(self, integration_client, test_package):
|
|
"""Test that resumed download can verify content hasn't changed."""
|
|
project, package = test_package
|
|
content = b"resume etag verification test content"
|
|
expected_hash = compute_sha256(content)
|
|
upload_test_file(integration_client, project, package, content, tag="resume-etag")
|
|
|
|
# Get ETag from first request
|
|
response1 = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/resume-etag",
|
|
params={"mode": "proxy"},
|
|
headers={"Range": "bytes=0-9"},
|
|
)
|
|
assert response1.status_code == 206
|
|
etag = response1.headers.get("ETag")
|
|
assert etag == f'"{expected_hash}"'
|
|
|
|
# Resume with If-Match to ensure content hasn't changed
|
|
# (Note: If-Match would fail and return 412 if content changed)
|
|
response2 = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/resume-etag",
|
|
params={"mode": "proxy"},
|
|
headers={"Range": "bytes=10-"},
|
|
)
|
|
assert response2.status_code == 206
|
|
# ETag should be the same
|
|
assert response2.headers.get("ETag") == etag
|
|
|
|
|
|
class TestLargeFileStreaming:
|
|
"""Tests for streaming large files."""
|
|
|
|
@pytest.mark.integration
|
|
def test_stream_1mb_file(self, integration_client, test_package, sized_content):
|
|
"""Test streaming a 1MB file."""
|
|
project, package = test_package
|
|
content, expected_hash = sized_content(SIZE_1MB, seed=500)
|
|
|
|
upload_test_file(integration_client, project, package, content, tag="stream-1mb")
|
|
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/stream-1mb",
|
|
params={"mode": "proxy"},
|
|
)
|
|
assert response.status_code == 200
|
|
assert len(response.content) == SIZE_1MB
|
|
assert compute_sha256(response.content) == expected_hash
|
|
|
|
@pytest.mark.integration
|
|
def test_stream_large_file_has_correct_headers(
|
|
self, integration_client, test_package, sized_content
|
|
):
|
|
"""Test that large file streaming has correct headers."""
|
|
project, package = test_package
|
|
content, expected_hash = sized_content(SIZE_100KB, seed=501)
|
|
|
|
upload_test_file(integration_client, project, package, content, tag="stream-hdr")
|
|
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/stream-hdr",
|
|
params={"mode": "proxy"},
|
|
)
|
|
assert response.status_code == 200
|
|
assert int(response.headers.get("Content-Length", 0)) == SIZE_100KB
|
|
assert response.headers.get("X-Checksum-SHA256") == expected_hash
|
|
assert response.headers.get("Accept-Ranges") == "bytes"
|
|
|
|
@pytest.mark.integration
|
|
def test_range_request_on_large_file(
|
|
self, integration_client, test_package, sized_content
|
|
):
|
|
"""Test range request on a larger file."""
|
|
project, package = test_package
|
|
content, _ = sized_content(SIZE_100KB, seed=502)
|
|
|
|
upload_test_file(integration_client, project, package, content, tag="range-large")
|
|
|
|
# Request a slice from the middle
|
|
start = 50000
|
|
end = 50999
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/range-large",
|
|
params={"mode": "proxy"},
|
|
headers={"Range": f"bytes={start}-{end}"},
|
|
)
|
|
assert response.status_code == 206
|
|
assert len(response.content) == 1000
|
|
assert response.content == content[start : end + 1]
|
|
|
|
|
|
class TestDownloadModes:
|
|
"""Tests for different download modes."""
|
|
|
|
@pytest.mark.integration
|
|
def test_proxy_mode_streams_content(self, integration_client, test_package):
|
|
"""Test proxy mode streams content through backend."""
|
|
project, package = test_package
|
|
content = b"proxy mode test content"
|
|
upload_test_file(integration_client, project, package, content, tag="mode-proxy")
|
|
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/mode-proxy",
|
|
params={"mode": "proxy"},
|
|
)
|
|
assert response.status_code == 200
|
|
assert response.content == content
|
|
|
|
@pytest.mark.integration
|
|
def test_presigned_mode_returns_url(self, integration_client, test_package):
|
|
"""Test presigned mode returns JSON with URL."""
|
|
project, package = test_package
|
|
content = b"presigned mode test"
|
|
upload_test_file(integration_client, project, package, content, tag="mode-presign")
|
|
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/mode-presign",
|
|
params={"mode": "presigned"},
|
|
)
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert "url" in data
|
|
assert "expires_at" in data
|
|
assert data["url"].startswith("http")
|
|
|
|
@pytest.mark.integration
|
|
def test_redirect_mode_returns_302(self, integration_client, test_package):
|
|
"""Test redirect mode returns 302 to presigned URL."""
|
|
project, package = test_package
|
|
content = b"redirect mode test"
|
|
upload_test_file(integration_client, project, package, content, tag="mode-redir")
|
|
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/mode-redir",
|
|
params={"mode": "redirect"},
|
|
follow_redirects=False,
|
|
)
|
|
assert response.status_code == 302
|
|
assert "Location" in response.headers
|
|
|
|
|
|
class TestIntegrityDuringStreaming:
|
|
"""Tests for data integrity during streaming downloads."""
|
|
|
|
@pytest.mark.integration
|
|
def test_checksum_header_matches_content(self, integration_client, test_package):
|
|
"""Test X-Checksum-SHA256 header matches actual downloaded content."""
|
|
project, package = test_package
|
|
content = b"integrity check content"
|
|
expected_hash = compute_sha256(content)
|
|
upload_test_file(integration_client, project, package, content, tag="integrity")
|
|
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/integrity",
|
|
params={"mode": "proxy"},
|
|
)
|
|
assert response.status_code == 200
|
|
|
|
header_hash = response.headers.get("X-Checksum-SHA256")
|
|
actual_hash = compute_sha256(response.content)
|
|
|
|
assert header_hash == expected_hash
|
|
assert actual_hash == expected_hash
|
|
assert header_hash == actual_hash
|
|
|
|
@pytest.mark.integration
|
|
def test_etag_matches_content_hash(self, integration_client, test_package):
|
|
"""Test ETag header matches content hash."""
|
|
project, package = test_package
|
|
content = b"etag integrity test"
|
|
expected_hash = compute_sha256(content)
|
|
upload_test_file(integration_client, project, package, content, tag="etag-int")
|
|
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/etag-int",
|
|
params={"mode": "proxy"},
|
|
)
|
|
assert response.status_code == 200
|
|
|
|
etag = response.headers.get("ETag", "").strip('"')
|
|
actual_hash = compute_sha256(response.content)
|
|
|
|
assert etag == expected_hash
|
|
assert actual_hash == expected_hash
|
|
|
|
@pytest.mark.integration
|
|
def test_digest_header_present(self, integration_client, test_package):
|
|
"""Test Digest header is present in RFC 3230 format."""
|
|
project, package = test_package
|
|
content = b"digest header test"
|
|
upload_test_file(integration_client, project, package, content, tag="digest")
|
|
|
|
response = integration_client.get(
|
|
f"/api/v1/project/{project}/{package}/+/digest",
|
|
params={"mode": "proxy"},
|
|
)
|
|
assert response.status_code == 200
|
|
assert "Digest" in response.headers
|
|
assert response.headers["Digest"].startswith("sha-256=")
|