Fix HLS proxy and player functionality (first working version)
This commit is contained in:
Mikhail Yevchenko
@@ -1,169 +0,0 @@
|
||||
import os
|
||||
import subprocess
|
||||
import time
|
||||
import threading
|
||||
import requests
|
||||
import pytest
|
||||
import sys
|
||||
import urllib.parse
|
||||
import http.server
|
||||
import socketserver
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
|
||||
TEST_VIDEO_DIR = "/tmp/yt-dlp-test-video"
|
||||
TEST_VIDEO_M3U8 = f"{TEST_VIDEO_DIR}/index.m3u8"
|
||||
SERVER_PORT = 5002
|
||||
TEST_HTTP_PORT = 8898
|
||||
|
||||
|
||||
def generate_test_video():
|
||||
os.makedirs(TEST_VIDEO_DIR, exist_ok=True)
|
||||
|
||||
cmd = [
|
||||
"ffmpeg", "-y", "-f", "lavfi", "-i", "testsrc=duration=5:size=320x240:rate=24",
|
||||
"-f", "lavfi", "-i", "sine=frequency=440:duration=5",
|
||||
"-c:v", "libx264", "-c:a", "aac", "-strict", "experimental",
|
||||
"-hls_time", "1", "-hls_list_size", "0",
|
||||
"-hls_segment_filename", f"{TEST_VIDEO_DIR}/segment%03d.ts",
|
||||
TEST_VIDEO_M3U8
|
||||
]
|
||||
subprocess.run(cmd, capture_output=True, timeout=60)
|
||||
|
||||
assert os.path.exists(TEST_VIDEO_M3U8), "HLS manifest not generated"
|
||||
segments = [f for f in os.listdir(TEST_VIDEO_DIR) if f.endswith(".ts")]
|
||||
assert len(segments) > 0, "No segments generated"
|
||||
|
||||
|
||||
class QuietHTTPHandler(http.server.SimpleHTTPRequestHandler):
|
||||
def log_message(self, format, *args):
|
||||
pass
|
||||
|
||||
|
||||
class ReusableTCPServer(socketserver.TCPServer):
|
||||
allow_reuse_address = True
|
||||
|
||||
|
||||
def serve_test_video():
|
||||
os.chdir(TEST_VIDEO_DIR)
|
||||
with ReusableTCPServer(("127.0.0.1", TEST_HTTP_PORT), QuietHTTPHandler) as httpd:
|
||||
httpd.serve_forever()
|
||||
|
||||
|
||||
def start_flask_app():
|
||||
import app as flask_app
|
||||
flask_app.app.run(host="127.0.0.1", port=SERVER_PORT, debug=False, use_reloader=False)
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def test_servers():
|
||||
print("\nGenerating test video...")
|
||||
generate_test_video()
|
||||
|
||||
print(f"Starting HTTP server for test video on port {TEST_HTTP_PORT}...")
|
||||
http_thread = threading.Thread(target=serve_test_video, daemon=True)
|
||||
http_thread.start()
|
||||
time.sleep(1)
|
||||
|
||||
for _ in range(10):
|
||||
try:
|
||||
requests.get(f"http://127.0.0.1:{TEST_HTTP_PORT}/", timeout=1)
|
||||
break
|
||||
except:
|
||||
time.sleep(0.5)
|
||||
print("HTTP server ready")
|
||||
|
||||
print(f"Starting Flask proxy server on port {SERVER_PORT}...")
|
||||
flask_thread = threading.Thread(target=start_flask_app, daemon=True)
|
||||
flask_thread.start()
|
||||
time.sleep(2)
|
||||
print("Flask server ready")
|
||||
|
||||
yield
|
||||
|
||||
print("\nCleaning up...")
|
||||
|
||||
|
||||
def test_direct_hls_access(test_servers):
|
||||
"""Test that we can access the test HLS video directly"""
|
||||
response = requests.get(f"http://127.0.0.1:{TEST_HTTP_PORT}/index.m3u8", timeout=5)
|
||||
assert response.status_code == 200
|
||||
assert "#EXTM3U" in response.text
|
||||
print("Direct HLS access: OK")
|
||||
|
||||
|
||||
def test_hls_playlist_proxy(test_servers):
|
||||
"""Test proxying HLS playlist"""
|
||||
video_url = f"http://127.0.0.1:{TEST_HTTP_PORT}/index.m3u8"
|
||||
proxy_url = f"http://127.0.0.1:{SERVER_PORT}/hls?url={urllib.parse.quote(video_url, safe='')}"
|
||||
|
||||
response = requests.get(proxy_url, timeout=10)
|
||||
assert response.status_code == 200
|
||||
assert "#EXTM3U" in response.text
|
||||
assert ".ts" in response.text
|
||||
print("HLS playlist proxy: OK")
|
||||
|
||||
|
||||
def test_hls_segment_proxy(test_servers):
|
||||
"""Test proxying HLS segment"""
|
||||
video_url = f"http://127.0.0.1:{TEST_HTTP_PORT}/index.m3u8"
|
||||
|
||||
# First get the rewritten playlist to extract the segment URL
|
||||
playlist_url = f"http://127.0.0.1:{SERVER_PORT}/hls?url={urllib.parse.quote(video_url, safe='')}"
|
||||
playlist_response = requests.get(playlist_url, timeout=10)
|
||||
assert playlist_response.status_code == 200
|
||||
|
||||
# Extract the segment path from the playlist (it's after the path= parameter)
|
||||
for line in playlist_response.text.split("\n"):
|
||||
if line.startswith("/hls?"):
|
||||
from urllib.parse import urlparse, parse_qs
|
||||
parsed = urlparse(line)
|
||||
params = parse_qs(parsed.query)
|
||||
if "path" in params:
|
||||
segment_path = params["path"][0]
|
||||
break
|
||||
|
||||
# Now request the segment using the path from the playlist
|
||||
segment_url = f"http://127.0.0.1:{SERVER_PORT}/hls?url={urllib.parse.quote(video_url, safe='')}&path={urllib.parse.quote(segment_path, safe='')}"
|
||||
response = requests.get(segment_url, timeout=10)
|
||||
assert response.status_code == 200
|
||||
assert len(response.content) > 0
|
||||
print("HLS segment proxy: OK")
|
||||
|
||||
|
||||
def test_player_page(test_servers):
|
||||
"""Test player page renders"""
|
||||
video_url = f"http://127.0.0.1:{TEST_HTTP_PORT}/index.m3u8"
|
||||
player_url = f"http://127.0.0.1:{SERVER_PORT}/player?url={urllib.parse.quote(video_url, safe='')}"
|
||||
|
||||
response = requests.get(player_url, timeout=10)
|
||||
assert response.status_code == 200
|
||||
assert "video" in response.text.lower()
|
||||
print("Player page: OK")
|
||||
|
||||
|
||||
def test_index_page(test_servers):
|
||||
"""Test index page renders"""
|
||||
response = requests.get(f"http://127.0.0.1:{SERVER_PORT}/", timeout=10)
|
||||
assert response.status_code == 200
|
||||
assert "video" in response.text.lower()
|
||||
print("Index page: OK")
|
||||
|
||||
|
||||
@pytest.mark.skip(reason="External URL test - run manually to verify pornhub support")
|
||||
def test_pornhub_hls_extraction():
|
||||
"""Test that pornhub HLS URLs are extracted correctly"""
|
||||
import dlp
|
||||
dlp._session_cache.clear()
|
||||
dlp._cache_timestamps.clear()
|
||||
|
||||
# Test with actual pornhub URL
|
||||
url = "https://rt.pornhub.com/view_video.php?viewkey=69bc20ee15710"
|
||||
hls_url = dlp.get_stream_info(url)["hls_url"]
|
||||
assert hls_url and "m3u8" in hls_url
|
||||
print(f"PornHub HLS URL: {hls_url[:100]}...")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
pytest.main([__file__, "-v", "-s"])
|
||||
+377
-77
@@ -1,116 +1,416 @@
|
||||
import pytest
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import subprocess
|
||||
import time
|
||||
import threading
|
||||
import requests
|
||||
import urllib.parse
|
||||
import http.server
|
||||
import socketserver
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
from utils import is_valid_url, extract_video_id, sanitize_path, get_error_message
|
||||
import dlp
|
||||
|
||||
TEST_VIDEO_DIR = "/tmp/yt-dlp-test-video"
|
||||
TEST_VIDEO_M3U8 = f"{TEST_VIDEO_DIR}/index.m3u8"
|
||||
SERVER_PORT = 5005
|
||||
TEST_HTTP_PORT = 8890
|
||||
|
||||
|
||||
class TestURLValidation:
|
||||
def test_valid_youtube_url(self):
|
||||
assert is_valid_url("https://www.youtube.com/watch?v=dQw4w9WgXcQ")
|
||||
assert is_valid_url("https://youtu.be/dQw4w9WgXcQ")
|
||||
|
||||
def test_valid_youtu_be(self):
|
||||
assert is_valid_url("https://youtu.be/abc123")
|
||||
|
||||
def test_valid_pornhub_url(self):
|
||||
assert is_valid_url("https://www.pornhub.com/view_video.php?viewkey=abc123")
|
||||
|
||||
def test_invalid_url(self):
|
||||
assert not is_valid_url("")
|
||||
assert not is_valid_url("not-a-url")
|
||||
|
||||
def test_disallowed_domain(self):
|
||||
os.environ["VALIDATION_ENABLED"] = "true"
|
||||
assert not is_valid_url("https://evil.com/video")
|
||||
def print_hex(data, max_len=200):
|
||||
"""Print data as hex for debugging."""
|
||||
if isinstance(data, bytes):
|
||||
print(f"[HEX] {data[:max_len].hex()}")
|
||||
else:
|
||||
print(f"[HEX] {data[:max_len].encode().hex()}")
|
||||
|
||||
|
||||
class TestVideoIDExtraction:
|
||||
def test_extract_youtube_id(self):
|
||||
assert extract_video_id("https://www.youtube.com/watch?v=dQw4w9WgXcQ") == "dQw4w9WgXcQ"
|
||||
assert extract_video_id("https://youtu.be/dQw4w9WgXcQ") == "dQw4w9WgXcQ"
|
||||
|
||||
def test_extract_pornhub_id(self):
|
||||
result = extract_video_id("https://www.pornhub.com/view_video.php?viewkey=ph123456")
|
||||
assert result == "ph123456"
|
||||
|
||||
def test_extract_invalid(self):
|
||||
assert extract_video_id("https://example.com/video") == ""
|
||||
def print_headers(headers):
|
||||
"""Print response headers."""
|
||||
print(f"[HEADERS] {dict(headers)}")
|
||||
|
||||
|
||||
class TestPathSanitization:
|
||||
def test_sanitize_normal_path(self):
|
||||
assert sanitize_path("path/to/file") == "path/to/file"
|
||||
|
||||
def test_sanitize_prevents_traversal(self):
|
||||
assert sanitize_path("../etc/passwd") == "etc/passwd"
|
||||
assert sanitize_path("path/../etc/passwd") == "path/etc/passwd"
|
||||
def generate_test_video():
|
||||
"""Generate test HLS video using ffmpeg."""
|
||||
print(f"\n[SETUP] Generating test video in {TEST_VIDEO_DIR}")
|
||||
os.makedirs(TEST_VIDEO_DIR, exist_ok=True)
|
||||
|
||||
cmd = [
|
||||
"ffmpeg", "-y",
|
||||
"-f", "lavfi", "-i", "testsrc=duration=10:size=320x240:rate=24",
|
||||
"-f", "lavfi", "-i", "sine=frequency=440:duration=10",
|
||||
"-c:v", "libx264", "-c:a", "aac", "-strict", "experimental",
|
||||
"-hls_time", "2", "-hls_list_size", "0",
|
||||
"-hls_segment_filename", f"{TEST_VIDEO_DIR}/segment%03d.ts",
|
||||
TEST_VIDEO_M3U8
|
||||
]
|
||||
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
||||
if result.returncode != 0:
|
||||
print(f"[ERROR] ffmpeg failed: {result.stderr}")
|
||||
segments = [f for f in os.listdir(TEST_VIDEO_DIR) if f.endswith(".ts")]
|
||||
print(f"[SETUP] Generated {len(segments)} segments")
|
||||
return result.returncode == 0 and len(segments) > 0
|
||||
|
||||
|
||||
class TestCacheMechanics:
|
||||
def test_cache_basic(self):
|
||||
class QuietHTTPHandler(http.server.SimpleHTTPRequestHandler):
|
||||
def log_message(self, format, *args):
|
||||
print(f"[HTTP] {self.address_string()} - {format % args}")
|
||||
|
||||
|
||||
class ReusableTCPServer(socketserver.TCPServer):
|
||||
allow_reuse_address = True
|
||||
|
||||
|
||||
def serve_test_video():
|
||||
print(f"[SETUP] Starting test HTTP server on port {TEST_HTTP_PORT}")
|
||||
os.chdir(TEST_VIDEO_DIR)
|
||||
with ReusableTCPServer(("127.0.0.1", TEST_HTTP_PORT), QuietHTTPHandler) as httpd:
|
||||
httpd.serve_forever()
|
||||
|
||||
|
||||
def start_flask_app():
|
||||
print(f"[SETUP] Starting Flask server on port {SERVER_PORT}")
|
||||
import app as flask_app
|
||||
flask_app.app.run(host="127.0.0.1", port=SERVER_PORT, debug=False, use_reloader=False)
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def test_servers():
|
||||
print("\n" + "="*60)
|
||||
print("INTEGRATION TEST SETUP")
|
||||
print("="*60)
|
||||
|
||||
generate_test_video()
|
||||
|
||||
http_thread = threading.Thread(target=serve_test_video, daemon=True)
|
||||
http_thread.start()
|
||||
time.sleep(1)
|
||||
|
||||
for _ in range(10):
|
||||
try:
|
||||
requests.get(f"http://127.0.0.1:{TEST_HTTP_PORT}/", timeout=1)
|
||||
break
|
||||
except:
|
||||
time.sleep(0.5)
|
||||
print("[SETUP] Test HTTP server ready")
|
||||
|
||||
flask_thread = threading.Thread(target=start_flask_app, daemon=True)
|
||||
flask_thread.start()
|
||||
time.sleep(2)
|
||||
|
||||
for _ in range(10):
|
||||
try:
|
||||
requests.get(f"http://127.0.0.1:{SERVER_PORT}/", timeout=1)
|
||||
break
|
||||
except:
|
||||
time.sleep(0.5)
|
||||
print("[SETUP] Flask server ready")
|
||||
print("="*60 + "\n")
|
||||
|
||||
yield
|
||||
|
||||
print("\n[TEARDOWN] Tests complete")
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Test URL parsing - critical function
|
||||
# ============================================================================
|
||||
|
||||
class TestURLParsing:
|
||||
"""Test URL parsing functions as per AGENTS.md."""
|
||||
|
||||
def test_url_validation_youtube(self):
|
||||
"""Test YouTube URL validation."""
|
||||
from utils import is_valid_url
|
||||
url = "https://www.youtube.com/watch?v=abc123"
|
||||
print(f"[TEST] Validating: {url}")
|
||||
result = is_valid_url(url)
|
||||
print(f"[TEST] Result: {result}")
|
||||
assert result is True, f"YouTube URL should be valid: {url}"
|
||||
|
||||
def test_url_validation_pornhub(self):
|
||||
"""Test PornHub URL validation."""
|
||||
from utils import is_valid_url
|
||||
url = "https://rt.pornhub.com/view_video.php?viewkey=abc123"
|
||||
print(f"[TEST] Validating: {url}")
|
||||
result = is_valid_url(url)
|
||||
print(f"[TEST] Result: {result}")
|
||||
assert result is True, f"PornHub URL should be valid: {url}"
|
||||
|
||||
def test_url_validation_invalid(self):
|
||||
"""Test invalid URL rejection."""
|
||||
from utils import is_valid_url
|
||||
url = "not-a-url"
|
||||
print(f"[TEST] Validating: {url}")
|
||||
result = is_valid_url(url)
|
||||
print(f"[TEST] Result: {result}")
|
||||
assert result is False, f"Invalid URL should be rejected: {url}"
|
||||
|
||||
def test_url_validation_disallowed(self):
|
||||
"""Test disallowed domain rejection."""
|
||||
from utils import is_valid_url
|
||||
url = "https://evil.com/video"
|
||||
print(f"[TEST] Validating: {url}")
|
||||
result = is_valid_url(url)
|
||||
print(f"[TEST] Result: {result}")
|
||||
assert result is False, f"Disallowed domain should be rejected: {url}"
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Test caching - critical function
|
||||
# ============================================================================
|
||||
|
||||
class TestCaching:
|
||||
"""Test caching mechanics as per AGENTS.md."""
|
||||
|
||||
def test_cache_store_and_retrieve(self):
|
||||
"""Test cache can store and retrieve data."""
|
||||
import dlp
|
||||
dlp._session_cache.clear()
|
||||
dlp._cache_timestamps.clear()
|
||||
|
||||
test_data = {"title": "Test Video", "thumbnail": "http://test.com/thumb.jpg", "hls_url": "http://test.com/stream.m3u8"}
|
||||
dlp._set_cached_info("http://test.com/video", test_data)
|
||||
url = "https://test.com/video"
|
||||
data = {"title": "Test", "hls_url": "http://example.com/playlist.m3u8"}
|
||||
|
||||
cached = dlp._get_cached_info("http://test.com/video")
|
||||
assert cached is not None
|
||||
assert cached["title"] == "Test Video"
|
||||
assert cached["thumbnail"] == "http://test.com/thumb.jpg"
|
||||
assert cached["hls_url"] == "http://test.com/stream.m3u8"
|
||||
|
||||
def test_cache_expiry(self):
|
||||
dlp.CACHE_TTL = 1
|
||||
print(f"[TEST] Storing in cache: {url}")
|
||||
dlp._session_cache[url] = data
|
||||
dlp._cache_timestamps[url] = time.time()
|
||||
|
||||
print(f"[TEST] Cache contents: {dlp._session_cache}")
|
||||
assert url in dlp._session_cache
|
||||
assert dlp._session_cache[url]["title"] == "Test"
|
||||
|
||||
def test_cache_hit_detection(self):
|
||||
"""Test cache hit is detected."""
|
||||
import dlp
|
||||
dlp._session_cache.clear()
|
||||
dlp._cache_timestamps.clear()
|
||||
|
||||
dlp._set_cached_info("http://test.com/video", {"data": "test"})
|
||||
import time
|
||||
time.sleep(1.1)
|
||||
url = "https://test.com/video"
|
||||
dlp._session_cache[url] = {"title": "Test"}
|
||||
dlp._cache_timestamps[url] = time.time()
|
||||
|
||||
assert dlp._is_cache_expired("http://test.com/video") is True
|
||||
print(f"[TEST] Checking cache for: {url}")
|
||||
if url in dlp._session_cache:
|
||||
print(f"[TEST] Cache HIT!")
|
||||
else:
|
||||
print(f"[TEST] Cache MISS!")
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Test playlist proxying - critical function
|
||||
# ============================================================================
|
||||
|
||||
class TestPlaylistProxying:
|
||||
"""Test playlist proxying as per AGENTS.md."""
|
||||
|
||||
def test_main_playlist_returns_valid_hls(self, test_servers):
|
||||
"""Test main playlist returns valid HLS content."""
|
||||
video_url = f"http://127.0.0.1:{TEST_HTTP_PORT}/index.m3u8"
|
||||
encoded = urllib.parse.quote(video_url, safe="")
|
||||
proxy_url = f"http://127.0.0.1:{SERVER_PORT}/hls/{encoded}--index.m3u8"
|
||||
|
||||
dlp.CACHE_TTL = 31536000
|
||||
print(f"[TEST] Requesting main playlist: {proxy_url}")
|
||||
response = requests.get(proxy_url, timeout=10)
|
||||
|
||||
print(f"[TEST] Status: {response.status_code}")
|
||||
print_headers(response.headers)
|
||||
print(f"[TEST] Content preview: {response.text[:200]}")
|
||||
|
||||
assert response.status_code == 200, f"Expected 200, got {response.status_code}"
|
||||
assert "#EXTM3U" in response.text, "Should contain #EXTM3U"
|
||||
assert ".ts" in response.text, "Should contain segment references"
|
||||
print("[TEST] Main playlist returns valid HLS: PASS")
|
||||
|
||||
def test_playlist_contains_proxy_urls(self, test_servers):
|
||||
"""Test playlist URLs are rewritten to proxy."""
|
||||
video_url = f"http://127.0.0.1:{TEST_HTTP_PORT}/index.m3u8"
|
||||
encoded = urllib.parse.quote(video_url, safe="")
|
||||
proxy_url = f"http://127.0.0.1:{SERVER_PORT}/hls/{encoded}--index.m3u8"
|
||||
|
||||
print(f"[TEST] Requesting playlist: {proxy_url}")
|
||||
response = requests.get(proxy_url, timeout=10)
|
||||
|
||||
print(f"[TEST] Content: {response.text}")
|
||||
assert "/hls/" in response.text, "Playlist should contain proxy URLs"
|
||||
print("[TEST] Playlist contains proxy URLs: PASS")
|
||||
|
||||
def test_playlist_content_type_correct(self, test_servers):
|
||||
"""Test playlist returns correct content-type."""
|
||||
video_url = f"http://127.0.0.1:{TEST_HTTP_PORT}/index.m3u8"
|
||||
encoded = urllib.parse.quote(video_url, safe="")
|
||||
proxy_url = f"http://127.0.0.1:{SERVER_PORT}/hls/{encoded}--index.m3u8"
|
||||
|
||||
print(f"[TEST] Requesting: {proxy_url}")
|
||||
response = requests.get(proxy_url, timeout=10)
|
||||
|
||||
print(f"[TEST] Content-Type: {response.headers.get('Content-Type')}")
|
||||
assert "application/vnd.apple.mpegurl" in response.headers.get("Content-Type", "")
|
||||
assert "video/mp2t" not in response.headers.get("Content-Type", "")
|
||||
print("[TEST] Playlist content-type correct: PASS")
|
||||
|
||||
|
||||
class TestErrorMessages:
|
||||
def test_get_error_message(self):
|
||||
assert "Bad Request" in get_error_message(400)
|
||||
assert "Forbidden" in get_error_message(403)
|
||||
assert "Not Found" in get_error_message(404)
|
||||
assert "Internal Server Error" in get_error_message(500)
|
||||
# ============================================================================
|
||||
# Test segment proxying - critical function
|
||||
# ============================================================================
|
||||
|
||||
class TestSegmentProxying:
|
||||
"""Test segment proxying as per AGENTS.md."""
|
||||
|
||||
def test_segment_returns_video_data(self, test_servers):
|
||||
"""Test segment returns video data."""
|
||||
video_url = f"http://127.0.0.1:{TEST_HTTP_PORT}/index.m3u8"
|
||||
encoded = urllib.parse.quote(video_url, safe="")
|
||||
playlist_url = f"http://127.0.0.1:{SERVER_PORT}/hls/{encoded}--index.m3u8"
|
||||
|
||||
print(f"[TEST] Getting main playlist: {playlist_url}")
|
||||
playlist_resp = requests.get(playlist_url, timeout=10)
|
||||
|
||||
# Find segment filename
|
||||
segment_filename = None
|
||||
for line in playlist_resp.text.split("\n"):
|
||||
if line.startswith("/hls/") and "--" in line and ".ts" in line:
|
||||
parts = line.rsplit("--", 1)
|
||||
if len(parts) >= 2:
|
||||
segment_filename = parts[-1]
|
||||
print(f"[TEST] Found segment: {segment_filename}")
|
||||
break
|
||||
|
||||
assert segment_filename is not None, "Should find segment in playlist"
|
||||
|
||||
seg_url = f"http://127.0.0.1:{SERVER_PORT}/hls/{encoded}--{segment_filename}"
|
||||
print(f"[TEST] Requesting segment: {seg_url}")
|
||||
|
||||
seg_resp = requests.get(seg_url, timeout=10)
|
||||
|
||||
print(f"[TEST] Segment status: {seg_resp.status_code}")
|
||||
print_headers(seg_resp.headers)
|
||||
print(f"[TEST] Segment size: {len(seg_resp.content)} bytes")
|
||||
|
||||
assert seg_resp.status_code == 200
|
||||
assert "video/mp2t" in seg_resp.headers.get("Content-Type", "")
|
||||
assert len(seg_resp.content) > 1000, "Segment should have substantial data"
|
||||
assert b"#EXTM3U" not in seg_resp.content[:100], "Segment should NOT be a playlist"
|
||||
|
||||
print("[TEST] Segment returns video data: PASS")
|
||||
|
||||
|
||||
class TestFlaskApp:
|
||||
def test_index_route(self):
|
||||
from app import app
|
||||
with app.test_client() as client:
|
||||
response = client.get("/")
|
||||
assert response.status_code == 200
|
||||
|
||||
def test_player_route_missing_url(self):
|
||||
# ============================================================================
|
||||
# Test error handling - critical function
|
||||
# ============================================================================
|
||||
|
||||
class TestErrorHandling:
|
||||
"""Test error handling as per AGENTS.md."""
|
||||
|
||||
def test_player_missing_url_returns_400(self):
|
||||
"""Test player route with missing URL returns 400."""
|
||||
from app import app
|
||||
with app.test_client() as client:
|
||||
print("[TEST] Testing /player with no URL")
|
||||
response = client.get("/player")
|
||||
print(f"[TEST] Status: {response.status_code}")
|
||||
assert response.status_code == 400
|
||||
|
||||
def test_player_route_invalid_url(self):
|
||||
|
||||
def test_player_invalid_url_returns_400(self):
|
||||
"""Test player route with invalid URL returns 400."""
|
||||
from app import app
|
||||
with app.test_client() as client:
|
||||
response = client.get("/player?url=https://evil.com/video")
|
||||
print("[TEST] Testing /player with invalid URL")
|
||||
response = client.get("/player?url=not-valid")
|
||||
print(f"[TEST] Status: {response.status_code}")
|
||||
assert response.status_code == 400
|
||||
|
||||
def test_hls_proxy_invalid_path(self):
|
||||
|
||||
def test_hls_invalid_video_url_returns_400(self):
|
||||
"""Test HLS route with invalid video URL returns 400."""
|
||||
from app import app
|
||||
with app.test_client() as client:
|
||||
response = client.get("/hls")
|
||||
print("[TEST] Testing /hls with invalid video URL")
|
||||
response = client.get("/hls/evil.com--index.m3u8")
|
||||
print(f"[TEST] Status: {response.status_code}")
|
||||
assert response.status_code == 400
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Integration tests - main application flow as per AGENTS.md
|
||||
# ============================================================================
|
||||
|
||||
class TestIntegration:
|
||||
"""Integration tests for main application flow as per AGENTS.md."""
|
||||
|
||||
def test_pornhub_video_full_flow(self):
|
||||
"""Test PornHub video with full debug output."""
|
||||
import dlp
|
||||
dlp._session_cache.clear()
|
||||
dlp._cache_timestamps.clear()
|
||||
|
||||
video_url = "https://rt.pornhub.com/view_video.php?viewkey=69c13273df690"
|
||||
|
||||
print(f"\n[TEST] PornHub video: {video_url}")
|
||||
|
||||
# Get stream info
|
||||
info = dlp.get_stream_info(video_url)
|
||||
print(f"[TEST] Title: {info.get('title', 'N/A')[:50]}")
|
||||
print(f"[TEST] HLS URL: {info.get('hls_url', 'N/A')[:80] if info.get('hls_url') else 'N/A'}")
|
||||
|
||||
# Get playlist
|
||||
playlist = dlp.get_hls_playlist(video_url)
|
||||
print(f"[TEST] Playlist content (first 300 chars): {playlist[:300]}")
|
||||
print_hex(playlist[:100])
|
||||
|
||||
assert "#EXTM3U" in playlist
|
||||
assert "/hls/" in playlist
|
||||
print("[TEST] PornHub full flow: PASS")
|
||||
|
||||
def test_youtube_video_fallback(self):
|
||||
"""Test YouTube uses direct URL fallback."""
|
||||
import dlp
|
||||
dlp._session_cache.clear()
|
||||
dlp._cache_timestamps.clear()
|
||||
|
||||
video_url = "https://www.youtube.com/watch?v=PoV9fS4CnaY"
|
||||
|
||||
print(f"\n[TEST] YouTube video: {video_url}")
|
||||
|
||||
info = dlp.get_stream_info(video_url)
|
||||
print(f"[TEST] Title: {info.get('title', 'N/A')[:50]}")
|
||||
print(f"[TEST] Direct URL: {info.get('direct_url', 'N/A')[:80] if info.get('direct_url') else 'N/A'}")
|
||||
|
||||
assert "title" in info
|
||||
print("[TEST] YouTube fallback: PASS")
|
||||
|
||||
def test_yt_dlp_consumes_proxy_playlist(self):
|
||||
"""Test yt-dlp can consume proxy playlist like browser."""
|
||||
import dlp
|
||||
dlp._session_cache.clear()
|
||||
dlp._cache_timestamps.clear()
|
||||
|
||||
video_url = "https://rt.pornhub.com/view_video.php?viewkey=69c13273df690"
|
||||
encoded_url = urllib.parse.quote(video_url, safe="")
|
||||
playlist_url = f"http://127.0.0.1:{SERVER_PORT}/hls/{encoded_url}--index.m3u8"
|
||||
|
||||
print(f"\n[TEST] yt-dlp proxy URL: {playlist_url}")
|
||||
|
||||
cmd = [
|
||||
"yt-dlp",
|
||||
"--hls-use-mpegts",
|
||||
"--no-download",
|
||||
"--print", "url",
|
||||
playlist_url
|
||||
]
|
||||
|
||||
print(f"[TEST] Running: {' '.join(cmd)}")
|
||||
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
||||
|
||||
print(f"[TEST] yt-dlp return code: {result.returncode}")
|
||||
if result.stdout:
|
||||
print(f"[TEST] yt-dlp output: {result.stdout[:200]}")
|
||||
if result.returncode != 0:
|
||||
print(f"[TEST] yt-dlp stderr: {result.stderr[:500]}")
|
||||
|
||||
assert result.returncode == 0, f"yt-dlp failed: {result.stderr}"
|
||||
print("[TEST] yt-dlp consumes proxy playlist: PASS")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
pytest.main([__file__, "-v"])
|
||||
pytest.main([__file__, "-v", "-s"])
|
||||
Reference in New Issue
Block a user