static-http 0.1.4__tar.gz → 1.0.0__tar.gz

{static_http-0.1.4/src/static_http.egg-info → static_http-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: static-http
-Version: 0.1.4
+Version: 1.0.0
 Summary: A temporary dependency-free static HTTP server with byte-range support.
 Author: John Paul Ellis
 License-Expression: MIT

{static_http-0.1.4 → static_http-1.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "static-http"
-version = "0.1.4"
+version = "1.0.0"
 description = "A temporary dependency-free static HTTP server with byte-range support."
 readme = "README.md"
 requires-python = ">=3.10"

{static_http-0.1.4 → static_http-1.0.0}/src/http_here/__init__.py

@@ -1,3 +1,3 @@
 """Utilities for running a dependency-free local static HTTP server."""
 
-__version__ = "0.1.4"
+__version__ = "1.0.0"

{static_http-0.1.4 → static_http-1.0.0}/src/http_here/cli.py

@@ -128,7 +128,7 @@ def _build_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "--include-hidden",
         action="store_true",
-        help="Include dot-prefixed files/directories when serving and listing directories.",
+        help="Include dot-prefixed and platform-hidden files/directories when serving and listing directories.",
     )
     parser.add_argument(
         "--version",

{static_http-0.1.4 → static_http-1.0.0}/src/http_here/keyboard.py

@@ -23,14 +23,14 @@ def start_quit_watcher(on_quit) -> tuple[threading.Event, bool]:
             while not stop_event.is_set():
                 if msvcrt.kbhit():
                     ch = msvcrt.getwch()
-                    if ch.lower() == "q":
+                    if ch.lower() == "q" or ch == "\x03":
                         if not stop_event.is_set():
                             stop_event.set()
                             on_quit()
                 if stop_event.wait(0.1):
                     return
 
-        thread = threading.Thread(target=_watch, name="http-here-keyboard", daemon=True)
+        thread = threading.Thread(target=_watch, name="static-http-keyboard", daemon=True)
         thread.start()
         return stop_event, False
     except Exception:
@@ -56,7 +56,7 @@ def start_quit_watcher(on_quit) -> tuple[threading.Event, bool]:
                     if not ready:
                         continue
                     ch = os.read(fd, 1).decode(errors="ignore")
-                    if ch.lower() == "q":
+                    if ch.lower() == "q" or ch == "\x03":
                         stop_event.set()
                         on_quit()
             finally:
@@ -65,7 +65,7 @@ def start_quit_watcher(on_quit) -> tuple[threading.Event, bool]:
                 except Exception:
                     pass
 
-        thread = threading.Thread(target=_watch, name="http-here-keyboard", daemon=True)
+        thread = threading.Thread(target=_watch, name="static-http-keyboard", daemon=True)
         thread.start()
         return stop_event, False
     except Exception:
@@ -81,6 +81,6 @@ def start_quit_watcher(on_quit) -> tuple[threading.Event, bool]:
                 on_quit()
                 return
 
-    thread = threading.Thread(target=_watch, name="http-here-keyboard", daemon=True)
+    thread = threading.Thread(target=_watch, name="static-http-keyboard", daemon=True)
     thread.start()
     return stop_event, True

{static_http-0.1.4 → static_http-1.0.0}/src/http_here/qrcode.py

@@ -36,37 +36,28 @@ def _gf_mul(x: int, y: int) -> int:
     return result
 
 
-def _gf_pow(x: int, power: int) -> int:
-    result = 1
-    for _ in range(power):
-        result = _gf_mul(result, x)
-    return result
-
-
 def _generator_poly(degree: int) -> list[int]:
-    result = [1]
-    for i in range(degree):
-        result = _poly_mul(result, [1, _gf_pow(2, i)])
-    return result
-
-
-def _poly_mul(left: list[int], right: list[int]) -> list[int]:
-    result = [0] * (len(left) + len(right) - 1)
-    for i, left_value in enumerate(left):
-        for j, right_value in enumerate(right):
-            result[i + j] ^= _gf_mul(left_value, right_value)
+    result = [0] * degree
+    result[-1] = 1
+    root = 1
+    for _ in range(degree):
+        for i in range(degree):
+            result[i] = _gf_mul(result[i], root)
+            if i + 1 < degree:
+                result[i] ^= result[i + 1]
+        root = _gf_mul(root, 0x02)
     return result
 
 
 def _reed_solomon(data: list[int], degree: int) -> list[int]:
-    generator = _generator_poly(degree)
-    result = data + [0] * degree
-    for i, value in enumerate(data):
-        if value == 0:
-            continue
-        for j, coefficient in enumerate(generator):
-            result[i + j] ^= _gf_mul(coefficient, value)
-    return result[-degree:]
+    divisor = _generator_poly(degree)
+    result = [0] * degree
+    for byte in data:
+        factor = byte ^ result.pop(0)
+        result.append(0)
+        for i, coefficient in enumerate(divisor):
+            result[i] ^= _gf_mul(coefficient, factor)
+    return result
 
 
 def _append_bits(bits: list[int], value: int, length: int) -> None:
@@ -139,7 +130,6 @@ def _draw_function_patterns(matrix: list[list[bool | None]], function: list[list
         _set_function(matrix, function, 6, i, i % 2 == 0)
         _set_function(matrix, function, i, 6, i % 2 == 0)
 
-    _set_function(matrix, function, size - 8, 8, True)
     _draw_format_bits(matrix, function, 0)
 
 
@@ -199,44 +189,24 @@ def _format_bits(mask: int) -> int:
 def _draw_format_bits(matrix: list[list[bool | None]], function: list[list[bool]], mask: int) -> None:
     bits = _format_bits(mask)
     size = len(matrix)
-    positions_a = [
-        (8, 0),
-        (8, 1),
-        (8, 2),
-        (8, 3),
-        (8, 4),
-        (8, 5),
-        (8, 7),
-        (8, 8),
-        (7, 8),
-        (5, 8),
-        (4, 8),
-        (3, 8),
-        (2, 8),
-        (1, 8),
-        (0, 8),
-    ]
-    positions_b = [
-        (size - 1, 8),
-        (size - 2, 8),
-        (size - 3, 8),
-        (size - 4, 8),
-        (size - 5, 8),
-        (size - 6, 8),
-        (size - 7, 8),
-        (8, size - 8),
-        (8, size - 7),
-        (8, size - 6),
-        (8, size - 5),
-        (8, size - 4),
-        (8, size - 3),
-        (8, size - 2),
-        (8, size - 1),
-    ]
-    for i, (row, col) in enumerate(positions_a):
-        _set_function(matrix, function, row, col, ((bits >> i) & 1) == 1)
-    for i, (row, col) in enumerate(positions_b):
-        _set_function(matrix, function, row, col, ((bits >> i) & 1) == 1)
+    for i in range(15):
+        dark = ((bits >> i) & 1) == 1
+
+        if i < 6:
+            _set_function(matrix, function, i, 8, dark)
+        elif i < 8:
+            _set_function(matrix, function, i + 1, 8, dark)
+        else:
+            _set_function(matrix, function, size - 15 + i, 8, dark)
+
+        if i < 8:
+            _set_function(matrix, function, 8, size - i - 1, dark)
+        elif i == 8:
+            _set_function(matrix, function, 8, 7, dark)
+        else:
+            _set_function(matrix, function, 8, 14 - i, dark)
+
+    _set_function(matrix, function, size - 8, 8, True)
 
 
 def _penalty(matrix: list[list[bool | None]]) -> int:

{static_http-0.1.4 → static_http-1.0.0}/src/http_here/server.py

@@ -40,6 +40,10 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
         for name, value in self._extra_headers.items():
             self.send_header(name, value)
 
+    def end_headers(self) -> None:
+        self._add_custom_headers()
+        super().end_headers()
+
     def log_message(self, format: str, *args) -> None:
         if self._quiet:
             return
@@ -69,6 +73,14 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
     def _is_hidden_entry(self, name: str, path: str) -> bool:
         return self._is_hidden(name) or self._has_hidden_attribute(path)
 
+    def _is_within_root(self, path: str) -> bool:
+        root = os.path.realpath(self.directory)
+        real_candidate = os.path.realpath(path)
+        try:
+            return os.path.commonpath([real_candidate, root]) == root
+        except ValueError:
+            return False
+
     def translate_path(self, path: str) -> str | None:
         # Safe path mapping inspired by SimpleHTTPRequestHandler, with strict traversal defense.
         path = path.split("?", 1)[0]
@@ -97,9 +109,7 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
                 return None
 
         candidate = os.path.normpath(candidate)
-        root = os.path.realpath(self.directory)
-        real_candidate = os.path.realpath(candidate)
-        if os.path.commonpath([real_candidate, root]) != root:
+        if not self._is_within_root(candidate):
             return None
 
         return candidate
@@ -109,7 +119,6 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
         self.send_header("Content-Range", unsatisfiable_content_range(size))
         self.send_header("Accept-Ranges", "bytes")
         self.send_header("Content-Length", "0")
-        self._add_custom_headers()
         self.end_headers()
 
     def _write_not_modified(self, path: str, mtime: datetime) -> None:
@@ -118,7 +127,6 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
         self.send_header("Content-Type", self.guess_type(path))
         self.send_header("Last-Modified", self.date_time_string(mtime.timestamp()))
         self.send_header("Content-Length", "0")
-        self._add_custom_headers()
         self.end_headers()
 
     def send_head(self) -> io.BufferedIOBase | None:
@@ -135,13 +143,17 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
                 location = urllib.parse.urlunsplit(("", "", parts.path + "/", parts.query, parts.fragment))
                 self.send_response(HTTPStatus.MOVED_PERMANENTLY)
                 self.send_header("Location", location)
-                self._add_custom_headers()
+                self.send_header("Content-Length", "0")
                 self.end_headers()
                 return None
 
             for index_name in ("index.html", "index.htm"):
                 index_path = os.path.join(path, index_name)
-                if os.path.exists(index_path):
+                if (
+                    os.path.exists(index_path)
+                    and not self._is_hidden_entry(index_name, index_path)
+                    and self._is_within_root(index_path)
+                ):
                     path = index_path
                     break
             else:
@@ -150,6 +162,10 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
                     return None
                 return self.list_directory(path)
 
+        if not self._is_within_root(path):
+            self.send_error(HTTPStatus.BAD_REQUEST, "Invalid request path")
+            return None
+
         ctype = self.guess_type(path)
         try:
             f = open(path, "rb")
@@ -165,7 +181,7 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
                 return None
 
             file_size = stats.st_size
-            mtime = datetime.fromtimestamp(stats.st_mtime, tz=timezone.utc)
+            mtime = datetime.fromtimestamp(stats.st_mtime, tz=timezone.utc).replace(microsecond=0)
 
             if_modified_since = self.headers.get("If-Modified-Since")
             if if_modified_since:
@@ -206,9 +222,8 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
                 f = _RangeFile(f, end - start + 1)
 
             self.send_header("Content-Type", ctype)
-            self.send_header("Last-Modified", self.date_time_string(stats.st_mtime))
+            self.send_header("Last-Modified", self.date_time_string(mtime.timestamp()))
             self.send_header("Accept-Ranges", "bytes")
-            self._add_custom_headers()
             self.end_headers()
             return f
         except Exception:
@@ -264,7 +279,6 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
         self.send_response(HTTPStatus.OK)
         self.send_header("Content-Type", f"text/html; charset={enc}")
         self.send_header("Content-Length", str(len(encoded)))
-        self._add_custom_headers()
         self.end_headers()
         return f
 

{static_http-0.1.4 → static_http-1.0.0/src/static_http.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: static-http
-Version: 0.1.4
+Version: 1.0.0
 Summary: A temporary dependency-free static HTTP server with byte-range support.
 Author: John Paul Ellis
 License-Expression: MIT

static_http-1.0.0/tests/test_qrcode.py

@@ -0,0 +1,355 @@
+from __future__ import annotations
+
+import io
+import re
+from collections import namedtuple
+
+import pytest
+
+from http_here import qrcode
+
+
+class _TtyStringIO(io.StringIO):
+    def isatty(self) -> bool:
+        return True
+
+
+_FORMAT_MASK_BY_BITS = {
+    int("111011111000100", 2): 0,
+    int("111001011110011", 2): 1,
+    int("111110110101010", 2): 2,
+    int("111100010011101", 2): 3,
+    int("110011000101111", 2): 4,
+    int("110001100011000", 2): 5,
+    int("110110001000001", 2): 6,
+    int("110100101110110", 2): 7,
+}
+_ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
+
+
+def _wide_terminal(monkeypatch: pytest.MonkeyPatch) -> None:
+    fake_size = namedtuple("Size", "columns lines")(120, 40)
+    monkeypatch.setattr(qrcode.shutil, "get_terminal_size", lambda fallback=(80, 24): fake_size)
+
+
+def _parse_plain_rendered_matrix(rendered: str) -> list[list[bool]]:
+    qr_lines = rendered.splitlines()[:-1]
+    size = len(qr_lines) - 8
+    assert size > 0
+
+    matrix = []
+    for line in qr_lines[4 : 4 + size]:
+        cells = [line[i : i + 2] for i in range(0, len(line), 2)]
+        assert len(cells) >= size + 8
+        matrix.append([cell != "  " for cell in cells[4 : 4 + size]])
+    return matrix
+
+
+def _parse_ansi_cells(line: str) -> list[bool]:
+    cells = []
+    dark = False
+    space_count = 0
+    index = 0
+
+    while index < len(line):
+        match = _ANSI_RE.match(line, index)
+        if match:
+            sequence = match.group(0)
+            if sequence == "\x1b[40m":
+                dark = True
+            elif sequence in {"\x1b[107m", "\x1b[0m"}:
+                dark = False
+            index = match.end()
+            continue
+
+        assert line[index] == " "
+        space_count += 1
+        if space_count == 2:
+            cells.append(dark)
+            space_count = 0
+        index += 1
+
+    assert space_count == 0
+    return cells
+
+
+def _parse_ansi_rendered_matrix(rendered: str) -> list[list[bool]]:
+    qr_lines = rendered.splitlines()[:-1]
+    size = len(qr_lines) - 8
+    assert size > 0
+
+    matrix = []
+    for line in qr_lines[4 : 4 + size]:
+        cells = _parse_ansi_cells(line)
+        assert len(cells) >= size + 8
+        matrix.append(cells[4 : 4 + size])
+    return matrix
+
+
+def _mark_function_modules(size: int) -> list[list[bool]]:
+    version = (size - 17) // 4
+    function = [[False for _ in range(size)] for _ in range(size)]
+
+    def mark(row: int, col: int) -> None:
+        if 0 <= row < size and 0 <= col < size:
+            function[row][col] = True
+
+    def mark_finder(top: int, left: int) -> None:
+        for row in range(top - 1, top + 8):
+            for col in range(left - 1, left + 8):
+                mark(row, col)
+
+    mark_finder(0, 0)
+    mark_finder(0, size - 7)
+    mark_finder(size - 7, 0)
+
+    if version > 1:
+        center = size - 7
+        for row in range(center - 2, center + 3):
+            for col in range(center - 2, center + 3):
+                mark(row, col)
+
+    for i in range(8, size - 8):
+        mark(6, i)
+        mark(i, 6)
+
+    for i in range(15):
+        if i < 6:
+            mark(i, 8)
+        elif i < 8:
+            mark(i + 1, 8)
+        else:
+            mark(size - 15 + i, 8)
+
+        if i < 8:
+            mark(8, size - i - 1)
+        elif i == 8:
+            mark(8, 7)
+        else:
+            mark(8, 14 - i)
+
+    mark(size - 8, 8)
+    return function
+
+
+def _read_format_mask(matrix: list[list[bool]]) -> int:
+    size = len(matrix)
+    bits = 0
+
+    for i in range(15):
+        if i < 6:
+            row, col = i, 8
+        elif i < 8:
+            row, col = i + 1, 8
+        else:
+            row, col = size - 15 + i, 8
+
+        if matrix[row][col]:
+            bits |= 1 << i
+
+    assert bits in _FORMAT_MASK_BY_BITS, f"unknown format bits: {bits:015b}"
+    return _FORMAT_MASK_BY_BITS[bits]
+
+
+def _mask(mask: int, row: int, col: int) -> bool:
+    if mask == 0:
+        return (row + col) % 2 == 0
+    if mask == 1:
+        return row % 2 == 0
+    if mask == 2:
+        return col % 3 == 0
+    if mask == 3:
+        return (row + col) % 3 == 0
+    if mask == 4:
+        return (row // 2 + col // 3) % 2 == 0
+    if mask == 5:
+        return (row * col) % 2 + (row * col) % 3 == 0
+    if mask == 6:
+        return ((row * col) % 2 + (row * col) % 3) % 2 == 0
+    return ((row + col) % 2 + (row * col) % 3) % 2 == 0
+
+
+def _read_data_bits(matrix: list[list[bool]], mask: int) -> list[int]:
+    size = len(matrix)
+    function = _mark_function_modules(size)
+    bits = []
+    row = size - 1
+    direction = -1
+    col = size - 1
+
+    while col > 0:
+        if col == 6:
+            col -= 1
+        while 0 <= row < size:
+            for offset in range(2):
+                c = col - offset
+                if function[row][c]:
+                    continue
+                bit = matrix[row][c]
+                if _mask(mask, row, c):
+                    bit = not bit
+                bits.append(1 if bit else 0)
+            row += direction
+        row -= direction
+        direction = -direction
+        col -= 2
+
+    return bits
+
+
+def _decode_rendered_qr(matrix: list[list[bool]]) -> str:
+    bits = _read_data_bits(matrix, _read_format_mask(matrix))
+    cursor = 0
+
+    def read(length: int) -> int:
+        nonlocal cursor
+        value = 0
+        for bit in bits[cursor : cursor + length]:
+            value = (value << 1) | bit
+        cursor += length
+        return value
+
+    mode = read(4)
+    assert mode == 0b0100
+
+    byte_count = read(8)
+    payload = bytes(read(8) for _ in range(byte_count))
+    return payload.decode("utf-8")
+
+
+def test_qr_renders_on_wide_terminal() -> None:
+    fake_size = namedtuple("Size", "columns lines")(80, 24)
+    monkeypatch = pytest.MonkeyPatch()
+    monkeypatch.setattr(qrcode.shutil, "get_terminal_size", lambda fallback=(80, 24): fake_size)
+    out = io.StringIO()
+    try:
+        assert qrcode.render_qr("http://localhost:8080/", stream=out)
+    finally:
+        monkeypatch.undo()
+    assert out.getvalue().strip() != ""
+
+
+def test_qr_uses_forced_terminal_contrast_on_tty() -> None:
+    fake_size = namedtuple("Size", "columns lines")(80, 24)
+    monkeypatch = pytest.MonkeyPatch()
+    monkeypatch.setattr(qrcode.shutil, "get_terminal_size", lambda fallback=(80, 24): fake_size)
+    out = _TtyStringIO()
+    try:
+        assert qrcode.render_qr("http://localhost:8080/", stream=out)
+    finally:
+        monkeypatch.undo()
+    rendered = out.getvalue()
+    assert "\x1b[40m" in rendered
+    assert "\x1b[107m" in rendered
+
+
+def test_plain_rendered_qr_output_decodes_to_original_url(monkeypatch: pytest.MonkeyPatch) -> None:
+    _wide_terminal(monkeypatch)
+    url = "http://192.168.1.205:8080/"
+    out = io.StringIO()
+
+    assert qrcode.render_qr(url, stream=out)
+
+    assert _decode_rendered_qr(_parse_plain_rendered_matrix(out.getvalue())) == url
+
+
+def test_ansi_rendered_qr_output_decodes_to_original_url(monkeypatch: pytest.MonkeyPatch) -> None:
+    _wide_terminal(monkeypatch)
+    url = "http://localhost:8080/"
+    out = _TtyStringIO()
+
+    assert qrcode.render_qr(url, stream=out)
+
+    assert _decode_rendered_qr(_parse_ansi_rendered_matrix(out.getvalue())) == url
+
+
+def test_qr_payload_limit_is_78_utf8_bytes() -> None:
+    multibyte = "\u00e9"
+
+    assert len(("a" * 78).encode("utf-8")) == 78
+    assert len((multibyte * 39).encode("utf-8")) == 78
+
+    assert len(qrcode._build_matrix("a" * 78)) == 33
+    assert len(qrcode._build_matrix(multibyte * 39)) == 33
+
+    with pytest.raises(ValueError, match="too long"):
+        qrcode._build_matrix("a" * 79)
+    with pytest.raises(ValueError, match="too long"):
+        qrcode._build_matrix(multibyte * 40)
+
+
+def test_qr_known_format_bits_and_version_selection() -> None:
+    assert f"{qrcode._format_bits(0):015b}" == "111011111000100"
+    assert len(qrcode._build_matrix("http://localhost:8080/")) == 25
+    assert len(qrcode._build_matrix("http://192.168.1.205:8080/")) == 25
+
+
+def test_reed_solomon_matches_known_version_2_l_codewords() -> None:
+    data = qrcode._encode_data(b"http://localhost:8080/", 2)
+
+    assert data == [
+        65,
+        102,
+        135,
+        71,
+        71,
+        3,
+        162,
+        242,
+        246,
+        198,
+        246,
+        54,
+        22,
+        198,
+        134,
+        247,
+        55,
+        67,
+        163,
+        131,
+        3,
+        131,
+        2,
+        240,
+        236,
+        17,
+        236,
+        17,
+        236,
+        17,
+        236,
+        17,
+        236,
+        17,
+    ]
+    assert qrcode._reed_solomon(data, qrcode._ECC_CODEWORDS[2]) == [224, 235, 163, 25, 95, 161, 5, 47, 66, 94]
+
+
+def test_format_bits_use_dark_module_and_second_copy_positions() -> None:
+    size = 25
+    matrix = [[None for _ in range(size)] for _ in range(size)]
+    function = [[False for _ in range(size)] for _ in range(size)]
+
+    qrcode._draw_function_patterns(matrix, function, 2)
+    qrcode._draw_format_bits(matrix, function, 4)
+    bits = qrcode._format_bits(4)
+
+    assert matrix[size - 8][8] is True
+    assert matrix[0][8] == bool(bits & 1)
+    assert matrix[8][size - 1] == bool(bits & 1)
+    assert matrix[8][7] == bool((bits >> 8) & 1)
+    assert matrix[size - 1][8] == bool(bits & 1)
+    assert function[size - 8][8] is True
+
+
+def test_qr_warns_when_terminal_too_narrow() -> None:
+    fake_size = namedtuple("Size", "columns lines")(20, 24)
+    monkeypatch = pytest.MonkeyPatch()
+    monkeypatch.setattr(qrcode.shutil, "get_terminal_size", lambda fallback=(80, 24): fake_size)
+    out = io.StringIO()
+    try:
+        assert not qrcode.render_qr("http://localhost:8080/", stream=out)
+    finally:
+        monkeypatch.undo()
+    assert "too narrow" in out.getvalue().lower()

{static_http-0.1.4 → static_http-1.0.0}/tests/test_server.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import contextlib
+import os
 from http.client import HTTPResponse
 import threading
 import urllib.error
@@ -83,6 +84,40 @@ def test_head_returns_headers_without_body(tmp_path: Path) -> None:
             assert resp.read() == b""
 
 
+def test_if_modified_since_matches_last_modified_header(tmp_path: Path) -> None:
+    file_path = tmp_path / "hello.txt"
+    file_path.write_bytes(b"abc")
+    os.utime(file_path, (1_700_000_000.5, 1_700_000_000.5))
+
+    with _running_server(
+        tmp_path,
+        extra_headers={},
+        disable_dir_list=False,
+        quiet=True,
+    ) as srv:
+        url = _http_url(srv, "/hello.txt")
+        with urllib.request.urlopen(url) as resp:
+            last_modified = resp.headers["Last-Modified"]
+
+        req = urllib.request.Request(url, headers={"If-Modified-Since": last_modified})
+        with pytest.raises(urllib.error.HTTPError) as exc:
+            urllib.request.urlopen(req)
+        assert exc.value.code == 304
+
+
+def test_custom_headers_are_added_to_error_responses(tmp_path: Path) -> None:
+    with _running_server(
+        tmp_path,
+        extra_headers={"Access-Control-Allow-Origin": "*"},
+        disable_dir_list=False,
+        quiet=True,
+    ) as srv:
+        with pytest.raises(urllib.error.HTTPError) as exc:
+            urllib.request.urlopen(_http_url(srv, "/missing.txt"))
+        assert exc.value.code == 404
+        assert exc.value.headers["Access-Control-Allow-Origin"] == "*"
+
+
 def test_headers_and_directory_listing_controls(tmp_path: Path) -> None:
     root = tmp_path / "dir"
     root.mkdir()
@@ -178,6 +213,25 @@ def test_path_traversal_cannot_escape_root(tmp_path: Path) -> None:
         assert exc.value.code in {400, 404, 200}
 
 
+def test_directory_index_symlink_cannot_escape_root(tmp_path: Path) -> None:
+    outside = tmp_path.parent / "outside-index.html"
+    outside.write_bytes(b"outside")
+    try:
+        os.symlink(outside, tmp_path / "index.html")
+    except (OSError, NotImplementedError) as exc:
+        pytest.skip(f"symlinks are not available: {exc}")
+
+    with _running_server(
+        tmp_path,
+        extra_headers={},
+        disable_dir_list=False,
+        quiet=True,
+    ) as srv:
+        with urllib.request.urlopen(_http_url(srv, "/")) as resp:
+            assert resp.status == 200
+            assert b"outside" not in resp.read()
+
+
 def test_directory_redirect_preserves_query_string(tmp_path: Path) -> None:
     (tmp_path / "dir").mkdir()
 

static_http-0.1.4/tests/test_qrcode.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-import io
-from collections import namedtuple
-
-import pytest
-
-from http_here import qrcode
-
-
-class _TtyStringIO(io.StringIO):
-    def isatty(self) -> bool:
-        return True
-
-
-def test_qr_renders_on_wide_terminal() -> None:
-    fake_size = namedtuple("Size", "columns lines")(80, 24)
-    monkeypatch = pytest.MonkeyPatch()
-    monkeypatch.setattr(qrcode.shutil, "get_terminal_size", lambda fallback=(80, 24): fake_size)
-    out = io.StringIO()
-    try:
-        assert qrcode.render_qr("http://localhost:8080/", stream=out)
-    finally:
-        monkeypatch.undo()
-    assert out.getvalue().strip() != ""
-
-
-def test_qr_uses_forced_terminal_contrast_on_tty() -> None:
-    fake_size = namedtuple("Size", "columns lines")(80, 24)
-    monkeypatch = pytest.MonkeyPatch()
-    monkeypatch.setattr(qrcode.shutil, "get_terminal_size", lambda fallback=(80, 24): fake_size)
-    out = _TtyStringIO()
-    try:
-        assert qrcode.render_qr("http://localhost:8080/", stream=out)
-    finally:
-        monkeypatch.undo()
-    rendered = out.getvalue()
-    assert "\x1b[40m" in rendered
-    assert "\x1b[107m" in rendered
-
-
-def test_qr_known_format_bits_and_version_selection() -> None:
-    assert f"{qrcode._format_bits(0):015b}" == "111011111000100"
-    assert len(qrcode._build_matrix("http://localhost:8080/")) == 25
-    assert len(qrcode._build_matrix("http://192.168.1.205:8080/")) == 25
-
-
-def test_qr_warns_when_terminal_too_narrow() -> None:
-    fake_size = namedtuple("Size", "columns lines")(20, 24)
-    monkeypatch = pytest.MonkeyPatch()
-    monkeypatch.setattr(qrcode.shutil, "get_terminal_size", lambda fallback=(80, 24): fake_size)
-    out = io.StringIO()
-    try:
-        assert not qrcode.render_qr("http://localhost:8080/", stream=out)
-    finally:
-        monkeypatch.undo()
-    assert "too narrow" in out.getvalue().lower()