..

Author: jtfmumm

crates/uv-client/src/error.rs

@@ -236,6 +236,9 @@ pub enum ErrorKind {
     #[error("Invalid `Content-Type` header for {0}")]
     InvalidContentTypeHeader(Url, #[source] http::header::ToStrError),
 
+    #[error("Invalid status code: {0}")]
+    InvalidStatusCode(String),
+
     #[error("Unsupported `Content-Type` \"{1}\" for {0}. Expected JSON or HTML.")]
     UnsupportedMediaType(Url, String),
 

crates/uv-client/src/registry_client.rs

@@ -331,8 +331,10 @@ impl RegistryClient {
                     let _permit = download_concurrency.acquire().await;
                     match index.format {
                         IndexFormat::Simple => {
-                            let status_code_strategy =
-                                self.index_urls.status_code_strategy_for(index.url);
+                            let status_code_strategy = self
+                                .index_urls
+                                .status_code_strategy_for(index.url)
+                                .map_err(|e| ErrorKind::InvalidStatusCode(e.to_string()))?;
                             if let Some(metadata) = self
                                 .simple_single_index(
                                     package_name,
@@ -364,8 +366,10 @@ impl RegistryClient {
                         let _permit = download_concurrency.acquire().await;
                         match index.format {
                             IndexFormat::Simple => {
-                                let status_code_strategy =
-                                    self.index_urls.status_code_strategy_for(index.url);
+                                let status_code_strategy = self
+                                    .index_urls
+                                    .status_code_strategy_for(index.url)
+                                    .map_err(|e| ErrorKind::InvalidStatusCode(e.to_string()))?;
                                 let metadata = self
                                     .simple_single_index(
                                         package_name,
@@ -506,11 +510,11 @@ impl RegistryClient {
             Err(err) => match err.into_kind() {
                 // The package could not be found in the remote index.
                 ErrorKind::WrappedReqwestError(url, err) => {
-                    let decision = if let Some(status) = err.status() {
-                        status_code_strategy.handle_status_code(status, index, capabilities)
-                    } else {
-                        IndexStatusCodeDecision::Stop
-                    };
+                    let decision = err
+                        .status()
+                        .map_or(IndexStatusCodeDecision::Stop, |status| {
+                            status_code_strategy.handle_status_code(status, index, capabilities)
+                        });
                     match decision {
                         IndexStatusCodeDecision::Continue => Ok(None),
                         IndexStatusCodeDecision::Stop => {

crates/uv-distribution-types/src/index.rs

@@ -1,6 +1,7 @@
 use std::path::Path;
 use std::str::FromStr;
 
+use http::status::InvalidStatusCode;
 use http::StatusCode;
 use serde::{Deserialize, Deserializer, Serialize};
 use thiserror::Error;
@@ -230,12 +231,12 @@ impl Index {
     }
 
     /// Return the [`IndexStatusCodeStrategy`] for this index.
-    pub fn status_code_strategy(&self) -> IndexStatusCodeStrategy {
-        if !self.ignore_error_codes.is_empty() {
-            IndexStatusCodeStrategy::from_ignored_error_codes(&self.ignore_error_codes)
+    pub fn status_code_strategy(&self) -> Result<IndexStatusCodeStrategy, IndexSourceError> {
+        Ok(if !self.ignore_error_codes.is_empty() {
+            IndexStatusCodeStrategy::from_ignored_error_codes(&self.ignore_error_codes)?
         } else {
             IndexStatusCodeStrategy::from_index_url(self.url.url())
-        }
+        })
     }
 }
 
@@ -403,4 +404,6 @@ pub enum IndexSourceError {
     IndexName(#[from] IndexNameError),
     #[error("Index included a name, but the name was empty")]
     EmptyName,
+    #[error(transparent)]
+    StatusCode(#[from] InvalidStatusCode),
 }

crates/uv-distribution-types/src/index_url.rs

@@ -13,7 +13,7 @@ use url::{ParseError, Url};
 
 use uv_pep508::{split_scheme, Scheme, VerbatimUrl, VerbatimUrlError};
 
-use crate::{Index, IndexStatusCodeStrategy, Verbatim};
+use crate::{Index, IndexSourceError, IndexStatusCodeStrategy, Verbatim};
 
 static PYPI_URL: LazyLock<Url> = LazyLock::new(|| Url::parse("https://pypi.org/simple").unwrap());
 
@@ -539,13 +539,16 @@ impl<'a> IndexUrls {
     }
 
     /// Return the [`IndexStatusCodeStrategy`] for an [`IndexUrl`].
-    pub fn status_code_strategy_for(&self, url: &IndexUrl) -> IndexStatusCodeStrategy {
+    pub fn status_code_strategy_for(
+        &self,
+        url: &IndexUrl,
+    ) -> Result<IndexStatusCodeStrategy, IndexSourceError> {
         for index in &self.indexes {
             if index.url() == url {
                 return index.status_code_strategy();
             }
         }
-        IndexStatusCodeStrategy::Default
+        Ok(IndexStatusCodeStrategy::Default)
     }
 }
 

crates/uv-distribution-types/src/status_code_strategy.rs

@@ -1,4 +1,4 @@
-use http::StatusCode;
+use http::{status::InvalidStatusCode, StatusCode};
 use rustc_hash::FxHashSet;
 use url::Url;
 
@@ -32,13 +32,12 @@ impl IndexStatusCodeStrategy {
     }
 
     /// Derive a strategy from a list of status codes to ignore.
-    pub fn from_ignored_error_codes(status_codes: &[u16]) -> Self {
+    pub fn from_ignored_error_codes(status_codes: &[u16]) -> Result<Self, InvalidStatusCode> {
         let status_codes = status_codes
             .iter()
             .map(|code| StatusCode::from_u16(*code))
-            .collect::<Result<FxHashSet<_>, _>>()
-            .expect("Status codes should be valid.");
-        Self::IgnoreErrorCodes { status_codes }
+            .collect::<Result<FxHashSet<_>, _>>()?;
+        Ok(Self::IgnoreErrorCodes { status_codes })
     }
 
     /// Based on the strategy, decide whether to continue searching the next index
@@ -110,13 +109,14 @@ mod tests {
     }
 
     #[test]
-    fn test_strategy_custom_error_codes() {
+    fn test_strategy_custom_error_codes() -> Result<()> {
         let status_codes =
             FxHashSet::from_iter(vec![StatusCode::UNAUTHORIZED, StatusCode::FORBIDDEN]);
         assert_eq!(
-            IndexStatusCodeStrategy::from_ignored_error_codes(&[401, 403]),
+            IndexStatusCodeStrategy::from_ignored_error_codes(&[401, 403])?,
             IndexStatusCodeStrategy::IgnoreErrorCodes { status_codes }
         );
+        Ok(())
     }
 
     #[test]