| use super::*; |
| use crate::exec_output::StreamOutput; |
| use crate::protocol::RateLimitWindow; |
| use chrono::DateTime; |
| use chrono::Duration as ChronoDuration; |
| use chrono::TimeZone; |
| use chrono::Utc; |
| use codex_http_client::HttpResponse; |
| use http::Response as RawHttpResponse; |
| use http::StatusCode; |
| use pretty_assertions::assert_eq; |
| use std::time::Duration; |
|
|
| #[test] |
| fn codex_err_debug_preserves_legacy_shape() { |
| let actual = [ |
| CodexErr::Timeout, |
| CodexErr::Stream("disconnected".to_string()), |
| CodexErr::Stream("retry later".to_string()).with_retry_delay(Duration::from_secs(2)), |
| CodexErr::InternalServerError.with_retry_delay(Duration::from_secs(3)), |
| ] |
| .map(|err| format!("{err:?}")); |
|
|
| assert_eq!( |
| actual, |
| [ |
| "Timeout".to_string(), |
| "Stream(\"disconnected\", None)".to_string(), |
| "Stream(\"retry later\", Some(2s))".to_string(), |
| "InternalServerError".to_string(), |
| ] |
| ); |
| } |
|
|
| #[test] |
| fn retryability_preserves_error_details_distinctions() { |
| let errors = [ |
| (CodexErr::ServerOverloaded, false), |
| ( |
| CodexErr::new(CodexErrorDetails::RateLimitExceeded("retry later".into())), |
| true, |
| ), |
| ( |
| CodexErr::RetryLimit(RetryLimitReachedError { |
| status: StatusCode::TOO_MANY_REQUESTS, |
| request_id: None, |
| }), |
| false, |
| ), |
| ( |
| CodexErr::UnexpectedStatus(UnexpectedResponseError { |
| status: StatusCode::TOO_MANY_REQUESTS, |
| body: String::new(), |
| user_message: None, |
| url: None, |
| cf_ray: None, |
| request_id: None, |
| identity_authorization_error: None, |
| identity_error_code: None, |
| }), |
| true, |
| ), |
| ( |
| CodexErrorDetails::ToolCollision("functions.update_plan".to_string()).into(), |
| false, |
| ), |
| (CodexErr::InternalServerError, true), |
| ]; |
|
|
| for (err, expected) in errors { |
| assert_eq!( |
| err.is_retryable(), |
| expected, |
| "unexpected retryability for {err:?}" |
| ); |
| } |
| } |
|
|
| fn rate_limit_snapshot() -> RateLimitSnapshot { |
| let primary_reset_at = Utc |
| .with_ymd_and_hms(2024, 1, 1, 1, 0, 0) |
| .unwrap() |
| .timestamp(); |
| let secondary_reset_at = Utc |
| .with_ymd_and_hms(2024, 1, 1, 2, 0, 0) |
| .unwrap() |
| .timestamp(); |
| RateLimitSnapshot { |
| limit_id: None, |
| limit_name: None, |
| normal_model_slug: None, |
| primary: Some(RateLimitWindow { |
| used_percent: 50.0, |
| window_minutes: Some(60), |
| resets_at: Some(primary_reset_at), |
| }), |
| secondary: Some(RateLimitWindow { |
| used_percent: 30.0, |
| window_minutes: Some(120), |
| resets_at: Some(secondary_reset_at), |
| }), |
| credits: None, |
| individual_limit: None, |
| spend_control_reached: None, |
| plan_type: None, |
| rate_limit_reached_type: None, |
| } |
| } |
|
|
| fn with_now_override<T>(now: DateTime<Utc>, f: impl FnOnce() -> T) -> T { |
| NOW_OVERRIDE.with(|cell| { |
| *cell.borrow_mut() = Some(now); |
| let result = f(); |
| *cell.borrow_mut() = None; |
| result |
| }) |
| } |
|
|
| #[test] |
| fn usage_limit_reached_error_formats_plus_plan() { |
| let err = UsageLimitReachedError { |
| plan_type: Some(PlanType::Known(KnownPlan::Plus)), |
| resets_at: None, |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: None, |
| }; |
| assert_eq!( |
| err.to_string(), |
| "You’ve hit your usage limit. Upgrade to Pro (https://chatgpt.com/explore/pro), visit https://chatgpt.com/codex/settings/usage to purchase more credits or try again later." |
| ); |
| } |
|
|
| #[test] |
| fn usage_limit_reached_error_formats_rate_limit_reached_types() { |
| let cases = [ |
| ( |
| RateLimitReachedType::RateLimitReached, |
| "You’ve hit your usage limit. Upgrade to Pro (https://chatgpt.com/explore/pro), visit https://chatgpt.com/codex/settings/usage to purchase more credits or try again later.", |
| ), |
| ( |
| RateLimitReachedType::WorkspaceOwnerCreditsDepleted, |
| "Your workspace is out of credits. Add credits to continue.", |
| ), |
| ( |
| RateLimitReachedType::WorkspaceMemberCreditsDepleted, |
| "Your workspace is out of credits. Ask your workspace owner to refill in order to continue.", |
| ), |
| ( |
| RateLimitReachedType::WorkspaceOwnerUsageLimitReached, |
| "You hit your spend cap set in your workspace. Increase your spend cap to continue.", |
| ), |
| ( |
| RateLimitReachedType::WorkspaceMemberUsageLimitReached, |
| "You hit your spend cap set by the owner of your workspace. Ask an owner to increase your spend cap to continue.", |
| ), |
| ]; |
|
|
| for (rate_limit_reached_type, expected) in cases { |
| let err = UsageLimitReachedError { |
| plan_type: Some(PlanType::Known(KnownPlan::Plus)), |
| resets_at: None, |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: Some(rate_limit_reached_type), |
| }; |
|
|
| assert_eq!(err.to_string(), expected); |
| } |
| } |
|
|
| #[test] |
| fn server_overloaded_maps_to_protocol() { |
| let err = CodexErr::ServerOverloaded; |
| assert_eq!( |
| err.to_codex_protocol_error(), |
| CodexErrorInfo::ServerOverloaded |
| ); |
| } |
|
|
| #[test] |
| fn sandbox_denied_uses_aggregated_output_when_stderr_empty() { |
| let output = ExecToolCallOutput { |
| exit_code: 77, |
| stdout: StreamOutput::new(String::new()), |
| stderr: StreamOutput::new(String::new()), |
| aggregated_output: StreamOutput::new("aggregate detail".to_string()), |
| duration: Duration::from_millis(10), |
| timed_out: false, |
| }; |
| let err = CodexErr::Sandbox(SandboxErr::Denied { |
| output: Box::new(output), |
| network_policy_decision: None, |
| }); |
| assert_eq!(get_error_message_ui(&err), "aggregate detail"); |
| } |
|
|
| #[test] |
| fn sandbox_denied_reports_both_streams_when_available() { |
| let output = ExecToolCallOutput { |
| exit_code: 9, |
| stdout: StreamOutput::new("stdout detail".to_string()), |
| stderr: StreamOutput::new("stderr detail".to_string()), |
| aggregated_output: StreamOutput::new(String::new()), |
| duration: Duration::from_millis(10), |
| timed_out: false, |
| }; |
| let err = CodexErr::Sandbox(SandboxErr::Denied { |
| output: Box::new(output), |
| network_policy_decision: None, |
| }); |
| assert_eq!(get_error_message_ui(&err), "stderr detail\nstdout detail"); |
| } |
|
|
| #[test] |
| fn sandbox_denied_reports_stdout_when_no_stderr() { |
| let output = ExecToolCallOutput { |
| exit_code: 11, |
| stdout: StreamOutput::new("stdout only".to_string()), |
| stderr: StreamOutput::new(String::new()), |
| aggregated_output: StreamOutput::new(String::new()), |
| duration: Duration::from_millis(8), |
| timed_out: false, |
| }; |
| let err = CodexErr::Sandbox(SandboxErr::Denied { |
| output: Box::new(output), |
| network_policy_decision: None, |
| }); |
| assert_eq!(get_error_message_ui(&err), "stdout only"); |
| } |
|
|
| #[test] |
| fn to_error_event_handles_response_stream_failed() { |
| let response = RawHttpResponse::builder() |
| .status(StatusCode::TOO_MANY_REQUESTS) |
| .body("") |
| .unwrap(); |
| let source = HttpResponse::from(response) |
| .error_for_status_ref() |
| .unwrap_err() |
| .with_url("http://example.com".parse().unwrap()); |
| let err = CodexErr::ResponseStreamFailed(ResponseStreamFailed { |
| source, |
| request_id: Some("req-123".to_string()), |
| }); |
|
|
| let event = err.to_error_event(Some("prefix".to_string())); |
|
|
| assert_eq!( |
| event.message, |
| "prefix: Error while reading the server response: HTTP status client error (429 Too Many Requests) for url (http://example.com/), request id: req-123" |
| ); |
| assert_eq!( |
| event.codex_error_info, |
| Some(CodexErrorInfo::ResponseStreamConnectionFailed { |
| http_status_code: Some(429) |
| }) |
| ); |
| } |
|
|
| #[test] |
| fn sandbox_denied_reports_exit_code_when_no_output_available() { |
| let output = ExecToolCallOutput { |
| exit_code: 13, |
| stdout: StreamOutput::new(String::new()), |
| stderr: StreamOutput::new(String::new()), |
| aggregated_output: StreamOutput::new(String::new()), |
| duration: Duration::from_millis(5), |
| timed_out: false, |
| }; |
| let err = CodexErr::Sandbox(SandboxErr::Denied { |
| output: Box::new(output), |
| network_policy_decision: None, |
| }); |
| assert_eq!( |
| get_error_message_ui(&err), |
| "command failed inside sandbox with exit code 13" |
| ); |
| } |
|
|
| #[test] |
| fn usage_limit_reached_error_formats_free_plan() { |
| let err = UsageLimitReachedError { |
| plan_type: Some(PlanType::Known(KnownPlan::Free)), |
| resets_at: None, |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: None, |
| }; |
| assert_eq!( |
| err.to_string(), |
| "You’ve hit your usage limit. Upgrade to Plus to continue using Codex (https://chatgpt.com/explore/plus), or try again later." |
| ); |
| } |
|
|
| #[test] |
| fn usage_limit_reached_error_formats_go_plan() { |
| let err = UsageLimitReachedError { |
| plan_type: Some(PlanType::Known(KnownPlan::Go)), |
| resets_at: None, |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: None, |
| }; |
| assert_eq!( |
| err.to_string(), |
| "You’ve hit your usage limit. Upgrade to Plus to continue using Codex (https://chatgpt.com/explore/plus), or try again later." |
| ); |
| } |
|
|
| #[test] |
| fn usage_limit_reached_error_formats_default_when_none() { |
| let err = UsageLimitReachedError { |
| plan_type: None, |
| resets_at: None, |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: None, |
| }; |
| assert_eq!( |
| err.to_string(), |
| "You’ve hit your usage limit. Try again later." |
| ); |
| } |
|
|
| #[test] |
| fn usage_limit_reached_error_formats_team_plan() { |
| let base = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap(); |
| let resets_at = base + ChronoDuration::hours(1); |
| with_now_override(base, move || { |
| let expected_time = format_retry_timestamp(&resets_at); |
| let err = UsageLimitReachedError { |
| plan_type: Some(PlanType::Known(KnownPlan::Team)), |
| resets_at: Some(resets_at), |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: None, |
| }; |
| let expected = format!( |
| "You’ve hit your usage limit. To get more access now, send a request to your admin or try again at {expected_time}." |
| ); |
| assert_eq!(err.to_string(), expected); |
| }); |
| } |
|
|
| #[test] |
| fn usage_limit_reached_error_formats_business_plan_without_reset() { |
| for plan in [ |
| KnownPlan::Business, |
| KnownPlan::Ent26, |
| KnownPlan::EnterpriseCbpAutomation, |
| ] { |
| let err = UsageLimitReachedError { |
| plan_type: Some(PlanType::Known(plan)), |
| resets_at: None, |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: None, |
| }; |
| assert_eq!( |
| err.to_string(), |
| "You’ve hit your usage limit. To get more access now, send a request to your admin or try again later." |
| ); |
| } |
| } |
|
|
| #[test] |
| fn usage_limit_reached_error_formats_self_serve_business_prolite_plan() { |
| let err = UsageLimitReachedError { |
| plan_type: Some(PlanType::Known(KnownPlan::SelfServeBusinessProLite)), |
| resets_at: None, |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: None, |
| }; |
| assert_eq!( |
| err.to_string(), |
| "You’ve hit your usage limit. To get more access now, send a request to your admin or try again later." |
| ); |
| } |
|
|
| #[test] |
| fn usage_limit_reached_error_formats_self_serve_business_usage_based_plan() { |
| let err = UsageLimitReachedError { |
| plan_type: Some(PlanType::Known(KnownPlan::SelfServeBusinessUsageBased)), |
| resets_at: None, |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: None, |
| }; |
| assert_eq!( |
| err.to_string(), |
| "You’ve hit your usage limit. To get more access now, send a request to your admin or try again later." |
| ); |
| } |
|
|
| #[test] |
| fn usage_limit_reached_error_formats_enterprise_cbp_usage_based_plan() { |
| let err = UsageLimitReachedError { |
| plan_type: Some(PlanType::Known(KnownPlan::EnterpriseCbpUsageBased)), |
| resets_at: None, |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: None, |
| }; |
| assert_eq!( |
| err.to_string(), |
| "You’ve hit your usage limit. To get more access now, send a request to your admin or try again later." |
| ); |
| } |
|
|
| #[test] |
| fn usage_limit_reached_error_formats_default_for_other_plans() { |
| for plan in [ |
| KnownPlan::Enterprise, |
| KnownPlan::Edu, |
| KnownPlan::EduPlus, |
| KnownPlan::EduPro, |
| ] { |
| let err = UsageLimitReachedError { |
| plan_type: Some(PlanType::Known(plan)), |
| resets_at: None, |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: None, |
| }; |
| assert_eq!( |
| err.to_string(), |
| "You’ve hit your usage limit. Try again later." |
| ); |
| } |
| } |
|
|
| #[test] |
| fn usage_limit_reached_error_formats_pro_plan_with_reset() { |
| let base = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap(); |
| let resets_at = base + ChronoDuration::hours(1); |
| with_now_override(base, move || { |
| let expected_time = format_retry_timestamp(&resets_at); |
| let err = UsageLimitReachedError { |
| plan_type: Some(PlanType::Known(KnownPlan::Pro)), |
| resets_at: Some(resets_at), |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: None, |
| }; |
| let expected = format!( |
| "You’ve hit your usage limit. Visit https://chatgpt.com/codex/settings/usage to purchase more credits or try again at {expected_time}." |
| ); |
| assert_eq!(err.to_string(), expected); |
| }); |
| } |
|
|
| #[test] |
| fn usage_limit_reached_error_hides_upsell_for_non_codex_limit_name() { |
| let base = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap(); |
| let resets_at = base + ChronoDuration::hours(1); |
| with_now_override(base, move || { |
| let expected_time = format_retry_timestamp(&resets_at); |
| let err = UsageLimitReachedError { |
| plan_type: Some(PlanType::Known(KnownPlan::Plus)), |
| resets_at: Some(resets_at), |
| rate_limits: Some(Box::new(RateLimitSnapshot { |
| limit_id: Some("codex_other".to_string()), |
| limit_name: Some("codex_other".to_string()), |
| ..rate_limit_snapshot() |
| })), |
| promo_message: Some( |
| "Visit https://chatgpt.com/codex/settings/usage to purchase more credits" |
| .to_string(), |
| ), |
| rate_limit_reached_type: None, |
| }; |
| let expected = format!( |
| "You’ve hit your usage limit for codex_other. Switch to another model now, or try again at {expected_time}." |
| ); |
| assert_eq!(err.to_string(), expected); |
| }); |
| } |
|
|
| #[test] |
| fn usage_limit_reached_includes_minutes_when_available() { |
| let base = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap(); |
| let resets_at = base + ChronoDuration::minutes(5); |
| with_now_override(base, move || { |
| let expected_time = format_retry_timestamp(&resets_at); |
| let err = UsageLimitReachedError { |
| plan_type: None, |
| resets_at: Some(resets_at), |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: None, |
| }; |
| let expected = format!("You’ve hit your usage limit. Try again at {expected_time}."); |
| assert_eq!(err.to_string(), expected); |
| }); |
| } |
|
|
| #[test] |
| fn unexpected_status_non_html_is_unchanged() { |
| let err = UnexpectedResponseError { |
| status: StatusCode::FORBIDDEN, |
| body: "plain text error".to_string(), |
| user_message: None, |
| url: Some("http://example.com/plain".to_string()), |
| cf_ray: None, |
| request_id: None, |
| identity_authorization_error: None, |
| identity_error_code: None, |
| }; |
| let status = StatusCode::FORBIDDEN.to_string(); |
| let url = "http://example.com/plain"; |
| assert_eq!( |
| err.to_string(), |
| format!("unexpected status {status}: plain text error, url: {url}") |
| ); |
| } |
|
|
| #[test] |
| fn unexpected_status_uses_user_message_and_preserves_response_context() { |
| let err = UnexpectedResponseError { |
| status: StatusCode::UNAUTHORIZED, |
| body: "provider-specific response".to_string(), |
| user_message: Some("Provider-specific guidance".to_string()), |
| url: Some("https://example.com/v1/responses".to_string()), |
| cf_ray: None, |
| request_id: Some("req-provider".to_string()), |
| identity_authorization_error: None, |
| identity_error_code: None, |
| }; |
|
|
| assert_eq!( |
| err.to_string(), |
| "Provider-specific guidance, url: https://example.com/v1/responses, request id: req-provider" |
| ); |
| } |
|
|
| #[test] |
| fn unexpected_status_prefers_error_message_when_present() { |
| let err = UnexpectedResponseError { |
| status: StatusCode::UNAUTHORIZED, |
| body: r#"{"error":{"message":"Workspace is not authorized in this region."},"status":401}"# |
| .to_string(), |
| user_message: None, |
| url: Some("https://chatgpt.com/backend-api/codex/responses".to_string()), |
| cf_ray: None, |
| request_id: Some("req-123".to_string()), |
| identity_authorization_error: None, |
| identity_error_code: None, |
| }; |
| let status = StatusCode::UNAUTHORIZED.to_string(); |
| assert_eq!( |
| err.to_string(), |
| format!( |
| "unexpected status {status}: Workspace is not authorized in this region., url: https://chatgpt.com/backend-api/codex/responses, request id: req-123" |
| ) |
| ); |
| } |
|
|
| #[test] |
| fn unexpected_status_truncates_long_body_with_ellipsis() { |
| let long_body = "x".repeat(UNEXPECTED_RESPONSE_BODY_MAX_BYTES + 10); |
| let err = UnexpectedResponseError { |
| status: StatusCode::BAD_GATEWAY, |
| body: long_body, |
| user_message: None, |
| url: Some("http://example.com/long".to_string()), |
| cf_ray: None, |
| request_id: Some("req-long".to_string()), |
| identity_authorization_error: None, |
| identity_error_code: None, |
| }; |
| let status = StatusCode::BAD_GATEWAY.to_string(); |
| let expected_body = format!("{}...", "x".repeat(UNEXPECTED_RESPONSE_BODY_MAX_BYTES)); |
| assert_eq!( |
| err.to_string(), |
| format!( |
| "unexpected status {status}: {expected_body}, url: http://example.com/long, request id: req-long" |
| ) |
| ); |
| } |
|
|
| #[test] |
| fn unexpected_status_includes_cf_ray_and_request_id() { |
| let err = UnexpectedResponseError { |
| status: StatusCode::UNAUTHORIZED, |
| body: "plain text error".to_string(), |
| user_message: None, |
| url: Some("https://chatgpt.com/backend-api/codex/responses".to_string()), |
| cf_ray: Some("9c81f9f18f2fa49d-LHR".to_string()), |
| request_id: Some("req-xyz".to_string()), |
| identity_authorization_error: None, |
| identity_error_code: None, |
| }; |
| let status = StatusCode::UNAUTHORIZED.to_string(); |
| assert_eq!( |
| err.to_string(), |
| format!( |
| "unexpected status {status}: plain text error, url: https://chatgpt.com/backend-api/codex/responses, cf-ray: 9c81f9f18f2fa49d-LHR, request id: req-xyz" |
| ) |
| ); |
| } |
|
|
| #[test] |
| fn unexpected_status_includes_identity_auth_details() { |
| let err = UnexpectedResponseError { |
| status: StatusCode::UNAUTHORIZED, |
| body: "plain text error".to_string(), |
| user_message: None, |
| url: Some("https://chatgpt.com/backend-api/codex/models".to_string()), |
| cf_ray: Some("cf-ray-auth-401-test".to_string()), |
| request_id: Some("req-auth".to_string()), |
| identity_authorization_error: Some("missing_authorization_header".to_string()), |
| identity_error_code: Some("token_expired".to_string()), |
| }; |
| let status = StatusCode::UNAUTHORIZED.to_string(); |
| assert_eq!( |
| err.to_string(), |
| format!( |
| "unexpected status {status}: plain text error, url: https://chatgpt.com/backend-api/codex/models, cf-ray: cf-ray-auth-401-test, request id: req-auth, auth error: missing_authorization_header, auth error code: token_expired" |
| ) |
| ); |
| } |
|
|
| #[test] |
| fn usage_limit_reached_includes_hours_and_minutes() { |
| let base = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap(); |
| let resets_at = base + ChronoDuration::hours(3) + ChronoDuration::minutes(32); |
| with_now_override(base, move || { |
| let expected_time = format_retry_timestamp(&resets_at); |
| let err = UsageLimitReachedError { |
| plan_type: Some(PlanType::Known(KnownPlan::Plus)), |
| resets_at: Some(resets_at), |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: None, |
| }; |
| let expected = format!( |
| "You’ve hit your usage limit. Upgrade to Pro (https://chatgpt.com/explore/pro), visit https://chatgpt.com/codex/settings/usage to purchase more credits or try again at {expected_time}." |
| ); |
| assert_eq!(err.to_string(), expected); |
| }); |
| } |
|
|
| #[test] |
| fn usage_limit_reached_includes_days_hours_minutes() { |
| let base = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap(); |
| let resets_at = |
| base + ChronoDuration::days(2) + ChronoDuration::hours(3) + ChronoDuration::minutes(5); |
| with_now_override(base, move || { |
| let expected_time = format_retry_timestamp(&resets_at); |
| let err = UsageLimitReachedError { |
| plan_type: None, |
| resets_at: Some(resets_at), |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: None, |
| }; |
| let expected = format!("You’ve hit your usage limit. Try again at {expected_time}."); |
| assert_eq!(err.to_string(), expected); |
| }); |
| } |
|
|
| #[test] |
| fn usage_limit_reached_less_than_minute() { |
| let base = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap(); |
| let resets_at = base + ChronoDuration::seconds(30); |
| with_now_override(base, move || { |
| let expected_time = format_retry_timestamp(&resets_at); |
| let err = UsageLimitReachedError { |
| plan_type: None, |
| resets_at: Some(resets_at), |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: None, |
| rate_limit_reached_type: None, |
| }; |
| let expected = format!("You’ve hit your usage limit. Try again at {expected_time}."); |
| assert_eq!(err.to_string(), expected); |
| }); |
| } |
|
|
| #[test] |
| fn usage_limit_reached_with_promo_message() { |
| let base = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap(); |
| let resets_at = base + ChronoDuration::seconds(30); |
| with_now_override(base, move || { |
| let expected_time = format_retry_timestamp(&resets_at); |
| let err = UsageLimitReachedError { |
| plan_type: None, |
| resets_at: Some(resets_at), |
| rate_limits: Some(Box::new(rate_limit_snapshot())), |
| promo_message: Some( |
| "To continue using Codex, start a free trial of <PLAN> today".to_string(), |
| ), |
| rate_limit_reached_type: None, |
| }; |
| let expected = format!( |
| "You’ve hit your usage limit. To continue using Codex, start a free trial of <PLAN> today, or try again at {expected_time}." |
| ); |
| assert_eq!(err.to_string(), expected); |
| }); |
| } |
|
|
