use super::*;
use crate::completion::CompletionRequest;
use crate::effect::EffectId;
use crate::http_client;
use crate::providers::auth::{DeviceCodeHandler, MemoryTokenStore, TokenStore};
use crate::providers::chatgpt::auth::{AuthSource, Authenticator};
use crate::test_utils::{MockHttpResponse, SequencedHttpClient};
use http::StatusCode;
use std::time::{Duration, SystemTime};
async fn refreshed_with(reply: MockHttpResponse) -> anyhow::Result<ErrorReport> {
let store = Arc::new(MemoryTokenStore::default());
store
.save(
chatgpt::PROVIDER_NAME,
r#"{"refresh_token":"synthetic-refresh","expires_at":0}"#,
)
.await
.map_err(anyhow::Error::from_boxed)?;
let auth = Authenticator::new(
AuthSource::OAuth,
store,
DeviceCodeHandler::default(),
false,
);
let http = DynHttpClient::new(SequencedHttpClient::new([reply]));
let spec = Catalog::builtin()
.resolve("chatgpt/gpt-6.1-sol")?
.spec
.clone();
let model = SignedInModel::new(spec, auth, http)?;
let kind = EffectKind::Completion {
request: Arc::new(CompletionRequest::new("hi")),
stream: false,
};
let outcome = model
.serve(kind, Dispatch::new(EffectId::from_raw(0), false))
.await
.into_outcome()
.await;
outcome
.err()
.ok_or_else(|| anyhow::anyhow!("the call had no credential"))
}
#[tokio::test]
async fn a_failed_refresh_keeps_the_class_of_its_reply() -> anyhow::Result<()> {
let mut wait = http::HeaderMap::new();
wait.insert(http::header::RETRY_AFTER, "7".parse()?);
let refused = r#"{"error":"invalid_request","error_description":"no"}"#;
for (reply, retryable, asked) in [
(
MockHttpResponse::error_with_headers(StatusCode::TOO_MANY_REQUESTS, "slow down", wait),
true,
Some(Duration::from_secs(7)),
),
(
MockHttpResponse::error(StatusCode::SERVICE_UNAVAILABLE, "down"),
true,
None,
),
(
MockHttpResponse::error(StatusCode::BAD_REQUEST, refused),
false,
None,
),
] {
let report = refreshed_with(reply).await?;
let message = &report.message;
anyhow::ensure!(report.retryable == retryable, "{report:?}");
anyhow::ensure!(report.kind == ErrorKind::ProviderResponse, "{report:?}");
anyhow::ensure!(report.http_status.is_some(), "{report:?}");
anyhow::ensure!(report.retry_after(SystemTime::now()) == asked, "{report:?}");
anyhow::ensure!(
message.contains("ChatGPT token refresh failed"),
"{message}"
);
anyhow::ensure!(message.ends_with("sign in again") != retryable, "{message}");
}
Ok(())
}
#[test]
fn a_failed_sign_in_without_a_reply_keeps_its_class() -> anyhow::Result<()> {
let reset = || std::io::Error::from(std::io::ErrorKind::ConnectionReset);
for (error, retryable) in [
(
AuthError::Http(http_client::Error::transient(reset())),
true,
),
(
AuthError::Http(http_client::Error::permanent(reset())),
false,
),
(
AuthError::Message("ChatGPT sign-in required.".into()),
false,
),
] {
let report = failed_sign_in(error);
anyhow::ensure!(report.retryable == retryable, "{report:?}");
anyhow::ensure!(
report.message.ends_with("sign in again") != retryable,
"{}",
report.message
);
}
Ok(())
}