Ensure ConfigurationContext respects global strictExport setting

Author: somiljain2006

plugin/src/main/java/io/jenkins/plugins/casc/Attribute.java

@@ -273,7 +273,7 @@ public CNode describe(Owner instance, ConfigurationContext context) throws Confi
                 return seq;
             }
             return _describe(c, context, o, shouldBeMasked);
-        } catch (Exception | AssertionError e) {
+        } catch (Exception | /* Jenkins.getDescriptorOrDie */ AssertionError e) {
             if (context.isStrictExport()) {
                 if (e instanceof ConfiguratorException) {
                     throw (ConfiguratorException) e;

plugin/src/main/java/io/jenkins/plugins/casc/CasCGlobalConfig.java

@@ -15,6 +15,7 @@
 public class CasCGlobalConfig extends GlobalConfiguration {
 
     private String configurationPath;
+    private boolean strictExport = false;
 
     @DataBoundConstructor
     public CasCGlobalConfig(String configurationPath) {
@@ -40,6 +41,15 @@ public void setConfigurationPath(String configurationPath) {
         this.configurationPath = configurationPath;
     }
 
+    public boolean isStrictExport() {
+        return strictExport;
+    }
+
+    @DataBoundSetter
+    public void setStrictExport(boolean strictExport) {
+        this.strictExport = strictExport;
+    }
+
     @Override
     public boolean configure(StaplerRequest2 req, JSONObject json) throws FormException {
         req.bindJSON(this, json);

plugin/src/main/java/io/jenkins/plugins/casc/ConfigurationAsCode.java

@@ -595,17 +595,11 @@ public void doReference(StaplerRequest2 req, StaplerResponse2 res) throws Except
 
     @Restricted(NoExternalUse.class)
     public void export(OutputStream out) throws Exception {
-        export(out, false);
-    }
-
-    @Restricted(NoExternalUse.class)
-    public void export(OutputStream out, boolean strict) throws Exception {
         final List<NodeTuple> tuples = new ArrayList<>();
 
         final ConfigurationContext context = new ConfigurationContext(registry);
-        context.setStrictExport(strict);
-        for (RootElementConfigurator root : RootElementConfigurator.all()) {
-            final CNode config = root.describe(root.getTargetComponent(context), context);
+        for (RootElementConfigurator<?> root : RootElementConfigurator.all()) {
+            final CNode config = describeRoot(root, context);
             final Node valueNode = toYaml(config);
             if (valueNode == null) {
                 continue;
@@ -621,6 +615,11 @@ public void export(OutputStream out, boolean strict) throws Exception {
         }
     }
 
+    private <T> CNode describeRoot(RootElementConfigurator<T> root, ConfigurationContext context) throws Exception {
+        T component = root.getTargetComponent(context);
+        return root.describe(component, context);
+    }
+
     @Restricted(NoExternalUse.class) // for testing only
     public static void serializeYamlNode(Node root, Writer writer) throws IOException {
         DumperOptions options = new DumperOptions();

plugin/src/main/java/io/jenkins/plugins/casc/ConfigurationContext.java

@@ -7,6 +7,8 @@
 import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.List;
+import jenkins.model.GlobalConfiguration;
+import jenkins.model.Jenkins;
 import org.apache.commons.lang3.math.NumberUtils;
 import org.kohsuke.stapler.Stapler;
 
@@ -60,6 +62,13 @@ public ConfigurationContext(ConfiguratorRegistry registry, String mergeStrategy)
         this.mergeStrategy = mergeStrategy != null
                 ? mergeStrategy
                 : getPropertyOrEnv(CASC_MERGE_STRATEGY_ENV, CASC_MERGE_STRATEGY_PROPERTY);
+        Jenkins jenkins = Jenkins.getInstanceOrNull();
+        if (jenkins != null) {
+            CasCGlobalConfig config = GlobalConfiguration.all().get(CasCGlobalConfig.class);
+            if (config != null) {
+                this.strictExport = config.isStrictExport();
+            }
+        }
     }
 
     private String getPropertyOrEnv(String envKey, String proKey) {

plugin/src/test/java/io/jenkins/plugins/casc/AttributeTest.java

@@ -1,5 +1,8 @@
 package io.jenkins.plugins.casc;
 
+import static java.lang.reflect.Proxy.newProxyInstance;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsString;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -267,9 +270,10 @@ public <T> Configurator<T> lookup(Type type) {
         CNode node = attr.describe(dummyInstance, context);
 
         assertInstanceOf(Scalar.class, node, "Should return a Scalar node on failure in non-strict mode");
-        assertTrue(
-                ((Scalar) node).getValue().contains("FAILED TO EXPORT"),
-                "Scalar should contain the fallback failure message");
+        assertThat(
+                "Scalar should contain the fallback failure message",
+                ((Scalar) node).getValue(),
+                containsString("FAILED TO EXPORT"));
 
         context.setStrictExport(true);
         ConfiguratorException exception = assertThrows(
@@ -279,8 +283,62 @@ public <T> Configurator<T> lookup(Type type) {
                 },
                 "Should completely abort and throw ConfiguratorException in strict mode");
 
-        assertTrue(
-                exception.getMessage().contains("No configurator found"),
-                "Exception message should accurately reflect the missing configurator");
+        assertThat(exception.getMessage(), containsString("No configurator found"));
+    }
+
+    @Test
+    @SuppressWarnings({"ExtractMethodRecommender", "unchecked"})
+    void describeWrapsGenericExceptionsInStrictMode() throws Exception {
+
+        Configurator<?> dummyConfigurator = (Configurator<?>) newProxyInstance(
+                Configurator.class.getClassLoader(), new Class<?>[] {Configurator.class}, (proxy, method, args) -> {
+                    String methodName = method.getName();
+                    return switch (methodName) {
+                        case "equals" -> args != null && args.length == 1 && proxy == args[0];
+                        case "hashCode" -> System.identityHashCode(proxy);
+                        case "toString" -> "DummyConfiguratorProxy";
+                        case "describe" ->
+                            throw new IllegalStateException("Intentional generic failure from dummy configurator");
+                        default -> null;
+                    };
+                });
+
+        ConfiguratorRegistry dummyRegistry = new ConfiguratorRegistry() {
+            @Override
+            public RootElementConfigurator<?> lookupRootElement(String name) {
+                return null;
+            }
+
+            @Override
+            @NonNull
+            public <T> Configurator<T> lookupOrFail(Type type) {
+                return (Configurator<T>) dummyConfigurator;
+            }
+
+            @Override
+            public <T> Configurator<T> lookup(Type type) {
+                return (Configurator<T>) dummyConfigurator;
+            }
+        };
+
+        ConfigurationContext context = new ConfigurationContext(dummyRegistry);
+        context.setStrictExport(true);
+
+        Attribute<NonSecretField, String> attr = new Attribute<>("passwordPath", String.class);
+        NonSecretField dummyInstance = new NonSecretField("my-dummy-path");
+
+        ConfiguratorException exception = assertThrows(
+                ConfiguratorException.class,
+                () -> {
+                    attr.describe(dummyInstance, context);
+                },
+                "Should wrap generic exception into a ConfiguratorException in strict mode");
+
+        assertThat(
+                exception.getMessage(),
+                containsString("Failed to export io.jenkins.plugins.casc.AttributeTest$NonSecretField#passwordPath"));
+        assertThat(
+                exception.getCause().getMessage(),
+                containsString("Intentional generic failure from dummy configurator"));
     }
 }

plugin/src/test/java/io/jenkins/plugins/casc/ConfigurationAsCodeApiTest.java

@@ -11,6 +11,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
+import jenkins.model.GlobalConfiguration;
 import jenkins.model.Jenkins;
 import org.htmlunit.HttpMethod;
 import org.htmlunit.WebRequest;
@@ -193,9 +194,14 @@ public void testDoReplace_ValidSource() throws Exception {
     public void testExportStrictMode_SuccessOnCleanJenkins() throws Exception {
         configureAdminSecurity();
 
+        CasCGlobalConfig config = GlobalConfiguration.all().get(CasCGlobalConfig.class);
+        if (config != null) {
+            config.setStrictExport(true);
+        }
+
         ByteArrayOutputStream out = new ByteArrayOutputStream();
 
-        ConfigurationAsCode.get().export(out, true);
+        ConfigurationAsCode.get().export(out);
 
         String exportedYaml = out.toString(StandardCharsets.UTF_8);
 

test-harness/src/main/java/io/jenkins/plugins/casc/misc/JenkinsConfiguredRule.java

@@ -1,8 +1,10 @@
 package io.jenkins.plugins.casc.misc;
 
+import io.jenkins.plugins.casc.CasCGlobalConfig;
 import io.jenkins.plugins.casc.ConfigurationAsCode;
 import java.io.ByteArrayOutputStream;
 import java.nio.charset.StandardCharsets;
+import jenkins.model.GlobalConfiguration;
 import org.jvnet.hudson.test.JenkinsRule;
 
 public class JenkinsConfiguredRule extends JenkinsRule {
@@ -17,7 +19,20 @@ public class JenkinsConfiguredRule extends JenkinsRule {
     public String exportToString(boolean strict) throws Exception {
         final ByteArrayOutputStream out = new ByteArrayOutputStream();
 
-        ConfigurationAsCode.get().export(out, strict);
+        CasCGlobalConfig config = GlobalConfiguration.all().get(CasCGlobalConfig.class);
+        boolean originalStrict = config != null && config.isStrictExport();
+
+        if (config != null) {
+            config.setStrictExport(strict);
+        }
+
+        try {
+            ConfigurationAsCode.get().export(out);
+        } finally {
+            if (config != null) {
+                config.setStrictExport(originalStrict);
+            }
+        }
 
         return out.toString(StandardCharsets.UTF_8);
     }