Firing CDI events on BeforeCommit, AfterCommit and AfterRollback.

.gitignore

@@ -2,3 +2,7 @@
 .classpath
 .settings
 target
+
+.DS_Store
+
+bin/

README.markdown

@@ -34,6 +34,37 @@ To do that you just need to add the follow content into your project's `beans.xm
 </decorators>
 ```
 
+# CDI Events
+
+While the JPATransactionInterceptor worries about handling the transaction, you can observe CDI events to include some logic of yours.
+
+**Please, note that if you specializes or override the JPATransactionInterceptor, those events won't be fired.**
+
+*Remember that CDI Events doesn't have an order when executing observers, so, when observing the same event in more than one method, they should be independents.*
+
+The events are:
+* Before trying to commit the transaction: `BeforeCommit`;
+* After successfully committing the transaction: `AfterCommit`;
+* After successfully rolling back (rollback) the transaction: `AfterRollback`;
+
+```Java
+import javax.enterprise.event.Observes;
+
+import br.com.caelum.vraptor.jpa.event.BeforeCommit;
+import br.com.caelum.vraptor.jpa.event.AfterCommit;
+import br.com.caelum.vraptor.jpa.event.AfterRollback;
+
+public class JPATransactionEventsObserver {
+	/* You can @Inject any dependencies here. */
+
+	public void beforeCommit(@Observes BeforeCommit before) {/* ... */}
+
+	public void afterCommit(@Observes AfterCommit after) {/* ... */}
+
+	public void afterRollback(@Observes AfterRollback after) {/* ... */}
+}
+```
+
 # Help
 
 Get help from vraptor developers and the community at VRaptor's mailing list.

src/main/java/br/com/caelum/vraptor/jpa/JPATransactionInterceptor.java

@@ -16,6 +16,7 @@
  */
 package br.com.caelum.vraptor.jpa;
 
+import javax.enterprise.inject.spi.BeanManager;
 import javax.inject.Inject;
 import javax.persistence.EntityManager;
 import javax.persistence.EntityTransaction;
@@ -24,6 +25,9 @@
 import br.com.caelum.vraptor.Intercepts;
 import br.com.caelum.vraptor.http.MutableResponse;
 import br.com.caelum.vraptor.interceptor.SimpleInterceptorStack;
+import br.com.caelum.vraptor.jpa.event.AfterCommit;
+import br.com.caelum.vraptor.jpa.event.AfterRollback;
+import br.com.caelum.vraptor.jpa.event.BeforeCommit;
 import br.com.caelum.vraptor.validator.Validator;
 
 /**
@@ -36,6 +40,7 @@
 @Intercepts
 public class JPATransactionInterceptor implements JPAInterceptor {
 
+	private final BeanManager beanManager;
 	private final EntityManager manager;
 	private final Validator validator;
 	private final MutableResponse response;
@@ -44,11 +49,12 @@ public class JPATransactionInterceptor implements JPAInterceptor {
 	 * @deprecated CDI eyes only.
 	 */
 	protected JPATransactionInterceptor() {
-		this(null, null, null);
+		this(null, null, null, null);
 	}
 
 	@Inject
-	public JPATransactionInterceptor(EntityManager manager, Validator validator, MutableResponse response) {
+	public JPATransactionInterceptor(BeanManager beanManager, EntityManager manager, Validator validator, MutableResponse response) {
+		this.beanManager = beanManager;
 		this.manager = manager;
 		this.validator = validator;
 		this.response = response;
@@ -71,13 +77,18 @@ public void intercept(SimpleInterceptorStack stack) {
 		} finally {
 			if (transaction != null && transaction.isActive()) {
 				transaction.rollback();
+				beanManager.fireEvent(new AfterRollback());
 			}
 		}
 	}
 
 	private void commit(EntityTransaction transaction) {
+		if (transaction.isActive())
+			beanManager.fireEvent(new BeforeCommit());
+
 		if (!validator.hasErrors() && transaction.isActive()) {
 			transaction.commit();
+			beanManager.fireEvent(new AfterCommit());
 		}
 	}
 

src/main/java/br/com/caelum/vraptor/jpa/event/AfterCommit.java

@@ -0,0 +1,3 @@
+package br.com.caelum.vraptor.jpa.event;
+
+public class AfterCommit {}

src/main/java/br/com/caelum/vraptor/jpa/event/AfterRollback.java

@@ -0,0 +1,3 @@
+package br.com.caelum.vraptor.jpa.event;
+
+public class AfterRollback {}

src/main/java/br/com/caelum/vraptor/jpa/event/BeforeCommit.java

@@ -0,0 +1,3 @@
+package br.com.caelum.vraptor.jpa.event;
+
+public class BeforeCommit {}

src/test/java/br/com/caelum/vraptor/jpa/JPATransactionInterceptorTest.java

@@ -1,11 +1,14 @@
 package br.com.caelum.vraptor.jpa;
 
 import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.isA;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import javax.enterprise.inject.spi.BeanManager;
 import javax.persistence.EntityManager;
 import javax.persistence.EntityTransaction;
 
@@ -14,14 +17,20 @@
 import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
 
 import br.com.caelum.vraptor.controller.ControllerMethod;
 import br.com.caelum.vraptor.http.MutableResponse;
 import br.com.caelum.vraptor.interceptor.SimpleInterceptorStack;
+import br.com.caelum.vraptor.jpa.event.AfterCommit;
+import br.com.caelum.vraptor.jpa.event.AfterRollback;
+import br.com.caelum.vraptor.jpa.event.BeforeCommit;
 import br.com.caelum.vraptor.validator.Validator;
 
 public class JPATransactionInterceptorTest {
 
+	@Mock private BeanManager beanManager;
     @Mock private EntityManager entityManager;
     @Mock private SimpleInterceptorStack stack;
     @Mock private ControllerMethod method;
@@ -34,33 +43,52 @@ public class JPATransactionInterceptorTest {
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
-        interceptor = new JPATransactionInterceptor(entityManager, validator, response);
+        interceptor = new JPATransactionInterceptor(beanManager, entityManager, validator, response);
+
+        // Returns false when transaction.isActive() is called after committing the transaction.
+        doAnswer(new Answer<Void>() {
+			@Override
+			public Void answer(InvocationOnMock invocation) throws Throwable {
+				when(transaction.isActive()).thenReturn(false);
+				return null;
+			}
+		}).when(transaction).commit();
     }
 
     @Test
     public void shouldStartAndCommitTransaction() throws Exception {
 
         when(entityManager.getTransaction()).thenReturn(transaction);
         when(transaction.isActive()).thenReturn(true);
+        when(validator.hasErrors()).thenReturn(false);
 
         interceptor.intercept(stack);
 
-        InOrder callOrder = inOrder(entityManager, transaction, stack);
+        InOrder callOrder = inOrder(beanManager, entityManager, transaction, stack);
         callOrder.verify(entityManager).getTransaction();
         callOrder.verify(transaction).begin();
         callOrder.verify(stack).next();
+        callOrder.verify(beanManager).fireEvent(isA(BeforeCommit.class));
         callOrder.verify(transaction).commit();
+        callOrder.verify(beanManager).fireEvent(isA(AfterCommit.class));
+
+        verify(beanManager, never()).fireEvent(isA(AfterRollback.class));
     }
 
     @Test
     public void shouldRollbackTransactionIfStillActiveWhenExecutionFinishes() throws Exception {
 
         when(entityManager.getTransaction()).thenReturn(transaction);
         when(transaction.isActive()).thenReturn(true);
+        when(validator.hasErrors()).thenReturn(true);
 
         interceptor.intercept(stack);
 
         verify(transaction).rollback();
+
+        verify(beanManager).fireEvent(isA(BeforeCommit.class));
+        verify(beanManager, never()).fireEvent(isA(AfterCommit.class));
+        verify(beanManager).fireEvent(isA(AfterRollback.class));
     }
 
     @Test
@@ -73,6 +101,10 @@ public void shouldRollbackIfValidatorHasErrors() {
         interceptor.intercept(stack);
 
         verify(transaction).rollback();
+
+        verify(beanManager).fireEvent(isA(BeforeCommit.class));
+        verify(beanManager, never()).fireEvent(isA(AfterCommit.class));
+        verify(beanManager).fireEvent(isA(AfterRollback.class));
     }
 
     @Test
@@ -85,6 +117,10 @@ public void shouldCommitIfValidatorHasNoErrors() {
         interceptor.intercept(stack);
 
         verify(transaction).commit();
+
+        verify(beanManager).fireEvent(isA(BeforeCommit.class));
+        verify(beanManager).fireEvent(isA(AfterCommit.class));
+        verify(beanManager, never()).fireEvent(isA(AfterRollback.class));
     }
 
     @Test
@@ -96,15 +132,42 @@ public void doNothingIfHasNoActiveTransation() {
         interceptor.intercept(stack);
 
         verify(transaction, never()).rollback();
+        verify(transaction, never()).commit();
+
+        verify(beanManager, never()).fireEvent(isA(BeforeCommit.class));
+        verify(beanManager, never()).fireEvent(isA(AfterCommit.class));
+        verify(beanManager, never()).fireEvent(isA(AfterRollback.class));
     }
 
     @Test
-	public void shouldConfigureARedirectListener() {
+	public void shouldConfigureARedirectListenerWhenTransactionIsCommited() {
 
 		when(entityManager.getTransaction()).thenReturn(transaction);
+		when(transaction.isActive()).thenReturn(true);
+        when(validator.hasErrors()).thenReturn(false);
 
 		interceptor.intercept(stack);
 
 		verify(response).addRedirectListener(any(MutableResponse.RedirectListener.class));
+
+        verify(beanManager).fireEvent(isA(BeforeCommit.class));
+        verify(beanManager).fireEvent(isA(AfterCommit.class));
+        verify(beanManager, never()).fireEvent(isA(AfterRollback.class));
 	}
+
+    @Test
+    public void shouldConfigureARedirectListenerWhenTransactionIsRolledback() {
+
+    	when(entityManager.getTransaction()).thenReturn(transaction);
+    	when(transaction.isActive()).thenReturn(true);
+    	when(validator.hasErrors()).thenReturn(true);
+
+    	interceptor.intercept(stack);
+
+    	verify(response).addRedirectListener(any(MutableResponse.RedirectListener.class));
+
+    	verify(beanManager).fireEvent(isA(BeforeCommit.class));
+    	verify(beanManager, never()).fireEvent(isA(AfterCommit.class));
+    	verify(beanManager).fireEvent(isA(AfterRollback.class));
+    }
 }