[hibernate#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;
+}
+}
+}