Skip to content

Commit 5a5f2b5

Browse files
blafondDavideD
blafond
authored and
DavideD
committed
[#1582] Convert tests to JUnit5
1 parent 47faaa1 commit 5a5f2b5

File tree

159 files changed

+5417
-4283
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

159 files changed

+5417
-4283
lines changed

‎hibernate-reactive-core/src/test/java/org/hibernate/reactive/BatchFetchTest.java‎

Lines changed: 46 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,19 @@
99
import java.util.Collection;
1010
import java.util.List;
1111
import java.util.Objects;
12+
import java.util.concurrent.CompletionStage;
13+
import java.util.concurrent.TimeUnit;
14+
15+
import org.hibernate.Hibernate;
16+
import org.hibernate.LockMode;
17+
import org.hibernate.annotations.BatchSize;
18+
import org.hibernate.reactive.util.impl.CompletionStages;
19+
20+
import org.junit.jupiter.api.Disabled;
21+
import org.junit.jupiter.api.Test;
22+
23+
import io.vertx.junit5.Timeout;
24+
import io.vertx.junit5.VertxTestContext;
1225
import jakarta.persistence.CascadeType;
1326
import jakarta.persistence.Entity;
1427
import jakarta.persistence.FetchType;
@@ -27,34 +40,27 @@
2740
import jakarta.persistence.Transient;
2841
import jakarta.persistence.Version;
2942

30-
import org.hibernate.Hibernate;
31-
import org.hibernate.LockMode;
32-
import org.hibernate.annotations.BatchSize;
33-
34-
import org.junit.After;
35-
import org.junit.Ignore;
36-
import org.junit.Test;
37-
38-
import io.vertx.ext.unit.TestContext;
39-
43+
import static org.junit.jupiter.api.Assertions.assertEquals;
44+
import static org.junit.jupiter.api.Assertions.assertFalse;
45+
import static org.junit.jupiter.api.Assertions.assertTrue;
4046

47+
@Timeout( value = 5, timeUnit = TimeUnit.MINUTES ) // DB2 seems to take longer than other DB's
4148
public class BatchFetchTest extends BaseReactiveTest {
4249

4350
@Override
4451
protected Collection<Class<?>> annotatedEntities() {
45-
return List.of( Node.class, Element.class );
52+
return List.of( Element.class, Node.class );
4653
}
4754

48-
@After
49-
public void cleanDb(TestContext context) {
50-
test( context, getSessionFactory()
51-
.withTransaction( s -> s.createQuery( "delete from Element" ).executeUpdate()
52-
.thenCompose( v -> s.createQuery( "delete from Node" ).executeUpdate() ) ) );
55+
@Override
56+
public CompletionStage<Void> cleanDb() {
57+
getSessionFactory().close();
58+
return CompletionStages.voidFuture();
5359
}
5460

5561
@Test
56-
@Ignore // See https://github.com/hibernate/hibernate-reactive/issues/1501
57-
public void testQuery(TestContext context) {
62+
@Disabled// See https://github.com/hibernate/hibernate-reactive/issues/1501
63+
public void testQuery(VertxTestContext context) {
5864
Node basik = new Node( "Child" );
5965
basik.parent = new Node( "Parent" );
6066
basik.elements.add( new Element( basik ) );
@@ -69,33 +75,33 @@ public void testQuery(TestContext context) {
6975
.thenCompose( s -> s.createQuery( "from Node n order by id", Node.class )
7076
.getResultList()
7177
.thenCompose( list -> {
72-
context.assertEquals( list.size(), 2 );
78+
assertEquals( list.size(), 2 );
7379
Node n1 = list.get( 0 );
7480
Node n2 = list.get( 1 );
75-
context.assertFalse( Hibernate.isInitialized( n1.getElements() ), "'n1.elements' should not be initialize" );
76-
context.assertFalse( Hibernate.isInitialized( n2.getElements() ), "'n2.elements' should not be initialize" );
81+
assertFalse( Hibernate.isInitialized( n1.getElements() ), "'n1.elements' should not be initialize" );
82+
assertFalse( Hibernate.isInitialized( n2.getElements() ), "'n2.elements' should not be initialize" );
7783
return s.fetch( n1.getElements() )
7884
.thenAccept( elements -> {
79-
context.assertTrue( Hibernate.isInitialized( elements ), "'elements' after fetch should not be initialize" );
80-
context.assertTrue( Hibernate.isInitialized( n1.getElements() ), "'n1.elements' after fetch should be initialize" );
81-
context.assertTrue( Hibernate.isInitialized( n2.getElements() ), "'n2.elements' after fetch should be initialize" );
85+
assertTrue( Hibernate.isInitialized( elements ), "'elements' after fetch should not be initialize" );
86+
assertTrue( Hibernate.isInitialized( n1.getElements() ), "'n1.elements' after fetch should be initialize" );
87+
assertTrue( Hibernate.isInitialized( n2.getElements() ), "'n2.elements' after fetch should be initialize" );
8288
} );
8389
} )
8490
)
8591
.thenCompose( v -> openSession() )
8692
.thenCompose( s -> s.createQuery( "from Element e order by id", Element.class )
8793
.getResultList()
8894
.thenCompose( list -> {
89-
context.assertEquals( list.size(), 5 );
90-
list.forEach( element -> context.assertFalse( Hibernate.isInitialized( element.node ) ) );
91-
list.forEach( element -> context.assertEquals( s.getLockMode( element.node ), LockMode.NONE ) );
95+
assertEquals( list.size(), 5 );
96+
list.forEach( element -> assertFalse( Hibernate.isInitialized( element.node ) ) );
97+
list.forEach( element -> assertEquals( s.getLockMode( element.node ), LockMode.NONE ) );
9298
return s.fetch( list.get( 0 ).node )
9399
.thenAccept( node -> {
94-
context.assertTrue( Hibernate.isInitialized( node ) );
100+
assertTrue( Hibernate.isInitialized( node ) );
95101
//TODO: I would like to assert that they're all initialized
96102
// but apparently it doesn't set the proxies to init'd
97103
// so check the LockMode as a workaround
98-
list.forEach( element -> context.assertEquals(
104+
list.forEach( element -> assertEquals(
99105
s.getLockMode( element.node ),
100106
LockMode.READ
101107
) );
@@ -106,7 +112,7 @@ public void testQuery(TestContext context) {
106112
}
107113

108114
@Test
109-
public void testBatchLoad(TestContext context) {
115+
public void testBatchLoad(VertxTestContext context) {
110116
Node basik = new Node( "Child" );
111117
basik.parent = new Node( "Parent" );
112118
basik.elements.add( new Element( basik ) );
@@ -120,19 +126,19 @@ public void testBatchLoad(TestContext context) {
120126
.thenCompose( v -> openSession() )
121127
.thenCompose( s -> s.find( Element.class, basik.elements.get( 1 ).id, basik.elements.get( 2 ).id, basik.elements.get( 0 ).id ) )
122128
.thenAccept( elements -> {
123-
context.assertFalse( elements.isEmpty() );
124-
context.assertEquals( 3, elements.size() );
125-
context.assertEquals( basik.elements.get( 1 ).id, elements.get( 0 ).id );
126-
context.assertEquals( basik.elements.get( 2 ).id, elements.get( 1 ).id );
127-
context.assertEquals( basik.elements.get( 0 ).id, elements.get( 2 ).id );
129+
assertFalse( elements.isEmpty() );
130+
assertEquals( 3, elements.size() );
131+
assertEquals( basik.elements.get( 1 ).id, elements.get( 0 ).id );
132+
assertEquals( basik.elements.get( 2 ).id, elements.get( 1 ).id );
133+
assertEquals( basik.elements.get( 0 ).id, elements.get( 2 ).id );
128134
} )
129135
);
130136
}
131137

132138
// If it's only one collection a different method is called
133139
// See ReactivePaddedBatchingCollectionInitializer#reactiveInitialize
134140
@Test
135-
public void testWithCollection(TestContext context) {
141+
public void testWithCollection(VertxTestContext context) {
136142
Node node = new Node( "Child" );
137143
node.elements.add( new Element( node ) );
138144
node.elements.add( new Element( node ) );
@@ -145,12 +151,12 @@ public void testWithCollection(TestContext context) {
145151
.createQuery( "from Node n order by id", Node.class )
146152
.getResultList()
147153
.thenCompose( list -> {
148-
context.assertEquals( list.size(), 1 );
154+
assertEquals( list.size(), 1 );
149155
Node n1 = list.get( 0 );
150-
context.assertFalse( Hibernate.isInitialized( n1.elements ) );
156+
assertFalse( Hibernate.isInitialized( n1.elements ) );
151157
return s.fetch( n1.elements ).thenAccept( elements -> {
152-
context.assertTrue( Hibernate.isInitialized( elements ) );
153-
context.assertTrue( Hibernate.isInitialized( n1.elements ) );
158+
assertTrue( Hibernate.isInitialized( elements ) );
159+
assertTrue( Hibernate.isInitialized( n1.elements ) );
154160
} );
155161
} )
156162
)

‎hibernate-reactive-core/src/test/java/org/hibernate/reactive/BatchQueryOnConnectionTest.java‎

Lines changed: 29 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -11,20 +11,24 @@
1111
import java.util.List;
1212
import java.util.Set;
1313
import java.util.concurrent.CompletionStage;
14-
import jakarta.persistence.Entity;
15-
import jakarta.persistence.Id;
14+
import java.util.concurrent.TimeUnit;
1615

1716
import org.hibernate.reactive.pool.ReactiveConnection;
1817
import org.hibernate.reactive.pool.impl.OracleParameters;
1918
import org.hibernate.reactive.pool.impl.PostgresParameters;
2019
import org.hibernate.reactive.pool.impl.SQLServerParameters;
2120

22-
import org.junit.Test;
21+
import org.junit.jupiter.api.Test;
2322

24-
import io.vertx.ext.unit.TestContext;
23+
import io.vertx.junit5.Timeout;
24+
import io.vertx.junit5.VertxTestContext;
25+
import jakarta.persistence.Entity;
26+
import jakarta.persistence.Id;
2527

2628
import static org.hibernate.reactive.containers.DatabaseConfiguration.dbType;
29+
import static org.junit.jupiter.api.Assertions.assertEquals;
2730

31+
@Timeout( value = 5, timeUnit = TimeUnit.MINUTES )
2832
public class BatchQueryOnConnectionTest extends BaseReactiveTest {
2933

3034
private static final int BATCH_SIZE = 20;
@@ -35,44 +39,44 @@ protected Set<Class<?>> annotatedEntities() {
3539
}
3640

3741
@Test
38-
public void testBatchInsertSizeEqMultiple(TestContext context) {
42+
public void testBatchInsertSizeEqMultiple(VertxTestContext context) {
3943
test( context, doBatchInserts( context, 50, BATCH_SIZE )
4044
.thenAccept( paramsBatches -> {
41-
context.assertEquals( 3, paramsBatches.size() );
42-
context.assertEquals( 20, paramsBatches.get( 0 ).size() );
43-
context.assertEquals( 20, paramsBatches.get( 1 ).size() );
44-
context.assertEquals( 10, paramsBatches.get( 2 ).size() );
45+
assertEquals( 3, paramsBatches.size() );
46+
assertEquals( 20, paramsBatches.get( 0 ).size() );
47+
assertEquals( 20, paramsBatches.get( 1 ).size() );
48+
assertEquals( 10, paramsBatches.get( 2 ).size() );
4549
} )
4650
);
4751
}
4852

4953
@Test
50-
public void testBatchInsertUpdateSizeLtMultiple(TestContext context) {
54+
public void testBatchInsertUpdateSizeLtMultiple(VertxTestContext context) {
5155
test( context, doBatchInserts( context, 50, BATCH_SIZE - 1 )
5256
.thenAccept( paramsBatches -> {
53-
context.assertEquals( 3, paramsBatches.size() );
54-
context.assertEquals( 19, paramsBatches.get( 0 ).size() );
55-
context.assertEquals( 19, paramsBatches.get( 1 ).size() );
56-
context.assertEquals( 12, paramsBatches.get( 2 ).size() );
57+
assertEquals( 3, paramsBatches.size() );
58+
assertEquals( 19, paramsBatches.get( 0 ).size() );
59+
assertEquals( 19, paramsBatches.get( 1 ).size() );
60+
assertEquals( 12, paramsBatches.get( 2 ).size() );
5761
} )
5862
);
5963
}
6064

6165
@Test
62-
public void testBatchInsertUpdateSizeGtMultiple(TestContext context) {
66+
public void testBatchInsertUpdateSizeGtMultiple(VertxTestContext context) {
6367
test( context, doBatchInserts( context, 50, BATCH_SIZE + 1 )
6468
.thenAccept( paramsBatches -> {
65-
context.assertEquals( 5, paramsBatches.size() );
66-
context.assertEquals( 20, paramsBatches.get( 0 ).size() );
67-
context.assertEquals( 1, paramsBatches.get( 1 ).size() );
68-
context.assertEquals( 20, paramsBatches.get( 2 ).size() );
69-
context.assertEquals( 1, paramsBatches.get( 3 ).size() );
70-
context.assertEquals( 8, paramsBatches.get( 4 ).size() );
69+
assertEquals( 5, paramsBatches.size() );
70+
assertEquals( 20, paramsBatches.get( 0 ).size() );
71+
assertEquals( 1, paramsBatches.get( 1 ).size() );
72+
assertEquals( 20, paramsBatches.get( 2 ).size() );
73+
assertEquals( 1, paramsBatches.get( 3 ).size() );
74+
assertEquals( 8, paramsBatches.get( 4 ).size() );
7175
} )
7276
);
7377
}
7478

75-
public CompletionStage<List<List<Object[]>>> doBatchInserts(TestContext context, int nEntities, int nEntitiesMultiple) {
79+
public CompletionStage<List<List<Object[]>>> doBatchInserts(VertxTestContext context, int nEntities, int nEntitiesMultiple) {
7680
final String insertSql = process( "insert into DataPoint (description, x, y, id) values (?, ?, ?, ?)" );
7781

7882
List<List<Object[]>> paramsBatches = new ArrayList<>();
@@ -103,9 +107,9 @@ public CompletionStage<List<List<Object[]>>> doBatchInserts(TestContext context,
103107
stage = stage.thenCompose( connection -> connection
104108
.update( insertSql, batch )
105109
.thenApply( updateCounts -> {
106-
context.assertEquals( batch.size(), updateCounts.length );
110+
assertEquals( batch.size(), updateCounts.length );
107111
for ( int updateCount : updateCounts ) {
108-
context.assertEquals( 1, updateCount );
112+
assertEquals( 1, updateCount );
109113
}
110114
return connection;
111115
} ) );
@@ -115,7 +119,7 @@ public CompletionStage<List<List<Object[]>>> doBatchInserts(TestContext context,
115119
.thenCompose( ignore -> openSession() )
116120
.thenCompose( s -> s
117121
.createQuery( "select count(*) from DataPoint" ).getSingleResult()
118-
.thenAccept( result -> context.assertEquals( (long) nEntities, result ) ) )
122+
.thenAccept( result -> assertEquals( (long) nEntities, result ) ) )
119123
.thenApply( v -> paramsBatches );
120124
}
121125

‎hibernate-reactive-core/src/test/java/org/hibernate/reactive/BatchingConnectionTest.java‎

Lines changed: 23 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,9 @@
55
*/
66
package org.hibernate.reactive;
77

8+
import java.util.concurrent.CompletionStage;
9+
import java.util.concurrent.TimeUnit;
10+
811
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
912
import org.hibernate.cfg.AvailableSettings;
1013
import org.hibernate.cfg.Configuration;
@@ -15,15 +18,19 @@
1518
import org.hibernate.reactive.stage.impl.StageSessionImpl;
1619
import org.hibernate.reactive.stage.impl.StageStatelessSessionImpl;
1720
import org.hibernate.reactive.testing.SqlStatementTracker;
21+
import org.hibernate.reactive.util.impl.CompletionStages;
1822

19-
import org.junit.Test;
23+
import org.junit.jupiter.api.Test;
2024

21-
import io.vertx.ext.unit.TestContext;
25+
import io.vertx.junit5.Timeout;
26+
import io.vertx.junit5.VertxTestContext;
2227

2328
import static org.assertj.core.api.Assertions.assertThat;
2429
import static org.hibernate.reactive.util.impl.CompletionStages.loop;
2530
import static org.hibernate.reactive.util.impl.CompletionStages.voidFuture;
31+
import static org.junit.jupiter.api.Assertions.assertEquals;
2632

33+
@Timeout( value = 5, timeUnit = TimeUnit.MINUTES )
2734
public class BatchingConnectionTest extends ReactiveSessionTest {
2835

2936
private static SqlStatementTracker sqlTracker;
@@ -53,8 +60,14 @@ private static boolean filter(String s) {
5360
return false;
5461
}
5562

63+
@Override
64+
public CompletionStage<Void> cleanDb() {
65+
getSessionFactory().close();
66+
return CompletionStages.voidFuture();
67+
}
68+
5669
@Test
57-
public void testBatchingWithPersistAll(TestContext context) {
70+
public void testBatchingWithPersistAll(VertxTestContext context) {
5871
test( context, openSession()
5972
.thenCompose( s -> s
6073
.persist(
@@ -80,7 +93,7 @@ public void testBatchingWithPersistAll(TestContext context) {
8093
}
8194

8295
@Test
83-
public void testBatching(TestContext context) {
96+
public void testBatching(VertxTestContext context) {
8497
test(
8598
context,
8699
openSession()
@@ -108,7 +121,7 @@ public void testBatching(TestContext context) {
108121
.thenCompose( v -> s.<Long>createQuery("select count(*) from GuineaPig where name='Zero'")
109122
.getSingleResult()
110123
.thenAccept( count -> {
111-
context.assertEquals( 3L, count);
124+
assertEquals( 3L, count);
112125
assertThat( sqlTracker.getLoggedQueries() ).hasSize( 1 );
113126
assertThat( sqlTracker.getLoggedQueries().get( 0 ) )
114127
.matches(
@@ -124,7 +137,7 @@ public void testBatching(TestContext context) {
124137
.thenCompose( v -> s.<Long>createQuery("select count(*) from GuineaPig")
125138
.getSingleResult()
126139
.thenAccept( count -> {
127-
context.assertEquals( 0L, count);
140+
assertEquals( 0L, count);
128141
assertThat( sqlTracker.getLoggedQueries() ).hasSize( 1 );
129142
assertThat( sqlTracker.getLoggedQueries().get( 0 ) )
130143
.matches( "delete from pig where id=.+ and version=.+" );
@@ -136,15 +149,15 @@ public void testBatching(TestContext context) {
136149
}
137150

138151
@Test
139-
public void testBatchingConnection(TestContext context) {
152+
public void testBatchingConnection(VertxTestContext context) {
140153
test( context, openSession()
141154
.thenAccept( session -> assertThat( ( (StageSessionImpl) session ).getReactiveConnection() )
142155
.isInstanceOf( BatchingConnection.class ) )
143156
);
144157
}
145158

146159
@Test
147-
public void testBatchingConnectionWithStateless(TestContext context) {
160+
public void testBatchingConnectionWithStateless(VertxTestContext context) {
148161
test( context, openStatelessSession()
149162
.thenAccept( session -> assertThat( ( (StageStatelessSessionImpl) session ).getReactiveConnection() )
150163
// Stateless session is not affected by the STATEMENT_BATCH_SIZE property
@@ -153,15 +166,15 @@ public void testBatchingConnectionWithStateless(TestContext context) {
153166
}
154167

155168
@Test
156-
public void testBatchingConnectionMutiny(TestContext context) {
169+
public void testBatchingConnectionMutiny(VertxTestContext context) {
157170
test( context, openMutinySession()
158171
.invoke( session -> assertThat( ( (MutinySessionImpl) session ).getReactiveConnection() )
159172
.isInstanceOf( BatchingConnection.class ) )
160173
);
161174
}
162175

163176
@Test
164-
public void testBatchingConnectionWithMutinyStateless(TestContext context) {
177+
public void testBatchingConnectionWithMutinyStateless(VertxTestContext context) {
165178
test( context, openMutinyStatelessSession()
166179
.invoke( session -> assertThat( ( (MutinyStatelessSessionImpl) session ).getReactiveConnection() )
167180
// Stateless session is not affected by the STATEMENT_BATCH_SIZE property

0 commit comments

Comments
 (0)