use std::fmt::{self, Debug, Formatter};
use std::future::Future;
use std::marker::PhantomData;
use crate::provider::{future, ProvideCredentials};
#[derive(Copy, Clone)]
pub struct ProvideCredentialsFn<'c, T> {
f: T,
phantom: PhantomData<&'c T>,
}
impl<T> Debug for ProvideCredentialsFn<'_, T> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(f, "ProvideCredentialsFn")
}
}
impl<'c, T, F> ProvideCredentials for ProvideCredentialsFn<'c, T>
where
T: Fn() -> F + Send + Sync + 'c,
F: Future<Output = crate::provider::Result> + Send + 'static,
{
fn provide_credentials<'a>(&'a self) -> future::ProvideCredentials<'a>
where
Self: 'a,
{
future::ProvideCredentials::new((self.f)())
}
}
pub fn provide_credentials_fn<'c, T, F>(f: T) -> ProvideCredentialsFn<'c, T>
where
T: Fn() -> F + Send + Sync + 'c,
F: Future<Output = crate::provider::Result> + Send + 'static,
{
ProvideCredentialsFn {
f,
phantom: Default::default(),
}
}
#[cfg(test)]
mod test {
use crate::credential_fn::provide_credentials_fn;
use crate::{provider::ProvideCredentials, Credentials};
fn assert_send_sync<T: Send + Sync>() {}
#[test]
fn creds_are_send_sync() {
assert_send_sync::<Credentials>()
}
#[tokio::test]
async fn provide_credentials_fn_closure_can_borrow() {
fn check_is_str_ref(_input: &str) {}
async fn test_async_provider(input: String) -> crate::provider::Result {
Ok(Credentials::new(&input, &input, None, None, "test"))
}
let things_to_borrow = vec!["one".to_string(), "two".to_string()];
let mut providers = Vec::new();
for thing in &things_to_borrow {
let provider = provide_credentials_fn(move || {
check_is_str_ref(thing);
test_async_provider(thing.into())
});
providers.push(provider);
}
let (two, one) = (providers.pop().unwrap(), providers.pop().unwrap());
assert_eq!(
"one",
one.provide_credentials().await.unwrap().access_key_id()
);
assert_eq!(
"two",
two.provide_credentials().await.unwrap().access_key_id()
);
}
}