1use std::time::Duration;
12
13use fred::prelude::*;
14
15pub use fred;
16
17mod swr;
18pub use swr::Swr;
19
20#[derive(Clone)]
26pub struct CacheConfig {
27 pub url: String,
28 pub pool_size: usize,
29 pub ca_cert_path: Option<String>,
33 pub password: Option<String>,
48}
49
50fn redact_url(url: &str) -> String {
60 let Some(scheme_end) = url.find("://") else {
61 return "<redacted>".to_string();
62 };
63 let (scheme, rest) = url.split_at(scheme_end + 3);
64
65 let search_end = rest.find(['?', '#']).unwrap_or(rest.len());
68 let after_userinfo = match rest[..search_end].rfind('@') {
69 Some(at_pos) => &rest[at_pos + 1..],
70 None if rest.contains('@') => {
71 return format!("{scheme}<redacted>");
75 }
76 None => rest,
77 };
78
79 let host_end = after_userinfo
80 .find(['/', '?', '#'])
81 .unwrap_or(after_userinfo.len());
82 format!("{scheme}{}", &after_userinfo[..host_end])
83}
84
85impl std::fmt::Debug for CacheConfig {
89 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
90 f.debug_struct("CacheConfig")
91 .field("url", &redact_url(&self.url))
92 .field("pool_size", &self.pool_size)
93 .field("ca_cert_path", &self.ca_cert_path)
94 .field("password", &self.password.as_ref().map(|_| "<redacted>"))
95 .finish()
96 }
97}
98
99impl CacheConfig {
100 pub fn from_env() -> anyhow::Result<Self> {
108 let url = std::env::var("VALKEY_URL")
109 .or_else(|_| std::env::var("REDIS_URL"))
110 .map_err(|_| anyhow::anyhow!("VALKEY_URL (or REDIS_URL) not set"))?;
111 let pool_size = std::env::var("VALKEY_POOL_SIZE")
112 .ok()
113 .and_then(|v| v.parse().ok())
114 .unwrap_or(6);
115 let ca_cert_path = std::env::var("VALKEY_CA_CERT").ok();
116 let password = std::env::var("VALKEY_PASSWORD")
117 .ok()
118 .filter(|v| !v.is_empty());
119 Ok(Self {
120 url,
121 pool_size,
122 ca_cert_path,
123 password,
124 })
125 }
126}
127
128pub type CachePool = Pool;
129
130const RECONNECT_MIN_DELAY_MS: u32 = 100;
131const RECONNECT_MAX_DELAY_MS: u32 = 30_000;
132const COMMAND_TIMEOUT: Duration = Duration::from_secs(1);
133const INITIAL_CONNECT_WAIT: Duration = Duration::from_secs(5);
134
135fn percent_encode_userinfo(url: &str) -> String {
167 let Some(scheme_end) = url.find("://") else {
168 return url.to_string();
169 };
170 let (scheme, rest) = url.split_at(scheme_end + 3);
171
172 let search_end = rest.find(['?', '#']).unwrap_or(rest.len());
174 let Some(at_pos) = rest[..search_end].rfind('@') else {
175 return url.to_string();
176 };
177
178 let (userinfo, after_at) = rest.split_at(at_pos);
179 let after_at = &after_at[1..]; let host_end = after_at.find(['/', '?', '#']).unwrap_or(after_at.len());
183 let (host_part, tail) = after_at.split_at(host_end);
184
185 let encode_set: &percent_encoding::AsciiSet = percent_encoding::NON_ALPHANUMERIC;
190
191 if let Some((user, pass)) = userinfo.split_once(':') {
192 let enc_user = percent_encoding::utf8_percent_encode(user, encode_set);
193 let enc_pass = percent_encoding::utf8_percent_encode(pass, encode_set);
194 format!("{scheme}{enc_user}:{enc_pass}@{host_part}{tail}")
195 } else {
196 let enc_user = percent_encoding::utf8_percent_encode(userinfo, encode_set);
197 format!("{scheme}{enc_user}@{host_part}{tail}")
198 }
199}
200
201fn rustls_config_with_ca(ca_cert_path: &str) -> anyhow::Result<fred::rustls::ClientConfig> {
205 let pem_bytes = std::fs::read(ca_cert_path)
206 .map_err(|e| anyhow::anyhow!("failed to read VALKEY_CA_CERT ({ca_cert_path}): {e}"))?;
207 let mut reader = std::io::BufReader::new(pem_bytes.as_slice());
208 let certs: Vec<_> = rustls_pemfile::certs(&mut reader)
209 .collect::<Result<_, _>>()
210 .map_err(|e| anyhow::anyhow!("failed to parse VALKEY_CA_CERT PEM: {e}"))?;
211 if certs.is_empty() {
212 anyhow::bail!("VALKEY_CA_CERT ({ca_cert_path}) contains no certificates");
213 }
214
215 let mut roots = fred::rustls::RootCertStore::empty();
216 for cert in certs {
217 roots
218 .add(cert)
219 .map_err(|e| anyhow::anyhow!("invalid CA certificate in VALKEY_CA_CERT: {e}"))?;
220 }
221
222 Ok(fred::rustls::ClientConfig::builder()
223 .with_root_certificates(roots)
224 .with_no_client_auth())
225}
226
227const TRANSIENT_IO_ERRORS: &[&str] = &[
228 "ConnectionRefused",
229 "ConnectionReset",
230 "ConnectionAborted",
231 "TimedOut",
232 "HostUnreachable",
233 "NetworkUnreachable",
234 "NotConnected",
235 "BrokenPipe",
236 "UnexpectedEof",
237 "failed to lookup address",
238];
239
240fn is_transient(error: &Error) -> bool {
241 match error.kind() {
242 ErrorKind::Timeout | ErrorKind::Canceled => true,
243 ErrorKind::IO => TRANSIENT_IO_ERRORS
244 .iter()
245 .any(|kind| error.details().contains(kind)),
246 _ => false,
247 }
248}
249
250pub async fn connect(config: &CacheConfig) -> anyhow::Result<CachePool> {
251 let sanitized_url = percent_encode_userinfo(&config.url);
252 let mut cfg =
253 Config::from_url(&sanitized_url).map_err(|e| anyhow::anyhow!("invalid VALKEY_URL: {e}"))?;
254
255 if let Some(password) = &config.password {
259 cfg.password = Some(password.clone());
260 }
261
262 let tls_enabled = config.url.starts_with("rediss://");
263 if tls_enabled {
264 if let Some(ca_cert_path) = &config.ca_cert_path {
265 let client_config = rustls_config_with_ca(ca_cert_path)?;
266 cfg.tls = Some(client_config.into());
267 }
268 }
271
272 let performance = PerformanceConfig {
273 default_command_timeout: COMMAND_TIMEOUT,
274 ..PerformanceConfig::default()
275 };
276 let reconnect =
277 ReconnectPolicy::new_exponential(0, RECONNECT_MIN_DELAY_MS, RECONNECT_MAX_DELAY_MS, 2);
278 let build = |cfg: Config| {
279 Pool::new(
280 cfg,
281 Some(performance.clone()),
282 None,
283 Some(reconnect.clone()),
284 config.pool_size,
285 )
286 .map_err(|e| anyhow::anyhow!("failed to build Valkey pool: {e}"))
287 };
288
289 let probe = build(cfg.clone())?;
290 let _handle = probe.connect();
291 match tokio::time::timeout(INITIAL_CONNECT_WAIT, probe.wait_for_connect()).await {
292 Ok(Ok(())) => {
293 tracing::info!(
294 pool_size = config.pool_size,
295 tls = tls_enabled,
296 "connected to Valkey"
297 );
298 return Ok(probe);
299 }
300 Ok(Err(e)) if !is_transient(&e) => {
301 let _ = probe.quit().await;
302 return Err(anyhow::anyhow!("Valkey connect failed: {e}"));
303 }
304 Ok(Err(e)) => tracing::warn!(
305 error = %e,
306 "Valkey unreachable at startup, reconnecting in the background"
307 ),
308 Err(_) => tracing::warn!(
309 wait_secs = INITIAL_CONNECT_WAIT.as_secs(),
310 "Valkey not connected yet, reconnecting in the background"
311 ),
312 }
313
314 let _ = probe.quit().await;
315 cfg.fail_fast = false;
316 let pool = build(cfg)?;
317 let _handle = pool.connect();
318 Ok(pool)
319}
320
321#[cfg(test)]
322mod tests {
323 use super::*;
324 use fred::interfaces::KeysInterface;
325
326 fn tls_env() -> Option<(String, String)> {
331 let url = std::env::var("TEST_VALKEY_TLS_URL").ok()?;
332 let ca = std::env::var("TEST_VALKEY_TLS_CA").ok()?;
333 Some((url, ca))
334 }
335
336 #[tokio::test]
337 async fn connects_over_tls_with_valid_ca() {
338 let Some((url, ca_cert_path)) = tls_env() else {
339 eprintln!("skipping: TEST_VALKEY_TLS_URL / TEST_VALKEY_TLS_CA not set");
340 return;
341 };
342
343 let pool = connect(&CacheConfig {
344 url,
345 pool_size: 2,
346 ca_cert_path: Some(ca_cert_path),
347 password: None,
348 })
349 .await
350 .expect("expected TLS connect with valid CA to succeed");
351
352 pool.set::<(), _, _>("ferrlabs-cache:tls-test", "ok", None, None, false)
353 .await
354 .expect("SET over TLS should succeed");
355 let value: String = pool
356 .get("ferrlabs-cache:tls-test")
357 .await
358 .expect("GET over TLS should succeed");
359 assert_eq!(value, "ok");
360 }
361
362 #[tokio::test]
363 async fn rejects_tls_connection_without_trusted_ca() {
364 let Some((url, _)) = tls_env() else {
365 eprintln!("skipping: TEST_VALKEY_TLS_URL / TEST_VALKEY_TLS_CA not set");
366 return;
367 };
368
369 let result = tokio::time::timeout(
373 std::time::Duration::from_secs(10),
374 connect(&CacheConfig {
375 url,
376 pool_size: 1,
377 ca_cert_path: None,
378 password: None,
379 }),
380 )
381 .await;
382
383 if let Ok(connect_result) = result {
386 assert!(
387 connect_result.is_err(),
388 "connecting over TLS without a trusted CA must fail"
389 );
390 }
391 }
392
393 #[tokio::test]
394 async fn rejects_wrong_explicit_ca() {
395 let Some((url, _)) = tls_env() else {
402 eprintln!("skipping: TEST_VALKEY_TLS_URL / TEST_VALKEY_TLS_CA not set");
403 return;
404 };
405 let Ok(wrong_ca) = std::env::var("TEST_VALKEY_TLS_WRONG_CA") else {
406 eprintln!("skipping: TEST_VALKEY_TLS_WRONG_CA not set");
407 return;
408 };
409
410 let result = tokio::time::timeout(
411 std::time::Duration::from_secs(10),
412 connect(&CacheConfig {
413 url,
414 pool_size: 1,
415 ca_cert_path: Some(wrong_ca),
416 password: None,
417 }),
418 )
419 .await;
420
421 if let Ok(connect_result) = result {
424 assert!(
425 connect_result.is_err(),
426 "connecting over TLS with a non-signing CA must fail"
427 );
428 }
429 }
430
431 #[test]
434 fn percent_encode_userinfo_splits_on_last_at_for_password_containing_at() {
435 let raw = "redis://:ab@cd@127.0.0.1:6379";
438 let sanitized = percent_encode_userinfo(raw);
439 assert_eq!(sanitized, "redis://:ab%40cd@127.0.0.1:6379");
440 }
441
442 #[test]
443 fn percent_encode_userinfo_splits_on_first_colon_for_password_containing_colon() {
444 let raw = "redis://:ab:cd@127.0.0.1:6379";
447 let sanitized = percent_encode_userinfo(raw);
448 assert_eq!(sanitized, "redis://:ab%3Acd@127.0.0.1:6379");
449 }
450
451 #[test]
452 fn percent_encode_userinfo_encodes_percent_sign_itself() {
453 let raw = "redis://:ab%cd@127.0.0.1:6379";
458 let sanitized = percent_encode_userinfo(raw);
459 assert_eq!(sanitized, "redis://:ab%25cd@127.0.0.1:6379");
460 }
461
462 #[test]
463 fn percent_encode_userinfo_covers_slash_plus_equals() {
464 let raw = "redis://:ab/cd+ef=gh@127.0.0.1:6379";
465 let sanitized = percent_encode_userinfo(raw);
466 assert_eq!(sanitized, "redis://:ab%2Fcd%2Bef%3Dgh@127.0.0.1:6379");
467 }
468
469 #[test]
470 fn percent_encode_userinfo_leaves_url_without_userinfo_unchanged() {
471 let raw = "redis://127.0.0.1:6379";
472 assert_eq!(percent_encode_userinfo(raw), raw);
473 }
474
475 #[test]
476 fn percent_encode_userinfo_preserves_db_index_path() {
477 let raw = "redis://:ab/cd@127.0.0.1:6379/0";
480 let sanitized = percent_encode_userinfo(raw);
481 assert_eq!(sanitized, "redis://:ab%2Fcd@127.0.0.1:6379/0");
482 }
483
484 #[test]
485 fn percent_encode_userinfo_ignores_at_sign_outside_the_authority() {
486 let raw = "redis://:pw@127.0.0.1:6379/0?note=a@b";
491 let sanitized = percent_encode_userinfo(raw);
492 assert_eq!(sanitized, "redis://:pw@127.0.0.1:6379/0?note=a@b");
493
494 let parsed = Config::from_url(&sanitized).expect("should parse");
496 let host = &parsed.server.hosts()[0];
497 assert_eq!(&*host.host, "127.0.0.1");
498 assert_eq!(host.port, 6379);
499 }
500
501 #[test]
502 fn percent_encode_userinfo_handles_slash_password_together_with_path_and_query() {
503 let raw = "redis://:ab/cd+ef=gh@127.0.0.1:6379/0?note=a@b";
507 let sanitized = percent_encode_userinfo(raw);
508 assert_eq!(
509 sanitized,
510 "redis://:ab%2Fcd%2Bef%3Dgh@127.0.0.1:6379/0?note=a@b"
511 );
512
513 let parsed = Config::from_url(&sanitized).expect("should parse");
514 let host = &parsed.server.hosts()[0];
515 assert_eq!(&*host.host, "127.0.0.1");
516 assert_eq!(host.port, 6379);
517 }
518
519 #[test]
520 fn percent_encode_userinfo_leaves_url_without_userinfo_but_with_path_query_unchanged() {
521 let raw = "redis://127.0.0.1:6379/0?x=1@2";
524 assert_eq!(percent_encode_userinfo(raw), raw);
525 }
526
527 #[test]
528 fn percent_encode_userinfo_preserves_rediss_scheme() {
529 let raw = "rediss://:ab/cd@127.0.0.1:6380";
530 let sanitized = percent_encode_userinfo(raw);
531 assert_eq!(sanitized, "rediss://:ab%2Fcd@127.0.0.1:6380");
532 }
533
534 fn url_safe_password_env() -> Option<String> {
544 std::env::var("TEST_VALKEY_URL_SAFE_PASSWORD_URL").ok()
545 }
546
547 #[tokio::test]
548 async fn connects_with_raw_password_containing_url_breaking_characters() {
549 let Some(url) = url_safe_password_env() else {
550 eprintln!("skipping: TEST_VALKEY_URL_SAFE_PASSWORD_URL not set");
551 return;
552 };
553
554 let pool = connect(&CacheConfig {
560 url,
561 pool_size: 2,
562 ca_cert_path: None,
563 password: None,
564 })
565 .await
566 .expect("connect with a raw URL-breaking password should succeed");
567
568 pool.set::<(), _, _>("ferrlabs-cache:url-safe-pw-test", "ok", None, None, false)
569 .await
570 .expect("SET should succeed once AUTH has decoded the real password");
571 let value: String = pool
572 .get("ferrlabs-cache:url-safe-pw-test")
573 .await
574 .expect("GET should succeed");
575 assert_eq!(value, "ok");
576 }
577
578 fn password_env() -> Option<(String, String)> {
589 let url = std::env::var("TEST_VALKEY_PASSWORD_URL").ok()?;
590 let password = std::env::var("TEST_VALKEY_PASSWORD").ok()?;
591 Some((url, password))
592 }
593
594 #[tokio::test]
595 async fn connects_with_password_supplied_out_of_band() {
596 let Some((url, password)) = password_env() else {
597 eprintln!("skipping: TEST_VALKEY_PASSWORD_URL / TEST_VALKEY_PASSWORD not set");
598 return;
599 };
600
601 let pool = connect(&CacheConfig {
603 url,
604 pool_size: 2,
605 ca_cert_path: None,
606 password: Some(password),
607 })
608 .await
609 .expect("connect with password supplied via CacheConfig::password should succeed");
610
611 pool.set::<(), _, _>(
612 "ferrlabs-cache:password-field-test",
613 "ok",
614 None,
615 None,
616 false,
617 )
618 .await
619 .expect("SET should succeed once AUTH has used the out-of-band password");
620 let value: String = pool
621 .get("ferrlabs-cache:password-field-test")
622 .await
623 .expect("GET should succeed");
624 assert_eq!(value, "ok");
625 }
626
627 fn unencodable_password_env() -> Option<(String, String)> {
638 let url = std::env::var("TEST_VALKEY_UNENCODABLE_PASSWORD_URL").ok()?;
639 let password = std::env::var("TEST_VALKEY_UNENCODABLE_PASSWORD").ok()?;
640 Some((url, password))
641 }
642
643 #[tokio::test]
644 async fn url_with_credentials_cannot_represent_a_password_containing_question_mark_or_hash() {
645 let Some((url, password)) = unencodable_password_env() else {
665 eprintln!(
666 "skipping: TEST_VALKEY_UNENCODABLE_PASSWORD_URL / TEST_VALKEY_UNENCODABLE_PASSWORD not set"
667 );
668 return;
669 };
670
671 let scheme_end = url.find("://").expect("test URL must have a scheme");
674 let (scheme, authority) = url.split_at(scheme_end + 3);
675 let raw_url_with_creds = format!("{scheme}:{password}@{authority}");
676
677 let result = connect(&CacheConfig {
678 url: raw_url_with_creds,
679 pool_size: 1,
680 ca_cert_path: None,
681 password: None,
682 })
683 .await;
684 assert!(
685 result.is_err(),
686 "a raw '?'/'#'-containing password embedded in the URL must not \
687 produce a working connection — this is exactly why VALKEY_PASSWORD exists"
688 );
689 }
690
691 #[tokio::test]
692 async fn valkey_password_handles_a_password_containing_question_mark_or_hash() {
693 let Some((url, password)) = unencodable_password_env() else {
697 eprintln!(
698 "skipping: TEST_VALKEY_UNENCODABLE_PASSWORD_URL / TEST_VALKEY_UNENCODABLE_PASSWORD not set"
699 );
700 return;
701 };
702
703 let pool = connect(&CacheConfig {
704 url,
705 pool_size: 2,
706 ca_cert_path: None,
707 password: Some(password),
708 })
709 .await
710 .expect("a password containing '?'/'#' supplied via VALKEY_PASSWORD should connect fine");
711
712 pool.set::<(), _, _>(
713 "ferrlabs-cache:unencodable-password-test",
714 "ok",
715 None,
716 None,
717 false,
718 )
719 .await
720 .expect("SET should succeed");
721 let value: String = pool
722 .get("ferrlabs-cache:unencodable-password-test")
723 .await
724 .expect("GET should succeed");
725 assert_eq!(value, "ok");
726 }
727
728 #[tokio::test]
729 async fn config_password_takes_priority_over_url_credentials() {
730 let Some((url, password)) = password_env() else {
734 eprintln!("skipping: TEST_VALKEY_PASSWORD_URL / TEST_VALKEY_PASSWORD not set");
735 return;
736 };
737
738 let scheme_end = url.find("://").expect("test URL must have a scheme");
739 let (scheme, authority) = url.split_at(scheme_end + 3);
740 let url_with_wrong_creds = format!("{scheme}:not-the-real-password@{authority}");
741
742 let pool = connect(&CacheConfig {
743 url: url_with_wrong_creds,
744 pool_size: 2,
745 ca_cert_path: None,
746 password: Some(password),
747 })
748 .await
749 .expect("CacheConfig::password must take priority over URL credentials");
750
751 pool.set::<(), _, _>(
752 "ferrlabs-cache:password-priority-test",
753 "ok",
754 None,
755 None,
756 false,
757 )
758 .await
759 .expect("SET should succeed using the out-of-band password");
760 let value: String = pool
761 .get("ferrlabs-cache:password-priority-test")
762 .await
763 .expect("GET should succeed");
764 assert_eq!(value, "ok");
765 }
766
767 #[test]
770 fn debug_redacts_password_and_url_credentials() {
771 let config = CacheConfig {
775 url: "redis://:supersecret@host:6379".to_string(),
776 pool_size: 6,
777 ca_cert_path: None,
778 password: Some("supersecret".to_string()),
779 };
780
781 let rendered = format!("{config:?}");
782
783 assert!(
784 !rendered.contains("supersecret"),
785 "Debug must not leak the password (from the field or the URL), got: {rendered}"
786 );
787 assert!(
788 rendered.contains("<redacted>"),
789 "Debug should mark the password as redacted, got: {rendered}"
790 );
791 assert!(
793 rendered.contains("host:6379"),
794 "Debug should keep the host for debuggability, got: {rendered}"
795 );
796 assert!(rendered.contains("pool_size: 6"), "got: {rendered}");
797 }
798
799 #[test]
800 fn debug_renders_absent_password_as_none() {
801 let config = CacheConfig {
802 url: "redis://127.0.0.1:6379".to_string(),
803 pool_size: 2,
804 ca_cert_path: Some("/etc/ssl/ca.pem".to_string()),
805 password: None,
806 };
807
808 let rendered = format!("{config:?}");
809
810 assert!(
811 rendered.contains("password: None"),
812 "an absent password should render as None, got: {rendered}"
813 );
814 assert!(
816 rendered.contains("redis://127.0.0.1:6379"),
817 "got: {rendered}"
818 );
819 assert!(rendered.contains("/etc/ssl/ca.pem"), "got: {rendered}");
820 }
821
822 #[test]
823 fn debug_redacts_url_whose_password_contains_a_raw_question_mark() {
824 let config = CacheConfig {
829 url: "redis://:pa?ss#word/x+y=z@127.0.0.1:6379".to_string(),
830 pool_size: 1,
831 ca_cert_path: None,
832 password: None,
833 };
834
835 let rendered = format!("{config:?}");
836
837 for leak in ["pa?ss", "#word", "x+y=z", "pa?"] {
840 assert!(
841 !rendered.contains(leak),
842 "Debug must not leak any part of an unparseable password \
843 (found {leak:?}), got: {rendered}"
844 );
845 }
846 assert!(rendered.contains("<redacted>"), "got: {rendered}");
847 }
848
849 fn unreachable_config() -> CacheConfig {
850 CacheConfig {
851 url: "redis://127.0.0.1:1".to_string(),
852 pool_size: 2,
853 ca_cert_path: None,
854 password: None,
855 }
856 }
857
858 #[tokio::test]
859 async fn connect_returns_a_pool_when_valkey_is_unreachable() {
860 let started = std::time::Instant::now();
861 let pool = connect(&unreachable_config()).await;
862 assert!(
863 pool.is_ok(),
864 "connect must not fail on an unreachable server"
865 );
866 assert!(
867 started.elapsed() <= INITIAL_CONNECT_WAIT + Duration::from_secs(2),
868 "connect waited {:?}",
869 started.elapsed()
870 );
871 }
872
873 #[tokio::test]
874 async fn pool_keeps_retrying_after_an_unreachable_startup() {
875 let pool = connect(&unreachable_config()).await.expect("pool");
876
877 let second = pool
878 .connect()
879 .await
880 .expect("the connection task must not panic")
881 .expect_err("a live router task refuses a second connect");
882
883 assert_eq!(
884 second.kind(),
885 &ErrorKind::Config,
886 "expected the router task to still hold the command channel, got: {second}"
887 );
888 assert!(
889 second.details().contains("already running"),
890 "expected the router task to still hold the command channel, got: {second}"
891 );
892 }
893
894 #[tokio::test]
895 async fn swr_loads_directly_within_the_command_timeout_when_valkey_is_down() {
896 let pool = connect(&unreachable_config()).await.expect("pool");
897 let swr = Swr {
898 pool: &pool,
899 key: "test:unreachable",
900 fresh_ttl: Duration::from_secs(30),
901 hard_ttl: Duration::from_secs(300),
902 lock_ttl: Duration::from_secs(30),
903 bypass: false,
904 };
905 let started = std::time::Instant::now();
906 let value: u32 = swr
907 .get_or_load(|| async { Ok(42) })
908 .await
909 .expect("loader value");
910 assert_eq!(value, 42);
911 assert!(
912 started.elapsed() <= COMMAND_TIMEOUT * 3,
913 "fallback took {:?}",
914 started.elapsed()
915 );
916 }
917
918 #[test]
919 fn network_failures_are_transient() {
920 for kind in [
921 std::io::ErrorKind::ConnectionRefused,
922 std::io::ErrorKind::TimedOut,
923 std::io::ErrorKind::ConnectionReset,
924 ] {
925 assert!(
926 is_transient(&Error::from(std::io::Error::from(kind))),
927 "{kind:?}"
928 );
929 }
930 assert!(is_transient(&Error::new(ErrorKind::Timeout, "timed out")));
931 }
932
933 #[test]
934 fn misconfiguration_is_not_transient() {
935 let bad_certificate = std::io::Error::new(
936 std::io::ErrorKind::InvalidData,
937 fred::rustls::Error::InvalidCertificate(fred::rustls::CertificateError::UnknownIssuer),
938 );
939 assert!(!is_transient(&Error::from(bad_certificate)));
940 assert!(!is_transient(&Error::new(ErrorKind::Auth, "WRONGPASS")));
941 assert!(!is_transient(&Error::new(
942 ErrorKind::Tls,
943 "invalid configuration"
944 )));
945 assert!(!is_transient(&Error::new(ErrorKind::Url, "invalid url")));
946 }
947}