added unit tests

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

Author: seun-ja

crates/factor-variables/tests/factor_test.rs

@@ -35,6 +35,114 @@ async fn provider_works() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn validate_variable_existence_successful() -> anyhow::Result<()> {
+    let factors = TestFactors {
+        variables: VariablesFactor::default(),
+    };
+    let providers = vec![Box::new(MockProvider) as _];
+    let runtime_config = TestFactorsRuntimeConfig {
+        variables: Some(RuntimeConfig { providers }),
+    };
+    let env = TestEnvironment::new(factors)
+        .extend_manifest(toml! {
+            [variables]
+            foo = { required = true }
+
+            [component.test-component]
+            source = "does-not-exist.wasm"
+        })
+        .runtime_config(runtime_config)?;
+
+    let state = env.build_instance_state().await?;
+    let resolver = state.variables.expression_resolver();
+
+    resolver.validate_variable_existence().await?;
+
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn validate_variable_existence_successful_with_default_value() -> anyhow::Result<()> {
+    let factors = TestFactors {
+        variables: VariablesFactor::default(),
+    };
+    let providers = vec![Box::new(MockProvider) as _];
+    let runtime_config = TestFactorsRuntimeConfig {
+        variables: Some(RuntimeConfig { providers }),
+    };
+    let env = TestEnvironment::new(factors)
+        .extend_manifest(toml! {
+            [variables]
+            baz = { default = "var" }
+
+            [component.test-component]
+            source = "does-not-exist.wasm"
+        })
+        .runtime_config(runtime_config)?;
+
+    let state = env.build_instance_state().await?;
+    let resolver = state.variables.expression_resolver();
+
+    resolver.validate_variable_existence().await?;
+
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn validate_variable_existence_successful_with_dynamic_provider() -> anyhow::Result<()> {
+    let factors = TestFactors {
+        variables: VariablesFactor::default(),
+    };
+    let providers = vec![Box::new(DynamicMockProvider) as _];
+    let runtime_config = TestFactorsRuntimeConfig {
+        variables: Some(RuntimeConfig { providers }),
+    };
+    let env = TestEnvironment::new(factors)
+        .extend_manifest(toml! {
+            [variables]
+            baz = { required = true }
+
+            [component.test-component]
+            source = "does-not-exist.wasm"
+        })
+        .runtime_config(runtime_config)?;
+
+    let state = env.build_instance_state().await?;
+    let resolver = state.variables.expression_resolver();
+
+    resolver.validate_variable_existence().await?;
+
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn validate_variable_existence_fails() -> anyhow::Result<()> {
+    let factors = TestFactors {
+        variables: VariablesFactor::default(),
+    };
+    let providers = vec![Box::new(MockProvider) as _];
+    let runtime_config = TestFactorsRuntimeConfig {
+        variables: Some(RuntimeConfig { providers }),
+    };
+    let env = TestEnvironment::new(factors)
+        .extend_manifest(toml! {
+            [variables]
+            baz = { required = true }
+
+            [component.test-component]
+            source = "does-not-exist.wasm"
+        })
+        .runtime_config(runtime_config)?;
+
+    let state = env.build_instance_state().await?;
+    let resolver = state.variables.expression_resolver();
+
+    assert!(resolver.validate_variable_existence().await.is_err());
+
+    Ok(())
+}
+
 #[derive(Debug)]
 struct MockProvider;
 
@@ -47,6 +155,20 @@ impl Provider for MockProvider {
         }
     }
 
+    fn kind(&self) -> ProviderVariableKind {
+        ProviderVariableKind::Static
+    }
+}
+
+#[derive(Debug)]
+struct DynamicMockProvider;
+
+#[spin_world::async_trait]
+impl Provider for DynamicMockProvider {
+    async fn get(&self, _key: &Key) -> anyhow::Result<Option<String>> {
+        Ok(None)
+    }
+
     fn kind(&self) -> ProviderVariableKind {
         ProviderVariableKind::Dynamic
     }

crates/trigger/src/cli/variable.rs

@@ -11,9 +11,9 @@ impl<F: RuntimeFactors, U> ExecutorHooks<F, U> for VariablesValidatorHook {
         &self,
         configured_app: &spin_factors::ConfiguredApp<F>,
     ) -> anyhow::Result<()> {
-        let variables_factor = configured_app.app_state::<VariablesFactor>()?;
+        let variables_factor_app_state = configured_app.app_state::<VariablesFactor>()?;
 
-        let expression_resolver = variables_factor.expression_resolver();
+        let expression_resolver = variables_factor_app_state.expression_resolver();
         expression_resolver.validate_variable_existence().await?;
 
         Ok(())