HHH-19846 Drop JUnit 4 usage

Author: dreab8

gradle.properties

@@ -1,4 +1,4 @@
-db=mysql_ci
+db=h2
 
 # Keep all these properties in sync unless you know what you are doing!
 # We set '-Dlog4j2.disableJmx=true' to prevent classloader leaks triggered by the logger.

hibernate-core/src/test/java/org/hibernate/orm/test/connections/AggressiveReleaseTest.java

@@ -4,53 +4,65 @@
  */
 package org.hibernate.orm.test.connections;
 
-import java.sql.Connection;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
 import org.hibernate.ScrollableResults;
 import org.hibernate.Session;
-import org.hibernate.cfg.AvailableSettings;
 import org.hibernate.cfg.Environment;
 import org.hibernate.dialect.H2Dialect;
 import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
+import org.hibernate.engine.spi.SessionFactoryImplementor;
 import org.hibernate.internal.util.SerializationHelper;
 import org.hibernate.resource.jdbc.spi.PhysicalConnectionHandlingMode;
-import org.hibernate.resource.transaction.backend.jta.internal.JtaTransactionCoordinatorBuilderImpl;
 import org.hibernate.stat.Statistics;
-
-import org.hibernate.testing.RequiresDialect;
 import org.hibernate.testing.jta.TestingJtaBootstrap;
 import org.hibernate.testing.jta.TestingJtaPlatformImpl;
-import org.junit.Test;
+import org.hibernate.testing.orm.junit.RequiresDialect;
+import org.hibernate.testing.orm.junit.ServiceRegistry;
+import org.hibernate.testing.orm.junit.SessionFactoryScope;
+import org.hibernate.testing.orm.junit.Setting;
+import org.hibernate.testing.orm.junit.SettingConfiguration;
+import org.hibernate.testing.orm.junit.SettingProvider;
+import org.junit.jupiter.api.Test;
+
+import java.sql.Connection;
+import java.util.ArrayList;
+import java.util.List;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hibernate.cfg.TransactionSettings.ENABLE_LAZY_LOAD_NO_TRANS;
+import static org.hibernate.cfg.TransactionSettings.TRANSACTION_COORDINATOR_STRATEGY;
+import static org.junit.jupiter.api.Assertions.fail;
 
 /**
  * Implementation of AggressiveReleaseTest.
  *
  * @author Steve Ebersole
  */
 @RequiresDialect(H2Dialect.class)
+@ServiceRegistry(
+		settings = {
+				@Setting(name = Environment.GENERATE_STATISTICS, value = "true"),
+				@Setting(name = Environment.STATEMENT_BATCH_SIZE, value = "0"),
+				@Setting(name = TRANSACTION_COORDINATOR_STRATEGY, value = "jta"),
+				@Setting(name = ENABLE_LAZY_LOAD_NO_TRANS, value = "true")
+		},
+		settingProviders = @SettingProvider(
+				settingName = Environment.CONNECTION_HANDLING,
+				provider = AggressiveReleaseTest.ConnectionmHandlingProvider.class
+		),
+		settingConfigurations = @SettingConfiguration(configurer = TestingJtaBootstrap.class)
+)
 public class AggressiveReleaseTest extends ConnectionManagementTestCase {
-	@Override
-	protected void addSettings(Map<String,Object> settings) {
-		super.addSettings( settings );
-
-		TestingJtaBootstrap.prepare( settings );
-//		settings.put( Environment.TRANSACTION_STRATEGY, CMTTransactionFactory.class.getName() );
-		settings.put( AvailableSettings.TRANSACTION_COORDINATOR_STRATEGY, JtaTransactionCoordinatorBuilderImpl.class.getName() );
-		settings.put( Environment.CONNECTION_HANDLING, PhysicalConnectionHandlingMode.DELAYED_ACQUISITION_AND_RELEASE_AFTER_STATEMENT.toString() );
-		settings.put( Environment.GENERATE_STATISTICS, "true" );
-		settings.put( Environment.STATEMENT_BATCH_SIZE, "0" );
+
+	public static class ConnectionmHandlingProvider implements SettingProvider.Provider<String> {
+		@Override
+		public String getSetting() {
+			return PhysicalConnectionHandlingMode.DELAYED_ACQUISITION_AND_RELEASE_AFTER_STATEMENT.toString();
+		}
 	}
 
 	@Override
-	protected Session getSessionUnderTest() throws Throwable {
-		return openSession();
+	protected Session getSessionUnderTest(SessionFactoryScope scope) {
+		return scope.getSessionFactory().openSession();
 	}
 
 	@Override
@@ -70,10 +82,11 @@ protected void done() throws Throwable {
 	// Some additional tests specifically for the aggressive-release functionality...
 
 	@Test
-	public void testSerializationOnAfterStatementAggressiveRelease() throws Throwable {
+	public void testSerializationOnAfterStatementAggressiveRelease(SessionFactoryScope scope) throws Throwable {
 		prepare();
+		Session s = null;
 		try {
-			Session s = getSessionUnderTest();
+			s = getSessionUnderTest( scope );
 			Silly silly = new Silly( "silly" );
 			s.persist( silly );
 
@@ -86,134 +99,157 @@ public void testSerializationOnAfterStatementAggressiveRelease() throws Throwabl
 			s.remove( silly );
 			s.flush();
 
-			release( s );
 		}
 		finally {
+			release( s, scope );
 			done();
 		}
 	}
 
 	@Test
-	public void testSerializationFailsOnAfterStatementAggressiveReleaseWithOpenResources() throws Throwable {
+	public void testSerializationFailsOnAfterStatementAggressiveReleaseWithOpenResources(SessionFactoryScope scope)
+			throws Throwable {
 		prepare();
-		Session s = getSessionUnderTest();
+		try (Session s = getSessionUnderTest( scope )) {
 
-		Silly silly = new Silly( "silly" );
-		s.persist( silly );
-
-		// this should cause the CM to obtain a connection, and then release it
-		s.flush();
+			Silly silly = new Silly( "silly" );
+			s.persist( silly );
 
-		// both scroll() and iterate() cause batching to hold on
-		// to resources, which should make aggressive-release not release
-		// the connection (and thus cause serialization to fail)
-		try (ScrollableResults sr = s.createQuery( "from Silly" ).scroll()) {
-			sr.next();
+			// this should cause the CM to obtain a connection, and then release it
+			s.flush();
 
-			try {
-				SerializationHelper.serialize( s );
-				fail( "Serialization allowed on connected session; or aggressive release released connection with open resources" );
-			}
-			catch (IllegalStateException e) {
-				// expected behavior
+			// both scroll() and iterate() cause batching to hold on
+			// to resources, which should make aggressive-release not release
+			// the connection (and thus cause serialization to fail)
+			try (ScrollableResults<Silly> sr = s.createQuery( "from Silly", Silly.class ).scroll()) {
+				sr.next();
+
+				try {
+					SerializationHelper.serialize( s );
+					fail( "Serialization allowed on connected session; or aggressive release released connection with open resources" );
+				}
+				catch (IllegalStateException e) {
+					// expected behavior
+				}
+
+				// getting the first row only because SybaseASE15Dialect throws NullPointerException
+				// if data is not read before closing the ResultSet
+				sr.next();
+
+				// Closing the ScrollableResults does currently force batching to
+				// aggressively release the connection
 			}
+			SerializationHelper.serialize( s );
 
-			// getting the first row only because SybaseASE15Dialect throws NullPointerException
-			// if data is not read before closing the ResultSet
-			sr.next();
-
-			// Closing the ScrollableResults does currently force batching to
-			// aggressively release the connection
+			s.remove( silly );
+			s.flush();
 		}
-		SerializationHelper.serialize( s );
-
-		s.remove( silly );
-		s.flush();
-
-		release( s );
 		done();
 	}
 
 	@Test
-	public void testQueryScrolling() throws Throwable {
+	public void testQueryScrolling(SessionFactoryScope scope) throws Throwable {
 		prepare();
-		Session s = getSessionUnderTest();
-		Silly silly = new Silly( "silly" );
-		s.persist( silly );
-		s.flush();
-
-		try (ScrollableResults sr = s.createQuery( "from Silly" ).scroll()) {
-			assertTrue( sr.next() );
-			Silly silly2 = (Silly) sr.get();
-			assertEquals( silly, silly2 );
-		}
+		Session s = null;
+		try {
+			s = getSessionUnderTest(scope);
+			Silly silly = new Silly( "silly" );
+			s.persist( silly );
+			s.flush();
 
-		try (ScrollableResults sr = s.createQuery( "from Silly" ).scroll();
-			ScrollableResults sr2 = s.createQuery( "from Silly where name = 'silly'" ).scroll()) {
-			assertTrue( sr.next() );
-			assertEquals( silly, sr.get() );
-			assertTrue( sr2.next() );
-			assertEquals( silly, sr2.get() );
-		}
+			try (ScrollableResults<Silly> sr = s.createQuery( "from Silly", Silly.class ).scroll()) {
+				assertThat( sr.next() ).isTrue();
+				Silly silly2 = sr.get();
+				assertThat( silly2 ).isEqualTo( silly );
+			}
 
-		s.remove( silly );
-		s.flush();
+			try (ScrollableResults<Silly> sr = s.createQuery( "from Silly", Silly.class ).scroll();
+				ScrollableResults<Silly> sr2 = s.createQuery( "from Silly where name = 'silly'", Silly.class )
+						.scroll()) {
+				assertThat( sr.next() ).isTrue();
+				assertThat( sr.get() ).isEqualTo( silly );
+				assertThat( sr2.next() ).isTrue();
+				assertThat( sr2.get() ).isEqualTo( silly );
+			}
 
-		release( s );
-		done();
+			s.remove( silly );
+			s.flush();
+		}
+		finally {
+			release( s, scope );
+			done();
+		}
 	}
 
 	@Test
-	public void testSuppliedConnection() throws Throwable {
+	public void testSuppliedConnection(SessionFactoryScope scope) throws Throwable {
+		SessionFactoryImplementor sessionFactory = scope.getSessionFactory();
 		prepare();
 
-		Connection originalConnection = sessionFactory().getServiceRegistry().getService( ConnectionProvider.class ).getConnection();
-		Session session = sessionFactory().withOptions().connection( originalConnection ).openSession();
-
-		Silly silly = new Silly( "silly" );
-		session.persist( silly );
+		Connection originalConnection = sessionFactory.getServiceRegistry().getService( ConnectionProvider.class )
+				.getConnection();
+		Session session = null;
+		try {
+			session = sessionFactory.withOptions().connection( originalConnection ).openSession();
 
-		// this will cause the connection manager to cycle through the aggressive release logic;
-		// it should not release the connection since we explicitly suplied it ourselves.
-		session.flush();
-		assertTrue( session.isConnected() );
+			Silly silly = new Silly( "silly" );
+			session.persist( silly );
 
-		session.remove( silly );
-		session.flush();
+			// this will cause the connection manager to cycle through the aggressive release logic;
+			// it should not release the connection since we explicitly suplied it ourselves.
+			session.flush();
+			assertThat( session.isConnected() ).isTrue();
 
-		release( session );
-		done();
+			session.remove( silly );
+			session.flush();
+		}
+		finally {
+			release( session, scope );
+			done();
+			sessionFactory.getServiceRegistry().getService( ConnectionProvider.class )
+					.closeConnection( originalConnection );
 
-		sessionFactory().getServiceRegistry().getService( ConnectionProvider.class ).closeConnection( originalConnection );
+		}
 	}
 
 	@Test
-	public void testConnectionMaintanenceDuringFlush() throws Throwable {
-		final Statistics statistics = sessionFactory().getStatistics();
+	public void testConnectionMaintanenceDuringFlush(SessionFactoryScope scope) throws Throwable {
+		SessionFactoryImplementor sessionFactory = scope.getSessionFactory();
+
+		final Statistics statistics = sessionFactory.getStatistics();
 		prepare();
-		Session s = getSessionUnderTest();
 
-		List<Silly> entities = new ArrayList<Silly>();
-		for ( int i = 0; i < 10; i++ ) {
-			Other other = new Other( "other-" + i );
-			Silly silly = new Silly( "silly-" + i, other );
-			entities.add( silly );
-			s.persist( silly );
-		}
-		s.flush();
+		Session s = null;
+		try {
+			s = getSessionUnderTest( scope );
+
+			List<Silly> entities = new ArrayList<>();
+			for ( int i = 0; i < 10; i++ ) {
+				Other other = new Other( "other-" + i );
+				Silly silly = new Silly( "silly-" + i, other );
+				entities.add( silly );
+				s.persist( silly );
+			}
+			s.flush();
 
-		for ( Silly silly : entities ) {
-			silly.setName( "new-" + silly.getName() );
-			silly.getOther().setName( "new-" + silly.getOther().getName() );
+			for ( Silly silly : entities ) {
+				silly.setName( "new-" + silly.getName() );
+				silly.getOther().setName( "new-" + silly.getOther().getName() );
+			}
+			long initialCount = statistics.getConnectCount();
+			s.flush();
+			assertThat( statistics.getConnectCount() )
+					.describedAs( "connection not maintained through flush" )
+					.isEqualTo( initialCount + 1 );
+
+			s.createMutationQuery( "delete from Silly" ).executeUpdate();
+			s.createMutationQuery( "delete from Other" ).executeUpdate();
+			s.getTransaction().commit();
 		}
-		long initialCount = statistics.getConnectCount();
-		s.flush();
-		assertEquals( "connection not maintained through flush", initialCount + 1, statistics.getConnectCount() );
-
-		s.createQuery( "delete from Silly" ).executeUpdate();
-		s.createQuery( "delete from Other" ).executeUpdate();
-		s.getTransaction().commit();
-		release( s );
-		done();
+		finally {
+			release( s, scope );
+			done();
+		}
+
 	}
 }