aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/provider/async.rs117
-rw-r--r--src/provider/blocking.rs88
2 files changed, 205 insertions, 0 deletions
diff --git a/src/provider/async.rs b/src/provider/async.rs
index 5b4bf89..06e1d1d 100644
--- a/src/provider/async.rs
+++ b/src/provider/async.rs
@@ -255,3 +255,120 @@ impl Clone for AsyncFactoryProvider
}
}
}
+
+#[cfg(test)]
+mod tests
+{
+ use std::error::Error;
+
+ use super::*;
+ use crate::test_utils::{mocks, subjects_async};
+
+ #[tokio::test]
+ async fn async_transient_type_provider_works() -> Result<(), Box<dyn Error>>
+ {
+ let transient_type_provider = AsyncTransientTypeProvider::<
+ subjects_async::UserManager,
+ mocks::async_di_container::MockAsyncDIContainer,
+ >::new();
+
+ let di_container = mocks::async_di_container::MockAsyncDIContainer::new();
+
+ assert!(
+ matches!(
+ transient_type_provider
+ .provide(&Arc::new(di_container), vec![])
+ .await?,
+ AsyncProvidable::Transient(_)
+ ),
+ "The provided type is not transient"
+ );
+
+ Ok(())
+ }
+
+ #[tokio::test]
+ async fn async_singleton_provider_works() -> Result<(), Box<dyn Error>>
+ {
+ let singleton_provider = AsyncSingletonProvider::<
+ subjects_async::UserManager,
+ mocks::async_di_container::MockAsyncDIContainer,
+ >::new(ThreadsafeSingletonPtr::new(
+ subjects_async::UserManager {},
+ ));
+
+ let di_container = mocks::async_di_container::MockAsyncDIContainer::new();
+
+ assert!(
+ matches!(
+ singleton_provider
+ .provide(&Arc::new(di_container), vec![])
+ .await?,
+ AsyncProvidable::Singleton(_)
+ ),
+ "The provided type is not a singleton"
+ );
+
+ Ok(())
+ }
+
+ #[tokio::test]
+ #[cfg(feature = "factory")]
+ async fn async_factory_provider_works() -> Result<(), Box<dyn Error>>
+ {
+ use crate::interfaces::any_factory::AnyThreadsafeFactory;
+ use crate::ptr::ThreadsafeFactoryPtr;
+
+ struct FooFactory;
+
+ impl AnyThreadsafeFactory for FooFactory {}
+
+ let factory_provider = AsyncFactoryProvider::new(
+ ThreadsafeFactoryPtr::new(FooFactory),
+ AsyncFactoryVariant::Normal,
+ );
+
+ let default_factory_provider = AsyncFactoryProvider::new(
+ ThreadsafeFactoryPtr::new(FooFactory),
+ AsyncFactoryVariant::Default,
+ );
+
+ let async_default_factory_provider = AsyncFactoryProvider::new(
+ ThreadsafeFactoryPtr::new(FooFactory),
+ AsyncFactoryVariant::AsyncDefault,
+ );
+
+ let di_container =
+ Arc::new(mocks::async_di_container::MockAsyncDIContainer::new());
+
+ assert!(
+ matches!(
+ factory_provider.provide(&di_container, vec![]).await?,
+ AsyncProvidable::Factory(_)
+ ),
+ "The provided type is not a factory"
+ );
+
+ assert!(
+ matches!(
+ default_factory_provider
+ .provide(&di_container, vec![])
+ .await?,
+ AsyncProvidable::DefaultFactory(_)
+ ),
+ "The provided type is not a default factory"
+ );
+
+ assert!(
+ matches!(
+ async_default_factory_provider
+ .provide(&di_container, vec![])
+ .await?,
+ AsyncProvidable::AsyncDefaultFactory(_)
+ ),
+ "The provided type is not a async default factory"
+ );
+
+ Ok(())
+ }
+}
diff --git a/src/provider/blocking.rs b/src/provider/blocking.rs
index b768b55..435a8e5 100644
--- a/src/provider/blocking.rs
+++ b/src/provider/blocking.rs
@@ -154,3 +154,91 @@ where
})
}
}
+
+#[cfg(test)]
+mod tests
+{
+ use std::error::Error;
+
+ use super::*;
+ use crate::test_utils::{mocks, subjects};
+
+ #[test]
+ fn transient_type_provider_works() -> Result<(), Box<dyn Error>>
+ {
+ let transient_type_provider = TransientTypeProvider::<
+ subjects::UserManager,
+ mocks::blocking_di_container::MockDIContainer,
+ >::new();
+
+ let di_container = mocks::blocking_di_container::MockDIContainer::new();
+
+ assert!(
+ matches!(
+ transient_type_provider.provide(&Rc::new(di_container), vec![])?,
+ Providable::Transient(_)
+ ),
+ "The provided type is not transient"
+ );
+
+ Ok(())
+ }
+
+ #[test]
+ fn singleton_provider_works() -> Result<(), Box<dyn Error>>
+ {
+ let singleton_provider =
+ SingletonProvider::<
+ subjects::UserManager,
+ mocks::blocking_di_container::MockDIContainer,
+ >::new(SingletonPtr::new(subjects::UserManager {}));
+
+ let di_container = mocks::blocking_di_container::MockDIContainer::new();
+
+ assert!(
+ matches!(
+ singleton_provider.provide(&Rc::new(di_container), vec![])?,
+ Providable::Singleton(_)
+ ),
+ "The provided type is not a singleton"
+ );
+
+ Ok(())
+ }
+
+ #[test]
+ #[cfg(feature = "factory")]
+ fn factory_provider_works() -> Result<(), Box<dyn Error>>
+ {
+ use crate::interfaces::any_factory::AnyFactory;
+ use crate::ptr::FactoryPtr;
+
+ struct FooFactory;
+
+ impl AnyFactory for FooFactory {}
+
+ let factory_provider = FactoryProvider::new(FactoryPtr::new(FooFactory), false);
+ let default_factory_provider =
+ FactoryProvider::new(FactoryPtr::new(FooFactory), true);
+
+ let di_container = Rc::new(mocks::blocking_di_container::MockDIContainer::new());
+
+ assert!(
+ matches!(
+ factory_provider.provide(&di_container, vec![])?,
+ Providable::Factory(_)
+ ),
+ "The provided type is not a factory"
+ );
+
+ assert!(
+ matches!(
+ default_factory_provider.provide(&di_container, vec![])?,
+ Providable::DefaultFactory(_)
+ ),
+ "The provided type is not a default factory"
+ );
+
+ Ok(())
+ }
+}