chore: Add k8s snapshot test, rework test utils

Author: Techassi

Cargo.lock

@@ -46,4 +46,5 @@ schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 serde_yaml.workspace = true
+snafu.workspace = true
 trybuild.workspace = true

crates/stackable-versioned-macros/Cargo.toml

@@ -0,0 +1,21 @@
+#[versioned(
+    version(name = "v1alpha1"),
+    version(name = "v1beta1"),
+    version(name = "v1"),
+    k8s(
+        group = "stackable.tech",
+        singular = "foo",
+        plural = "foos",
+        namespaced,
+    )
+)]
+// ---
+#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
+pub struct FooSpec {
+    #[versioned(
+        added(since = "v1beta1"),
+        changed(since = "v1", from_name = "bah", from_type = "u16")
+    )]
+    bar: usize,
+    baz: bool,
+}

crates/stackable-versioned-macros/fixtures/inputs/k8s/basic.rs

@@ -506,15 +506,24 @@ mod test {
 
     #[test]
     fn default_snapshots() {
-        let settings = test_utils::set_snapshot_path();
-        let _guard = settings.bind_to_scope();
+        let _settings_guard = test_utils::set_snapshot_path().bind_to_scope();
 
         glob!("../fixtures/inputs/default", "*.rs", |path| {
-            let input = std::fs::read_to_string(path).unwrap();
-            let (attrs, input) = test_utils::prepare_from_string(input);
-            let expanded = versioned_impl(attrs, input).to_string();
-            let formatted = prettyplease::unparse(&syn::parse_file(&expanded).unwrap());
+            let formatted = test_utils::expand_from_file(path)
+                .inspect_err(|err| eprintln!("{err}"))
+                .unwrap();
+            assert_snapshot!(formatted);
+        });
+    }
+
+    #[test]
+    fn k8s_snapshots() {
+        let _settings_guard = test_utils::set_snapshot_path().bind_to_scope();
 
+        glob!("../fixtures/inputs/k8s", "*.rs", |path| {
+            let formatted = test_utils::expand_from_file(path)
+                .inspect_err(|err| eprintln!("{err}"))
+                .unwrap();
             assert_snapshot!(formatted);
         });
     }

crates/stackable-versioned-macros/fixtures/snapshots/stackable_versioned_macros__test__k8s_snapshots.snap

@@ -1,34 +1,70 @@
-use std::{path::PathBuf, str::FromStr, sync::LazyLock};
+use std::{
+    path::{Path, PathBuf},
+    str::FromStr,
+    sync::LazyLock,
+};
 
 use insta::Settings;
 use proc_macro2::TokenStream;
 use regex::Regex;
+use snafu::{OptionExt, ResultExt, Snafu};
 use syn::DeriveInput;
 
+use crate::versioned_impl;
+
 const DELIMITER: &str = "// ---\n";
 
 static REGEX: LazyLock<Regex> = LazyLock::new(|| {
     Regex::new(r"#\[versioned\(\n(?P<args>[[:ascii:]]+)\n\)\]")
         .expect("failed to compile versioned regex")
 });
 
-pub(crate) fn prepare_from_string(input: String) -> (TokenStream, DeriveInput) {
-    let (attrs, input) = input
-        .split_once(DELIMITER)
-        .expect("failed to find delimiter");
+#[derive(Debug, Snafu)]
+pub(crate) enum Error {
+    #[snafu(display("failed to read input file"))]
+    ReadFile { source: std::io::Error },
+
+    #[snafu(display("failed to find delimiter"))]
+    MissingDelimiter,
+
+    #[snafu(display("failed to find regex match group"))]
+    MissingRegexMatchGroup,
+
+    #[snafu(display("failed to parse token stream"))]
+    ParseTokenStream { source: proc_macro2::LexError },
+
+    #[snafu(display("failed to parse derive input"))]
+    ParseDeriveInput { source: syn::Error },
+
+    #[snafu(display("failed to parse output file"))]
+    ParseOutputFile { source: syn::Error },
+}
+
+pub(crate) fn expand_from_file(path: &Path) -> Result<String, Error> {
+    let input = std::fs::read_to_string(path).context(ReadFileSnafu)?;
+    let (attrs, input) = prepare_from_string(input)?;
+
+    let expanded = versioned_impl(attrs, input).to_string();
+    let parsed = syn::parse_file(&expanded).context(ParseOutputFileSnafu)?;
+
+    Ok(prettyplease::unparse(&parsed))
+}
+
+fn prepare_from_string(input: String) -> Result<(TokenStream, DeriveInput), Error> {
+    let (attrs, input) = input.split_once(DELIMITER).context(MissingDelimiterSnafu)?;
 
     let attrs = REGEX
         .captures(attrs)
         .unwrap()
         .name("args")
-        .expect("args match group must be available")
+        .context(MissingRegexMatchGroupSnafu)?
         .as_str();
 
-    let attrs = TokenStream::from_str(attrs).expect("attrs must parse as a token stream");
-    let input = TokenStream::from_str(input).expect("input mus parse as a token stream");
-    let input = syn::parse2(input).expect("input must parse as derive input");
+    let attrs = TokenStream::from_str(attrs).context(ParseTokenStreamSnafu)?;
+    let input = TokenStream::from_str(input).context(ParseTokenStreamSnafu)?;
+    let input = syn::parse2(input).context(ParseDeriveInputSnafu)?;
 
-    (attrs, input)
+    Ok((attrs, input))
 }
 
 pub(crate) fn set_snapshot_path() -> Settings {

crates/stackable-versioned-macros/src/lib.rs

@@ -32,10 +32,6 @@ fn default_macros() {
 #[cfg(feature = "k8s")]
 #[allow(dead_code)]
 mod k8s {
-    // mod pass {
-    //     mod crd;
-    // }
-
     // mod fail {
     //     mod crd;
     // }
@@ -45,6 +41,5 @@ mod k8s {
 #[test]
 fn k8s_macros() {
     let t = trybuild::TestCases::new();
-    t.pass("tests/k8s/pass/*.rs");
     t.compile_fail("tests/k8s/fail/*.rs");
 }