Search for JsonValue in all classes and interfaces (#4770)

T3rm1 · ewaostrowska · web-flow · commit 383a6cf53684 · 2026-04-08T10:01:07.000+02:00
* fix: Include extended classes and implemented interfaces for JsonValue method search

* refactor and add tests

---------

Co-authored-by: Ewa Ostrowska &lt;ewa.ostrowska@smartbear.com&gt;
diff --git a/modules/swagger-core/src/main/java/io/swagger/v3/core/jackson/ModelResolver.java b/modules/swagger-core/src/main/java/io/swagger/v3/core/jackson/ModelResolver.java
@@ -1344,10 +1344,8 @@ protected Schema _createSchemaForEnum(Class<Enum<?>> enumClass) {
         boolean useIndex = _mapper.isEnabled(SerializationFeature.WRITE_ENUMS_USING_INDEX);
         boolean useToString = _mapper.isEnabled(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
 
-        Optional<Method> jsonValueMethod = Arrays.stream(enumClass.getDeclaredMethods())
-                .filter(m -> m.isAnnotationPresent(JsonValue.class))
-                .filter(m -> m.getAnnotation(JsonValue.class).value())
-                .findFirst();
+		Optional<Method> jsonValueMethod = ReflectionUtils.getAnnotatedMethods(enumClass, JsonValue.class).stream()
+				.findFirst();
 
         Optional<Field> jsonValueField = Arrays.stream(enumClass.getDeclaredFields())
                 .filter(f -> f.isAnnotationPresent(JsonValue.class))
diff --git a/modules/swagger-core/src/main/java/io/swagger/v3/core/util/ReflectionUtils.java b/modules/swagger-core/src/main/java/io/swagger/v3/core/util/ReflectionUtils.java
@@ -486,6 +486,29 @@ public static Optional<Object> safeGet(Field field, Object obj) {
         } catch (IllegalAccessException e) {
             return Optional.empty();
         }
+    }
 
+    public static List<Method> getAnnotatedMethods(Class<?> type, Class<? extends Annotation> annotation) {
+        List<Method> methods = new ArrayList<>();
+        for (Class<?> clazz = type; clazz != Object.class; clazz = clazz.getSuperclass()) {
+            collectAnnotatedDeclaredMethods(clazz, annotation, methods);
+        }
+        collectAnnotatedMethodsFromInterfaces(type, annotation, methods);
+        return methods;
+    }
+
+    private static void collectAnnotatedMethodsFromInterfaces(Class<?> type, Class<? extends Annotation> annotation, List<Method> methods) {
+        for (Class<?> iface : type.getInterfaces()) {
+            collectAnnotatedDeclaredMethods(iface, annotation, methods);
+            collectAnnotatedMethodsFromInterfaces(iface, annotation, methods);
+        }
+    }
+
+    private static void collectAnnotatedDeclaredMethods(Class<?> cls, Class<? extends Annotation> annotation, List<Method> methods) {
+        for (Method method : cls.getDeclaredMethods()) {
+            if (method.isAnnotationPresent(annotation)) {
+                methods.add(method);
+            }
+        }
     }
 }
diff --git a/modules/swagger-core/src/test/java/io/swagger/v3/core/converting/EnumPropertyTest.java b/modules/swagger-core/src/test/java/io/swagger/v3/core/converting/EnumPropertyTest.java
@@ -7,6 +7,8 @@
 import io.swagger.v3.core.jackson.ModelResolver;
 import io.swagger.v3.core.jackson.TypeNameResolver;
 import io.swagger.v3.core.matchers.SerializationMatchers;
+import io.swagger.v3.core.oas.models.JacksonValueDefaultMethodEnum;
+import io.swagger.v3.core.oas.models.JacksonValuePrivateEnum;
 import io.swagger.v3.core.oas.models.Model1979;
 import io.swagger.v3.core.oas.models.ModelWithEnumField;
 import io.swagger.v3.core.oas.models.ModelWithEnumProperty;
@@ -20,9 +22,11 @@
 import org.testng.annotations.Test;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Map;
 
 import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertNotNull;
 import static org.testng.Assert.assertTrue;
 
 public class EnumPropertyTest {
@@ -235,5 +239,31 @@ public void testExtractJacksonEnumFields() {
         assertTrue(sixthEnumProperty instanceof StringSchema);
         final StringSchema sixthStringProperty = (StringSchema) sixthEnumProperty;
         assertEquals(sixthStringProperty.getEnum(), Arrays.asList("one", "two", "three"));
+
+        final Schema seventhEnumProperty = (Schema) model.getProperties().get("seventhEnumValue");
+        assertTrue(seventhEnumProperty instanceof IntegerSchema);
+        final IntegerSchema seventhEnumStringProperty = (IntegerSchema) seventhEnumProperty;
+        assertEquals(seventhEnumStringProperty.getEnum(), Collections.singletonList(10));
+
+        final Schema eighthEnumProperty = (Schema) model.getProperties().get("eighthEnumValue");
+        assertTrue(eighthEnumProperty instanceof StringSchema);
+        final StringSchema eighthStringProperty = (StringSchema) eighthEnumProperty;
+        assertEquals(eighthStringProperty.getEnum(), Arrays.asList("alpha", "beta", "gamma"));
+    }
+
+    @Test(description = "it should extract enum values from a private @JsonValue method declared directly on the enum (issue #3998)")
+    public void testJsonValueOnPrivateMethodIsRecognized() {
+        final Schema schema = context.resolve(new AnnotatedType(JacksonValuePrivateEnum.class));
+        assertNotNull(schema);
+        assertEquals(schema.getType(), "string");
+        assertEquals(schema.getEnum(), Arrays.asList("one", "two", "three"));
+    }
+
+    @Test(description = "it should extract enum values from a @JsonValue default method declared on an implemented interface")
+    public void testJsonValueOnInterfaceDefaultMethodIsRecognized() {
+        final Schema schema = context.resolve(new AnnotatedType(JacksonValueDefaultMethodEnum.class));
+        assertNotNull(schema);
+        assertEquals(schema.getType(), "string");
+        assertEquals(schema.getEnum(), Arrays.asList("alpha", "beta", "gamma"));
     }
 }
diff --git a/modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/InterfaceWithDefaultJsonValue.java b/modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/InterfaceWithDefaultJsonValue.java
@@ -0,0 +1,11 @@
+package io.swagger.v3.core.oas.models;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public interface InterfaceWithDefaultJsonValue {
+
+    @JsonValue
+    default String toValue() {
+        return "default";
+    }
+}
diff --git a/modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/InterfaceWithJacksonValue.java b/modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/InterfaceWithJacksonValue.java
@@ -0,0 +1,9 @@
+package io.swagger.v3.core.oas.models;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public interface InterfaceWithJacksonValue {
+
+	@JsonValue
+	int getJsonValue();
+}
diff --git a/modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/JacksonValueDefaultMethodEnum.java b/modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/JacksonValueDefaultMethodEnum.java
@@ -0,0 +1,15 @@
+package io.swagger.v3.core.oas.models;
+
+/**
+ * Enum whose @JsonValue comes from a default method declared on the implemented interface.
+ * The enum overrides the method (without repeating @JsonValue), so the annotation is only
+ * present on the interface's default method declaration.
+ */
+public enum JacksonValueDefaultMethodEnum implements InterfaceWithDefaultJsonValue {
+    ALPHA, BETA, GAMMA;
+
+    @Override
+    public String toValue() {
+        return this.name().toLowerCase();
+    }
+}
diff --git a/modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/JacksonValueInInterfaceEnum.java b/modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/JacksonValueInInterfaceEnum.java
@@ -0,0 +1,18 @@
+
+package io.swagger.v3.core.oas.models;
+
+public enum JacksonValueInInterfaceEnum implements InterfaceWithJacksonValue {
+
+	TEN(10);
+
+	private final int jsonValue;
+
+	JacksonValueInInterfaceEnum(int jsonValue) {
+		this.jsonValue = jsonValue;
+	}
+
+	@Override
+	public int getJsonValue() {
+		return jsonValue;
+	}
+}
diff --git a/modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/ModelWithJacksonEnumField.java b/modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/ModelWithJacksonEnumField.java
@@ -10,4 +10,6 @@ public class ModelWithJacksonEnumField {
     public JacksonValueFieldEnum fourthEnumValue;
     public JacksonIntegerValueFieldEnum fifthEnumValue;
     public JacksonValuePrivateEnum sixthEnumValue;
+    public JacksonValueInInterfaceEnum seventhEnumValue;
+    public JacksonValueDefaultMethodEnum eighthEnumValue;
 }
diff --git a/modules/swagger-core/src/test/java/io/swagger/v3/core/util/reflection/ReflectionUtilsTest.java b/modules/swagger-core/src/test/java/io/swagger/v3/core/util/reflection/ReflectionUtilsTest.java
@@ -1,5 +1,6 @@
 package io.swagger.v3.core.util.reflection;
 
+import com.fasterxml.jackson.annotation.JsonValue;
 import io.swagger.v3.core.util.ReflectionUtils;
 import io.swagger.v3.core.util.reflection.resources.Child;
 import io.swagger.v3.core.util.reflection.resources.IParent;
@@ -192,6 +193,60 @@ public void getParameterAnnotationsForOverriddenAnnotationTest() throws NoSuchMe
         assertEquals(((AnnotationInterface)parameterAnnotations[0][0]).value(), "level4");
     }
 
+    @Test
+    public void getAnnotatedMethods_returnsEmptyWhenNoMethodHasAnnotation() {
+        List<Method> methods = ReflectionUtils.getAnnotatedMethods(String.class, JsonValue.class);
+        assertTrue(methods.isEmpty());
+    }
+
+    @Test
+    public void getAnnotatedMethods_findsAnnotationInSuperclass() {
+        List<Method> methods = ReflectionUtils.getAnnotatedMethods(SubclassWithoutJsonValue.class, JsonValue.class);
+        assertEquals(methods.size(), 1);
+        assertEquals(methods.get(0).getName(), "getJsonValue");
+    }
+
+    @Test
+    public void getAnnotatedMethods_findsMultipleMatchesAcrossClassHierarchy() {
+        List<Method> methods = ReflectionUtils.getAnnotatedMethods(SubclassWithOwnJsonValue.class, JsonValue.class);
+        assertEquals(methods.size(), 2);
+        List<String> names = methods.stream().map(Method::getName).collect(Collectors.toList());
+        assertTrue(names.contains("getJsonValue"));
+        assertTrue(names.contains("getSubJsonValue"));
+    }
+
+    @Test
+    public void getAnnotatedMethods_findsDefaultMethodAnnotationFromInterface() {
+        List<Method> methods = ReflectionUtils.getAnnotatedMethods(ImplementorWithoutOverride.class, JsonValue.class);
+        assertEquals(methods.size(), 1);
+        assertEquals(methods.get(0).getName(), "toValue");
+    }
+
+    // --- Support classes for getAnnotatedMethods tests ---
+
+    private static class SuperclassWithJsonValue {
+        @JsonValue
+        public String getJsonValue() { return "super"; }
+    }
+
+    private static class SubclassWithoutJsonValue extends SuperclassWithJsonValue {
+        public String getOtherMethod() { return "other"; }
+    }
+
+    private static class SubclassWithOwnJsonValue extends SuperclassWithJsonValue {
+        @JsonValue
+        public String getSubJsonValue() { return "sub"; }
+    }
+
+    private interface InterfaceWithDefaultJsonValue {
+        @JsonValue
+        default String toValue() { return "from-interface"; }
+    }
+
+    private static class ImplementorWithoutOverride implements InterfaceWithDefaultJsonValue {}
+
+    // ---
+
     @Tag(name = "inherited tag")
     private interface AnnotatedInterface {}
 

Original file line number	Diff line number	Diff line change
`@@ -10,4 +10,6 @@ public class ModelWithJacksonEnumField {`
`10`	`10`	`public JacksonValueFieldEnum fourthEnumValue;`
`11`	`11`	`public JacksonIntegerValueFieldEnum fifthEnumValue;`
`12`	`12`	`public JacksonValuePrivateEnum sixthEnumValue;`
	`13`	`+ public JacksonValueInInterfaceEnum seventhEnumValue;`
	`14`	`+ public JacksonValueDefaultMethodEnum eighthEnumValue;`
`13`	`15`	`}`