act: improve test

src/main/java/io/spring/jdbc/oracle/accessor/ClassRecord.java

@@ -1,12 +1,12 @@
 package io.spring.jdbc.oracle.accessor;
 
-import java.util.Objects;
+import io.spring.jdbc.oracle.utils.Validators;
 
 public record ClassRecord<T>(Class<T> mappedClass) {
 
     public ClassRecord {
 
-        Objects.requireNonNull(mappedClass, "mapped class");
+        Validators.requireNotNull(mappedClass, "Mapped class");
     }
 
     public boolean isTypeRecord() {

src/main/java/io/spring/jdbc/oracle/utils/MapperUtils.java → src/main/java/io/spring/jdbc/oracle/utils/Mappers.java

@@ -3,20 +3,19 @@
 import io.spring.jdbc.oracle.exception.ValueException;
 import io.spring.jdbc.oracle.mapper.property.TypeProperty;
 import java.util.Collection;
-import java.util.Objects;
 import java.util.Optional;
 import org.springframework.beans.BeanUtils;
 import org.springframework.core.ResolvableType;
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.ReflectionUtils;
 
-public final class MapperUtils {
+public final class Mappers {
 
-    private MapperUtils() {
+    private Mappers() {
     }
 
-    public static Object[] toArrayOrNull(Object object) {
+    public static Object[] toArray(Object object) {
 
         return Optional.ofNullable(object)
             .map(o -> {
@@ -33,10 +32,7 @@ public static Object[] toArrayOrNull(Object object) {
 
     public static Class<?> extractClassFromArray(TypeDescriptor typeDescriptor) {
 
-        var resolvableType = Objects.requireNonNull(
-                typeDescriptor,
-                "STRUCT_ARRAY type is invalid"
-            )
+        var resolvableType = Validators.requireNotNull(typeDescriptor, "TypeDescriptor")
             .getResolvableType();
 
         var cls = resolvableType.isArray()

src/main/java/io/spring/jdbc/oracle/utils/Strings.java

@@ -2,48 +2,27 @@
 
 import static io.spring.jdbc.oracle.utils.Matchers.not;
 
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
 public final class Strings {
 
     public static final String EMPTY = "";
-    public static final String NOT_BLANK = "%s must not be blank";
-    public static final String NOT_NULL = "%s must not be null";
 
     private Strings() {
     }
 
-    public static boolean isBlank(final String input) {
-
-        return input == null
-            || input.isBlank();
-    }
-
     public static boolean isNotBlank(final String input) {
 
         return not(isBlank(input));
     }
 
-    public static String firstNoneBlank(final String... values) {
+    public static boolean isBlank(final String input) {
 
-        return stream(values)
-            .filter(Strings::isNotBlank)
-            .findFirst()
-            .orElse(null);
+        return input == null
+            || input.isBlank();
     }
 
     public static boolean equalsIgnoreCase(final String value, final String compareValue) {
 
         return value != null && value.equalsIgnoreCase(compareValue);
     }
 
-    private static Stream<String> stream(final String... values) {
-
-        return Optional.ofNullable(values)
-            .stream()
-            .flatMap(Arrays::stream);
-    }
-
 }

src/main/java/io/spring/jdbc/oracle/utils/Validators.java

@@ -0,0 +1,33 @@
+package io.spring.jdbc.oracle.utils;
+
+import io.spring.jdbc.oracle.exception.ValueException;
+
+public final class Validators {
+
+    private static final String NOT_BLANK = "%s must not be blank";
+    private static final String NOT_NULL = "%s must not be null";
+
+    private Validators() {
+    }
+
+    public static <T> T requireNotNull(final T value, final String message) {
+
+        if (value == null) {
+
+            throw new ValueException(NOT_NULL.formatted(message));
+        }
+
+        return value;
+    }
+
+    public static String requireNotBank(final String value, final String message) {
+
+        if (Strings.isBlank(value)) {
+
+            throw new ValueException(NOT_BLANK.formatted(message));
+        }
+
+        return value;
+    }
+
+}

src/test/java/io/spring/jdbc/oracle/accessor/ClassRecordTest.java

@@ -1,10 +1,10 @@
 package io.spring.jdbc.oracle.accessor;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatNullPointerException;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 
+import io.spring.jdbc.oracle.exception.ValueException;
 import java.math.BigDecimal;
-import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.DisplayNameGeneration;
 import org.junit.jupiter.api.DisplayNameGenerator;
 import org.junit.jupiter.api.Nested;
@@ -16,12 +16,11 @@ class ClassRecordTest {
     @Test
     void throw_exception_when_class_is_null() {
 
-        assertThatNullPointerException()
+        assertThatExceptionOfType(ValueException.class)
             .isThrownBy(() -> new ClassRecord<>(null));
     }
 
     @Nested
-    @DisplayName("method isTypeRecord")
     class IsTypeRecord {
 
         @Test

src/test/java/io/spring/jdbc/oracle/utils/MapperUtilsTest.java → src/test/java/io/spring/jdbc/oracle/utils/MappersTest.java

@@ -18,44 +18,43 @@
 import org.springframework.core.convert.TypeDescriptor;
 
 @DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class)
-class MapperUtilsTest {
+class MappersTest {
 
     @Nested
-    class ToArrayOrNull {
+    class ToArray {
 
         @Test
         void return_null_when_input_is_null() {
 
-            assertThat(MapperUtils.toArrayOrNull(null))
+            assertThat(Mappers.toArray(null))
                 .isNull();
         }
 
         @Test
         void throw_exception_when_input_is_neither_array_nor_collection() {
 
             assertThatExceptionOfType(IllegalArgumentException.class)
-                .isThrownBy(() -> MapperUtils.toArrayOrNull("null"));
+                .isThrownBy(() -> Mappers.toArray("null"));
 
             assertThatExceptionOfType(IllegalArgumentException.class)
-                .isThrownBy(() -> MapperUtils.toArrayOrNull(Integer.class));
+                .isThrownBy(() -> Mappers.toArray(Integer.class));
 
             var emptyMap = Collections.emptyMap();
             assertThatExceptionOfType(IllegalArgumentException.class)
-                .isThrownBy(() -> MapperUtils.toArrayOrNull(emptyMap));
+                .isThrownBy(() -> Mappers.toArray(emptyMap));
         }
 
         @Test
         void return_object_array() {
 
-            assertThat(MapperUtils.toArrayOrNull(Collections.emptyList()))
-                .isEmpty();
+            assertThat(Mappers.toArray(Collections.emptyList()))
+                .isEqualTo(new Object[0]);
 
-            assertThat(MapperUtils.toArrayOrNull(new String[0]))
-                .isEmpty();
+            assertThat(Mappers.toArray(new String[0]))
+                .isEqualTo(new Object[0]);
 
-            assertThat(MapperUtils.toArrayOrNull(List.of(1, "X")))
-                .isNotEmpty()
-                .containsExactly(1, "X");
+            assertThat(Mappers.toArray(List.of(1, "X")))
+                .isEqualTo(new Object[]{1, "X"});
         }
 
     }
@@ -67,35 +66,42 @@ class ExtractClassFromArray {
         void throw_exception_when_input_is_either_null_or_not_array_type() {
 
             assertThatExceptionOfType(NullPointerException.class)
-                .isThrownBy(() -> MapperUtils.extractClassFromArray(null));
+                .isThrownBy(() -> Mappers.extractClassFromArray(null));
 
             var classTypeDescriptor = TypeDescriptor.valueOf(null);
             assertThatExceptionOfType(ArrayIndexOutOfBoundsException.class)
-                .isThrownBy(() -> MapperUtils.extractClassFromArray(classTypeDescriptor));
+                .isThrownBy(() -> Mappers.extractClassFromArray(classTypeDescriptor));
 
             var bigDecimalTypeDescriptor = TypeDescriptor.forObject(BigDecimal.TEN);
             assertThatExceptionOfType(ArrayIndexOutOfBoundsException.class)
-                .isThrownBy(() -> MapperUtils.extractClassFromArray(bigDecimalTypeDescriptor));
+                .isThrownBy(() -> Mappers.extractClassFromArray(bigDecimalTypeDescriptor));
+        }
+
+        @Test
+        void return_null_when_type_class_is_not_determined() {
+
+            assertThat(Mappers.extractClassFromArray(TypeDescriptor.forObject(List.of())))
+                .isNull();
         }
 
         @Test
         void return_type_class() {
 
             var array = TypeDescriptor.array(TypeDescriptor.valueOf(BigDecimal.class));
-            assertThat(MapperUtils.extractClassFromArray(array))
+            assertThat(Mappers.extractClassFromArray(array))
                 .isEqualTo(BigDecimal.class);
 
-            assertThat(MapperUtils.extractClassFromArray(TypeDescriptor.forObject(new Integer[0])))
+            assertThat(Mappers.extractClassFromArray(TypeDescriptor.forObject(new Integer[0])))
                 .isEqualTo(Integer.class);
 
             var collection = TypeDescriptor.collection(
                 List.class,
                 TypeDescriptor.valueOf(String.class)
             );
-            assertThat(MapperUtils.extractClassFromArray(collection))
+            assertThat(Mappers.extractClassFromArray(collection))
                 .isEqualTo(String.class);
 
-            assertThat(MapperUtils.extractClassFromArray(TypeDescriptor.forObject(List.of())))
+            assertThat(Mappers.extractClassFromArray(TypeDescriptor.forObject(List.of())))
                 .isNull();
         }
 
@@ -107,10 +113,10 @@ class ConvertValue {
         @Test
         void return_null_when_method_has_null_value_parameter() {
 
-            assertThat(MapperUtils.convertValue(null, "X"))
+            assertThat(Mappers.convertValue(null, "X"))
                 .isNull();
 
-            assertThat(MapperUtils.convertValue(new TypeProperty(), null))
+            assertThat(Mappers.convertValue(new TypeProperty(), null))
                 .isNull();
         }
 
@@ -121,20 +127,17 @@ void throw_exception_when_method_convert_is_not_found() {
             typeProperty.setConverter(NoneConverter.class);
 
             assertThatExceptionOfType(ValueException.class)
-                .isThrownBy(() -> MapperUtils.convertValue(typeProperty, BigDecimal.ONE));
+                .isThrownBy(() -> Mappers.convertValue(typeProperty, BigDecimal.ONE));
         }
 
         @Test
-        void convert_bigDecimal_to_integer() {
+        void convert_BigDecimal_to_integer() {
 
             var typeProperty = new TypeProperty();
             typeProperty.setConverter(BigDecimalToInteger.class);
 
-            assertThat(MapperUtils.convertValue(typeProperty, BigDecimal.ONE))
+            assertThat(Mappers.convertValue(typeProperty, BigDecimal.ONE))
                 .isEqualTo(1);
-
-            assertThat(MapperUtils.convertValue(typeProperty, null))
-                .isNull();
         }
 
         public record BigDecimalToInteger() implements OracleConverter<BigDecimal, Integer> {

src/test/java/io/spring/jdbc/oracle/utils/StringsTest.java

@@ -1,8 +1,6 @@
 package io.spring.jdbc.oracle.utils;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Test;
@@ -29,25 +27,13 @@ void isNotBlank() {
         assertTrue(Strings.isNotBlank("  Test "));
     }
 
-    @Test
-    void firstNoneBlank() {
-
-        assertNull(Strings.firstNoneBlank());
-        assertNull(Strings.firstNoneBlank((String) null));
-        assertNull(Strings.firstNoneBlank(null, "", null));
-        assertNull(Strings.firstNoneBlank(null, null, " "));
-
-        assertEquals("X", Strings.firstNoneBlank(null, "X", null));
-        assertEquals("X", Strings.firstNoneBlank(null, "X", " "));
-        assertEquals("X", Strings.firstNoneBlank(null, "", "X"));
-    }
-
     @Test
     void equalsIgnoreCase() {
 
         assertFalse(Strings.equalsIgnoreCase(null, null));
         assertFalse(Strings.equalsIgnoreCase(null, "X"));
         assertFalse(Strings.equalsIgnoreCase("X", null));
+        assertFalse(Strings.equalsIgnoreCase("X", "a"));
 
         assertTrue(Strings.equalsIgnoreCase("X", "x"));
         assertTrue(Strings.equalsIgnoreCase("X", "X"));

src/test/java/io/spring/jdbc/oracle/utils/ValidatorsTest.java

@@ -0,0 +1,29 @@
+package io.spring.jdbc.oracle.utils;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import io.spring.jdbc.oracle.exception.ValueException;
+import org.junit.jupiter.api.Test;
+
+class ValidatorsTest {
+
+    @Test
+    void requireNotNull() {
+
+        assertThrows(ValueException.class, () -> Validators.requireNotNull(null, "X"));
+
+        assertEquals("X", Validators.requireNotNull("X", "X"));
+    }
+
+    @Test
+    void requireNotBank() {
+
+        assertThrows(ValueException.class, () -> Validators.requireNotBank(null, "X"));
+        assertThrows(ValueException.class, () -> Validators.requireNotBank("", "X"));
+        assertThrows(ValueException.class, () -> Validators.requireNotBank("        ", "X"));
+
+        assertEquals("  Test ", Validators.requireNotBank("  Test ", "X"));
+    }
+
+}