test in app

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

Author: seun-ja

Cargo.lock

@@ -13,5 +13,6 @@ spin-serde = { path = "../serde" }
 thiserror = { workspace = true }
 
 [dev-dependencies]
+spin-manifest = { path = "../manifest" }
 toml = { workspace = true }
-tokio = { workspace = true }
+tokio = { workspace = true }

crates/app/Cargo.toml

@@ -341,3 +341,90 @@ pub fn retain_components(
 ) -> Result<LockedApp> {
     App::new("unused", locked).retain_components(components, validators)
 }
+
+#[cfg(test)]
+mod test {
+    use std::collections::HashSet;
+
+    use spin_manifest::schema::v2::{self, ComponentSpec, Trigger};
+
+    use super::*;
+
+    fn locked_trigger(
+        trigger_type: String,
+        mut trigger: v2::Trigger,
+    ) -> anyhow::Result<LockedTrigger> {
+        fn reference_id(spec: v2::ComponentSpec) -> toml::Value {
+            let v2::ComponentSpec::Reference(id) = spec else {
+                unreachable!("should have already been normalized");
+            };
+            id.as_ref().into()
+        }
+
+        if let Some(id) = trigger.component.map(reference_id) {
+            trigger.config.insert("component".into(), id);
+        }
+
+        Ok(LockedTrigger {
+            id: trigger.id,
+            trigger_type,
+            trigger_config: trigger.config.try_into()?,
+        })
+    }
+
+    pub fn locked_app() -> LockedApp {
+        LockedApp {
+            spin_lock_version: Default::default(),
+            must_understand: Default::default(),
+            metadata: Default::default(),
+            host_requirements: Default::default(),
+            variables: Default::default(),
+            triggers: vec![locked_trigger(
+                "http".to_owned(),
+                Trigger {
+                    id: Default::default(),
+                    component: Some(ComponentSpec::Reference(
+                        "empty".to_string().try_into().unwrap(),
+                    )),
+                    components: Default::default(),
+                    config: Default::default(),
+                },
+            )
+            .unwrap()],
+            components: vec![LockedComponent {
+                id: "empty".to_owned(),
+                metadata: Default::default(),
+                source: LockedComponentSource {
+                    content_type: "application/wasm".to_owned(),
+                    content: locked::ContentRef {
+                        source: Some("does-not-exist.wasm".to_owned()),
+                        inline: None,
+                        digest: None,
+                    },
+                },
+                env: Default::default(),
+                files: Default::default(),
+                config: Default::default(),
+                dependencies: Default::default(),
+                host_requirements: Default::default(),
+            }],
+        }
+    }
+
+    fn does_nothing_validator(_: &App, _: &[&str]) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_retain_components_filtering_for_only_component_works() {
+        let mut locked_app = locked_app();
+        locked_app = retain_components(locked_app, &["empty"], &[&does_nothing_validator]).unwrap();
+        let components = locked_app
+            .components
+            .iter()
+            .map(|c| c.id.to_string())
+            .collect::<HashSet<_>>();
+        assert!(components.contains("empty"));
+        assert!(components.len() == 1);
+    }
+}

crates/app/src/lib.rs

@@ -91,49 +91,3 @@ fn single_file_manifest(
 
     Ok(manifest)
 }
-
-#[cfg(test)]
-mod test {
-    use std::collections::HashSet;
-
-    use spin_app::{retain_components, App};
-
-    use super::*;
-
-    pub async fn build_locked_app(manifest: &toml::Table) -> anyhow::Result<LockedApp> {
-        let toml_str = toml::to_string(manifest).context("failed serializing manifest")?;
-        let dir = tempfile::tempdir().context("failed creating tempdir")?;
-        let path = dir.path().join("spin.toml");
-        std::fs::write(&path, toml_str).context("failed writing manifest")?;
-        from_file(&path, FilesMountStrategy::Direct, None).await
-    }
-
-    fn does_nothing_validator(_: &App, _: &[&str]) -> anyhow::Result<()> {
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn test_retain_components_filtering_for_only_component_works() {
-        let manifest = toml::toml! {
-            spin_manifest_version = 2
-
-            [application]
-            name = "test-app"
-
-            [[trigger.test-trigger]]
-            component = "empty"
-
-            [component.empty]
-            source = "does-not-exist.wasm"
-        };
-        let mut locked_app = build_locked_app(&manifest).await.unwrap();
-        locked_app = retain_components(locked_app, &["empty"], &[&does_nothing_validator]).unwrap();
-        let components = locked_app
-            .components
-            .iter()
-            .map(|c| c.id.to_string())
-            .collect::<HashSet<_>>();
-        assert!(components.contains("empty"));
-        assert!(components.len() == 1);
-    }
-}