fix tests and add annotation check by simple name string

Author: SirCotare

pom.xml

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <parent>

src/main/java/it/aboutbits/springboot/toolbox/swagger/customization/default_not_null/NullableCustomizer.java

@@ -130,12 +130,13 @@ private static boolean isNullable(
             AnnotatedType annotatedType,
             Annotation[] annotations
     ) {
-        if (annotatedType.isAnnotationPresent(org.jspecify.annotations.Nullable.class)) {
-            return true;
+        for (var annotation : annotatedType.getAnnotations()) {
+            if (annotation.annotationType().getSimpleName().equals("Nullable")) {
+                return true;
+            }
         }
         for (var annotation : annotations) {
-            var name = annotation.annotationType().getName();
-            if (name.equals("org.springframework.lang.Nullable") || name.equals("jakarta.annotation.Nullable")) {
+            if (annotation.annotationType().getSimpleName().equals("Nullable")) {
                 return true;
             }
         }

src/test/java/it/aboutbits/springboot/toolbox/swagger/customization/default_not_null/NullableCustomizerTest.java

@@ -7,10 +7,10 @@
 import org.jspecify.annotations.NullUnmarked;
 import org.junit.jupiter.api.Test;
 
-import java.util.List;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
 
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
 
 @NullUnmarked
 class NullableCustomizerTest {
@@ -52,6 +52,7 @@ public String directMethod() {
 
     @Test
     void shouldFindFieldInSuperClass() {
+        // given
         var customizer = new NullableCustomizer();
         var openApi = new OpenAPI();
         var components = new Components();
@@ -64,15 +65,19 @@ void shouldFindFieldInSuperClass() {
         components.addSchemas(SubClass.class.getName(), subClassSchema);
         openApi.setComponents(components);
 
-        assertDoesNotThrow(() -> customizer.customise(openApi));
+        // when
+        customizer.customise(openApi);
 
-        List<String> required = subClassSchema.getRequired();
-        assertTrue(required != null && required.contains("subField"), "subField should be required");
-        assertTrue(required == null || !required.contains("baseField"), "baseField should NOT be required");
+        // then
+        var required = subClassSchema.getRequired();
+
+        assertThat(required).as("subField should be required").contains("subField");
+        assertThat(required).as("baseField should NOT be required").doesNotContain("baseField");
     }
 
     @Test
     void shouldFindAnnotationOnGetter() {
+        // given
         var customizer = new NullableCustomizer();
         var openApi = new OpenAPI();
         var components = new Components();
@@ -84,14 +89,17 @@ void shouldFindAnnotationOnGetter() {
         components.addSchemas(MethodAnnotated.class.getName(), schema);
         openApi.setComponents(components);
 
-        assertDoesNotThrow(() -> customizer.customise(openApi));
+        // when
+        customizer.customise(openApi);
 
-        List<String> required = schema.getRequired();
-        assertTrue(required == null || !required.contains("annotatedGetter"), "annotatedGetter should NOT be required");
+        // then
+        var required = schema.getRequired();
+        assertThat(required).as("annotatedGetter should NOT be required").isNullOrEmpty();
     }
 
     @Test
     void shouldFindAnnotationOnDirectMethod() {
+        // given
         var customizer = new NullableCustomizer();
         var openApi = new OpenAPI();
         var components = new Components();
@@ -103,14 +111,17 @@ void shouldFindAnnotationOnDirectMethod() {
         components.addSchemas(DirectMethodAnnotated.class.getName(), schema);
         openApi.setComponents(components);
 
-        assertDoesNotThrow(() -> customizer.customise(openApi));
+        // when
+        customizer.customise(openApi);
 
-        List<String> required = schema.getRequired();
-        assertTrue(required == null || !required.contains("directMethod"), "directMethod should NOT be required");
+        // then
+        var required = schema.getRequired();
+        assertThat(required).as("directMethod should NOT be required").isNullOrEmpty();
     }
 
     @Test
     void shouldHandleConcatenatedFqns() {
+        // given
         var customizer = new NullableCustomizer();
         var openApi = new OpenAPI();
         var components = new Components();
@@ -124,17 +135,17 @@ void shouldHandleConcatenatedFqns() {
         components.addSchemas(concatenatedFqn, schema);
         openApi.setComponents(components);
 
-        assertDoesNotThrow(() -> customizer.customise(openApi));
+        // when
+        customizer.customise(openApi);
 
-        List<String> required = schema.getRequired();
-        assertTrue(
-                required == null || !required.contains("baseField"),
-                "baseField should NOT be required even with concatenated FQN"
-        );
+        // then
+        var required = schema.getRequired();
+        assertThat(required).as("baseField should NOT be required even with concatenated FQN").isNullOrEmpty();
     }
 
     @Test
     void shouldNotThrowWhenFieldNotFound() {
+        // given
         var customizer = new NullableCustomizer();
         var openApi = new OpenAPI();
         var components = new Components();
@@ -146,12 +157,50 @@ void shouldNotThrowWhenFieldNotFound() {
         components.addSchemas(SubClass.class.getName(), schema);
         openApi.setComponents(components);
 
-        assertDoesNotThrow(() -> customizer.customise(openApi));
+        // when
+        customizer.customise(openApi);
+
+        // then
+        var required = schema.getRequired();
+        assertThat(required).as("nonExistent field should be considered required if not found and not nullable")
+                .contains("nonExistent");
+    }
+
+    @Test
+    void shouldFindCustomNullableAnnotation() {
+        // given
+        var customizer = new NullableCustomizer();
+        var openApi = new OpenAPI();
+        var components = new Components();
+
+        var schema = new Schema<Object>();
+        schema.setName(CustomNullableClass.class.getName());
+        schema.addProperty("customNullableField", new StringSchema());
+
+        components.addSchemas(CustomNullableClass.class.getName(), schema);
+        openApi.setComponents(components);
+
+        // when
+        customizer.customise(openApi);
+
+        // then
+        var required = schema.getRequired();
+        assertThat(required).as("customNullableField should NOT be required").isNullOrEmpty();
+    }
+
+    public static class Nest {
+        @Retention(RetentionPolicy.RUNTIME)
+        public @interface Nullable {
+        }
+    }
 
-        List<String> required = schema.getRequired();
-        assertTrue(
-                required != null && required.contains("nonExistent"),
-                "nonExistent field should be considered required if not found and not nullable"
-        );
+    public static class CustomNullableClass {
+        @Nest.Nullable
+        private String customNullableField;
+
+        @SuppressWarnings("NullAway")
+        public String getCustomNullableField() {
+            return customNullableField;
+        }
     }
 }