Add more test cases.

Author: peterhuene

crates/wac-graph/src/graph.rs

@@ -74,7 +74,7 @@ pub enum Error {
         path: String,
     },
     /// The specified package version is invalid.
-    #[error("package version `{version}` is not a valid: {error}")]
+    #[error("package version `{version}` is not a valid semantic version")]
     InvalidPackageVersion {
         /// The version that was invalid.
         version: String,
@@ -144,7 +144,7 @@ pub enum Error {
         node: NodeId,
     },
     /// The instance does not export an item with the given name.
-    #[error("instance does not have an export `{export}`")]
+    #[error("instance does not have an export named `{export}`")]
     InstanceMissingExport {
         /// The instance node that is missing the export.
         node: NodeId,
@@ -195,7 +195,7 @@ pub enum Error {
     #[error("the node cannot be unmarked from export as it is a type definition")]
     MustExportDefinition,
     /// An implicit import on an instantiation conflicts with an explicit import node.
-    #[error("an instantiation node implicitly imports an item named `{name}`, but it conflicts with an explicit export of the same name")]
+    #[error("an instantiation node implicitly imports an item named `{name}`, but it conflicts with an explicit import node of the same name")]
     ImplicitImportConfig {
         /// The existing import node.
         import: NodeId,
@@ -205,9 +205,12 @@ pub enum Error {
         name: String,
     },
     /// An error occurred while aggregating a type.
-    #[error(transparent)]
+    #[error("failed to aggregate type definition for import `{import}`")]
     TypeAggregationError {
+        /// The name of the import being aggregated.
+        import: String,
         /// The type aggregation error.
+        #[source]
         source: anyhow::Error,
     },
 }
@@ -1436,7 +1439,10 @@ impl<'a, C> CompositionGraphEncoder<'a, C> {
 
                 aggregator = aggregator
                     .aggregate(name, package.types(), *kind, &mut cache)
-                    .map_err(|e| Error::TypeAggregationError { source: e })?;
+                    .map_err(|e| Error::TypeAggregationError {
+                        import: name.clone(),
+                        source: e,
+                    })?;
                 arguments.push((node, name));
             }
         }
@@ -1725,3 +1731,154 @@ impl<'a, C> CompositionGraphEncoder<'a, C> {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use wac_types::{DefinedType, PrimitiveType, Resource, ValueType};
+
+    #[test]
+    fn it_errors_with_type_not_defined() {
+        let mut graph = CompositionGraph::new();
+        // Define the type in a different type collection
+        let mut types = Types::new();
+        let id = types.add_defined_type(DefinedType::Alias(ValueType::Primitive(
+            PrimitiveType::Bool,
+        )));
+        assert!(matches!(
+            graph
+                .add_type_definition_node(
+                    "foo",
+                    Type::Value(ValueType::Defined {
+                        id,
+                        contains_borrow: false
+                    }),
+                    ()
+                )
+                .unwrap_err(),
+            Error::TypeNotDefined { .. }
+        ));
+    }
+
+    #[test]
+    fn it_adds_a_type_definition() {
+        let mut graph = CompositionGraph::new();
+        let id = graph
+            .types_mut()
+            .add_defined_type(DefinedType::Alias(ValueType::Primitive(
+                PrimitiveType::Bool,
+            )));
+        assert!(graph
+            .add_type_definition_node(
+                "foo",
+                Type::Value(ValueType::Defined {
+                    id,
+                    contains_borrow: false
+                }),
+                ()
+            )
+            .is_ok());
+    }
+
+    #[test]
+    fn it_cannot_define_a_resource() {
+        let mut graph = CompositionGraph::new();
+        let id = graph.types_mut().add_resource(Resource {
+            name: "a".to_string(),
+            alias_of: None,
+        });
+        assert!(matches!(
+            graph
+                .add_type_definition_node("foo", Type::Resource(id), ())
+                .unwrap_err(),
+            Error::CannotDefineResource
+        ));
+    }
+
+    #[test]
+    fn it_validates_package_ids() {
+        let mut graph = CompositionGraph::new();
+        let old = graph
+            .register_package(
+                Package::from_bytes("foo:bar", None, wat::parse_str("(component)").unwrap())
+                    .unwrap(),
+            )
+            .unwrap();
+
+        assert_eq!(old.index, 0);
+        assert_eq!(old.generation, 0);
+
+        graph.unregister_package(old).unwrap();
+
+        let new = graph
+            .register_package(
+                Package::from_bytes("foo:bar", None, wat::parse_str("(component)").unwrap())
+                    .unwrap(),
+            )
+            .unwrap();
+
+        assert_eq!(new.index, 0);
+        assert_eq!(new.generation, 1);
+
+        assert!(matches!(
+            graph.add_instantiation_node(old, ()).unwrap_err(),
+            Error::InvalidPackageId,
+        ));
+
+        graph.add_instantiation_node(new, ()).unwrap();
+    }
+
+    #[test]
+    fn it_validates_node_ids() {
+        let mut graph = CompositionGraph::new();
+        let pkg = graph
+            .register_package(
+                Package::from_bytes(
+                    "foo:bar",
+                    None,
+                    wat::parse_str(r#"(component (import "foo" (func)) (export "foo" (func 0)))"#)
+                        .unwrap(),
+                )
+                .unwrap(),
+            )
+            .unwrap();
+
+        let old = graph.add_instantiation_node(pkg, ()).unwrap();
+        assert_eq!(old.index, 0);
+        assert_eq!(old.generation, 0);
+
+        assert!(graph.remove_node(old));
+        let new = graph.add_instantiation_node(pkg, ()).unwrap();
+        assert_eq!(new.index, 0);
+        assert_eq!(new.generation, 1);
+
+        assert!(matches!(
+            graph.add_alias_node(old, "foo", ()).unwrap_err(),
+            Error::InvalidNodeId,
+        ));
+
+        graph.add_alias_node(new, "foo", ()).unwrap();
+    }
+
+    #[test]
+    fn it_must_export_a_type_definition() {
+        let mut graph = CompositionGraph::new();
+        let id = graph
+            .types_mut()
+            .add_defined_type(DefinedType::Alias(ValueType::Primitive(PrimitiveType::S32)));
+        let id = graph
+            .add_type_definition_node(
+                "foo",
+                Type::Value(ValueType::Defined {
+                    id,
+                    contains_borrow: false,
+                }),
+                (),
+            )
+            .unwrap();
+        assert!(matches!(
+            graph.unexport_node(id).unwrap_err(),
+            Error::MustExportDefinition
+        ));
+    }
+}

crates/wac-graph/tests/encoding.rs

@@ -1,12 +1,11 @@
-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{bail, Context, Result};
 use pretty_assertions::assert_eq;
 use semver::Version;
 use serde::Deserialize;
 use std::{
     collections::HashMap,
     fs::{self, File},
     path::{Path, PathBuf},
-    sync::Arc,
 };
 use wac_graph::{CompositionGraph, EncodeOptions, NodeId, PackageId};
 use wac_types::Package;
@@ -116,14 +115,13 @@ impl GraphFile {
                 )
             })?;
 
-            let package =
-                Package::from_bytes(&package.name, package.version.as_ref(), Arc::new(bytes))
-                    .with_context(|| {
-                        format!(
-                            "failed to decode package `{path}` for test case `{test_case}`",
-                            path = path.display()
-                        )
-                    })?;
+            let package = Package::from_bytes(&package.name, package.version.as_ref(), bytes)
+                .with_context(|| {
+                    format!(
+                        "failed to decode package `{path}` for test case `{test_case}`",
+                        path = path.display()
+                    )
+                })?;
 
             let id = graph.register_package(package).with_context(|| {
                 format!(
@@ -199,7 +197,9 @@ impl GraphFile {
                 format!("invalid target node index {target} referenced in argument {index} for test case `{test_case}`", target = argument.target)
             }).copied()?;
 
-            graph.add_argument_edge(source, target, &argument.name)?;
+            graph.add_argument_edge(source, target, &argument.name).with_context(|| {
+                format!("failed to add argument edge from source node {source} to target node {target} referenced in argument {index} for test case `{test_case}`", source = argument.source, target = argument.target)
+            })?;
         }
 
         Ok(())
@@ -255,13 +255,13 @@ fn encoding() -> Result<()> {
             .and_then(|graph| {
                 graph
                     .encode(EncodeOptions::default())
-                    .map_err(|e| anyhow!(e))
+                    .context("failed to encode the graph")
             });
 
         let (output, baseline_path) = if error_path.is_file() {
             match r {
                 Ok(_) => bail!("expected a test failure for test case `{test_case}`"),
-                Err(e) => (format!("{e:#}\n").replace('\\', "/"), &error_path),
+                Err(e) => (format!("{e:?}\n").replace('\\', "/"), &error_path),
             }
         } else {
             let bytes =

crates/wac-graph/tests/graphs/argument-already-satisfied/error.txt

@@ -0,0 +1,4 @@
+failed to add argument edge from source node 1 to target node 2 referenced in argument 1 for test case `argument-already-satisfied`
+
+Caused by:
+    argument `a` has already satisfied

crates/wac-graph/tests/graphs/argument-already-satisfied/foo.wat

@@ -0,0 +1,4 @@
+(component
+  (import "a" (func))
+  (type (export "bar") (func))
+)

crates/wac-graph/tests/graphs/argument-already-satisfied/graph.json

@@ -0,0 +1,36 @@
+{
+    "packages": [
+        {
+            "name": "test:foo",
+            "path": "foo.wat"
+        }
+    ],
+    "nodes": [
+        {
+            "type": "import",
+            "name": "foo",
+            "path": "test:foo/bar"
+        },
+        {
+            "type": "import",
+            "name": "bar",
+            "path": "test:foo/bar"
+        },
+        {
+            "type": "instantiation",
+            "package": 0
+        }
+    ],
+    "arguments": [
+        {
+            "source": 0,
+            "target": 2,
+            "name": "a"
+        },
+        {
+            "source": 1,
+            "target": 2,
+            "name": "a"
+        }
+    ]
+}

crates/wac-graph/tests/graphs/argument-type-mismatch/error.txt

@@ -0,0 +1,5 @@
+failed to add argument edge from source node 0 to target node 1 referenced in argument 0 for test case `argument-type-mismatch`
+
+Caused by:
+    0: mismatched instantiation argument `a`
+    1: expected instance, found function

crates/wac-graph/tests/graphs/argument-type-mismatch/foo.wat

@@ -0,0 +1,4 @@
+(component
+  (import "a" (instance))
+  (type (export "bar") (func))
+)

crates/wac-graph/tests/graphs/argument-type-mismatch/graph.json

@@ -0,0 +1,26 @@
+{
+    "packages": [
+        {
+            "name": "test:foo",
+            "path": "foo.wat"
+        }
+    ],
+    "nodes": [
+        {
+            "type": "import",
+            "name": "foo",
+            "path": "test:foo/bar"
+        },
+        {
+            "type": "instantiation",
+            "package": 0
+        }
+    ],
+    "arguments": [
+        {
+            "source": 0,
+            "target": 1,
+            "name": "a"
+        }
+    ]
+}

crates/wac-graph/tests/graphs/contains-cycle/error.txt

@@ -0,0 +1,4 @@
+failed to encode the graph
+
+Caused by:
+    the graph contains a cycle and cannot be encoded

crates/wac-graph/tests/graphs/contains-cycle/foo.wat

@@ -0,0 +1,3 @@
+(component
+  (import "i" (instance))
+)