[test] add derive macro tests

derive-macros/src/lib.rs

@@ -45,10 +45,10 @@ pub fn derive_schema(input: proc_macro::TokenStream) -> proc_macro::TokenStream
     let schema_fields = gen_schema_fields(&input.data);
     let output = quote! {
         #[automatically_derived]
-        impl crate::actions::schemas::ToDataType for #struct_ident {
-            fn to_data_type() -> crate::schema::DataType {
-                use crate::actions::schemas::{ToDataType, GetStructField, GetNullableContainerStructField};
-                crate::schema::DataType::struct_type([
+        impl delta_kernel::actions::schemas::ToDataType for #struct_ident {
+            fn to_data_type() -> delta_kernel::schema::DataType {
+                use delta_kernel::actions::schemas::{ToDataType, GetStructField, GetNullableContainerStructField};
+                delta_kernel::schema::DataType::struct_type([
                     #schema_fields
                 ])
             }
@@ -124,9 +124,9 @@ fn gen_schema_fields(data: &Data) -> TokenStream {
                             ).to_compile_error()
                         }
                     }
-                    quote_spanned! { field.span() => #(#type_path_quoted),* get_nullable_container_struct_field(stringify!(#name))}
+                    quote_spanned! { field.span() => #(#type_path_quoted)* get_nullable_container_struct_field(stringify!(#name))}
                 } else {
-                    quote_spanned! { field.span() => #(#type_path_quoted),* get_struct_field(stringify!(#name))}
+                    quote_spanned! { field.span() => #(#type_path_quoted)* get_struct_field(stringify!(#name))}
                 }
             }
             _ => Error::new(field.span(), format!("Can't handle type: {:?}", field.ty)).to_compile_error()

justfile

@@ -4,7 +4,8 @@ default:
 # run tests
 test:
     cargo test --features default-engine
-
+    cargo test --doc --features developer-visibility
+
 # lint codebase
 lint:
     cargo clippy --tests --features default-engine

kernel/src/actions/mod.rs

@@ -24,7 +24,11 @@ use serde::{Deserialize, Serialize};
 pub mod deletion_vector;
 pub mod set_transaction;
 
+#[cfg(feature = "developer-visibility")]
+pub mod schemas;
+#[cfg(not(feature = "developer-visibility"))]
 pub(crate) mod schemas;
+
 #[cfg(feature = "developer-visibility")]
 pub mod visitors;
 #[cfg(not(feature = "developer-visibility"))]

kernel/src/actions/schemas.rs

@@ -4,6 +4,7 @@ use std::collections::{HashMap, HashSet};
 
 use crate::schema::{ArrayType, DataType, MapType, StructField};
 
+#[cfg_attr(feature = "developer-visibility", visibility::make(pub))]
 pub(crate) trait ToDataType {
     fn to_data_type() -> DataType;
 }
@@ -62,10 +63,12 @@ impl<K: ToDataType, V: ToDataType> ToNullableContainerType for HashMap<K, V> {
     }
 }
 
+#[cfg_attr(feature = "developer-visibility", visibility::make(pub))]
 pub(crate) trait GetStructField {
     fn get_struct_field(name: impl Into<String>) -> StructField;
 }
 
+#[cfg_attr(feature = "developer-visibility", visibility::make(pub))]
 pub(crate) trait GetNullableContainerStructField {
     fn get_nullable_container_struct_field(name: impl Into<String>) -> StructField;
 }

kernel/src/lib.rs

@@ -50,7 +50,12 @@
     rust_2021_compatibility
 )]
 
+/// This allows the derive macro to refer to types in this crate using full crate name, instead of using `crate::`,
+/// which seem to be the only way to to test the macro generated code and macro compile failures
+extern crate self as delta_kernel;
+
 use std::any::Any;
+
 use std::sync::Arc;
 use std::{cmp::Ordering, ops::Range};
 
@@ -416,3 +421,47 @@ pub trait Engine: AsAny {
     /// Get the connector provided [`ParquetHandler`].
     fn get_parquet_handler(&self) -> Arc<dyn ParquetHandler>;
 }
+
+#[cfg(doctest)]
+mod doc_tests {
+
+    /// ```
+    /// # use delta_kernel_derive::Schema;
+    /// #[derive(Schema)]
+    /// pub struct WithFields {
+    ///     some_name: String,
+    /// }
+    /// ```
+    #[cfg(doctest)]
+    pub struct MacroTestStructWithField;
+
+    /// ```compile_fail
+    /// # use delta_kernel_derive::Schema;
+    /// #[derive(Schema)]
+    /// pub struct NoFields;
+    /// ```
+    #[cfg(doctest)]
+    pub struct MacroTestStructWithoutField;
+
+    /// ```compile_fail
+    /// # use delta_kernel_derive::Schema;
+    /// #[derive(Schema)]
+    /// pub struct WithInvalidAttributeTarget {
+    ///     #[drop_null_container_values]
+    ///     some_name: String,
+    /// }
+    /// ```
+    #[cfg(doctest)]
+    pub struct MacroTestStructWithInvalidAttributeTarget;
+
+    /// ```compile_fail
+    /// # use delta_kernel_derive::Schema;
+    /// # use syn::Token;
+    /// #[derive(Schema)]
+    /// pub struct WithInvalidFieldType {
+    ///     token: Token![struct],
+    /// }
+    /// ```
+    #[cfg(doctest)]
+    pub struct MacroTestStructWithInvalidFieldType;
+}