clone/codex
1
0
Fork 0
mirror of https://github.com/openai/codex.git synced 2026-04-24 14:45:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

use matcher

Browse Source
This commit is contained in:
Ahmed Ibrahim
2026-01-07 13:30:52 -08:00
parent eded1864b6
commit 70f09db901
6 changed files with 24 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
codex-rs/core/tests/common/test_codex.rs
View File

@@ -324,14 +324,13 @@ impl TestCodexHarness {
}
pub async fn request_bodies(&self) -> Vec<Value> {
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
self.server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.map(|req| {
req.body_json::<Value>()
.expect("request body to be valid JSON")

12
codex-rs/core/tests/suite/client.rs
View File

@@ -375,14 +375,13 @@ async fn includes_conversation_id_and_model_headers_in_request() {
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
// get request from the server
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let requests = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.collect::<Vec<_>>();
let request = requests
.first()
@@ -509,14 +508,13 @@ async fn chatgpt_auth_sends_correct_request() {
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
// get request from the server
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let requests = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.collect::<Vec<_>>();
let request = requests
.first()
@@ -1250,14 +1248,13 @@ async fn azure_responses_request_includes_store_and_reasoning_ids() {
}
}
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let requests = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.collect::<Vec<_>>();
assert_eq!(requests.len(), 1, "expected a single POST request");
let body: serde_json::Value = requests[0]
@@ -1872,14 +1869,13 @@ async fn history_dedupes_streamed_and_final_messages_across_turns() {
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
// Inspect the three captured requests.
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let requests = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.collect::<Vec<_>>();
assert_eq!(requests.len(), 3, "expected 3 requests (one per turn)");

13
codex-rs/core/tests/suite/compact.rs
View File

@@ -42,7 +42,6 @@ use pretty_assertions::assert_eq;
use serde_json::json;
use wiremock::Match;
use wiremock::MockServer;
use wiremock::matchers::method;
use wiremock::matchers::path_regex;
// --- Test helpers -----------------------------------------------------------
@@ -360,14 +359,13 @@ async fn manual_compact_uses_custom_prompt() {
assert_eq!(message, COMPACT_WARNING_MESSAGE);
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let requests = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.collect::<Vec<_>>();
let body = requests
.iter()
@@ -596,14 +594,13 @@ async fn multiple_auto_compact_per_task_runs_after_token_limit_hit() {
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
// collect the requests payloads from the model
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let requests_payloads = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.collect::<Vec<_>>();
let body = requests_payloads[0]
@@ -1129,14 +1126,13 @@ async fn auto_compact_runs_after_token_limit_hit() {
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let requests = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.collect::<Vec<_>>();
assert_eq!(
requests.len(),
@@ -1923,14 +1919,13 @@ async fn auto_compact_allows_multiple_attempts_when_interleaved_with_other_turn_
"auto compact should not emit task lifecycle events"
);
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let requests = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.collect::<Vec<_>>();
let request_bodies: Vec<String> = requests
.into_iter()

3
codex-rs/core/tests/suite/compact_resume_fork.rs
View File

@@ -774,14 +774,13 @@ fn normalize_line_endings(value: &mut Value) {
}
async fn gather_request_bodies(server: &MockServer) -> Vec<Value> {
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let mut bodies = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.map(|req| {
req.body_json::<Value>()
.expect("request body to be valid JSON")

13
codex-rs/core/tests/suite/review.rs
View File

@@ -35,7 +35,6 @@ use wiremock::Match;
use wiremock::Mock;
use wiremock::MockServer;
use wiremock::ResponseTemplate;
use wiremock::matchers::method;
use wiremock::matchers::path;
use wiremock::matchers::path_regex;
@@ -427,14 +426,13 @@ async fn review_uses_custom_review_model_from_config() {
let _complete = wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
// Assert the request body model equals the configured review model
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let requests = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.collect::<Vec<_>>();
let request = requests
.first()
@@ -556,14 +554,13 @@ async fn review_input_isolated_from_parent_history() {
let _complete = wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
// Assert the request `input` contains the environment context followed by the user review prompt.
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let requests = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.collect::<Vec<_>>();
let request = requests
.first()
@@ -691,14 +688,13 @@ async fn review_history_surfaces_in_parent_session() {
// Inspect the second request (parent turn) input contents.
// Parent turns include session initial messages (user_instructions, environment_context).
// Critically, no messages from the review thread should appear.
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let requests = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.collect::<Vec<_>>();
assert_eq!(requests.len(), 2);
let body = requests[1].body_json::<serde_json::Value>().unwrap();
@@ -817,14 +813,13 @@ async fn review_uses_overridden_cwd_for_base_branch_merge_base() {
let _entered = wait_for_event(&codex, |ev| matches!(ev, EventMsg::EnteredReviewMode(_))).await;
let _complete = wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let requests = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.collect::<Vec<_>>();
assert_eq!(requests.len(), 1);
let body = requests[0].body_json::<serde_json::Value>().unwrap();

30
codex-rs/core/tests/suite/unified_exec.rs
View File

@@ -1243,14 +1243,13 @@ async fn exec_command_reports_chunk_and_exit_metadata() -> Result<()> {
let requests = server.received_requests().await.expect("recorded requests");
assert!(!requests.is_empty(), "expected at least one POST request");
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let bodies = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.map(|req| {
req.body_json::<Value>()
.expect("request body to be valid JSON")
@@ -1359,14 +1358,13 @@ async fn unified_exec_respects_early_exit_notifications() -> Result<()> {
let requests = server.received_requests().await.expect("recorded requests");
assert!(!requests.is_empty(), "expected at least one POST request");
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let bodies = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.map(|req| {
req.body_json::<Value>()
.expect("request body to be valid JSON")
@@ -1496,14 +1494,13 @@ async fn write_stdin_returns_exit_metadata_and_clears_session() -> Result<()> {
let requests = server.received_requests().await.expect("recorded requests");
assert!(!requests.is_empty(), "expected at least one POST request");
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let bodies = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.map(|req| {
req.body_json::<Value>()
.expect("request body to be valid JSON")
@@ -1862,14 +1859,13 @@ async fn unified_exec_reuses_session_via_stdin() -> Result<()> {
let requests = server.received_requests().await.expect("recorded requests");
assert!(!requests.is_empty(), "expected at least one POST request");
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let bodies = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.map(|req| {
req.body_json::<Value>()
.expect("request body to be valid JSON")
@@ -2008,14 +2004,13 @@ PY
let requests = server.received_requests().await.expect("recorded requests");
assert!(!requests.is_empty(), "expected at least one POST request");
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let bodies = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.map(|req| {
req.body_json::<Value>()
.expect("request body to be valid JSON")
@@ -2129,14 +2124,13 @@ async fn unified_exec_timeout_and_followup_poll() -> Result<()> {
let requests = server.received_requests().await.expect("recorded requests");
assert!(!requests.is_empty(), "expected at least one POST request");
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let bodies = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.map(|req| {
req.body_json::<Value>()
.expect("request body to be valid JSON")
@@ -2227,14 +2221,13 @@ PY
let requests = server.received_requests().await.expect("recorded requests");
assert!(!requests.is_empty(), "expected at least one POST request");
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let bodies = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.map(|req| {
req.body_json::<Value>()
.expect("request body to be valid JSON")
@@ -2316,14 +2309,13 @@ async fn unified_exec_runs_under_sandbox() -> Result<()> {
let requests = server.received_requests().await.expect("recorded requests");
assert!(!requests.is_empty(), "expected at least one POST request");
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let bodies = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.map(|req| {
req.body_json::<Value>()
.expect("request body to be valid JSON")
@@ -2426,14 +2418,13 @@ async fn unified_exec_python_prompt_under_seatbelt() -> Result<()> {
let requests = server.received_requests().await.expect("recorded requests");
assert!(!requests.is_empty(), "expected at least one POST request");
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let bodies = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.map(|req| {
req.body_json::<Value>()
.expect("request body to be valid JSON")
@@ -2528,14 +2519,13 @@ async fn unified_exec_runs_on_all_platforms() -> Result<()> {
let requests = server.received_requests().await.expect("recorded requests");
assert!(!requests.is_empty(), "expected at least one POST request");
let method_matcher = method("POST");
let path_matcher = path_regex(".*/responses$");
let bodies = server
.received_requests()
.await
.expect("mock server should not fail")
.into_iter()
.filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
.filter(|req| path_matcher.matches(req))
.map(|req| {
req.body_json::<Value>()
.expect("request body to be valid JSON")