github/codex
4
0
Fork 0
mirror of https://github.com/openai/codex.git synced 2026-10-20 08:19:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove selected core test cases (#42066)

Browse Source 
## What changed

Remove targeted tests for history normalization, exec-policy amendments,
default reasoning effort, collaboration instruction overrides, and sandbox
approval telemetry.

GitOrigin-RevId: 6f79bf4cd4b625b4ff750e3aa00a88871afc97f4
This commit is contained in:
jif
2026-09-01 14:43:27 +00:00
committed by copyberry
parent 28097e98eb
commit 25ba0ae6cd
5 changed files with 0 additions and 328 deletions
Download Patch File Download Diff File Expand all files Collapse all files
codex-rs/core/src/context_manager/history_tests.rs
-40
View File
@@ -1660,46 +1660,6 @@ fn format_exec_output_prefers_line_marker_when_both_limits_exceeded() {
assert_truncated_message_matches(&truncated, "line-0-", /*expected_removed*/ 17_423);
}
#[cfg(not(debug_assertions))]
#[test]
fn normalize_adds_missing_output_for_function_call() {
let items = vec![ResponseItem::FunctionCall {
id: None,
name: "do_it".to_string(),
namespace: None,
arguments: "{}".to_string(),
call_id: "call-x".to_string(),
encrypted_function_args: None,
internal_chat_message_metadata_passthrough: None,
}];
let mut h = create_history_with_items(items);
h.normalize_history(&default_input_modalities());
assert_eq!(
raw_items(&h),
vec![
ResponseItem::FunctionCall {
id: None,
name: "do_it".to_string(),
namespace: None,
arguments: "{}".to_string(),
call_id: "call-x".to_string(),
encrypted_function_args: None,
internal_chat_message_metadata_passthrough: None,
},
ResponseItem::FunctionCallOutput {
id: None,
call_id: Some("call-x".to_string()),
name: None,
namespace: None,
output: FunctionCallOutputPayload::from_text("aborted".to_string()),
internal_chat_message_metadata_passthrough: None,
},
]
);
}
#[cfg(not(debug_assertions))]
#[test]
fn normalize_adds_missing_output_for_custom_tool_call() {
codex-rs/core/src/exec_policy_tests.rs
-19
View File
@@ -1763,25 +1763,6 @@ async fn proposed_execpolicy_amendment_is_present_for_single_command_without_pol
.await;
}
#[tokio::test]
async fn proposed_execpolicy_amendment_is_omitted_when_policy_prompts() {
assert_exec_approval_requirement_for_command(
ExecApprovalRequirementScenario {
policy_src: Some(r#"prefix_rule(pattern=["rm"], decision="prompt")"#.to_string()),
command: vec!["rm".to_string()],
approval_policy: AskForApproval::OnRequest,
permission_profile: PermissionProfile::Disabled,
sandbox_permissions: SandboxPermissions::UseDefault,
prefix_rule: None,
},
ExecApprovalRequirement::NeedsApproval {
reason: Some("`rm` requires approval by policy".to_string()),
proposed_execpolicy_amendment: None,
},
)
.await;
}
#[tokio::test]
async fn proposed_execpolicy_amendment_is_present_for_multi_command_scripts() {
assert_exec_approval_requirement_for_command(
codex-rs/core/tests/suite/client.rs
-36
View File
@@ -2297,42 +2297,6 @@ async fn includes_configured_max_effort_in_request() -> anyhow::Result<()> {
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn includes_no_effort_in_request() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = MockServer::start().await;
let resp_mock = mount_sse_once(
&server,
sse(vec![ev_response_created("resp1"), ev_completed("resp1")]),
)
.await;
let TestCodex { codex, .. } = test_codex().with_model("gpt-5.4").build(&server).await?;
codex
.start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
text: "hello".into(),
text_elements: Vec::new(),
}]))
.await
.unwrap();
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
let request = resp_mock.single_request();
let request_body = request.body_json();
assert_eq!(
request_body
.get("reasoning")
.and_then(|t| t.get("effort"))
.and_then(|v| v.as_str()),
Some("medium")
);
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn includes_default_reasoning_effort_in_request_when_defined_by_model_info()
-> anyhow::Result<()> {
codex-rs/core/tests/suite/collaboration_instructions.rs
-40
View File
@@ -615,46 +615,6 @@ async fn collaboration_instructions_omitted_when_disabled() -> Result<()> {
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn override_then_next_turn_uses_updated_collaboration_instructions() -> Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
let req = mount_sse_once(
&server,
sse(vec![ev_response_created("resp-1"), ev_completed("resp-1")]),
)
.await;
let test = test_codex().build(&server).await?;
let collab_text = "override instructions";
let collaboration_mode = collab_mode_with_instructions(Some(collab_text));
core_test_support::submit_thread_settings(
&test.codex,
ThreadSettingsOverrides {
collaboration_mode: Some(collaboration_mode),
..Default::default()
},
)
.await?;
test.codex
.start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
text: "hello".into(),
text_elements: Vec::new(),
}]))
.await?;
wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
let input = req.single_request().input();
let dev_texts = developer_texts(&input);
let collab_text = collab_xml(collab_text);
assert_eq!(count_messages_containing(&dev_texts, &collab_text), 1);
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn user_turn_overrides_collaboration_instructions_after_override() -> Result<()> {
skip_if_no_network!(Ok(()));
codex-rs/core/tests/suite/otel.rs
-193
View File
@@ -1408,70 +1408,6 @@ async fn handle_exec_command_user_approved_for_session_records_tool_decision() {
));
}
#[tokio::test]
#[traced_test]
async fn handle_sandbox_error_user_approves_retry_records_tool_decision() {
let server = start_mock_server().await;
let command = touch_command("codex-otel-approval-test");
mount_sse_once(
&server,
sse(vec![
exec_command_call("sandbox_retry_call", &command),
ev_completed("done"),
]),
)
.await;
mount_sse_once(
&server,
sse(vec![
ev_assistant_message("msg-1", "shell command done"),
ev_completed("done"),
]),
)
.await;
let TestCodex { codex, .. } = test_codex()
.with_config(|config| {
config.permissions.approval_policy =
Constrained::allow_any(AskForApproval::UnlessTrusted);
})
.build(&server)
.await
.unwrap();
codex
.start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
text: "retry".into(),
text_elements: Vec::new(),
}]))
.await
.unwrap();
let approval_event =
wait_for_event(&codex, |ev| matches!(ev, EventMsg::ExecApprovalRequest(_))).await;
let EventMsg::ExecApprovalRequest(approval) = approval_event else {
panic!("expected ExecApprovalRequest event");
};
codex
.submit(Op::ExecApproval {
id: approval.effective_approval_id(),
turn_id: None,
decision: ReviewDecision::Approved,
})
.await
.unwrap();
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TokenCount(_))).await;
logs_assert(tool_decision_assertion(
"sandbox_retry_call",
"approved",
"user",
));
}
#[tokio::test]
#[traced_test]
async fn handle_exec_command_user_denies_records_tool_decision() {
@@ -1535,132 +1471,3 @@ async fn handle_exec_command_user_denies_records_tool_decision() {
"user",
));
}
#[tokio::test]
#[traced_test]
async fn handle_sandbox_error_user_approves_for_session_records_tool_decision() {
let server = start_mock_server().await;
let command = touch_command("codex-otel-approval-test");
mount_sse_once(
&server,
sse(vec![
exec_command_call("sandbox_session_call", &command),
ev_completed("done"),
]),
)
.await;
mount_sse_once(
&server,
sse(vec![
ev_assistant_message("msg-1", "shell command done"),
ev_completed("done"),
]),
)
.await;
let TestCodex { codex, .. } = test_codex()
.with_config(|config| {
config.permissions.approval_policy =
Constrained::allow_any(AskForApproval::UnlessTrusted);
})
.build(&server)
.await
.unwrap();
codex
.start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
text: "persist".into(),
text_elements: Vec::new(),
}]))
.await
.unwrap();
let approval_event =
wait_for_event(&codex, |ev| matches!(ev, EventMsg::ExecApprovalRequest(_))).await;
let EventMsg::ExecApprovalRequest(approval) = approval_event else {
panic!("expected ExecApprovalRequest event");
};
codex
.submit(Op::ExecApproval {
id: approval.effective_approval_id(),
turn_id: None,
decision: ReviewDecision::ApprovedForSession,
})
.await
.unwrap();
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TokenCount(_))).await;
logs_assert(tool_decision_assertion(
"sandbox_session_call",
"approved_for_session",
"user",
));
}
#[tokio::test]
#[traced_test]
async fn handle_sandbox_error_user_denies_records_tool_decision() {
let server = start_mock_server().await;
let command = touch_command("codex-otel-approval-test");
mount_sse_once(
&server,
sse(vec![
exec_command_call("sandbox_deny_call", &command),
ev_completed("done"),
]),
)
.await;
mount_sse_once(
&server,
sse(vec![
ev_assistant_message("msg-1", "shell command done"),
ev_completed("done"),
]),
)
.await;
let TestCodex { codex, .. } = test_codex()
.with_config(|config| {
config.permissions.approval_policy =
Constrained::allow_any(AskForApproval::UnlessTrusted);
})
.build(&server)
.await
.unwrap();
codex
.start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
text: "deny".into(),
text_elements: Vec::new(),
}]))
.await
.unwrap();
let approval_event =
wait_for_event(&codex, |ev| matches!(ev, EventMsg::ExecApprovalRequest(_))).await;
let EventMsg::ExecApprovalRequest(approval) = approval_event else {
panic!("expected ExecApprovalRequest event");
};
codex
.submit(Op::ExecApproval {
id: approval.effective_approval_id(),
turn_id: None,
decision: ReviewDecision::denied("rejected by user"),
})
.await
.unwrap();
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TokenCount(_))).await;
logs_assert(tool_decision_assertion(
"sandbox_deny_call",
"denied",
"user",
));
}