[#1770] Add test for iniailizing field after fetching it

Author: dreab8

integration-tests/bytecode-enhancements-it/src/test/java/org/hibernate/reactive/it/LazyBasicFieldTest.java

@@ -6,12 +6,17 @@
 package org.hibernate.reactive.it;
 
 import org.hibernate.LazyInitializationException;
+import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
+import org.hibernate.cfg.Configuration;
+
+import org.hibernate.testing.SqlStatementTracker;
 
 import io.smallrye.mutiny.Uni;
 import java.util.Collection;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 import io.vertx.junit5.Timeout;
@@ -25,6 +30,33 @@
  */
 @Timeout(value = 10, timeUnit = TimeUnit.MINUTES)
 public class LazyBasicFieldTest extends BaseReactiveIT {
+
+	private static SqlStatementTracker sqlTracker;
+
+	@Override
+	protected Configuration constructConfiguration() {
+		Configuration configuration = super.constructConfiguration();
+
+		// Construct a tracker that collects query statements via the SqlStatementLogger framework.
+		// Pass in configuration properties to hand off any actual logging properties
+		sqlTracker = new SqlStatementTracker( LazyBasicFieldTest::selectQueryFilter, configuration.getProperties() );
+		return configuration;
+	}
+
+	@BeforeEach
+	public void clearTracker() {
+		sqlTracker.clear();
+	}
+
+	@Override
+	protected void addServices(StandardServiceRegistryBuilder builder) {
+		sqlTracker.registerService( builder );
+	}
+
+	private static boolean selectQueryFilter(String s) {
+		return s.toLowerCase().startsWith( "select " );
+	}
+
 	@Override
 	protected Collection<Class<?>> annotatedEntities() {
 		return List.of( Crew.class );
@@ -51,6 +83,31 @@ public void testFetchBasicField(VertxTestContext context) {
 		);
 	}
 
+	@Test
+	public void testFetchBasicFieldAlsoInitializesIt(VertxTestContext context) {
+		final Crew emily = new Crew();
+		emily.setId( 21L );
+		emily.setName( "Emily Jackson" );
+		emily.setRole( "Passenger" );
+		emily.setFate( "Unknown" );
+
+		test( context, getMutinySessionFactory()
+				.withTransaction( session -> session.persist( emily ) )
+				.chain( () -> getMutinySessionFactory()
+						.withSession( session -> session
+								.find( Crew.class, emily.getId() )
+								.call( crew -> session.fetch( crew, Crew_.role )
+										.invoke( role -> assertThat( role ).isEqualTo( emily.getRole() ) ) )
+								.invoke( () -> sqlTracker.clear() )
+								.call( crew -> session.fetch( crew, Crew_.role )
+										.invoke( role -> {
+											// No select query expected, the previous fetch must have initialized the role attribute
+											assertThat(sqlTracker.getLoggedQueries()).hasSize( 0 );
+											assertThat( role ).isEqualTo( emily.getRole() );} )
+								) ) )
+		);
+	}
+
 	@Test
 	public void testTransparentLazyFetching(VertxTestContext context) {
 		final Crew emily = new Crew();

integration-tests/bytecode-enhancements-it/src/test/java/org/hibernate/testing/SqlStatementTracker.java

@@ -0,0 +1,107 @@
+/* Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright: Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.testing;
+
+import org.hibernate.boot.registry.StandardServiceInitiator;
+import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
+import org.hibernate.engine.jdbc.internal.Formatter;
+import org.hibernate.engine.jdbc.spi.SqlStatementLogger;
+import org.hibernate.reactive.provider.Settings;
+import org.hibernate.service.spi.ServiceRegistryImplementor;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.function.Predicate;
+
+/**
+ * Track sql queries.
+ * <p>
+ * Check {@link #registerService(StandardServiceRegistryBuilder)} to register an instance of this class.
+ * It's not thread-safe.
+ * </p>
+ * @see #registerService(StandardServiceRegistryBuilder)
+ */
+public class SqlStatementTracker extends SqlStatementLogger {
+
+	private final Predicate<String> filter;
+
+	private final List<String> statements = new ArrayList<>();
+
+	public SqlStatementTracker(Predicate<String> predicate) {
+		this.filter = predicate;
+	}
+
+	public SqlStatementTracker(Predicate<String> predicate, Properties properties) {
+		super(
+				toBoolean( properties.get( Settings.SHOW_SQL ) ),
+				toBoolean( properties.get( Settings.FORMAT_SQL ) ),
+				toBoolean( properties.get( Settings.HIGHLIGHT_SQL ) ),
+				toLong( properties.get( Settings.LOG_SLOW_QUERY ) )
+		);
+		this.filter = predicate;
+	}
+
+	private static boolean toBoolean(Object obj) {
+		return Boolean.parseBoolean( (String) obj );
+	}
+
+	private static long toLong(Object obj) {
+		if ( obj == null ) {
+			return 0;
+		}
+		return Long.parseLong( (String) obj );
+	}
+
+	@Override
+	public void logStatement(String statement, Formatter formatter) {
+		addSql( statement );
+		super.logStatement( statement, formatter );
+	}
+
+	private void addSql(String sql) {
+		if ( filter.test( sql ) ) {
+			statements.add( sql );
+		}
+	}
+
+	public List<String> getLoggedQueries() {
+		return statements;
+	}
+
+	public void clear() {
+		statements.clear();
+	}
+
+	/**
+	 * Register the current sql tracker to the {@link StandardServiceRegistryBuilder}.
+	 *
+	 * @param builder the {@link StandardServiceRegistryBuilder} for the creation of the factory
+	 */
+	public void registerService(StandardServiceRegistryBuilder builder) {
+		Initiator initiator = new Initiator( this );
+		builder.addInitiator( initiator );
+	}
+
+	private static class Initiator implements StandardServiceInitiator<SqlStatementLogger> {
+		private final SqlStatementTracker sqlStatementTracker;
+
+		public Initiator(SqlStatementTracker sqlStatementTracker) {
+			this.sqlStatementTracker = sqlStatementTracker;
+		}
+
+		@Override
+		public SqlStatementLogger initiateService(Map configurationValues, ServiceRegistryImplementor registry) {
+			return sqlStatementTracker;
+		}
+
+		@Override
+		public Class<SqlStatementLogger> getServiceInitiated() {
+			return SqlStatementLogger.class;
+		}
+	}
+}