Update tests

Author: DavideD

hibernate-reactive-core/src/test/java/org/hibernate/reactive/types/JavaTypesArrayTest.java

@@ -46,22 +46,19 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 
+/**
+ * Test that we handle arrays as basic types and the @{@link Array} annotation.
+ * <p>
+ * Specifying the length doesn't seem to have any effect at the moment.
+ * Except for Postgres: Hibernate ORM will use a different SQL query for the creation of the table, but Postgres will
+ * ignore the limit anyway.
+ */
 @Timeout(value = 10, timeUnit = MINUTES)
 @DisabledFor(value = ORACLE, reason = "Vert.x does not support arrays for Oracle")
 public class JavaTypesArrayTest extends BaseReactiveTest {
 
 	private static SqlStatementTracker sqlTracker;
 
-	private final static Condition<String> IS_PG_CREATE_TABLE_QUERY = new Condition<>(
-			s -> s.toLowerCase().startsWith( "create table" ) && s.contains( "stringArrayWithArrayAnnotation varchar(255) array[5]," ),
-			"generated query for PostgreSQL `create table...`"
-	);
-
-	private final static Condition<String> IS_PG_CREATE_TABLE_NO_ARRAY_ANNOTATION_QUERY = new Condition<>(
-			s -> s.toLowerCase().startsWith( "create table" ) && s.contains( "stringArray varchar(255) array," ),
-			"generated query for PostgreSQL `create table...`"
-	);
-
 	@Override
 	protected Configuration constructConfiguration() {
 		Configuration configuration = super.constructConfiguration();
@@ -75,7 +72,7 @@ protected void addServices(StandardServiceRegistryBuilder builder) {
 	}
 
 	private static boolean filterCreateTable(String s) {
-		return s.toLowerCase().startsWith( "create table" );
+		return s.toLowerCase().startsWith( "create table " );
 	}
 
 	@Override
@@ -100,16 +97,12 @@ private void testField(
 	@Test
 	public void testStringArrayType(VertxTestContext context) {
 		Basic basic = new Basic();
-		String[] dataArray = { "Hello world!", "Hello earth" };
+		String[] dataArray = {"Hello world!", "Hello earth"};
 		basic.stringArray = dataArray;
 
 		testField( context, basic, found -> {
 			assertArrayEquals( dataArray, found.stringArray );
-			// PostgreSQL is the only DB that changes it's `create table...` statement to include array information
-			// This test checks that the logged query is correct and contains "array[100]"
-			if ( dbType() == POSTGRESQL ) {
-				assertThat( sqlTracker.getLoggedQueries() ).have( IS_PG_CREATE_TABLE_NO_ARRAY_ANNOTATION_QUERY );
-			}
+			validateStringColumns( "stringArray", null, 255 );
 		} );
 	}
 
@@ -121,37 +114,60 @@ public void testStringArrayTypeWithArrayAnnotation(VertxTestContext context) {
 
 		testField( context, basic, found -> {
 			assertArrayEquals( dataArray, found.stringArrayWithArrayAnnotation );
-			// PostgreSQL is the only DB that changes it's `create table...` statement to include array information
-			// This test checks that the logged query is correct and contains "array[100]"
-			if ( dbType() == POSTGRESQL ) {
-				assertThat( sqlTracker.getLoggedQueries() ).have( IS_PG_CREATE_TABLE_QUERY );
-			}
+			validateStringColumns( "stringArrayWithArrayAnnotation", 5, null );
 		} );
 	}
 
 	@Test
 	public void testStringArrayTypeWithColumnAnnotation(VertxTestContext context) {
 		Basic basic = new Basic();
-		String[] dataArray = { "Hello world!", "Hello earth" };
+		String[] dataArray = {"Hello world!", "Hello earth"};
 		basic.stringArrayWithColumnAnnotation = dataArray;
 
 		testField( context, basic, found -> {
 			assertArrayEquals( dataArray, found.stringArrayWithColumnAnnotation );
+			validateStringColumns( "stringArrayWithColumnAnnotation", null, 25 );
 		} );
 	}
 
 	@Test
 	public void testStringArrayTypeWithBothAnnotations(VertxTestContext context) {
 		Basic basic = new Basic();
-		String[] dataArray = { "Hello world!", "Hello earth" };
+		String[] dataArray = {"Hello world!", "Hello earth"};
 		basic.stringArrayWithBothAnnotations = dataArray;
 
 		testField( context, basic, found -> {
 			assertArrayEquals( dataArray, found.stringArrayWithBothAnnotations );
+			validateStringColumns( "stringArrayWithBothAnnotations", 5, 25 );
 		} );
 	}
 
+	private void validateStringColumns(String columnName, Integer arrayLength, Integer columnLength) {
+		// Only Postgres has a different behaviour if @Array is used
+		if ( dbType() == POSTGRESQL ) {
+			// Postgres will ignore the length of the array, but we can test the table creation sql query
+			// and make sure that the limit is defined
 
+			// Example of correct query definition: columnName varchar(123) array[2]
+			final StringBuilder conditionBuilder = new StringBuilder( columnName + " varchar(" );
+			if ( columnLength != null ) {
+				conditionBuilder.append( columnLength );
+			}
+			else {
+				// Default varchar length
+				conditionBuilder.append( 255 );
+			}
+			conditionBuilder.append( ") array" );
+			if ( arrayLength != null ) {
+				conditionBuilder.append( "[" ).append( arrayLength ).append( "]" );
+			}
+			Condition<String> condition = new Condition<>(
+					s -> s.contains( conditionBuilder ),
+					"Should contains the right column definition"
+			);
+			assertThat( sqlTracker.getLoggedQueries() ).have( condition );
+		}
+	}
 
 	@Test
 	public void testBooleanArrayType(VertxTestContext context) {
@@ -382,19 +398,24 @@ private static class Basic {
 		String[] stringArray;
 		@Array(length = 5)
 		String[] stringArrayWithArrayAnnotation;
-		@Column(length = 255)
+		@Column(length = 25)
 		String[] stringArrayWithColumnAnnotation;
 		@Array(length = 5)
-		@Column(length = 255)
+		@Column(length = 25)
 		String[] stringArrayWithBothAnnotations;
+
 		Boolean[] booleanArray;
 		boolean[] primitiveBooleanArray;
+
 		Integer[] integerArray;
 		int[] primitiveIntegerArray;
+
 		Long[] longArray;
 		long[] primitiveLongArray;
+
 		Float[] floatArray;
 		float[] primitiveFloatArray;
+
 		Double[] doubleArray;
 		double[] primitiveDoubleArray;
 		UUID[] uuidArray;