Skip to content

Commit bf725bc

Browse files
jrenaatjrenaat
committed
HHH-19846 - Drop JUnit 4 usage: org.hibernate.orm.test.jpa.criteria - WIP
Signed-off-by: Jan Schatteman <jschatte@redhat.com>
1 parent 0da7f88 commit bf725bc

19 files changed

+1318
-1601
lines changed

‎hibernate-core/src/test/java/org/hibernate/orm/test/jpa/criteria/alias/CriteriaMultiselectAliasTest.java‎

Lines changed: 26 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -4,51 +4,51 @@
44
*/
55
package org.hibernate.orm.test.jpa.criteria.alias;
66

7-
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
8-
import static org.junit.Assert.assertEquals;
9-
10-
import java.util.List;
11-
127
import jakarta.persistence.Entity;
138
import jakarta.persistence.Id;
149
import jakarta.persistence.criteria.CriteriaBuilder;
1510
import jakarta.persistence.criteria.CriteriaQuery;
1611
import jakarta.persistence.criteria.Root;
1712

18-
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
1913
import org.hibernate.query.Query;
14+
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
2015
import org.hibernate.testing.orm.junit.JiraKey;
16+
import org.hibernate.testing.orm.junit.Jpa;
2117
import org.hibernate.transform.Transformers;
22-
import org.junit.Before;
23-
import org.junit.Test;
18+
19+
import org.junit.jupiter.api.AfterEach;
20+
import org.junit.jupiter.api.BeforeEach;
21+
import org.junit.jupiter.api.Test;
22+
23+
import java.util.List;
24+
25+
import static org.junit.jupiter.api.Assertions.assertEquals;
2426

2527
/**
2628
* @author Vlad Mihalcea
2729
*/
28-
public class CriteriaMultiselectAliasTest extends BaseEntityManagerFunctionalTestCase {
29-
30-
@Override
31-
protected Class<?>[] getAnnotatedClasses() {
32-
return new Class[] {
33-
Book.class
34-
};
35-
}
30+
@Jpa(annotatedClasses = {CriteriaMultiselectAliasTest.Book.class})
31+
public class CriteriaMultiselectAliasTest {
3632

37-
@Before
38-
public void init() {
39-
doInJPA( this::entityManagerFactory, entityManager -> {
33+
@BeforeEach
34+
public void init(EntityManagerFactoryScope scope) {
35+
scope.inTransaction( entityManager -> {
4036
Book book = new Book();
4137
book.id = 1;
4238
book.name = bookName();
43-
4439
entityManager.persist( book );
4540
} );
4641
}
4742

43+
@AfterEach
44+
public void cleanup(EntityManagerFactoryScope scope) {
45+
scope.getEntityManagerFactory().getSchemaManager().truncate();
46+
}
47+
4848
@Test
4949
@JiraKey(value = "HHH-13140")
50-
public void testAlias() {
51-
doInJPA( this::entityManagerFactory, entityManager -> {
50+
public void testAlias(EntityManagerFactoryScope scope) {
51+
scope.inTransaction( entityManager -> {
5252
final CriteriaBuilder cb = entityManager.getCriteriaBuilder();
5353

5454
final CriteriaQuery<Object[]> query = cb.createQuery( Object[].class );
@@ -73,8 +73,8 @@ public void testAlias() {
7373

7474
@Test
7575
@JiraKey(value = "HHH-13192")
76-
public void testNoAliasInWhereClause() {
77-
doInJPA( this::entityManagerFactory, entityManager -> {
76+
public void testNoAliasInWhereClause(EntityManagerFactoryScope scope) {
77+
scope.inTransaction( entityManager -> {
7878
final CriteriaBuilder cb = entityManager.getCriteriaBuilder();
7979

8080
final CriteriaQuery<Object[]> query = cb.createQuery( Object[].class );
@@ -101,8 +101,8 @@ public void testNoAliasInWhereClause() {
101101

102102
@Test
103103
@JiraKey(value = "HHH-13192")
104-
public void testNoAliasInWhereClauseSimplified() {
105-
doInJPA( this::entityManagerFactory, entityManager -> {
104+
public void testNoAliasInWhereClauseSimplified(EntityManagerFactoryScope scope) {
105+
scope.inTransaction( entityManager -> {
106106
CriteriaBuilder cb = entityManager.getCriteriaBuilder();
107107
CriteriaQuery<Object> criteriaQuery = cb.createQuery();
108108
Root<Book> root = criteriaQuery.from( Book.class );

‎hibernate-core/src/test/java/org/hibernate/orm/test/jpa/criteria/basic/AggregationResultTest.java‎

Lines changed: 72 additions & 88 deletions
Original file line numberDiff line numberDiff line change
@@ -6,15 +6,16 @@
66

77
import java.math.BigDecimal;
88
import java.math.BigInteger;
9-
import jakarta.persistence.EntityManager;
9+
1010
import jakarta.persistence.criteria.CriteriaBuilder;
1111
import jakarta.persistence.criteria.CriteriaQuery;
1212
import jakarta.persistence.criteria.Root;
1313

14-
import org.hibernate.orm.test.jpa.metamodel.AbstractMetamodelSpecificTest;
1514
import org.hibernate.orm.test.jpa.metamodel.Product;
1615
import org.hibernate.orm.test.jpa.metamodel.Product_;
1716

17+
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
18+
import org.hibernate.testing.orm.junit.Jpa;
1819
import org.junit.jupiter.api.AfterEach;
1920
import org.junit.jupiter.api.BeforeEach;
2021
import org.junit.jupiter.api.Test;
@@ -24,134 +25,117 @@
2425
/**
2526
* @author Steve Ebersole
2627
*/
27-
public class AggregationResultTest extends AbstractMetamodelSpecificTest {
28+
@Jpa(annotatedClasses = {Product.class})
29+
public class AggregationResultTest {
2830
private CriteriaBuilder builder;
2931

3032
@BeforeEach
31-
public void createTestData() {
32-
builder = entityManagerFactory().getCriteriaBuilder();
33-
34-
EntityManager em = getOrCreateEntityManager();
35-
em.getTransaction().begin();
36-
Product product = new Product();
37-
product.setId( "product1" );
38-
product.setPrice( 1.23d );
39-
product.setQuantity( 1000 );
40-
product.setPartNumber( ( (long) Integer.MAX_VALUE ) + 1 );
41-
product.setRating( 1.999f );
42-
product.setSomeBigInteger( BigInteger.valueOf( 987654321 ) );
43-
product.setSomeBigDecimal( BigDecimal.valueOf( 987654.32 ) );
44-
em.persist( product );
45-
em.getTransaction().commit();
46-
em.close();
33+
public void createTestData(EntityManagerFactoryScope scope) {
34+
builder = scope.getEntityManagerFactory().getCriteriaBuilder();
35+
36+
scope.inTransaction( entityManager -> {
37+
Product product = new Product();
38+
product.setId( "product1" );
39+
product.setPrice( 1.23d );
40+
product.setQuantity( 1000 );
41+
product.setPartNumber( ((long) Integer.MAX_VALUE) + 1 );
42+
product.setRating( 1.999f );
43+
product.setSomeBigInteger( BigInteger.valueOf( 987654321 ) );
44+
product.setSomeBigDecimal( BigDecimal.valueOf( 987654.32 ) );
45+
entityManager.persist( product );
46+
} );
4747
}
4848

4949
@AfterEach
50-
public void cleanUpTestData() throws Exception {
51-
EntityManager em = getOrCreateEntityManager();
52-
em.getTransaction().begin();
53-
em.createQuery( "delete Product" ).executeUpdate();
54-
em.getTransaction().commit();
55-
em.close();
50+
public void cleanUpTestData(EntityManagerFactoryScope scope) {
51+
scope.getEntityManagerFactory().getSchemaManager().truncate();
5652
}
5753

5854
/**
5955
* Sum of Longs should return a Long
6056
*/
6157
@Test
62-
public void testSumOfLongs() {
63-
EntityManager em = getOrCreateEntityManager();
64-
em.getTransaction().begin();
65-
CriteriaQuery<Long> criteria = builder.createQuery( Long.class );
66-
Root<Product> productRoot = criteria.from( Product.class );
67-
criteria.select( builder.sum( productRoot.get( Product_.partNumber ) ) );
68-
Object sumResult = em.createQuery( criteria ).getSingleResult();
69-
assertReturnType( Long.class, sumResult );
70-
em.getTransaction().commit();
71-
em.close();
58+
public void testSumOfLongs(EntityManagerFactoryScope scope) {
59+
scope.inTransaction( entityManager -> {
60+
CriteriaQuery<Long> criteria = builder.createQuery( Long.class );
61+
Root<Product> productRoot = criteria.from( Product.class );
62+
criteria.select( builder.sum( productRoot.get( Product_.partNumber ) ) );
63+
Object sumResult = entityManager.createQuery( criteria ).getSingleResult();
64+
assertReturnType( Long.class, sumResult );
65+
} );
7266
}
7367

7468
/**
75-
* Sum of Integers should return an Integer; note that this is distinctly different than JPAQL
69+
* Sum of Integers should return an Integer; note that this is distinctly different from JPAQL
7670
*/
7771
@Test
78-
public void testSumOfIntegers() {
79-
EntityManager em = getOrCreateEntityManager();
80-
em.getTransaction().begin();
81-
CriteriaQuery<Integer> criteria = builder.createQuery( Integer.class );
82-
Root<Product> productRoot = criteria.from( Product.class );
83-
criteria.select( builder.sum( productRoot.get( Product_.quantity ) ) );
84-
Object sumResult = em.createQuery( criteria ).getSingleResult();
85-
assertReturnType( Integer.class, sumResult );
86-
em.getTransaction().commit();
87-
em.close();
72+
public void testSumOfIntegers(EntityManagerFactoryScope scope) {
73+
scope.inTransaction( entityManager -> {
74+
CriteriaQuery<Integer> criteria = builder.createQuery( Integer.class );
75+
Root<Product> productRoot = criteria.from( Product.class );
76+
criteria.select( builder.sum( productRoot.get( Product_.quantity ) ) );
77+
Object sumResult = entityManager.createQuery( criteria ).getSingleResult();
78+
assertReturnType( Integer.class, sumResult );
79+
} );
8880
}
8981

9082
/**
9183
* Sum of Doubles should return a Double
9284
*/
9385
@Test
94-
public void testSumOfDoubles() {
95-
EntityManager em = getOrCreateEntityManager();
96-
em.getTransaction().begin();
97-
CriteriaQuery<Double> criteria = builder.createQuery( Double.class );
98-
Root<Product> productRoot = criteria.from( Product.class );
99-
criteria.select( builder.sum( productRoot.get( Product_.price ) ) );
100-
Object sumResult = em.createQuery( criteria ).getSingleResult();
101-
assertReturnType( Double.class, sumResult );
102-
em.getTransaction().commit();
103-
em.close();
86+
public void testSumOfDoubles(EntityManagerFactoryScope scope) {
87+
scope.inTransaction( entityManager -> {
88+
CriteriaQuery<Double> criteria = builder.createQuery( Double.class );
89+
Root<Product> productRoot = criteria.from( Product.class );
90+
criteria.select( builder.sum( productRoot.get( Product_.price ) ) );
91+
Object sumResult = entityManager.createQuery( criteria ).getSingleResult();
92+
assertReturnType( Double.class, sumResult );
93+
} );
10494
}
10595

10696
/**
107-
* Sum of Floats should return a Float; note that this is distinctly different than JPAQL
97+
* Sum of Floats should return a Float; note that this is distinctly different from JPAQL
10898
*/
10999
@Test
110-
public void testSumOfFloats() {
111-
EntityManager em = getOrCreateEntityManager();
112-
em.getTransaction().begin();
113-
CriteriaQuery<Float> criteria = builder.createQuery( Float.class );
114-
Root<Product> productRoot = criteria.from( Product.class );
115-
criteria.select( builder.sum( productRoot.get( Product_.rating ) ) );
116-
Object sumResult = em.createQuery( criteria ).getSingleResult();
117-
assertReturnType( Float.class, sumResult );
118-
em.getTransaction().commit();
119-
em.close();
100+
public void testSumOfFloats(EntityManagerFactoryScope scope) {
101+
scope.inTransaction( entityManager -> {
102+
CriteriaQuery<Float> criteria = builder.createQuery( Float.class );
103+
Root<Product> productRoot = criteria.from( Product.class );
104+
criteria.select( builder.sum( productRoot.get( Product_.rating ) ) );
105+
Object sumResult = entityManager.createQuery( criteria ).getSingleResult();
106+
assertReturnType( Float.class, sumResult );
107+
} );
120108
}
121109

122110
/**
123111
* Sum of BigInteger should return a BigInteger
124112
*/
125113
@Test
126-
public void testSumOfBigIntegers() {
127-
EntityManager em = getOrCreateEntityManager();
128-
em.getTransaction().begin();
129-
CriteriaQuery<BigInteger> criteria = builder.createQuery( BigInteger.class );
130-
Root<Product> productRoot = criteria.from( Product.class );
131-
criteria.select( builder.sum( productRoot.get( Product_.someBigInteger ) ) );
132-
Object sumResult = em.createQuery( criteria ).getSingleResult();
133-
assertReturnType( BigInteger.class, sumResult );
134-
em.getTransaction().commit();
135-
em.close();
114+
public void testSumOfBigIntegers(EntityManagerFactoryScope scope) {
115+
scope.inTransaction( entityManager -> {
116+
CriteriaQuery<BigInteger> criteria = builder.createQuery( BigInteger.class );
117+
Root<Product> productRoot = criteria.from( Product.class );
118+
criteria.select( builder.sum( productRoot.get( Product_.someBigInteger ) ) );
119+
Object sumResult = entityManager.createQuery( criteria ).getSingleResult();
120+
assertReturnType( BigInteger.class, sumResult );
121+
} );
136122
}
137123

138124
/**
139125
* Sum of BigDecimal should return a BigDecimal
140126
*/
141127
@Test
142-
public void testSumOfBigDecimals() {
143-
EntityManager em = getOrCreateEntityManager();
144-
em.getTransaction().begin();
145-
CriteriaQuery<BigDecimal> criteria = builder.createQuery( BigDecimal.class );
146-
Root<Product> productRoot = criteria.from( Product.class );
147-
criteria.select( builder.sum( productRoot.get( Product_.someBigDecimal ) ) );
148-
Object sumResult = em.createQuery( criteria ).getSingleResult();
149-
assertReturnType( BigDecimal.class, sumResult );
150-
em.getTransaction().commit();
151-
em.close();
128+
public void testSumOfBigDecimals(EntityManagerFactoryScope scope) {
129+
scope.inTransaction( entityManager -> {
130+
CriteriaQuery<BigDecimal> criteria = builder.createQuery( BigDecimal.class );
131+
Root<Product> productRoot = criteria.from( Product.class );
132+
criteria.select( builder.sum( productRoot.get( Product_.someBigDecimal ) ) );
133+
Object sumResult = entityManager.createQuery( criteria ).getSingleResult();
134+
assertReturnType( BigDecimal.class, sumResult );
135+
} );
152136
}
153137

154-
private void assertReturnType(Class expectedType, Object value) {
138+
private void assertReturnType(Class<?> expectedType, Object value) {
155139
if ( value != null && ! expectedType.isInstance( value ) ) {
156140
fail(
157141
"Result value was not of expected type: expected [" + expectedType.getName()

0 commit comments

Comments
 (0)