test(dpp): co-locate validation_result aggregator tests with their version modules

The previous commit landed v0/v1-specific tests in
`validation_result/mod.rs::tests` alongside facade dispatch tests, which
duplicated coverage (the facade tests already exercise v0/v1 behavior
through dispatch). Move per-version behavior tests into their own
modules:

  flatten/v0/mod.rs::tests       — 3 tests for legacy Some(empty_vec)
  flatten/v1/mod.rs::tests       — 5 tests for canonical None-on-empty
  merge_many/v0/mod.rs::tests    — 3 tests for legacy Some(empty_vec)
  merge_many/v1/mod.rs::tests    — 4 tests for canonical None-on-empty
  mod.rs::tests                  — facade dispatch tests + struct/method tests

Same 61 tests, same coverage, no duplication.

Author: shumkov

packages/rs-dpp/src/validation/validation_result/flatten/v0/mod.rs

@@ -34,3 +34,42 @@ where
     });
     ValidationResult::new_with_data_and_errors(aggregate_data, aggregate_errors)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn merges_data_and_errors() {
+        let r1: ValidationResult<Vec<i32>, String> = ValidationResult::new_with_data(vec![1, 2]);
+        let r2: ValidationResult<Vec<i32>, String> =
+            ValidationResult::new_with_data_and_errors(vec![3], vec!["e".to_string()]);
+        let r3: ValidationResult<Vec<i32>, String> =
+            ValidationResult::new_with_error("e2".to_string());
+
+        let flat = flatten_v0(vec![r1, r2, r3]);
+        assert_eq!(flat.data, Some(vec![1, 2, 3]));
+        assert_eq!(flat.errors, vec!["e".to_string(), "e2".to_string()]);
+    }
+
+    #[test]
+    fn empty_input_returns_some_empty() {
+        // Legacy v11 behavior: Some(empty_vec), not None.
+        let flat: ValidationResult<Vec<i32>, String> =
+            flatten_v0(std::iter::empty::<ValidationResult<Vec<i32>, String>>());
+        assert_eq!(flat.data, Some(vec![]));
+        assert!(flat.errors.is_empty());
+    }
+
+    #[test]
+    fn all_inputs_no_data_returns_some_empty() {
+        let r1: ValidationResult<Vec<i32>, String> =
+            ValidationResult::new_with_error("e1".to_string());
+        let r2: ValidationResult<Vec<i32>, String> =
+            ValidationResult::new_with_error("e2".to_string());
+
+        let flat = flatten_v0(vec![r1, r2]);
+        assert_eq!(flat.data, Some(vec![]));
+        assert_eq!(flat.errors, vec!["e1".to_string(), "e2".to_string()]);
+    }
+}

packages/rs-dpp/src/validation/validation_result/flatten/v1/mod.rs

@@ -39,3 +39,64 @@ where
         ValidationResult::new_with_data_and_errors(aggregate_data, aggregate_errors)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn merges_non_empty_data() {
+        let r1: ValidationResult<Vec<i32>, String> = ValidationResult::new_with_data(vec![1, 2]);
+        let r2: ValidationResult<Vec<i32>, String> =
+            ValidationResult::new_with_data_and_errors(vec![3], vec!["e".to_string()]);
+        let r3: ValidationResult<Vec<i32>, String> =
+            ValidationResult::new_with_error("e2".to_string());
+
+        let flat = flatten_v1(vec![r1, r2, r3]);
+        assert_eq!(flat.data, Some(vec![1, 2, 3]));
+        assert_eq!(flat.errors, vec!["e".to_string(), "e2".to_string()]);
+    }
+
+    #[test]
+    fn empty_input_returns_none() {
+        let flat: ValidationResult<Vec<i32>, String> =
+            flatten_v1(std::iter::empty::<ValidationResult<Vec<i32>, String>>());
+        assert_eq!(flat.data, None);
+        assert!(flat.errors.is_empty());
+    }
+
+    #[test]
+    fn all_inputs_no_data_returns_none() {
+        // Downstream code (process_validation_result_v0:241) keys on
+        // data.is_none() to route to UnpaidConsensusError.
+        let r1: ValidationResult<Vec<i32>, String> =
+            ValidationResult::new_with_error("e1".to_string());
+        let r2: ValidationResult<Vec<i32>, String> =
+            ValidationResult::new_with_error("e2".to_string());
+
+        let flat = flatten_v1(vec![r1, r2]);
+        assert!(flat.data.is_none());
+        assert_eq!(flat.errors, vec!["e1".to_string(), "e2".to_string()]);
+    }
+
+    #[test]
+    fn some_empty_some_non_empty_returns_some() {
+        let r1: ValidationResult<Vec<i32>, String> = ValidationResult::new_with_data(vec![]);
+        let r2: ValidationResult<Vec<i32>, String> = ValidationResult::new_with_data(vec![42]);
+
+        let flat = flatten_v1(vec![r1, r2]);
+        assert_eq!(flat.data, Some(vec![42]));
+        assert!(flat.errors.is_empty());
+    }
+
+    #[test]
+    fn all_some_empty_returns_none() {
+        // All inputs had data:Some(empty_vec). The aggregate Vec is empty → data:None.
+        let r1: ValidationResult<Vec<i32>, String> = ValidationResult::new_with_data(vec![]);
+        let r2: ValidationResult<Vec<i32>, String> = ValidationResult::new_with_data(vec![]);
+
+        let flat = flatten_v1(vec![r1, r2]);
+        assert!(flat.data.is_none());
+        assert!(flat.errors.is_empty());
+    }
+}

packages/rs-dpp/src/validation/validation_result/merge_many/v0/mod.rs

@@ -34,3 +34,38 @@ where
     });
     ValidationResult::new_with_data_and_errors(aggregate_data, aggregate_errors)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn collects_data_into_vec() {
+        let r1: ValidationResult<i32, String> = ValidationResult::new_with_data(1);
+        let r2: ValidationResult<i32, String> = ValidationResult::new_with_data(2);
+        let r3: ValidationResult<i32, String> = ValidationResult::new_with_error("e".to_string());
+
+        let merged = merge_many_v0(vec![r1, r2, r3]);
+        assert_eq!(merged.data, Some(vec![1, 2]));
+        assert_eq!(merged.errors, vec!["e".to_string()]);
+    }
+
+    #[test]
+    fn empty_input_returns_some_empty() {
+        // Legacy v11 behavior: Some(empty_vec), not None.
+        let merged: ValidationResult<Vec<i32>, String> =
+            merge_many_v0(std::iter::empty::<ValidationResult<i32, String>>());
+        assert_eq!(merged.data, Some(vec![]));
+        assert!(merged.errors.is_empty());
+    }
+
+    #[test]
+    fn all_inputs_no_data_returns_some_empty() {
+        let r1: ValidationResult<i32, String> = ValidationResult::new_with_error("e1".to_string());
+        let r2: ValidationResult<i32, String> = ValidationResult::new_with_error("e2".to_string());
+
+        let merged = merge_many_v0(vec![r1, r2]);
+        assert_eq!(merged.data, Some(vec![]));
+        assert_eq!(merged.errors, vec!["e1".to_string(), "e2".to_string()]);
+    }
+}

packages/rs-dpp/src/validation/validation_result/merge_many/v1/mod.rs

@@ -38,3 +38,47 @@ where
         ValidationResult::new_with_data_and_errors(aggregate_data, aggregate_errors)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn collects_non_empty_data() {
+        let r1: ValidationResult<i32, String> = ValidationResult::new_with_data(1);
+        let r2: ValidationResult<i32, String> = ValidationResult::new_with_data(2);
+        let r3: ValidationResult<i32, String> = ValidationResult::new_with_error("e".to_string());
+
+        let merged = merge_many_v1(vec![r1, r2, r3]);
+        assert_eq!(merged.data, Some(vec![1, 2]));
+        assert_eq!(merged.errors, vec!["e".to_string()]);
+    }
+
+    #[test]
+    fn empty_input_returns_none() {
+        let merged: ValidationResult<Vec<i32>, String> =
+            merge_many_v1(std::iter::empty::<ValidationResult<i32, String>>());
+        assert!(merged.data.is_none());
+        assert!(merged.errors.is_empty());
+    }
+
+    #[test]
+    fn all_inputs_no_data_returns_none() {
+        let r1: ValidationResult<i32, String> = ValidationResult::new_with_error("e1".to_string());
+        let r2: ValidationResult<i32, String> = ValidationResult::new_with_error("e2".to_string());
+
+        let merged = merge_many_v1(vec![r1, r2]);
+        assert!(merged.data.is_none());
+        assert_eq!(merged.errors, vec!["e1".to_string(), "e2".to_string()]);
+    }
+
+    #[test]
+    fn some_data_returns_some() {
+        let r1: ValidationResult<i32, String> = ValidationResult::new_with_error("e1".to_string());
+        let r2: ValidationResult<i32, String> = ValidationResult::new_with_data(7);
+
+        let merged = merge_many_v1(vec![r1, r2]);
+        assert_eq!(merged.data, Some(vec![7]));
+        assert_eq!(merged.errors, vec!["e1".to_string()]);
+    }
+}

packages/rs-dpp/src/validation/validation_result/mod.rs

@@ -570,182 +570,11 @@ mod tests {
         assert_eq!(result.errors, vec!["bad".to_string()]);
     }
 
-    // -- flatten::v1::flatten_v1() (canonical, honors data.is_none() ⇔ no work done) --
-
-    #[test]
-    fn test_v1_flatten_merges_non_empty_data() {
-        let r1: ValidationResult<Vec<i32>, String> = ValidationResult::new_with_data(vec![1, 2]);
-        let r2: ValidationResult<Vec<i32>, String> =
-            ValidationResult::new_with_data_and_errors(vec![3], vec!["e".to_string()]);
-        let r3: ValidationResult<Vec<i32>, String> =
-            ValidationResult::new_with_error("e2".to_string());
-
-        let flat = flatten::v1::flatten_v1(vec![r1, r2, r3]);
-        assert_eq!(flat.data, Some(vec![1, 2, 3]));
-        assert_eq!(flat.errors, vec!["e".to_string(), "e2".to_string()]);
-    }
-
-    #[test]
-    fn test_v1_flatten_empty_input_returns_none_data() {
-        let flat: ValidationResult<Vec<i32>, String> =
-            flatten::v1::flatten_v1(std::iter::empty::<ValidationResult<Vec<i32>, String>>());
-        assert_eq!(flat.data, None);
-        assert!(flat.errors.is_empty());
-    }
-
-    #[test]
-    fn test_v1_flatten_all_inputs_no_data_returns_none() {
-        // When no input contributed data, return data:None — not
-        // Some(empty_vec). Downstream code
-        // (process_validation_result_v0:241) keys on data.is_none() to
-        // route to UnpaidConsensusError.
-        let r1: ValidationResult<Vec<i32>, String> =
-            ValidationResult::new_with_error("e1".to_string());
-        let r2: ValidationResult<Vec<i32>, String> =
-            ValidationResult::new_with_error("e2".to_string());
-
-        let flat = flatten::v1::flatten_v1(vec![r1, r2]);
-        assert!(flat.data.is_none());
-        assert_eq!(flat.errors, vec!["e1".to_string(), "e2".to_string()]);
-    }
-
-    #[test]
-    fn test_v1_flatten_some_empty_some_non_empty_returns_some() {
-        // Mixed input: one had data:Some(empty_vec), another had
-        // Some(non_empty). The aggregate is non-empty → data:Some(...).
-        let r1: ValidationResult<Vec<i32>, String> = ValidationResult::new_with_data(vec![]);
-        let r2: ValidationResult<Vec<i32>, String> = ValidationResult::new_with_data(vec![42]);
-
-        let flat = flatten::v1::flatten_v1(vec![r1, r2]);
-        assert_eq!(flat.data, Some(vec![42]));
-        assert!(flat.errors.is_empty());
-    }
-
-    #[test]
-    fn test_v1_flatten_all_some_empty_returns_none() {
-        // All inputs had data:Some(empty_vec). The aggregate Vec is
-        // empty → data:None.
-        let r1: ValidationResult<Vec<i32>, String> = ValidationResult::new_with_data(vec![]);
-        let r2: ValidationResult<Vec<i32>, String> = ValidationResult::new_with_data(vec![]);
-
-        let flat = flatten::v1::flatten_v1(vec![r1, r2]);
-        assert!(flat.data.is_none());
-        assert!(flat.errors.is_empty());
-    }
-
-    // -- merge_many::v1::merge_many_v1() (canonical) --
-
-    #[test]
-    fn test_v1_merge_many_collects_non_empty_data() {
-        let r1: ValidationResult<i32, String> = ValidationResult::new_with_data(1);
-        let r2: ValidationResult<i32, String> = ValidationResult::new_with_data(2);
-        let r3: ValidationResult<i32, String> = ValidationResult::new_with_error("e".to_string());
-
-        let merged = merge_many::v1::merge_many_v1(vec![r1, r2, r3]);
-        assert_eq!(merged.data, Some(vec![1, 2]));
-        assert_eq!(merged.errors, vec!["e".to_string()]);
-    }
-
-    #[test]
-    fn test_v1_merge_many_empty_input_returns_none_data() {
-        let merged: ValidationResult<Vec<i32>, String> =
-            merge_many::v1::merge_many_v1(std::iter::empty::<ValidationResult<i32, String>>());
-        assert!(merged.data.is_none());
-        assert!(merged.errors.is_empty());
-    }
-
-    #[test]
-    fn test_v1_merge_many_all_inputs_no_data_returns_none() {
-        let r1: ValidationResult<i32, String> = ValidationResult::new_with_error("e1".to_string());
-        let r2: ValidationResult<i32, String> = ValidationResult::new_with_error("e2".to_string());
-
-        let merged = merge_many::v1::merge_many_v1(vec![r1, r2]);
-        assert!(merged.data.is_none());
-        assert_eq!(merged.errors, vec!["e1".to_string(), "e2".to_string()]);
-    }
-
-    #[test]
-    fn test_v1_merge_many_some_data_returns_some() {
-        let r1: ValidationResult<i32, String> = ValidationResult::new_with_error("e1".to_string());
-        let r2: ValidationResult<i32, String> = ValidationResult::new_with_data(7);
-
-        let merged = merge_many::v1::merge_many_v1(vec![r1, r2]);
-        assert_eq!(merged.data, Some(vec![7]));
-        assert_eq!(merged.errors, vec!["e1".to_string()]);
-    }
-
-    // -- flatten::v0::flatten_v0() / merge_many::v0::merge_many_v0() --
-    // These pin the legacy `Some(empty_vec)`-on-no-data behavior preserved
-    // for PROTOCOL_VERSION_11 and below.
-
-    #[test]
-    fn test_v0_flatten_merges_data_and_errors() {
-        let r1: ValidationResult<Vec<i32>, String> = ValidationResult::new_with_data(vec![1, 2]);
-        let r2: ValidationResult<Vec<i32>, String> =
-            ValidationResult::new_with_data_and_errors(vec![3], vec!["e".to_string()]);
-        let r3: ValidationResult<Vec<i32>, String> =
-            ValidationResult::new_with_error("e2".to_string());
-
-        let flat = flatten::v0::flatten_v0(vec![r1, r2, r3]);
-        assert_eq!(flat.data, Some(vec![1, 2, 3]));
-        assert_eq!(flat.errors, vec!["e".to_string(), "e2".to_string()]);
-    }
-
-    #[test]
-    fn test_v0_flatten_empty_input_returns_some_empty() {
-        let flat: ValidationResult<Vec<i32>, String> =
-            flatten::v0::flatten_v0(std::iter::empty::<ValidationResult<Vec<i32>, String>>());
-        // Legacy v11 behavior: Some(empty_vec), not None.
-        assert_eq!(flat.data, Some(vec![]));
-        assert!(flat.errors.is_empty());
-    }
-
-    #[test]
-    fn test_v0_flatten_all_inputs_no_data_returns_some_empty() {
-        let r1: ValidationResult<Vec<i32>, String> =
-            ValidationResult::new_with_error("e1".to_string());
-        let r2: ValidationResult<Vec<i32>, String> =
-            ValidationResult::new_with_error("e2".to_string());
-
-        let flat = flatten::v0::flatten_v0(vec![r1, r2]);
-        assert_eq!(flat.data, Some(vec![]));
-        assert_eq!(flat.errors, vec!["e1".to_string(), "e2".to_string()]);
-    }
-
-    #[test]
-    fn test_v0_merge_many_collects_data_into_vec() {
-        let r1: ValidationResult<i32, String> = ValidationResult::new_with_data(1);
-        let r2: ValidationResult<i32, String> = ValidationResult::new_with_data(2);
-        let r3: ValidationResult<i32, String> = ValidationResult::new_with_error("e".to_string());
-
-        let merged = merge_many::v0::merge_many_v0(vec![r1, r2, r3]);
-        assert_eq!(merged.data, Some(vec![1, 2]));
-        assert_eq!(merged.errors, vec!["e".to_string()]);
-    }
-
-    #[test]
-    fn test_v0_merge_many_empty_input_returns_some_empty() {
-        let merged: ValidationResult<Vec<i32>, String> =
-            merge_many::v0::merge_many_v0(std::iter::empty::<ValidationResult<i32, String>>());
-        // Legacy v11 behavior: Some(empty_vec), not None.
-        assert_eq!(merged.data, Some(vec![]));
-        assert!(merged.errors.is_empty());
-    }
-
-    #[test]
-    fn test_v0_merge_many_all_inputs_no_data_returns_some_empty() {
-        let r1: ValidationResult<i32, String> = ValidationResult::new_with_error("e1".to_string());
-        let r2: ValidationResult<i32, String> = ValidationResult::new_with_error("e2".to_string());
-
-        let merged = merge_many::v0::merge_many_v0(vec![r1, r2]);
-        assert_eq!(merged.data, Some(vec![]));
-        assert_eq!(merged.errors, vec!["e1".to_string(), "e2".to_string()]);
-    }
-
     // -- facade dispatch (flatten / merge_many take platform_version) --
     //
     // These verify the version field on PlatformVersion correctly steers the
-    // facade to v0 vs v1 semantics.
+    // facade to v0 vs v1 semantics. Per-version behavior is tested in each
+    // version's own module (e.g. `flatten::v1::tests`).
 
     #[test]
     fn test_facade_flatten_v0_returns_some_empty_on_no_data() {