Handoff-40 Required #3: behavioral tests for If-Range

- Fixture server logs If-Range header and supports if-range-strict mode
  (returns 200 on validator mismatch) plus configurable ETag.
- piece_sends_if_range_when_validator_set: verifies If-Range header is sent
  with the session validator.
- piece_rejects_200_after_if_range_mismatch: verifies 200 after If-Range
  yields Changed (not silent acceptance).

Author: Linuxuser67

src/download_tests.rs

@@ -3097,7 +3097,7 @@ fn manager_pause_resume_cancel() {
             fail("bytes differ");
         }
         let ranges = std::fs::read_to_string(dir.join("ranges.log")).unwrap_or_default();
-        if !ranges.lines().any(|l| l.starts_with("bytes=")) {
+        if !ranges.lines().any(|l| l.contains("range=bytes=")) {
             fail("resume never sent a Range request (206 path untested)");
         }
 
@@ -6319,3 +6319,92 @@ fn dropping_manager_removes_scheduler_source() {
         "dropping the manager removes the scheduler source"
     );
 }
+
+/// If-Range header is sent when the session validator is set.
+/// The fixture server logs the If-Range header; we assert it matches.
+#[test]
+fn piece_sends_if_range_when_validator_set() {
+    let Fixture {
+        dir,
+        dl,
+        payload,
+        port,
+        server,
+    } = spawn_fixture("ifrange", "v.bin", 300_000, "0", &[], 44);
+    let (tx, _rx) = tokio::sync::mpsc::unbounded_channel();
+    let if_range = std::sync::Arc::new(std::sync::OnceLock::new());
+    let _ = if_range.set("\"test-etag-123\"".to_string());
+    let ctx = FetchCtx {
+        client: http_client().clone(),
+        url: format!("http://127.0.0.1:{port}/v.bin"),
+        dest: dl.join("v.bin"),
+        opts: DownloadOptions {
+            ..Default::default()
+        },
+        cookies: None,
+        timeout: Duration::from_secs(30),
+        tx,
+        if_range,
+    };
+    let total = payload.len() as u64;
+    // Fetch a piece; the server logs the If-Range header.
+    match tokio_rt().block_on(fetch_piece(&ctx, 0, 1023, total)) {
+        Ok(_) => {}
+        Err(_) => abort(&server, "piece fetch failed"),
+    }
+    // Verify the If-Range header was sent with our validator.
+    let log = std::fs::read_to_string(dir.join("ranges.log")).unwrap_or_default();
+    assert!(
+        log.contains("if-range=\"test-etag-123\""),
+        "If-Range header not sent or wrong value. Log:\n{log}"
+    );
+    cleanup(&server, &dir);
+}
+
+/// 200 after If-Range yields Changed: when the server's ETag doesn't match
+/// our If-Range, it returns 200 (full body) instead of 206. fetch_piece must
+/// fail with Changed, not silently accept the wrong bytes.
+#[test]
+fn piece_rejects_200_after_if_range_mismatch() {
+    // Use if-range-strict mode: server returns 200 if If-Range != ETAG.
+    let Fixture {
+        dir,
+        dl,
+        payload,
+        port,
+        server,
+    } = spawn_fixture(
+        "ifrange200",
+        "v.bin",
+        300_000,
+        "0",
+        &["if-range-strict", "\"server-etag\""],
+        45,
+    );
+    let (tx, _rx) = tokio::sync::mpsc::unbounded_channel();
+    let if_range = std::sync::Arc::new(std::sync::OnceLock::new());
+    // Our validator differs from the server's ETag.
+    let _ = if_range.set("\"client-etag\"".to_string());
+    let ctx = FetchCtx {
+        client: http_client().clone(),
+        url: format!("http://127.0.0.1:{port}/v.bin"),
+        dest: dl.join("v.bin"),
+        opts: DownloadOptions {
+            ..Default::default()
+        },
+        cookies: None,
+        timeout: Duration::from_secs(30),
+        tx,
+        if_range,
+    };
+    let total = payload.len() as u64;
+    match tokio_rt().block_on(fetch_piece(&ctx, 0, 1023, total)) {
+        Err(AttemptFail::Changed(_)) => {}
+        Ok(_) => abort(
+            &server,
+            "200 after If-Range mismatch must fail Changed, not succeed",
+        ),
+        Err(_) => abort(&server, "wrong error kind"),
+    }
+    cleanup(&server, &dir);
+}

tests/throttled_server.py

@@ -3,7 +3,9 @@
 Serves one file slowly (~160KB/s) so pause() always lands mid-transfer.
 Honors Range requests with 206 (exercises real resume); logs each
 request's range (or "full") for assertions.
-Usage: throttled_server.py PORT FILE RANGELOG
+Supports If-Range: logs the header, sends ETag, and in "if-range-strict"
+mode returns 200 if If-Range doesn't match (simulating a changed file).
+Usage: throttled_server.py PORT FILE RANGELOG [SLEEP] [DISPOSITION] [MODE] [ETAG]
 """
 import sys
 import time
@@ -16,14 +18,23 @@
 DISPOSITION = sys.argv[5] if len(sys.argv) > 5 else None
 # "throttle-ranges": 206 only for the bytes=0-0 probe, 403 for every other
 # Range request (simulates per-IP connection limits on file hosts).
+# "if-range-strict": if If-Range is present and doesn't match ETAG, return 200
+# (simulates a changed file); otherwise honor ranges normally.
 MODE = sys.argv[6] if len(sys.argv) > 6 else "normal"
+# ETag to send; defaults to a fixed value for If-Range testing.
+ETAG = sys.argv[7] if len(sys.argv) > 7 else '"test-etag-123"'
 
 
 class H(BaseHTTPRequestHandler):
     def do_GET(self):
         requested = self.headers.get("Range")
+        if_range = self.headers.get("If-Range")
         with open(RANGELOG, "a") as log:
-            log.write((requested or "full") + "\n")
+            # Log format: "range=<range>|if-range=<value>" for assertions.
+            # "full" if no Range header.
+            range_part = requested or "full"
+            if_range_part = if_range or "none"
+            log.write(f"range={range_part}|if-range={if_range_part}\n")
         start, end, is_range = 0, len(DATA) - 1, False
         if requested and requested.startswith("bytes="):
             is_range = True
@@ -46,6 +57,20 @@ def do_GET(self):
             self.send_response(403)
             self.end_headers()
             return
+        # If-Range strict mode: mismatch means the file changed → return 200
+        # with full body (client must detect Changed).
+        if MODE == "if-range-strict" and if_range and if_range != ETAG:
+            self.send_response(200)
+            self.send_header("Content-Length", str(len(DATA)))
+            self.send_header("Content-Type", "application/octet-stream")
+            self.send_header("ETag", ETAG)
+            self.end_headers()
+            try:
+                self.wfile.write(DATA)
+                self.wfile.flush()
+            except (BrokenPipeError, ConnectionResetError):
+                pass
+            return
         body = DATA[start : end + 1]
         if is_range:
             self.send_response(206)
@@ -54,6 +79,7 @@ def do_GET(self):
             self.send_response(200)
         self.send_header("Content-Length", str(len(body)))
         self.send_header("Content-Type", "application/octet-stream")
+        self.send_header("ETag", ETAG)
         if DISPOSITION:
             self.send_header("Content-Disposition", DISPOSITION)
         self.end_headers()