test: prove persistent cache reuse in session benchmarks

Address PR #563 review and CI: isolate test helpers, scope interpreter barriers by real prefixes, and prove cold/disk-warm/same-process cache behavior without ignored reconfiguration.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: karthiknadig

crates/pet/tests/fixtures/session_sitecustomize.py

@@ -10,10 +10,12 @@
 barrier = os.environ.get("PET_SESSION_RESOLVE_BARRIER")
 resolve_root = os.environ.get("PET_SESSION_RESOLVE_ROOT")
 if barrier and resolve_root:
-    executable = os.path.normcase(os.path.abspath(sys.executable))
-    root_executable_prefix = os.path.normcase(os.path.abspath(resolve_root)) + os.sep
-    if not executable.startswith(root_executable_prefix):
+    prefix = os.path.normcase(os.path.realpath(sys.prefix))
+    root_prefix = os.path.normcase(os.path.realpath(resolve_root)) + os.sep
+    if not prefix.startswith(root_prefix):
         barrier = None
+else:
+    barrier = None
 
 if barrier:
     root = Path(barrier)

crates/pet/tests/jsonrpc_client.rs

@@ -525,57 +525,6 @@ fn spawn_stdout_reader(stdout: ChildStdout, state: Arc<ClientState>) -> JoinHand
     })
 }
 
-#[cfg(test)]
-pub(crate) fn controlled_pending_request(
-    client: &PetJsonRpcClient,
-    submitted_at: Instant,
-) -> (PendingRequest, impl FnOnce(Result<Value, String>, Instant)) {
-    let id = REQUEST_ID.fetch_add(1, Ordering::SeqCst);
-    let (sender, receiver) = mpsc::channel();
-    client
-        .inner
-        .state
-        .pending
-        .lock()
-        .unwrap()
-        .insert(id, sender.clone());
-    let request = PendingRequest {
-        id,
-        method: "controlled".to_string(),
-        submitted_at,
-        receiver,
-        client: client.clone(),
-    };
-    let send = move |result, received_at| {
-        sender
-            .send(TimedResponse {
-                result,
-                received_at,
-            })
-            .expect("controlled pending receiver should remain connected");
-    };
-    (request, send)
-}
-
-#[cfg(test)]
-pub(crate) fn pending_request_registered(
-    client: &PetJsonRpcClient,
-    request: &PendingRequest,
-) -> bool {
-    client
-        .inner
-        .state
-        .pending
-        .lock()
-        .unwrap()
-        .contains_key(&request.id)
-}
-
-#[cfg(test)]
-pub(crate) fn pending_request_count(client: &PetJsonRpcClient) -> usize {
-    client.inner.state.pending.lock().unwrap().len()
-}
-
 fn spawn_stderr_reader(
     stderr: impl Read + Send + 'static,
     state: Arc<ClientState>,
@@ -649,3 +598,113 @@ pub(crate) fn read_message(reader: &mut BufReader<ChildStdout>) -> io::Result<Op
     })?;
     Ok(Some(message))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn controlled_pending_request(
+        client: &PetJsonRpcClient,
+        submitted_at: Instant,
+    ) -> (PendingRequest, impl FnOnce(Result<Value, String>, Instant)) {
+        let id = REQUEST_ID.fetch_add(1, Ordering::SeqCst);
+        let (sender, receiver) = mpsc::channel();
+        client
+            .inner
+            .state
+            .pending
+            .lock()
+            .unwrap()
+            .insert(id, sender.clone());
+        let request = PendingRequest {
+            id,
+            method: "controlled".to_string(),
+            submitted_at,
+            receiver,
+            client: client.clone(),
+        };
+        let send = move |result, received_at| {
+            sender
+                .send(TimedResponse {
+                    result,
+                    received_at,
+                })
+                .expect("controlled pending receiver should remain connected");
+        };
+        (request, send)
+    }
+
+    fn pending_request_registered(client: &PetJsonRpcClient, request: &PendingRequest) -> bool {
+        client
+            .inner
+            .state
+            .pending
+            .lock()
+            .unwrap()
+            .contains_key(&request.id)
+    }
+
+    fn pending_request_count(client: &PetJsonRpcClient) -> usize {
+        client.inner.state.pending.lock().unwrap().len()
+    }
+
+    #[test]
+    fn pending_request_uses_receipt_time_and_operation_deadline() {
+        let client = PetJsonRpcClient::spawn().expect("failed to spawn idle PET client");
+
+        let submitted_at = Instant::now() - Duration::from_secs(10);
+        let received_at = submitted_at + Duration::from_millis(125);
+        let (received, send_received) = controlled_pending_request(&client, submitted_at);
+        send_received(Ok(json!({ "ok": true })), received_at);
+        let (result, latency) = received
+            .wait(Duration::from_secs(30))
+            .expect("recorded response should be returned");
+        assert_eq!(result, json!({ "ok": true }));
+        assert_eq!(latency, Duration::from_millis(125));
+        assert_eq!(pending_request_count(&client), 0);
+
+        let consumed_after_deadline_at = Instant::now() - Duration::from_secs(31);
+        let (consumed_after_deadline, send_timely) =
+            controlled_pending_request(&client, consumed_after_deadline_at);
+        send_timely(
+            Ok(json!({ "timely": true })),
+            consumed_after_deadline_at + Duration::from_secs(29),
+        );
+        let (result, latency) = consumed_after_deadline
+            .wait(Duration::from_secs(30))
+            .expect("a timely received response remains valid when consumed after the deadline");
+        assert_eq!(result, json!({ "timely": true }));
+        assert_eq!(latency, Duration::from_secs(29));
+
+        let received_after_deadline_at = Instant::now() - Duration::from_secs(31);
+        let (received_after_deadline, send_late) =
+            controlled_pending_request(&client, received_after_deadline_at);
+        send_late(
+            Ok(json!({ "late": true })),
+            received_after_deadline_at + Duration::from_secs(30) + Duration::from_millis(1),
+        );
+        let error = received_after_deadline
+            .wait(Duration::from_secs(30))
+            .expect_err("a response received after the operation deadline must time out");
+        assert!(error.contains("Timed out waiting for controlled response"));
+        assert_eq!(pending_request_count(&client), 0);
+
+        let expired_at = Instant::now() - Duration::from_secs(31);
+        let (expired, _keep_sender_connected) = controlled_pending_request(&client, expired_at);
+        assert!(pending_request_registered(&client, &expired));
+        let error = expired
+            .wait(Duration::from_secs(30))
+            .expect_err("an expired operation must not receive a fresh wait budget");
+        assert!(error.contains("Timed out waiting for controlled response"));
+        assert_eq!(pending_request_count(&client), 0);
+
+        let (dropped, _keep_sender_connected) = controlled_pending_request(&client, Instant::now());
+        assert!(pending_request_registered(&client, &dropped));
+        drop(dropped);
+        assert_eq!(
+            pending_request_count(&client),
+            0,
+            "dropping a pending request must remove its map entry"
+        );
+    }
+}

crates/pet/tests/jsonrpc_server_test.rs

@@ -13,77 +13,10 @@ use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
 use tempfile::TempDir;
 
-mod jsonrpc_client;
+pub mod jsonrpc_client;
 
 use jsonrpc_client::{EnvironmentNotification, PetJsonRpcClient};
 
-#[test]
-fn pending_request_uses_receipt_time_and_operation_deadline() {
-    let client = PetJsonRpcClient::spawn().expect("failed to spawn idle PET client");
-
-    let submitted_at = Instant::now() - Duration::from_secs(10);
-    let received_at = submitted_at + Duration::from_millis(125);
-    let (received, send_received) =
-        jsonrpc_client::controlled_pending_request(&client, submitted_at);
-    send_received(Ok(json!({ "ok": true })), received_at);
-    let (result, latency) = received
-        .wait(Duration::from_secs(30))
-        .expect("recorded response should be returned");
-    assert_eq!(result, json!({ "ok": true }));
-    assert_eq!(latency, Duration::from_millis(125));
-    assert_eq!(jsonrpc_client::pending_request_count(&client), 0);
-
-    let consumed_after_deadline_at = Instant::now() - Duration::from_secs(31);
-    let (consumed_after_deadline, send_timely) =
-        jsonrpc_client::controlled_pending_request(&client, consumed_after_deadline_at);
-    send_timely(
-        Ok(json!({ "timely": true })),
-        consumed_after_deadline_at + Duration::from_secs(29),
-    );
-    let (result, latency) = consumed_after_deadline
-        .wait(Duration::from_secs(30))
-        .expect("a timely received response remains valid when consumed after the deadline");
-    assert_eq!(result, json!({ "timely": true }));
-    assert_eq!(latency, Duration::from_secs(29));
-
-    let received_after_deadline_at = Instant::now() - Duration::from_secs(31);
-    let (received_after_deadline, send_late) =
-        jsonrpc_client::controlled_pending_request(&client, received_after_deadline_at);
-    send_late(
-        Ok(json!({ "late": true })),
-        received_after_deadline_at + Duration::from_secs(30) + Duration::from_millis(1),
-    );
-    let error = received_after_deadline
-        .wait(Duration::from_secs(30))
-        .expect_err("a response received after the operation deadline must time out");
-    assert!(error.contains("Timed out waiting for controlled response"));
-    assert_eq!(jsonrpc_client::pending_request_count(&client), 0);
-
-    let expired_at = Instant::now() - Duration::from_secs(31);
-    let (expired, _keep_sender_connected) =
-        jsonrpc_client::controlled_pending_request(&client, expired_at);
-    assert!(jsonrpc_client::pending_request_registered(
-        &client, &expired
-    ));
-    let error = expired
-        .wait(Duration::from_secs(30))
-        .expect_err("an expired operation must not receive a fresh wait budget");
-    assert!(error.contains("Timed out waiting for controlled response"));
-    assert_eq!(jsonrpc_client::pending_request_count(&client), 0);
-
-    let (dropped, _keep_sender_connected) =
-        jsonrpc_client::controlled_pending_request(&client, Instant::now());
-    assert!(jsonrpc_client::pending_request_registered(
-        &client, &dropped
-    ));
-    drop(dropped);
-    assert_eq!(
-        jsonrpc_client::pending_request_count(&client),
-        0,
-        "dropping a pending request must remove its map entry"
-    );
-}
-
 fn frame_with_headers(payload: &[u8], headers: &[(&str, &str)], line_ending: &[u8]) -> Vec<u8> {
     let mut frame = Vec::new();
     for (name, value) in headers {