HHH-19846 - Remove JUnit4: org.hibernate.orm.test.distinct

Signed-off-by: Jan Schatteman <[email protected]>

Author: jrenaat

hibernate-core/src/test/java/org/hibernate/orm/test/distinct/SelectDistinctHqlTest.java

@@ -7,12 +7,14 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import org.hibernate.boot.SessionFactoryBuilder;
-
+import org.hibernate.testing.jdbc.SQLStatementInspector;
+import org.hibernate.testing.orm.junit.DomainModel;
 import org.hibernate.testing.orm.junit.JiraKey;
-import org.hibernate.testing.jdbc.SQLStatementInterceptor;
-import org.hibernate.testing.junit4.BaseNonConfigCoreFunctionalTestCase;
-import org.junit.Test;
+import org.hibernate.testing.orm.junit.SessionFactory;
+import org.hibernate.testing.orm.junit.SessionFactoryScope;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import jakarta.persistence.CascadeType;
 import jakarta.persistence.Column;
@@ -23,87 +25,79 @@
 import jakarta.persistence.NamedQuery;
 import jakarta.persistence.OneToMany;
 
-import static org.hibernate.testing.transaction.TransactionUtil.doInHibernate;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * @author Vlad Mihalcea
  */
 @JiraKey(value = "HHH-10965")
-public class SelectDistinctHqlTest extends BaseNonConfigCoreFunctionalTestCase {
+@DomainModel(annotatedClasses = {SelectDistinctHqlTest.Person.class, SelectDistinctHqlTest.Phone.class})
+@SessionFactory(useCollectingStatementInspector = true)
+public class SelectDistinctHqlTest {
 
 	private static final String DISTINCT_NAMED_QUERY = "distinct";
-	private SQLStatementInterceptor sqlStatementInterceptor;
-
-	@Override
-	protected void configureSessionFactoryBuilder(SessionFactoryBuilder sfb) {
-		sqlStatementInterceptor = new SQLStatementInterceptor( sfb );
-	}
+	private SQLStatementInspector SQLStatementInspector;
 
-	@Override
-	protected Class<?>[] getAnnotatedClasses() {
-		return new Class<?>[] {
-				Person.class,
-				Phone.class,
-		};
-	}
-
-	protected void prepareTest() {
-		doInHibernate( this::sessionFactory, session -> {
+	@BeforeEach
+	protected void setup(SessionFactoryScope scope) {
+		scope.inTransaction( session -> {
 			Person person = new Person();
 			person.id = 1L;
 			session.persist( person );
 
 			person.addPhone( new Phone( "027-123-4567" ) );
 			person.addPhone( new Phone( "028-234-9876" ) );
 		} );
+
+		SQLStatementInspector = scope.getCollectingStatementInspector();
+		SQLStatementInspector.clear();
 	}
 
-	@Override
-	protected boolean isCleanupTestDataRequired() {
-		return true;
+	@AfterEach
+	protected void tearDown(SessionFactoryScope scope) {
+		scope.dropData();
 	}
 
 	@Test
-	public void test() {
-		doInHibernate( this::sessionFactory, session -> {
-			sqlStatementInterceptor.getSqlQueries().clear();
-			List<Person> persons = session.createQuery( "select distinct p from Person p" )
+	public void test(SessionFactoryScope scope) {
+		scope.inTransaction( session -> {
+			SQLStatementInspector.getSqlQueries().clear();
+			List<Person> persons = session.createQuery( "select distinct p from Person p", Person.class )
 					.getResultList();
-			String sqlQuery = sqlStatementInterceptor.getSqlQueries().getLast();
+			String sqlQuery = SQLStatementInspector.getSqlQueries().get(0);
 			assertEquals( 1, persons.size() );
 			assertTrue( sqlQuery.contains( " distinct " ) );
 		} );
 
-		doInHibernate( this::sessionFactory, session -> {
-			List<Person> persons = session.createQuery( "select p from Person p left join fetch p.phones " )
+		scope.inTransaction( session -> {
+			List<Person> persons = session.createQuery( "select p from Person p left join fetch p.phones ", Person.class )
 					.getResultList();
 			// with Hibernate ORM 6 it is not necessary to use *distinct* to not duplicate the instances which own the association
 			assertEquals( 1, persons.size() );
 		} );
 
-		doInHibernate( this::sessionFactory, session -> {
-			sqlStatementInterceptor.getSqlQueries().clear();
-			List<Person> persons = session.createQuery( "select distinct p from Person p left join fetch p.phones " )
+		scope.inTransaction( session -> {
+			SQLStatementInspector.getSqlQueries().clear();
+			List<Person> persons = session.createQuery( "select distinct p from Person p left join fetch p.phones ", Person.class )
 					.getResultList();
 			assertEquals( 1, persons.size() );
-			String sqlQuery = sqlStatementInterceptor.getSqlQueries().getLast();
+			String sqlQuery = SQLStatementInspector.getSqlQueries().get(0);
 			assertTrue( sqlQuery.contains( " distinct " ) );
 		} );
 	}
 
 	@Test
 	@JiraKey(value = "HHH-13780")
-	public void testNamedQueryDistinctPassThroughTrueWhenNotSpecified() {
-		doInHibernate( this::sessionFactory, session -> {
-			sqlStatementInterceptor.getSqlQueries().clear();
+	public void testNamedQueryDistinctPassThroughTrueWhenNotSpecified(SessionFactoryScope scope) {
+		scope.inTransaction( session -> {
+			SQLStatementInspector.getSqlQueries().clear();
 			List<Person> persons =
 					session.createNamedQuery( DISTINCT_NAMED_QUERY, Person.class )
 							.setMaxResults( 5 )
 							.getResultList();
 			assertEquals( 1, persons.size() );
-			String sqlQuery = sqlStatementInterceptor.getSqlQueries().getLast();
+			String sqlQuery = SQLStatementInspector.getSqlQueries().get(0);
 			assertTrue( sqlQuery.contains( " distinct " ) );
 		} );
 	}