style: Satisfy clippy map_or and Duration unit lints (#11)

clippy 0.1.97 promotes two lints across the crate: map(f).unwrap_or(a)
on Result (use map_or), and constructing a Duration from a smaller unit
where a larger one reads better (from_secs(3600) -> from_hours(1)).

Mechanical rewrites only — every Duration keeps its exact value and the
map_or calls are semantically identical. No behavior change; full suite
passes (168 tests, --features testing).

Author: joshuaclayton

src/oidc/claims/mod.rs

@@ -192,7 +192,7 @@ impl Claims {
     /// considered valid.
     #[must_use]
     pub fn is_expired(&self) -> bool {
-        SystemTime::now() > self.exp + std::time::Duration::from_secs(60)
+        SystemTime::now() > self.exp + std::time::Duration::from_mins(1)
     }
 }
 

src/oidc/claims/serde.rs

@@ -25,13 +25,11 @@ impl Serialize for Claims {
         let iat_secs = self
             .iat
             .duration_since(UNIX_EPOCH)
-            .map(|d| d.as_secs())
-            .unwrap_or(0);
+            .map_or(0, |d| d.as_secs());
         let exp_secs = self
             .exp
             .duration_since(UNIX_EPOCH)
-            .map(|d| d.as_secs())
-            .unwrap_or(0);
+            .map_or(0, |d| d.as_secs());
         s.serialize_field("iat", &iat_secs)?;
         s.serialize_field("exp", &exp_secs)?;
         s.end()

src/oidc/token.rs

@@ -318,7 +318,7 @@ mod tests {
     }
 
     fn token_with_nbf_offset(offset_secs: i64) -> Token {
-        let exp = SystemTime::now() + Duration::from_secs(3600);
+        let exp = SystemTime::now() + Duration::from_hours(1);
         let iat = SystemTime::now() - Duration::from_secs(10);
         let nbf = if offset_secs >= 0 {
             SystemTime::now() + Duration::from_secs(offset_secs.cast_unsigned())
@@ -385,7 +385,7 @@ mod tests {
     }
 
     fn token_with_iat_offset(offset_secs: i64) -> Token {
-        let exp = SystemTime::now() + Duration::from_secs(3600);
+        let exp = SystemTime::now() + Duration::from_hours(1);
         let iat = if offset_secs >= 0 {
             SystemTime::now() + Duration::from_secs(offset_secs.cast_unsigned())
         } else {
@@ -429,7 +429,7 @@ mod tests {
     }
 
     fn token_with_nonce(nonce: Option<String>) -> Token {
-        let exp = SystemTime::now() + Duration::from_secs(3600);
+        let exp = SystemTime::now() + Duration::from_hours(1);
         let iat = SystemTime::now() - Duration::from_secs(10);
         let iss = url::Url::parse("https://issuer.example.com").expect("valid url");
         let claims = Claims::new(

src/pages.rs

@@ -386,7 +386,7 @@ mod tests {
     }
 
     fn future_expiry() -> SystemTime {
-        SystemTime::now() + Duration::from_secs(3600)
+        SystemTime::now() + Duration::from_hours(1)
     }
 
     #[test]

src/store.rs

@@ -103,7 +103,7 @@ mod tests {
         TokenSet::new(
             "access".to_string(),
             None,
-            Some(SystemTime::now() + Duration::from_secs(3600)),
+            Some(SystemTime::now() + Duration::from_hours(1)),
             "Bearer".to_string(),
             None,
             Vec::new(),

src/token/mod.rs

@@ -23,10 +23,7 @@ where
 {
     match time {
         Some(t) => {
-            let secs = t
-                .duration_since(UNIX_EPOCH)
-                .map(|d| d.as_secs())
-                .unwrap_or(0);
+            let secs = t.duration_since(UNIX_EPOCH).map_or(0, |d| d.as_secs());
             serializer.serialize_some(&secs)
         }
         None => serializer.serialize_none(),
@@ -292,39 +289,39 @@ mod tests {
 
     #[test]
     fn token_set_future_expiry_is_not_expired() {
-        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_secs(3600));
+        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_hours(1));
         assert!(!token.is_expired());
     }
 
     #[test]
     fn token_set_expiring_soon_is_within_threshold() {
         let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_secs(30));
-        assert!(token.expires_within(Duration::from_secs(60)));
+        assert!(token.expires_within(Duration::from_mins(1)));
     }
 
     #[test]
     fn token_set_far_future_not_within_threshold() {
-        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_secs(3600));
-        assert!(!token.expires_within(Duration::from_secs(60)));
+        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_hours(1));
+        assert!(!token.expires_within(Duration::from_mins(1)));
     }
 
     #[test]
     fn token_set_already_expired_is_within_any_threshold() {
         let token = make_token_set_expiring_at(UNIX_EPOCH);
-        assert!(token.expires_within(Duration::from_secs(60)));
+        assert!(token.expires_within(Duration::from_mins(1)));
     }
 
     #[test]
     fn token_set_serde_roundtrip_access_token() {
-        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_secs(3600));
+        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_hours(1));
         let json = serde_json::to_string(&token).expect("serialize");
         let decoded: TokenSet<Unvalidated> = serde_json::from_str(&json).expect("deserialize");
         assert_eq!(decoded.access_token().as_str(), "access_token_value");
     }
 
     #[test]
     fn token_set_expires_at_serializes_as_u64() {
-        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_secs(3600));
+        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_hours(1));
         let json = serde_json::to_string(&token).expect("serialize");
         let value: serde_json::Value = serde_json::from_str(&json).expect("parse");
         assert!(
@@ -356,14 +353,14 @@ mod tests {
 
     #[test]
     fn access_token_getter_returns_access_token_newtype() {
-        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_secs(3600));
+        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_hours(1));
         let at: &AccessToken = token.access_token();
         assert_eq!(at.as_str(), "access_token_value");
     }
 
     #[test]
     fn refresh_token_getter_returns_refresh_token_newtype() {
-        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_secs(3600));
+        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_hours(1));
         let rt: Option<&RefreshToken> = token.refresh_token();
         assert!(rt.is_some());
         assert_eq!(rt.unwrap().as_str(), "refresh_token_value");
@@ -374,7 +371,7 @@ mod tests {
         let token = TokenSet::new(
             "access".to_string(),
             None,
-            Some(SystemTime::now() + Duration::from_secs(3600)),
+            Some(SystemTime::now() + Duration::from_hours(1)),
             "Bearer".to_string(),
             None,
             Vec::new(),
@@ -385,7 +382,7 @@ mod tests {
 
     #[test]
     fn id_token_raw_absent_returns_none() {
-        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_secs(3600));
+        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_hours(1));
         assert!(token.id_token_raw().is_none());
     }
 
@@ -406,7 +403,7 @@ mod tests {
         let token = TokenSet::new(
             "access".to_string(),
             None,
-            Some(SystemTime::now() + Duration::from_secs(3600)),
+            Some(SystemTime::now() + Duration::from_hours(1)),
             "Bearer".to_string(),
             Some(oidc),
             Vec::new(),
@@ -417,15 +414,15 @@ mod tests {
 
     #[test]
     fn expires_at_is_publicly_callable() {
-        let expiry = SystemTime::now() + Duration::from_secs(3600);
+        let expiry = SystemTime::now() + Duration::from_hours(1);
         let token = make_token_set_expiring_at(expiry);
         // expires_at() must be pub - compile-time check
         let _ = token.expires_at();
     }
 
     #[test]
     fn scopes_returns_empty_slice_when_empty() {
-        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_secs(3600));
+        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_hours(1));
         assert_eq!(token.scopes(), &[] as &[OAuth2Scope]);
     }
 
@@ -434,7 +431,7 @@ mod tests {
         let token = TokenSet::new(
             "access".to_string(),
             None,
-            Some(SystemTime::now() + Duration::from_secs(3600)),
+            Some(SystemTime::now() + Duration::from_hours(1)),
             "Bearer".to_string(),
             None,
             vec![OAuth2Scope::OpenId, OAuth2Scope::Email],
@@ -455,7 +452,7 @@ mod tests {
 
     #[test]
     fn token_set_token_type_returns_bearer() {
-        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_secs(3600));
+        let token = make_token_set_expiring_at(SystemTime::now() + Duration::from_hours(1));
         assert_eq!(token.token_type(), "Bearer");
     }
 }

tests/refresh_flow.rs

@@ -69,7 +69,7 @@ async fn refresh_if_expiring_not_needed() {
 
     // Token has ~3600s expiry; 60s threshold means it is NOT expiring soon
     let result = auth
-        .refresh_if_expiring(&token_set, Duration::from_secs(60))
+        .refresh_if_expiring(&token_set, Duration::from_mins(1))
         .await;
 
     match result {
@@ -91,7 +91,7 @@ async fn refresh_if_expiring_refreshed() {
 
     // Token has ~3600s expiry; 7200s threshold means it IS expiring soon
     let result = auth
-        .refresh_if_expiring(&token_set, Duration::from_secs(7200))
+        .refresh_if_expiring(&token_set, Duration::from_hours(2))
         .await;
 
     match result {

tests/refresh_token_preservation.rs

@@ -79,7 +79,7 @@ async fn refresh_if_expiring_preserves_token_when_provider_omits_it() {
     let expired_tokens = expired_tokens.into_validated();
 
     let outcome = client
-        .refresh_if_expiring(&expired_tokens, Duration::from_secs(300))
+        .refresh_if_expiring(&expired_tokens, Duration::from_mins(5))
         .await;
 
     match outcome {