Skip recipe validation for imperative recipes in assertRecipesConfigure()

Recipes with optional parameters and a custom validate() requiring at
least one to be present fail assertRecipesConfigure() because they are
loaded with no arguments, leaving all optional params null.

Declarative recipes (from YAML) should still be validated since their
options are explicitly configured. Imperative recipes loaded with no
user-provided arguments are inherently unconfigured and validation
failures are expected.

Add a recipeValidation flag to RecipeSpec (following the existing
serializationValidation pattern) and gate validateAll() on it. In
assertRecipesConfigure(), disable validation for non-DeclarativeRecipe
instances.

Fixes #6840

Author: MBoegers

rewrite-test/src/main/java/org/openrewrite/test/RecipeSpec.java

@@ -92,6 +92,8 @@ public static RecipeSpec defaults() {
 
     boolean serializationValidation = true;
 
+    boolean recipeValidation = true;
+
     PrintOutputCapture.@Nullable MarkerPrinter markerPrinter;
 
     List<UncheckedConsumer<List<SourceFile>>> beforeRecipes = new ArrayList<>();
@@ -258,6 +260,11 @@ public RecipeSpec validateRecipeSerialization(boolean validate) {
         return this;
     }
 
+    public RecipeSpec validateRecipe(boolean validate) {
+        this.recipeValidation = validate;
+        return this;
+    }
+
     public RecipeSpec sourceSet(Function<List<SourceFile>, LargeSourceSet> sourceSetBuilder) {
         this.sourceSet = sourceSetBuilder;
         return this;

rewrite-test/src/main/java/org/openrewrite/test/RewriteTest.java

@@ -19,6 +19,7 @@
 import org.jspecify.annotations.Nullable;
 import org.openrewrite.*;
 import org.openrewrite.config.CompositeRecipe;
+import org.openrewrite.config.DeclarativeRecipe;
 import org.openrewrite.config.Environment;
 import org.openrewrite.config.OptionDescriptor;
 import org.openrewrite.internal.*;
@@ -90,10 +91,21 @@ default void assertRecipesConfigure(String packageName) {
             // scanRuntimeClasspath picks up all recipes in META-INF/rewrite regardless of whether their
             // names start with the package we intend to filter on here
             if (recipe.getName().startsWith(packageName)) {
+                // Imperative recipes are loaded with no user-provided arguments, so all optional
+                // parameters are null. Skip recipe validation for these since custom validate()
+                // methods (e.g. requiring at least one of several optional parameters) would
+                // fail on an unconfigured instance. Declarative recipes have their options
+                // configured from YAML and should still be validated.
+                boolean skipValidation = !(recipe instanceof DeclarativeRecipe);
                 softly.assertThatCode(() -> {
                     try {
                         rewriteRun(
-                                spec -> spec.recipe(recipe),
+                                spec -> {
+                                    spec.recipe(recipe);
+                                    if (skipValidation) {
+                                        spec.validateRecipe(false);
+                                    }
+                                },
                                 new SourceSpecs[0]
                         );
                     } catch (Throwable t) {
@@ -226,11 +238,13 @@ default void rewriteRun(Consumer<RecipeSpec> spec, SourceSpec<?>... sourceSpecs)
         for (SourceSpec<?> s : sourceSpecs) {
             s.customizeExecutionContext.accept(ctx);
         }
-        List<Validated<Object>> validations = new ArrayList<>();
-        recipe.validateAll(ctx, validations);
-        assertThat(validations.stream().filter(Validated::isInvalid))
-                .as("Recipe validation must have no failures")
-                .isEmpty();
+        if (testClassSpec.recipeValidation && testMethodSpec.recipeValidation) {
+            List<Validated<Object>> validations = new ArrayList<>();
+            recipe.validateAll(ctx, validations);
+            assertThat(validations.stream().filter(Validated::isInvalid))
+                    .as("Recipe validation must have no failures")
+                    .isEmpty();
+        }
 
         Map<Parser.Builder, List<SourceSpec<?>>> sourceSpecsByParser = new HashMap<>();
         List<Parser.Builder> methodSpecParsers = testMethodSpec.parsers;