improved test: making it maintainable

Signed-off-by: Aminu Oluwaseun Joshua <[email protected]>

Author: seun-ja

crates/expressions/tests/validation_test.rs

@@ -6,36 +6,39 @@ use spin_locked_app::Variable;
 #[derive(Default)]
 struct ResolverTester {
     providers: Vec<Box<dyn Provider>>,
+    variables: HashMap<String, Variable>,
 }
 
 impl ResolverTester {
     fn new() -> Self {
         Self::default()
     }
 
-    fn with_provider(mut self, provider: Box<dyn Provider>) -> Self {
-        self.providers.push(provider);
+    fn with_dynamic_provider(mut self) -> Self {
+        self.providers.push(Box::new(DynamicProvider));
         self
     }
 
-    fn make_resolver(
-        self,
-        key: Option<&str>,
-        default: Option<&str>,
-    ) -> anyhow::Result<ProviderResolver> {
-        let mut provider_resolver = ProviderResolver::new(
-            key.map(|k| {
-                vec![(
-                    k.to_string(),
-                    Variable {
-                        description: None,
-                        default: default.map(ToString::to_string),
-                        secret: false,
-                    },
-                )]
-            })
-            .unwrap_or_default(),
-        )?;
+    fn with_static_provider(mut self, key: &str, value: Option<&str>) -> Self {
+        self.providers
+            .push(Box::new(StaticProvider::with_variable(key, value)));
+        self
+    }
+
+    fn with_variable(mut self, (key, default): (&str, Option<&str>)) -> Self {
+        self.variables.insert(
+            key.to_string(),
+            Variable {
+                description: None,
+                default: default.map(ToString::to_string),
+                secret: false,
+            },
+        );
+        self
+    }
+
+    fn make_resolver(self) -> anyhow::Result<ProviderResolver> {
+        let mut provider_resolver = ProviderResolver::new(self.variables)?;
 
         for provider in self.providers {
             provider_resolver.add_provider(provider as _);
@@ -48,8 +51,8 @@ impl ResolverTester {
 #[tokio::test(flavor = "multi_thread")]
 async fn single_static_provider_with_no_variable_provided_is_valid() -> anyhow::Result<()> {
     let resolver = ResolverTester::new()
-        .with_provider(Box::new(StaticMockProvider::with_variables("foo", "bar")))
-        .make_resolver(None, None)?;
+        .with_static_provider("foo", Some("bar"))
+        .make_resolver()?;
 
     resolver.validate_variables().await?;
 
@@ -59,8 +62,9 @@ async fn single_static_provider_with_no_variable_provided_is_valid() -> anyhow::
 #[tokio::test(flavor = "multi_thread")]
 async fn if_single_static_provider_has_variable_value_validation_succeeds() -> anyhow::Result<()> {
     let resolver = ResolverTester::new()
-        .with_provider(Box::new(StaticMockProvider::with_variables("foo", "bar")))
-        .make_resolver(Some("foo"), None)?;
+        .with_static_provider("foo", Some("bar"))
+        .with_variable(("foo", None))
+        .make_resolver()?;
 
     resolver.validate_variables().await?;
 
@@ -71,8 +75,9 @@ async fn if_single_static_provider_has_variable_value_validation_succeeds() -> a
 async fn if_there_is_a_single_static_provider_and_it_does_not_contain_a_required_variable_then_validation_fails(
 ) -> anyhow::Result<()> {
     let resolver = ResolverTester::new()
-        .with_provider(Box::new(StaticMockProvider::with_variables("foo", "bar")))
-        .make_resolver(Some("baz"), None)?;
+        .with_static_provider("foo", Some("bar"))
+        .with_variable(("bar", None))
+        .make_resolver()?;
 
     assert!(resolver.validate_variables().await.is_err());
 
@@ -83,8 +88,9 @@ async fn if_there_is_a_single_static_provider_and_it_does_not_contain_a_required
 async fn if_there_is_a_dynamic_provider_then_validation_succeeds_even_if_a_static_provider_without_the_variable_is_in_play(
 ) -> anyhow::Result<()> {
     let resolver = ResolverTester::new()
-        .with_provider(Box::new(DynamicMockProvider))
-        .make_resolver(Some("baz"), None)?;
+        .with_dynamic_provider()
+        .with_variable(("bar", None))
+        .make_resolver()?;
 
     resolver.validate_variables().await?;
 
@@ -95,9 +101,10 @@ async fn if_there_is_a_dynamic_provider_then_validation_succeeds_even_if_a_stati
 async fn if_there_is_a_dynamic_provider_and_a_static_provider_then_validation_succeeds_even_if_a_static_provider_without_the_variable_is_in_play(
 ) -> anyhow::Result<()> {
     let resolver = ResolverTester::new()
-        .with_provider(Box::new(DynamicMockProvider))
-        .with_provider(Box::new(StaticMockProvider::with_variables("foo", "bar")))
-        .make_resolver(Some("baz"), None)?;
+        .with_dynamic_provider()
+        .with_static_provider("foo", Some("bar"))
+        .with_variable(("baz", None))
+        .make_resolver()?;
 
     resolver.validate_variables().await?;
 
@@ -108,9 +115,10 @@ async fn if_there_is_a_dynamic_provider_and_a_static_provider_then_validation_su
 async fn if_there_is_a_dynamic_provider_and_a_static_provider_then_validation_succeeds_even_if_a_static_provider_with_the_variable_is_in_play(
 ) -> anyhow::Result<()> {
     let resolver = ResolverTester::new()
-        .with_provider(Box::new(DynamicMockProvider))
-        .with_provider(Box::new(StaticMockProvider::with_variables("foo", "bar")))
-        .make_resolver(Some("baz"), Some("coo"))?;
+        .with_dynamic_provider()
+        .with_static_provider("foo", Some("bar"))
+        .with_variable(("baz", Some("coo")))
+        .make_resolver()?;
 
     resolver.validate_variables().await?;
 
@@ -120,9 +128,10 @@ async fn if_there_is_a_dynamic_provider_and_a_static_provider_then_validation_su
 #[tokio::test(flavor = "multi_thread")]
 async fn if_there_is_two_static_providers_where_one_has_data_is_valid() -> anyhow::Result<()> {
     let resolver = ResolverTester::new()
-        .with_provider(Box::new(StaticMockProvider::with_variables("foo", "bar")))
-        .with_provider(Box::new(StaticMockProvider::with_variables("baz", "hay")))
-        .make_resolver(Some("foo"), None)?;
+        .with_static_provider("foo", Some("bar"))
+        .with_static_provider("baz", Some("hay"))
+        .with_variable(("foo", None))
+        .make_resolver()?;
 
     resolver.validate_variables().await?;
 
@@ -133,9 +142,10 @@ async fn if_there_is_two_static_providers_where_one_has_data_is_valid() -> anyho
 async fn if_there_is_two_static_providers_where_first_provider_does_not_have_data_while_second_provider_does(
 ) -> anyhow::Result<()> {
     let resolver = ResolverTester::new()
-        .with_provider(Box::new(StaticMockProvider::with_variables("foo", "bar")))
-        .with_provider(Box::new(StaticMockProvider::with_variables("baz", "hay")))
-        .make_resolver(Some("baz"), None)?;
+        .with_static_provider("foo", Some("bar"))
+        .with_static_provider("baz", Some("hay"))
+        .with_variable(("baz", None))
+        .make_resolver()?;
 
     resolver.validate_variables().await?;
 
@@ -145,30 +155,31 @@ async fn if_there_is_two_static_providers_where_first_provider_does_not_have_dat
 #[tokio::test(flavor = "multi_thread")]
 async fn if_there_is_two_static_providers_neither_having_data_is_invalid() -> anyhow::Result<()> {
     let resolver = ResolverTester::new()
-        .with_provider(Box::new(StaticMockProvider::with_variables("foo", "bar")))
-        .with_provider(Box::new(StaticMockProvider::with_variables("baz", "hay")))
-        .make_resolver(Some("hello"), None)?;
+        .with_static_provider("foo", Some("bar"))
+        .with_static_provider("baz", Some("hay"))
+        .with_variable(("hello", None))
+        .make_resolver()?;
 
     assert!(resolver.validate_variables().await.is_err());
 
     Ok(())
 }
 
 #[derive(Debug)]
-struct StaticMockProvider {
+struct StaticProvider {
     variables: HashMap<String, Option<String>>,
 }
 
-impl StaticMockProvider {
-    fn with_variables(key: &str, value: &str) -> Self {
+impl StaticProvider {
+    fn with_variable(key: &str, value: Option<&str>) -> Self {
         Self {
-            variables: HashMap::from([(key.into(), Some(value.into()))]),
+            variables: HashMap::from([(key.into(), value.map(|v| v.into()))]),
         }
     }
 }
 
 #[spin_world::async_trait]
-impl Provider for StaticMockProvider {
+impl Provider for StaticProvider {
     async fn get(&self, key: &Key) -> anyhow::Result<Option<String>> {
         Ok(self.variables.get(key.as_str()).cloned().flatten())
     }
@@ -179,12 +190,12 @@ impl Provider for StaticMockProvider {
 }
 
 #[derive(Debug)]
-struct DynamicMockProvider;
+struct DynamicProvider;
 
 #[spin_world::async_trait]
-impl Provider for DynamicMockProvider {
+impl Provider for DynamicProvider {
     async fn get(&self, _key: &Key) -> anyhow::Result<Option<String>> {
-        Ok(None)
+        panic!("validation should never call get for a dynamic provider")
     }
 
     fn kind(&self) -> ProviderVariableKind {