9
9
import java .util .ArrayList ;
10
10
import java .util .List ;
11
11
12
- import jakarta .persistence .Entity ;
13
- import jakarta .persistence .GeneratedValue ;
14
- import jakarta .persistence .Id ;
15
-
16
12
import org .hibernate .FlushMode ;
17
13
import org .hibernate .HibernateException ;
18
- import org .hibernate .Session ;
19
14
import org .hibernate .boot .Metadata ;
20
- import org .hibernate .boot .registry . BootstrapServiceRegistryBuilder ;
15
+ import org .hibernate .boot .spi . BootstrapContext ;
21
16
import org .hibernate .engine .spi .SessionFactoryImplementor ;
22
17
import org .hibernate .event .service .spi .EventListenerRegistry ;
23
18
import org .hibernate .event .spi .AutoFlushEvent ;
24
19
import org .hibernate .event .spi .AutoFlushEventListener ;
25
20
import org .hibernate .event .spi .EventType ;
26
21
import org .hibernate .integrator .spi .Integrator ;
27
- import org .hibernate .service .spi .SessionFactoryServiceRegistry ;
28
22
29
- import org .hibernate .testing .junit4 .BaseCoreFunctionalTestCase ;
30
- import org .junit .Test ;
23
+ import org .hibernate .testing .orm .junit .BootstrapServiceRegistry ;
24
+ import org .hibernate .testing .orm .junit .DomainModel ;
25
+ import org .hibernate .testing .orm .junit .SessionFactory ;
26
+ import org .hibernate .testing .orm .junit .SessionFactoryScope ;
27
+ import org .junit .jupiter .api .Test ;
31
28
32
- import static org . junit . Assert . assertEquals ;
33
- import static org . junit . Assert . assertFalse ;
34
- import static org . junit . Assert . assertTrue ;
29
+ import jakarta . persistence . Entity ;
30
+ import jakarta . persistence . GeneratedValue ;
31
+ import jakarta . persistence . Id ;
35
32
36
- public class AutoFlushEventListenerTest extends BaseCoreFunctionalTestCase {
33
+ import static org .assertj .core .api .AssertionsForClassTypes .assertThat ;
34
+ import static org .junit .jupiter .api .Assertions .assertFalse ;
35
+ import static org .junit .jupiter .api .Assertions .assertTrue ;
37
36
38
- private TheListener listener = new TheListener ();
39
37
40
- @ Test
41
- public void testAutoFlushRequired () {
42
- listener .events .clear ();
43
-
44
- Session s = openSession ();
45
- s .beginTransaction ();
46
-
47
- s .persist ( new Entity1 () );
48
- assertEquals ( 0 , listener .events .size () );
49
-
50
- // An entity of this type was persisted; a flush is required
51
- session .createQuery ( "select i from Entity1 i" )
52
- .setHibernateFlushMode ( FlushMode .AUTO )
53
- .getResultList ();
54
- assertEquals ( 1 , listener .events .size () );
55
- assertTrue ( listener .events .get ( 0 ).isFlushRequired () );
56
-
57
- s .getTransaction ().commit ();
58
- assertEquals ( 1 , listener .events .size () );
59
- s .close ();
60
- assertEquals ( 1 , listener .events .size () );
61
- }
38
+ @ DomainModel (
39
+ annotatedClasses = {
40
+ AutoFlushEventListenerTest .Entity1 .class ,
41
+ AutoFlushEventListenerTest .Entity2 .class
42
+ }
43
+ )
44
+ @ SessionFactory
45
+ @ BootstrapServiceRegistry (
46
+ integrators = AutoFlushEventListenerTest .CustomLoadIntegrator .class
47
+ )
48
+ public class AutoFlushEventListenerTest {
49
+
50
+ private static final TheListener LISTENER = new TheListener ();
62
51
63
52
@ Test
64
- public void testAutoFlushNotRequired () {
65
- listener .events .clear ();
66
-
67
- Session s = openSession ();
68
- s .beginTransaction ();
69
-
70
- s .persist ( new Entity2 () );
71
- assertEquals ( 0 , listener .events .size () );
72
-
73
- // No entity of this type was persisted; no flush is required
74
- session .createQuery ( "select i from Entity1 i" )
75
- .setHibernateFlushMode ( FlushMode .AUTO )
76
- .getResultList ();
77
- assertEquals ( 1 , listener .events .size () );
78
- assertFalse ( listener .events .get ( 0 ).isFlushRequired () );
79
-
80
- s .getTransaction ().commit ();
81
- assertEquals ( 1 , listener .events .size () );
82
- s .close ();
83
- assertEquals ( 1 , listener .events .size () );
53
+ public void testAutoFlushRequired (SessionFactoryScope scope ) {
54
+ LISTENER .events .clear ();
55
+
56
+ scope .inSession (
57
+ session -> {
58
+ session .beginTransaction ();
59
+ try {
60
+ session .persist ( new Entity1 () );
61
+ assertThat ( LISTENER .events .size () ).isEqualTo ( 0 );
62
+
63
+ // An entity of this type was persisted; a flush is required
64
+ session .createQuery ( "select i from Entity1 i" , Entity1 .class )
65
+ .setHibernateFlushMode ( FlushMode .AUTO )
66
+ .getResultList ();
67
+ assertThat ( LISTENER .events .size () ).isEqualTo ( 1 );
68
+ assertTrue ( LISTENER .events .get ( 0 ).isFlushRequired () );
69
+
70
+ session .getTransaction ().commit ();
71
+ }
72
+ catch (Exception e ) {
73
+ session .getTransaction ().rollback ();
74
+ throw e ;
75
+ }
76
+ assertThat ( LISTENER .events .size () ).isEqualTo ( 1 );
77
+ }
78
+ );
79
+ assertThat ( LISTENER .events .size () ).isEqualTo ( 1 );
84
80
}
85
81
86
- @ Override
87
- protected void prepareBootstrapRegistryBuilder (BootstrapServiceRegistryBuilder builder ) {
88
- super .prepareBootstrapRegistryBuilder ( builder );
89
- builder .applyIntegrator (
90
- new Integrator () {
91
- @ Override
92
- public void integrate (
93
- Metadata metadata ,
94
- SessionFactoryImplementor sessionFactory ,
95
- SessionFactoryServiceRegistry serviceRegistry ) {
96
- serviceRegistry .getService ( EventListenerRegistry .class ).appendListeners (
97
- EventType .AUTO_FLUSH ,
98
- listener
99
- );
82
+ @ Test
83
+ public void testAutoFlushNotRequired (SessionFactoryScope scope ) {
84
+ LISTENER .events .clear ();
85
+
86
+ scope .inSession (
87
+ session -> {
88
+ session .beginTransaction ();
89
+ try {
90
+ session .persist ( new Entity2 () );
91
+ assertThat ( LISTENER .events .size () ).isEqualTo ( 0 );
92
+
93
+ // No entity of this type was persisted; no flush is required
94
+ session .createQuery ( "select i from Entity1 i" , Entity1 .class )
95
+ .setHibernateFlushMode ( FlushMode .AUTO )
96
+ .getResultList ();
97
+ assertThat ( LISTENER .events .size () ).isEqualTo ( 1 );
98
+ assertFalse ( LISTENER .events .get ( 0 ).isFlushRequired () );
99
+
100
+ session .getTransaction ().commit ();
100
101
}
101
-
102
- @ Override
103
- public void disintegrate (SessionFactoryImplementor sessionFactory ,
104
- SessionFactoryServiceRegistry serviceRegistry ) {
102
+ catch (Exception e ) {
103
+ session .getTransaction ().rollback ();
104
+ throw e ;
105
105
}
106
+ assertThat ( LISTENER .events .size () ).isEqualTo ( 1 );
106
107
}
107
108
);
109
+
110
+ assertThat ( LISTENER .events .size () ).isEqualTo ( 1 );
108
111
}
109
112
110
- @ Override
111
- protected Class <?>[] getAnnotatedClasses () {
112
- return new Class [] { Entity1 .class , Entity2 .class };
113
+ public static class CustomLoadIntegrator implements Integrator {
114
+ @ Override
115
+ public void integrate (
116
+ Metadata metadata ,
117
+ BootstrapContext bootstrapContext ,
118
+ SessionFactoryImplementor sessionFactory ) {
119
+ sessionFactory .getServiceRegistry ().getService ( EventListenerRegistry .class ).appendListeners (
120
+ EventType .AUTO_FLUSH ,
121
+ LISTENER
122
+ );
123
+ }
113
124
}
114
125
115
126
@ Entity (name = "Entity1" )
@@ -133,7 +144,7 @@ public Entity2() {
133
144
}
134
145
135
146
private static class TheListener implements AutoFlushEventListener {
136
- private List <AutoFlushEvent > events = new ArrayList <>();
147
+ final private List <AutoFlushEvent > events = new ArrayList <>();
137
148
138
149
@ Override
139
150
public void onAutoFlush (AutoFlushEvent event ) throws HibernateException {
0 commit comments