101 lines
3.7 KiB
Rust
101 lines
3.7 KiB
Rust
//! Refresh form encoding, response validation, and revision-aware cache behavior.
|
|
use sausage::cred::oauth2::*;
|
|
use std::{
|
|
sync::atomic::{AtomicUsize, Ordering},
|
|
time::{Duration, Instant},
|
|
};
|
|
use zeroize::Zeroizing;
|
|
struct Fake(AtomicUsize);
|
|
impl Http for Fake {
|
|
async fn send(&self, request: &Request, _: Instant) -> Result<Zeroizing<Vec<u8>>, Error> {
|
|
assert_eq!(request.method, "POST");
|
|
self.0.fetch_add(1, Ordering::SeqCst);
|
|
Ok(Zeroizing::new(br#"{"access_token":"SYNTHETIC","token_type":"Bearer","expires_in":3600,"scope":"one two"}"#.to_vec()))
|
|
}
|
|
}
|
|
#[tokio::test]
|
|
async fn encoding_and_cache() {
|
|
let req = request(
|
|
"https://tokens.example.test/token",
|
|
"REFRESH&=+",
|
|
"CLIENT",
|
|
"SECRET&=+",
|
|
)
|
|
.unwrap();
|
|
assert!(
|
|
req.body.as_str()
|
|
== "grant_type=refresh_token&refresh_token=REFRESH%26%3D%2B&client_id=CLIENT&client_secret=SECRET%26%3D%2B"
|
|
);
|
|
assert_eq!(req.headers[1].1, req.body.len().to_string());
|
|
let fake = Fake(AtomicUsize::new(0));
|
|
let mut cache = Cache::default();
|
|
let deadline = Instant::now() + Duration::from_secs(1);
|
|
let t = cache.refresh("id", 1, &req, &fake, deadline).await.unwrap();
|
|
assert_eq!(t.scopes.unwrap(), vec!["one", "two"]);
|
|
cache.refresh("id", 1, &req, &fake, deadline).await.unwrap();
|
|
assert_eq!(fake.0.load(Ordering::SeqCst), 1);
|
|
cache.refresh("id", 2, &req, &fake, deadline).await.unwrap();
|
|
assert_eq!(fake.0.load(Ordering::SeqCst), 2);
|
|
cache.clear();
|
|
cache.refresh("id", 2, &req, &fake, deadline).await.unwrap();
|
|
assert_eq!(fake.0.load(Ordering::SeqCst), 3);
|
|
for url in [
|
|
"http://tokens.example.test/token",
|
|
"https://user@tokens.example.test/token",
|
|
"https://tokens.example.test/token#x",
|
|
] {
|
|
assert!(request(url, "r", "c", "s").is_err());
|
|
}
|
|
}
|
|
#[tokio::test]
|
|
async fn expiry_and_failure() {
|
|
struct Expired(AtomicUsize);
|
|
impl Http for Expired {
|
|
async fn send(&self, _: &Request, _: Instant) -> Result<Zeroizing<Vec<u8>>, Error> {
|
|
self.0.fetch_add(1, Ordering::SeqCst);
|
|
Ok(Zeroizing::new(
|
|
br#"{"access_token":"SYNTHETIC","token_type":"Bearer","expires_in":1}"#.to_vec(),
|
|
))
|
|
}
|
|
}
|
|
struct Failed;
|
|
impl Http for Failed {
|
|
async fn send(&self, _: &Request, _: Instant) -> Result<Zeroizing<Vec<u8>>, Error> {
|
|
Err(Error)
|
|
}
|
|
}
|
|
let req = request("https://tokens.example.test/token", "r", "c", "s").unwrap();
|
|
let mut cache = Cache::default();
|
|
let http = Expired(AtomicUsize::new(0));
|
|
let deadline = Instant::now() + Duration::from_secs(1);
|
|
cache.refresh("id", 1, &req, &http, deadline).await.unwrap();
|
|
cache.refresh("id", 1, &req, &http, deadline).await.unwrap();
|
|
assert_eq!(http.0.load(Ordering::SeqCst), 2);
|
|
assert!(
|
|
cache
|
|
.refresh("id", 2, &req, &Failed, deadline)
|
|
.await
|
|
.is_err()
|
|
);
|
|
cache.refresh("id", 2, &req, &http, deadline).await.unwrap();
|
|
assert_eq!(http.0.load(Ordering::SeqCst), 3);
|
|
}
|
|
|
|
#[test]
|
|
fn validation() {
|
|
for data in [
|
|
br#"{"error":"invalid_grant","secret":"DO NOT ECHO"}"#.as_slice(),
|
|
br#"{"access_token":"","token_type":"Bearer","expires_in":3600}"#,
|
|
br#"{"access_token":"x","token_type":"MAC","expires_in":3600}"#,
|
|
br#"{"access_token":"x","token_type":"Bearer","expires_in":0}"#,
|
|
br#"{"access_token":"x\r\ny","token_type":"Bearer","expires_in":3600}"#,
|
|
] {
|
|
let e = decode(data).err().unwrap();
|
|
assert!(!e.to_string().contains("DO NOT ECHO"));
|
|
}
|
|
assert!(
|
|
decode(br#"{"access_token":"x","token_type":"Bearer","expires_in":18446744073709551615}"#)
|
|
.is_ok()
|
|
);
|
|
}
|