Skip to content

A full-featured download manager.

3.7 KB
Raw Blame
"""Exercise the real pinned HTTP client against local response-header fixtures."""

import hashlib
import sys
import tempfile
import threading
import unittest
from collections import Counter
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path

import aiohttp
from flatpak_node_generator.cache import Cache, FilesystemBasedCache
from flatpak_node_generator.requests import Requests

sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "scripts"))
from run_flatpak_node_generator import HeaderLimitedRequests, MAX_HEADER_FIELD_SIZE


BODY = b"unchanged locked source bytes\x00\xff\n"
REQUESTS = Counter()


class HeaderFixture(BaseHTTPRequestHandler):
    def do_GET(self):
        REQUESTS[self.path] += 1
        if self.path == "/retry" and REQUESTS[self.path] == 1:
            self.send_response(503)
            self.end_headers()
            return
        self.send_response(302 if self.path == "/redirect" else 200)
        size = MAX_HEADER_FIELD_SIZE + 1 if self.path == "/oversized" else 10000
        self.send_header("Content-Security-Policy", "x" * size)
        if self.path == "/redirect":
            self.send_header("Location", "/payload")
            self.end_headers()
            return
        self.send_header("Content-Length", str(len(BODY)))
        self.end_headers()
        try:
            self.wfile.write(BODY)
        except (BrokenPipeError, ConnectionResetError):
            pass  # Expected when the client rejects a response header.

    def log_message(self, *_args):
        pass


class HeaderLimitTests(unittest.IsolatedAsyncioTestCase):
    @classmethod
    def setUpClass(cls):
        cls.server = ThreadingHTTPServer(("127.0.0.1", 0), HeaderFixture)
        cls.thread = threading.Thread(target=cls.server.serve_forever, daemon=True)
        cls.thread.start()
        cls.base_url = f"http://127.0.0.1:{cls.server.server_port}"

    @classmethod
    def tearDownClass(cls):
        cls.server.shutdown()
        cls.server.server_close()
        cls.thread.join()

    def setUp(self):
        REQUESTS.clear()
        self.previous_retries = Requests.retries
        self.previous_cache = Cache.instance
        self.cache = tempfile.TemporaryDirectory()
        Requests.retries = 2
        Cache.instance = FilesystemBasedCache(Path(self.cache.name))

    def tearDown(self):
        Requests.retries = self.previous_retries
        Cache.instance = self.previous_cache
        self.cache.cleanup()

    async def test_fixture_exceeds_the_unmodified_client_limit(self):
        with self.assertRaises(aiohttp.ClientResponseError):
            await Requests().read_all(f"{self.base_url}/payload")

    async def test_larger_redirect_and_payload_headers_preserve_source_bytes(self):
        body = await HeaderLimitedRequests().read_all(f"{self.base_url}/redirect")
        self.assertEqual(body, BODY)
        self.assertEqual(hashlib.sha256(body).digest(), hashlib.sha256(BODY).digest())
        self.assertEqual(REQUESTS, {"/redirect": 1, "/payload": 1})

    async def test_headers_above_the_bound_still_fail_after_upstream_retries(self):
        with self.assertRaises(aiohttp.ClientResponseError):
            await HeaderLimitedRequests().read_all(f"{self.base_url}/oversized")
        self.assertEqual(REQUESTS["/oversized"], 2)

    async def test_status_retries_and_source_cache_remain_active(self):
        client = HeaderLimitedRequests()
        url = f"{self.base_url}/retry"
        self.assertEqual(await client.read_all(url, cachable=True), BODY)
        self.assertEqual(REQUESTS["/retry"], 2)
        with Cache.instance.get(f"requests:{url}").open_read() as cached:
            self.assertEqual(cached.read_all(), BODY)
        self.assertEqual(REQUESTS["/retry"], 2)


if __name__ == "__main__":
    unittest.main()