fix(schemas): support integer versions in unit test versions.include/exclude

IncludeExclude used StringOrArrayOfStrings which has no Number variant,
causing deserialization failures when YAML integers (e.g. `- 2`) appeared
in unit_test versions.include or versions.exclude lists.

Adds VersionIdentifier (number-or-string) and VersionOrVersionList types
scoped to IncludeExclude, leaving StringOrArrayOfStrings unchanged.

Co-Authored-By: Claude Sonnet 4.6 <[email protected]>

Author: grahamwetzler

crates/dbt-schemas/src/schemas/common.rs

@@ -25,7 +25,8 @@ use crate::schemas::semantic_layer::semantic_manifest::SemanticLayerElementConfi
 
 use super::relations::base::ComponentName;
 use super::serde::{
-    StringOrArrayOfStrings, bool_or_string_bool, bool_or_string_bool_default, i64_or_string_i64,
+    StringOrArrayOfStrings, VersionOrVersionList, bool_or_string_bool,
+    bool_or_string_bool_default, i64_or_string_i64,
 };
 
 /// Indicates where schema metadata originates from.
@@ -863,8 +864,8 @@ impl DbtChecksum {
 #[skip_serializing_none]
 #[derive(Deserialize, Serialize, Debug, Clone, DbtSchema)]
 pub struct IncludeExclude {
-    pub exclude: Option<StringOrArrayOfStrings>,
-    pub include: Option<StringOrArrayOfStrings>,
+    pub exclude: Option<VersionOrVersionList>,
+    pub include: Option<VersionOrVersionList>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone, DbtSchema, Default)]

crates/dbt-schemas/src/schemas/serde.rs

@@ -433,6 +433,45 @@ pub enum StringOrMap {
     MapValue(HashMap<String, YmlValue>),
 }
 
+// Number before String so YAML integers (e.g. `2`) match Number, not fail on String
+#[derive(Serialize, UntaggedEnumDeserialize, Debug, Clone, DbtSchema)]
+#[serde(untagged)]
+pub enum VersionIdentifier {
+    Number(f64),
+    String(String),
+}
+
+impl VersionIdentifier {
+    pub fn to_version_string(&self) -> String {
+        match self {
+            VersionIdentifier::Number(n) => {
+                if n.fract() == 0.0 {
+                    (*n as i64).to_string()
+                } else {
+                    n.to_string()
+                }
+            }
+            VersionIdentifier::String(s) => s.clone(),
+        }
+    }
+}
+
+#[derive(Serialize, UntaggedEnumDeserialize, Debug, Clone, DbtSchema)]
+#[serde(untagged)]
+pub enum VersionOrVersionList {
+    Single(VersionIdentifier),
+    List(Vec<VersionIdentifier>),
+}
+
+impl VersionOrVersionList {
+    pub fn to_strings(&self) -> Vec<String> {
+        match self {
+            VersionOrVersionList::Single(v) => vec![v.to_version_string()],
+            VersionOrVersionList::List(vs) => vs.iter().map(|v| v.to_version_string()).collect(),
+        }
+    }
+}
+
 #[derive(Serialize, UntaggedEnumDeserialize, Debug, Clone, DbtSchema)]
 #[serde(untagged)]
 pub enum StringOrArrayOfStrings {
@@ -991,6 +1030,7 @@ impl std::fmt::Display for FloatOrString {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::schemas::common::IncludeExclude;
     use dbt_common::serde_utils::Omissible;
 
     #[derive(Serialize, Deserialize)]
@@ -999,6 +1039,30 @@ mod tests {
         grants: OmissibleGrantConfig,
     }
 
+    #[test]
+    fn test_include_exclude_parses_integer_version() {
+        let yaml = "include:\n  - 2\n  - 3\n";
+        let ie: IncludeExclude = dbt_yaml::from_str(yaml).unwrap();
+        let strings = ie.include.unwrap().to_strings();
+        assert_eq!(strings, vec!["2", "3"]);
+    }
+
+    #[test]
+    fn test_include_exclude_parses_string_version() {
+        let yaml = "include:\n  - \"2\"\n  - \"3\"\n";
+        let ie: IncludeExclude = dbt_yaml::from_str(yaml).unwrap();
+        let strings = ie.include.unwrap().to_strings();
+        assert_eq!(strings, vec!["2", "3"]);
+    }
+
+    #[test]
+    fn test_include_exclude_parses_single_integer_version() {
+        let yaml = "include: 2\n";
+        let ie: IncludeExclude = dbt_yaml::from_str(yaml).unwrap();
+        let strings = ie.include.unwrap().to_strings();
+        assert_eq!(strings, vec!["2"]);
+    }
+
     #[test]
     fn test_grant_config_normalizes_string_to_array() {
         let mut grants: IndexMap<String, StringOrArrayOfStrings> = IndexMap::new();