Fix conditional parameter validation

- Determine effective test parameter value considering defaults
- Find matching 'when' clause including default_when
- Validate only parameters from the matching 'when' branch
- Ensure parameters from other branches are not present
- Handle missing test parameter values with defaults properly

Fixed 4 test cases for gx_conditional_boolean, gx_conditional_boolean_checked, and gx_conditional_select.

Author: jmchilton

client/src/components/Tool/structured.ts

@@ -694,27 +694,76 @@ function validateParameter(inputKey: string, inputValue: any, parameterModel: To
         }
     } else if (isGxConditional(parameterModel)) {
         const testParameter = parameterModel.test_parameter;
-        let testParameterEffectivelyOptional = testParameter.optional;
-        if (!testParameterEffectivelyOptional && "value" in testParameter && testParameter.value !== null) {
-            testParameterEffectivelyOptional = true;
-        }
         const whens = parameterModel.whens;
         const testParameterName = testParameter.name;
-        const testParameterValue = inputValue[testParameterName];
-        // validateParameter(testParameterName, testParameterValue, testParameter);
-        let testParameterValueFoundInWhen = false;
+        let testParameterValue = inputValue[testParameterName];
+        
+        // Determine effective test parameter value (use default if missing)
+        if (testParameterValue === undefined || testParameterValue === null) {
+            // Use default value from test parameter if available
+            if ("value" in testParameter && testParameter.value !== null && testParameter.value !== undefined) {
+                testParameterValue = testParameter.value;
+            }
+        }
+        
+        // Find matching "when" clause
+        let matchingWhen = null;
+        if (testParameterValue === null || testParameterValue === undefined) {
+            // Look for default_when
+            for (const when of whens) {
+                if (when.is_default_when) {
+                    matchingWhen = when;
+                    break;
+                }
+            }
+        } else {
+            // Look for matching discriminator
+            for (const when of whens) {
+                if (when.discriminator === testParameterValue) {
+                    matchingWhen = when;
+                    break;
+                }
+            }
+            // If no match found and test parameter has default, try default_when
+            if (!matchingWhen && "value" in testParameter && testParameter.value !== null) {
         for (const when of whens) {
-            const inputKey = when.discriminator;
-            if (inputKey === testParameterValue) {
-                testParameterValueFoundInWhen = true;
-                const whenParameters = when.parameters.concat([testParameter]);
+                    if (when.is_default_when) {
+                        matchingWhen = when;
+                        break;
+                    }
+                }
+            }
+        }
+        
+        if (matchingWhen) {
+            // Validate only parameters from the matching "when" branch
+            const whenParameters = matchingWhen.parameters.concat([testParameter]);
                 const whenResults = validateParameters(inputValue, whenParameters);
                 extendValidationResults(results, whenResults);
-                break;
+            
+            // Check for parameters from other branches that shouldn't be present
+            const allowedParameterNames = new Set<string>();
+            whenParameters.forEach(p => allowedParameterNames.add(p.name));
+            for (const when of whens) {
+                if (when !== matchingWhen) {
+                    for (const param of when.parameters) {
+                        if (param.name in inputValue && !allowedParameterNames.has(param.name)) {
+                            results.push(`Parameter ${param.name} is not valid for the selected conditional branch.`);
+                        }
+                    }
+                }
+            }
+        } else {
+            // No matching when clause found
+            if (testParameterValue === null || testParameterValue === undefined) {
+                // Check if test parameter is optional or has default
+                const hasDefault = "value" in testParameter && testParameter.value !== null && testParameter.value !== undefined;
+                if (!testParameter.optional && !hasDefault) {
+                    results.push(`Non optional conditional test parameter ${testParameterName} was not found in inputs.`);
+                }
+            } else {
+                results.push(`Invalid conditional test value (${testParameterValue}) for parameter (${testParameterName}).`);
             }
-        }
-        if (!testParameterValueFoundInWhen && !testParameterEffectivelyOptional) {
-            results.push(`Non optional conditional test parameter ${testParameterName} was not found in inputs.`);
         }
     } else if (isGxSection(parameterModel)) {
         // Section parameters contain nested child parameters