add support for Enum CustomTypes in the CustomTypeScanner

Author: ThoSap

src/main/java/it/aboutbits/springboot/toolbox/autoconfiguration/web/CustomTypeScanner.java

@@ -1,6 +1,7 @@
 package it.aboutbits.springboot.toolbox.autoconfiguration.web;
 
 import it.aboutbits.springboot.toolbox.reflection.util.ClassScannerUtil;
+import it.aboutbits.springboot.toolbox.reflection.util.CustomTypeReflectionUtil;
 import it.aboutbits.springboot.toolbox.type.CustomType;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
@@ -41,7 +42,7 @@ public void setAdditionalTypePackages(String[] additionalTypePackages) {
         this.relevantTypes = findAllCustomTypes(classScanner);
     }
 
-    @SuppressWarnings("rawtypes")
+    @SuppressWarnings({"rawtypes", "unchecked"})
     public static Set<Class<? extends CustomType>> findAllCustomTypes(ClassScannerUtil.ClassScanner classScanner) {
         return classScanner.getSubTypesOf(CustomType.class).stream()
                 .filter(item ->
@@ -50,6 +51,27 @@ public static Set<Class<? extends CustomType>> findAllCustomTypes(ClassScannerUt
                                         && !Modifier.isAbstract(item.getModifiers())
                                         && !item.isAnnotationPresent(DisableCustomTypeConfiguration.class)
                 )
+                .filter(item -> {
+                    if (item.isEnum()) {
+                        return true;
+                    }
+
+                    try {
+                        var constructor = CustomTypeReflectionUtil.getCustomTypeConstructor((Class<? extends CustomType<?>>) item);
+                        var wrappedType = constructor.getParameterTypes()[0];
+
+                        if (!CustomTypeReflectionUtil.isSupportedWrappedType(wrappedType)) {
+                            log.debug("CustomType {} has an unsupported wrapped type {} and will be ignored.", item.getName(), wrappedType.getName());
+                            return false;
+                        }
+
+                        return true;
+                    } catch (NoSuchMethodException _) {
+                        log.debug("CustomType {} is missing the required constructor and will be ignored.", item.getName());
+
+                        return false;
+                    }
+                })
                 .collect(Collectors.toSet());
     }
 

src/main/java/it/aboutbits/springboot/toolbox/reflection/util/CustomTypeReflectionUtil.java

@@ -1,11 +1,15 @@
 package it.aboutbits.springboot.toolbox.reflection.util;
 
 import it.aboutbits.springboot.toolbox.type.CustomType;
+import it.aboutbits.springboot.toolbox.type.ScaledBigDecimal;
 import org.jspecify.annotations.NullMarked;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.ParameterizedType;
+import java.math.BigDecimal;
+import java.math.BigInteger;
 import java.util.Arrays;
+import java.util.UUID;
 
 @NullMarked
 public final class CustomTypeReflectionUtil {
@@ -17,7 +21,7 @@ public static <T extends CustomType<?>> Constructor<T> getCustomTypeConstructor(
             return customType.getConstructor(
                     getWrappedType(customType)
             );
-        } catch (NoSuchMethodException | SecurityException e) {
+        } catch (NoSuchMethodException | SecurityException _) {
             throw new NoSuchMethodException();
         }
     }
@@ -43,4 +47,22 @@ public static Class<?> getWrappedType(Class<? extends CustomType<?>> customType)
 
         throw new NoSuchMethodException();
     }
+
+    public static boolean isSupportedWrappedType(Class<?> wrappedType) {
+        return Boolean.class.isAssignableFrom(wrappedType)
+                || String.class.isAssignableFrom(wrappedType)
+                || Character.class.isAssignableFrom(wrappedType)
+                || Byte.class.isAssignableFrom(wrappedType)
+                || Short.class.isAssignableFrom(wrappedType)
+                || Integer.class.isAssignableFrom(wrappedType)
+                || Long.class.isAssignableFrom(wrappedType)
+                || Float.class.isAssignableFrom(wrappedType)
+                || Double.class.isAssignableFrom(wrappedType)
+                || BigInteger.class.isAssignableFrom(wrappedType)
+                || BigDecimal.class.isAssignableFrom(wrappedType)
+                || ScaledBigDecimal.class.isAssignableFrom(wrappedType)
+                || UUID.class.isAssignableFrom(wrappedType)
+                || Enum.class.isAssignableFrom(wrappedType)
+                || wrappedType.isEnum();
+    }
 }

src/test/java/it/aboutbits/springboot/toolbox/autoconfiguration/web/CustomTypeScannerTest.java

@@ -0,0 +1,67 @@
+package it.aboutbits.springboot.toolbox.autoconfiguration.web;
+
+import it.aboutbits.springboot.toolbox.reflection.util.ClassScannerUtil;
+import it.aboutbits.springboot.toolbox.type.CustomType;
+import org.jspecify.annotations.NullMarked;
+import org.junit.jupiter.api.Test;
+
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@NullMarked
+class CustomTypeScannerTest {
+    @Test
+    @SuppressWarnings("unchecked")
+    void findAllCustomTypes_shouldFilterOutTypesMissingConstructor() {
+        // given
+        ClassScannerUtil.ClassScanner classScanner = mock(ClassScannerUtil.ClassScanner.class);
+        when(classScanner.getSubTypesOf(CustomType.class)).thenReturn(Set.of(
+                EnumCustomType.class,
+                InvalidCustomType.class,
+                UnsupportedWrappedTypeCustomType.class
+        ));
+
+        // when
+        Set<Class<? extends CustomType>> result = CustomTypeScanner.findAllCustomTypes(classScanner);
+
+        // then
+        assertThat(result)
+                .containsExactly(EnumCustomType.class)
+                .doesNotContain(InvalidCustomType.class)
+                .doesNotContain(UnsupportedWrappedTypeCustomType.class);
+    }
+
+    public enum EnumCustomType implements CustomType<EnumCustomType> {
+        VALUE;
+
+        @Override
+        public EnumCustomType value() {
+            return this;
+        }
+    }
+
+    @SuppressWarnings("checkstyle:RedundantModifier")
+    public static class InvalidCustomType implements CustomType<String> {
+        @Override
+        public String value() {
+            return "test";
+        }
+    }
+
+    @SuppressWarnings("checkstyle:RedundantModifier")
+    public static class UnsupportedWrappedTypeCustomType implements CustomType<Object> {
+        private final Object value;
+
+        public UnsupportedWrappedTypeCustomType(Object value) {
+            this.value = value;
+        }
+
+        @Override
+        public Object value() {
+            return value;
+        }
+    }
+}

src/test/java/it/aboutbits/springboot/toolbox/jackson/CustomTypeDeserializerTest.java

@@ -0,0 +1,43 @@
+package it.aboutbits.springboot.toolbox.jackson;
+
+import it.aboutbits.springboot.toolbox.autoconfiguration.web.CustomTypeScanner;
+import it.aboutbits.springboot.toolbox.type.CustomType;
+import org.jspecify.annotations.NullMarked;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+@NullMarked
+class CustomTypeDeserializerTest {
+    @Test
+    void constructor_withValidCustomType_shouldNotThrow() {
+        assertThatCode(() -> new CustomTypeDeserializer<>(EnumCustomType.class))
+                .doesNotThrowAnyException();
+    }
+
+    @Test
+    void constructor_withInvalidCustomType_shouldThrowException() {
+        assertThatExceptionOfType(CustomTypeDeserializer.CustomTypeDeserializerException.class)
+                .isThrownBy(() -> new CustomTypeDeserializer<>(InvalidCustomType.class))
+                .withMessageContaining("Unable to find constructor for type: it.aboutbits.springboot.toolbox.jackson.CustomTypeDeserializerTest$InvalidCustomType");
+    }
+
+    public enum EnumCustomType implements CustomType<EnumCustomType> {
+        VALUE;
+
+        @Override
+        public EnumCustomType value() {
+            return this;
+        }
+    }
+
+    @SuppressWarnings("checkstyle:RedundantModifier")
+    public static class InvalidCustomType implements CustomType<String> {
+        @Override
+        public String value() {
+            return "test";
+        }
+        // Missing constructor(String)
+    }
+}