Improve test coverage

itsallcode · Jan 20, 2024 · 7d0ed3c · 7d0ed3c
1 parent f11a4fd
commit 7d0ed3c
Show file tree

Hide file tree

Showing 5 changed files with 106 additions and 26 deletions.
diff --git a/src/main/java/org/itsallcode/jdbc/SimpleBatch.java b/src/main/java/org/itsallcode/jdbc/SimpleBatch.java
@@ -2,8 +2,7 @@
 
 import java.time.Duration;
 import java.time.Instant;
-import java.util.Arrays;
-import java.util.List;
+import java.util.*;
 import java.util.logging.Logger;
 
 import org.itsallcode.jdbc.SimpleParameterMetaData.Parameter;
@@ -20,9 +19,9 @@ class SimpleBatch implements AutoCloseable {
     private int currentBatchSize = 0;
 
     SimpleBatch(final SimplePreparedStatement statement, final Context context) {
-        this.statement = statement;
-        this.context = context;
-        this.parameterMetadata = statement.getParameterMetadata().getParameters();
+        this.statement = Objects.requireNonNull(statement, "statement");
+        this.context = Objects.requireNonNull(context, "context");
+        this.parameterMetadata = statement.getParameterMetadata().parameters();
     }
 
     SimpleBatch add(final Object... args) {

diff --git a/src/main/java/org/itsallcode/jdbc/SimpleParameterMetaData.java b/src/main/java/org/itsallcode/jdbc/SimpleParameterMetaData.java
@@ -1,33 +1,28 @@
 package org.itsallcode.jdbc;
 
-import java.sql.ParameterMetaData;
-import java.sql.SQLException;
+import java.sql.*;
 import java.util.*;
 
 /**
  * Wrapper for {@link ParameterMetaData} that simplifies usage.
+ * 
+ * @param parameters all parameters
  */
-public class SimpleParameterMetaData {
+public record SimpleParameterMetaData(List<Parameter> parameters) {
 
-    private final ParameterMetaData metaData;
-
-    SimpleParameterMetaData(final ParameterMetaData parameterMetaData) {
-        this.metaData = parameterMetaData;
+    static SimpleParameterMetaData create(final ParameterMetaData parameterMetaData) {
+        return new SimpleParameterMetaData(getParameters(parameterMetaData));
     }
 
-    /**
-     * Get all parameters.
-     * 
-     * @return all parameters
-     */
-    public List<Parameter> getParameters() {
+    private static List<Parameter> getParameters(final ParameterMetaData metaData) {
         try {
             final List<Parameter> parameters = new ArrayList<>(metaData.getParameterCount());
             for (int i = 1; i <= metaData.getParameterCount(); i++) {
-                parameters.add(new Parameter(metaData.getParameterClassName(i), metaData.getParameterType(i),
-                        metaData.getParameterTypeName(i), ParameterMode.of(metaData.getParameterMode(i)),
-                        metaData.getPrecision(i), metaData.getScale(i), metaData.isSigned(i),
-                        ParameterNullable.of(metaData.isNullable(i))));
+                parameters.add(
+                        new Parameter(metaData.getParameterClassName(i), JDBCType.valueOf(metaData.getParameterType(i)),
+                                metaData.getParameterTypeName(i), ParameterMode.of(metaData.getParameterMode(i)),
+                                metaData.getPrecision(i), metaData.getScale(i), metaData.isSigned(i),
+                                ParameterNullable.of(metaData.isNullable(i))));
             }
             return parameters;
         } catch (final SQLException e) {
@@ -82,7 +77,7 @@ private ParameterNullable(final int mode) {
 
         private static ParameterNullable of(final int mode) {
             return Arrays.stream(values()).filter(m -> m.mode == mode).findAny().orElseThrow(
-                    () -> new IllegalArgumentException("No parameter mode found for value " + mode));
+                    () -> new IllegalArgumentException("No parameter nullable mode found for value " + mode));
         }
     }
 
@@ -98,7 +93,7 @@ private static ParameterNullable of(final int mode) {
      * @param signed    {@code true} if the parameter is signed
      * @param nullable  nullability of the parameter
      */
-    public static record Parameter(String className, int type, String typeName, ParameterMode mode, int precision,
+    public static record Parameter(String className, JDBCType type, String typeName, ParameterMode mode, int precision,
             int scale, boolean signed, ParameterNullable nullable) {
     }
 }
diff --git a/src/main/java/org/itsallcode/jdbc/SimplePreparedStatement.java b/src/main/java/org/itsallcode/jdbc/SimplePreparedStatement.java
@@ -69,7 +69,7 @@ void addBatch() {
 
     SimpleParameterMetaData getParameterMetadata() {
         try {
-            return new SimpleParameterMetaData(statement.getParameterMetaData());
+            return SimpleParameterMetaData.create(statement.getParameterMetaData());
         } catch (final SQLException e) {
             throw new UncheckedSQLException("Error getting parameter metadata", e);
         }

diff --git a/src/test/java/org/itsallcode/jdbc/SimpleParameterMetaDataTest.java b/src/test/java/org/itsallcode/jdbc/SimpleParameterMetaDataTest.java
@@ -0,0 +1,83 @@
+package org.itsallcode.jdbc;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.mockito.Mockito.when;
+
+import java.sql.*;
+
+import org.itsallcode.jdbc.SimpleParameterMetaData.*;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import com.jparams.verifier.tostring.ToStringVerifier;
+
+import nl.jqno.equalsverifier.EqualsVerifier;
+
+@ExtendWith(MockitoExtension.class)
+class SimpleParameterMetaDataTest {
+    @Mock
+    ParameterMetaData parameterMetadataMock;
+
+    @Test
+    void testToString() {
+        ToStringVerifier.forClass(SimpleParameterMetaData.class).verify();
+    }
+
+    @Test
+    void testEqualsContract() {
+        EqualsVerifier.forClass(SimpleParameterMetaData.class).verify();
+    }
+
+    @Test
+    void createNoParameters() {
+        final SimpleParameterMetaData metaData = SimpleParameterMetaData.create(parameterMetadataMock);
+        assertThat(metaData.parameters()).isEmpty();
+    }
+
+    @Test
+    void singleParameter() throws SQLException {
+        when(parameterMetadataMock.getParameterCount()).thenReturn(1);
+        when(parameterMetadataMock.getParameterClassName(1)).thenReturn("className");
+        when(parameterMetadataMock.getParameterType(1)).thenReturn(Types.VARCHAR);
+        when(parameterMetadataMock.getParameterTypeName(1)).thenReturn("typeName");
+        when(parameterMetadataMock.getParameterMode(1)).thenReturn(ParameterMetaData.parameterModeInOut);
+        when(parameterMetadataMock.isNullable(1)).thenReturn(ParameterMetaData.parameterNoNulls);
+        when(parameterMetadataMock.isSigned(1)).thenReturn(true);
+        when(parameterMetadataMock.getScale(1)).thenReturn(42);
+        when(parameterMetadataMock.getPrecision(1)).thenReturn(23);
+        final SimpleParameterMetaData metaData = SimpleParameterMetaData.create(parameterMetadataMock);
+        final Parameter param = metaData.parameters().get(0);
+        assertAll(
+                () -> assertThat(metaData.parameters()).hasSize(1),
+                () -> assertThat(param.className()).isEqualTo("className"),
+                () -> assertThat(param.type()).isEqualTo(JDBCType.VARCHAR),
+                () -> assertThat(param.typeName()).isEqualTo("typeName"),
+                () -> assertThat(param.mode()).isEqualTo(ParameterMode.INOUT),
+                () -> assertThat(param.nullable()).isEqualTo(ParameterNullable.NO_NULLS),
+                () -> assertThat(param.precision()).isEqualTo(23),
+                () -> assertThat(param.scale()).isEqualTo(42),
+                () -> assertThat(param.signed()).isTrue());
+    }
+
+    @Test
+    void invalidNullable() throws SQLException {
+        when(parameterMetadataMock.getParameterCount()).thenReturn(1);
+        when(parameterMetadataMock.isNullable(1)).thenReturn(-99);
+        assertThatThrownBy(() -> SimpleParameterMetaData.create(parameterMetadataMock))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("No parameter nullable mode found for value -99");
+    }
+
+    @Test
+    void invalidMode() throws SQLException {
+        when(parameterMetadataMock.getParameterCount()).thenReturn(1);
+        when(parameterMetadataMock.getParameterMode(1)).thenReturn(-99);
+        assertThatThrownBy(() -> SimpleParameterMetaData.create(parameterMetadataMock))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("No parameter mode found for value -99");
+    }
+}
diff --git a/src/test/java/org/itsallcode/jdbc/SimplePreparedStatementTest.java b/src/test/java/org/itsallcode/jdbc/SimplePreparedStatementTest.java
@@ -27,6 +27,8 @@ class SimplePreparedStatementTest {
     ResultSetMetaData metaDataMock;
     @Mock
     PreparedStatementSetter preparedStatementSetterMock;
+    @Mock
+    ParameterMetaData parameterMetadataMock;
 
     @Test
     void executeQuery() throws SQLException {
@@ -102,7 +104,8 @@ void addBatchFails() throws SQLException {
     }
 
     @Test
-    void getParameterMetadata() {
+    void getParameterMetadata() throws SQLException {
+        when(statementMock.getParameterMetaData()).thenReturn(parameterMetadataMock);
         assertThat(testee().getParameterMetadata()).isNotNull();
     }