Added tests to batch-listeners project

radcortez · radcortez · commit a36dd6a61296 · 2013-11-24T19:49:22.000Z
diff --git a/batch/batch-listeners/pom.xml b/batch/batch-listeners/pom.xml
@@ -7,7 +7,14 @@
         <version>1.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
-        
+
     <artifactId>batch-listeners</artifactId>
     <packaging>war</packaging>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.javaee7</groupId>
+            <artifactId>util-samples</artifactId>
+        </dependency>
+    </dependencies>
 </project>
diff --git a/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/BatchListener.java b/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/BatchListener.java
@@ -0,0 +1,17 @@
+package org.javaee7.batch.listeners;
+
+import javax.interceptor.InterceptorBinding;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author Roberto Cortez
+ */
+@Inherited
+@InterceptorBinding
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD, ElementType.TYPE})
+public @interface BatchListener {}
diff --git a/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/BatchListenerInterceptor.java b/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/BatchListenerInterceptor.java
@@ -0,0 +1,25 @@
+package org.javaee7.batch.listeners;
+
+import javax.annotation.Priority;
+import javax.inject.Inject;
+import javax.interceptor.AroundInvoke;
+import javax.interceptor.Interceptor;
+import javax.interceptor.InvocationContext;
+
+/**
+ * @author Roberto Cortez
+ */
+@BatchListener
+@Interceptor
+@Priority(Interceptor.Priority.APPLICATION)
+public class BatchListenerInterceptor {
+    @Inject
+    private BatchListenerRecorder batchListenerRecorder;
+
+    @AroundInvoke
+    private Object recordListenersExecution(InvocationContext ctx) throws Exception {
+        batchListenerRecorder.addListenerMethodExecution(ctx.getMethod().getDeclaringClass(),
+                                                         ctx.getMethod().getName());
+        return ctx.proceed();
+    }
+}
diff --git a/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/BatchListenerRecorder.java b/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/BatchListenerRecorder.java
@@ -0,0 +1,35 @@
+package org.javaee7.batch.listeners;
+
+import javax.inject.Singleton;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author Roberto Cortez
+ */
+@Singleton
+public class BatchListenerRecorder {
+    private Map<String, Integer> recordedMethodExecutions = new HashMap<>();
+
+    public void addListenerMethodExecution(Class klass, String method) {
+        String key = getKey(klass, method);
+        if (recordedMethodExecutions.containsKey(key)) {
+            recordedMethodExecutions.put(key, recordedMethodExecutions.get(key) + 1);
+        } else {
+            recordedMethodExecutions.put(key, 1);
+        }
+    }
+
+    public boolean isListenerMethodExecuted(Class klass, String method) {
+        return recordedMethodExecutions.containsKey(getKey(klass, method));
+    }
+
+    public Integer totalListenerMethodExecutions(Class klass, String method) {
+        Integer total = recordedMethodExecutions.get(getKey(klass, method));
+        return total != null ? total : Integer.valueOf(0);
+    }
+
+    private String getKey(Class klass, String method) {
+        return klass.getName() + "." + method;
+    }
+}
diff --git a/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/MyChunkListener.java b/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/MyChunkListener.java
@@ -50,11 +50,13 @@
 public class MyChunkListener extends AbstractChunkListener {
 
     @Override
+    @BatchListener
     public void beforeChunk() throws Exception {
         System.out.println("MyChunkListener.beforeChunk");
     }
 
     @Override
+    @BatchListener
     public void afterChunk() throws Exception {
         System.out.println("MyChunkListener.afterChunk");
     }
diff --git a/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/MyItemProcessorListener.java b/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/MyItemProcessorListener.java
@@ -50,18 +50,20 @@
 public class MyItemProcessorListener extends AbstractItemProcessListener {
 
     @Override
+    @BatchListener
     public void beforeProcess(Object item) throws Exception {
         System.out.println("MyItemProcessorListener.beforeProcess: " + item);
     }
 
     @Override
+    @BatchListener
     public void afterProcess(Object item, Object result) throws Exception {
         System.out.println("MyItemProcessorListener.afterProcess: " + item + ", " + result);
     }
 
     @Override
+    @BatchListener
     public void onProcessError(Object item, Exception ex) throws Exception {
         System.out.println("MyItemProcessorListener.onProcessError: " + item + ", " + ex.getLocalizedMessage());
     }
-
 }
diff --git a/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/MyItemReadListener.java b/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/MyItemReadListener.java
@@ -50,19 +50,20 @@
 public class MyItemReadListener extends AbstractItemReadListener {
 
     @Override
+    @BatchListener
     public void beforeRead() throws Exception {
         System.out.println("MyItemReadListener.beforeRead");
     }
 
     @Override
+    @BatchListener
     public void afterRead(Object item) throws Exception {
         System.out.println("MyItemReadListener.afterRead: " + item);
     }
 
     @Override
+    @BatchListener
     public void onReadError(Exception ex) throws Exception {
         System.out.println("MyItemReadListener.onReadError: " + ex.getLocalizedMessage());
     }
-
-    
 }
diff --git a/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/MyItemWriteListener.java b/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/MyItemWriteListener.java
@@ -51,18 +51,20 @@
 public class MyItemWriteListener extends AbstractItemWriteListener {
 
     @Override
+    @BatchListener
     public void beforeWrite(List items) throws Exception {
         System.out.println("MyItemWriteListener.beforeWrite: " + items);
     }
 
     @Override
+    @BatchListener
     public void afterWrite(List items) throws Exception {
         System.out.println("MyItemWriteListener.afterWrite: " + items);
     }
 
     @Override
+    @BatchListener
     public void onWriteError(List items, Exception ex) throws Exception {
         System.out.println("MyItemWriteListener.onError: " + items + ", " + ex.getLocalizedMessage());
     }
-
 }
diff --git a/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/MyJobListener.java b/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/MyJobListener.java
@@ -50,13 +50,14 @@
 public class MyJobListener extends AbstractJobListener {
 
     @Override
+    @BatchListener
     public void beforeJob() {
         System.out.println("MyJobListener.beforeJob");
     }
 
     @Override
+    @BatchListener
     public void afterJob() {
         System.out.println("MyJobListener.afterJob");
     }
-
 }
diff --git a/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/MyStepListener.java b/batch/batch-listeners/src/main/java/org/javaee7/batch/listeners/MyStepListener.java
@@ -50,13 +50,14 @@
 public class MyStepListener extends AbstractStepListener {
 
     @Override
+    @BatchListener
     public void beforeStep() throws Exception {
         System.out.println("MyStepListener.beforeStep");
     }
 
     @Override
+    @BatchListener
     public void afterStep() throws Exception {
         System.out.println("MyStepListener.afterStep");
     }
-
 }
diff --git a/batch/batch-listeners/src/test/java/org.javaee7.batch.listeners/BatchListenersTest.java b/batch/batch-listeners/src/test/java/org.javaee7.batch.listeners/BatchListenersTest.java
@@ -0,0 +1,87 @@
+package org.javaee7.batch.listeners;
+
+import org.javaee7.util.BatchTestHelper;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.ArchivePaths;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.WebArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import javax.batch.operations.JobOperator;
+import javax.batch.runtime.BatchRuntime;
+import javax.batch.runtime.BatchStatus;
+import javax.batch.runtime.JobExecution;
+import javax.batch.runtime.Metric;
+import javax.batch.runtime.StepExecution;
+import javax.inject.Inject;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author Roberto Cortez
+ */
+@RunWith(Arquillian.class)
+public class BatchListenersTest {
+    @Inject
+    private BatchListenerRecorder batchListenerRecorder;
+
+    @Deployment
+    public static WebArchive createDeployment() {
+        WebArchive war = ShrinkWrap.create(WebArchive.class)
+                                   .addClass(BatchTestHelper.class)
+                                   .addPackage("org.javaee7.batch.listeners")
+                                   .addAsWebInfResource(EmptyAsset.INSTANCE, ArchivePaths.create("beans.xml"))
+                                   .addAsResource("META-INF/batch-jobs/myJob.xml");
+        System.out.println(war.toString(true));
+        return war;
+    }
+
+    @Test
+    public void testBatchListeners() throws Exception {
+        JobOperator jobOperator = BatchRuntime.getJobOperator();
+        Long executionId = jobOperator.start("myJob", new Properties());
+        JobExecution jobExecution = jobOperator.getJobExecution(executionId);
+
+        BatchTestHelper.keepTestAlive(jobExecution);
+
+        List<StepExecution> stepExecutions = jobOperator.getStepExecutions(executionId);
+        for (StepExecution stepExecution : stepExecutions) {
+            if (stepExecution.getStepName().equals("myStep")) {
+                Map<Metric.MetricType, Long> metricsMap = BatchTestHelper.getMetricsMap(stepExecution.getMetrics());
+
+                for (Metric metric : stepExecution.getMetrics()) {
+                    System.out.println("metric = " + metric);
+                }
+
+                assertEquals(10L, (long) metricsMap.get(Metric.MetricType.READ_COUNT));
+                assertEquals(10L / 2L, (long) metricsMap.get(Metric.MetricType.WRITE_COUNT));
+                assertEquals(10L / 3 + 10 % 3, (long) metricsMap.get(Metric.MetricType.COMMIT_COUNT));
+            }
+        }
+
+        assertTrue(batchListenerRecorder.isListenerMethodExecuted(MyJobListener.class, "beforeJob"));
+        assertTrue(batchListenerRecorder.isListenerMethodExecuted(MyJobListener.class, "afterJob"));
+
+        assertTrue(batchListenerRecorder.isListenerMethodExecuted(MyStepListener.class, "beforeStep"));
+        assertTrue(batchListenerRecorder.isListenerMethodExecuted(MyStepListener.class, "afterStep"));
+
+        assertTrue(batchListenerRecorder.isListenerMethodExecuted(MyChunkListener.class, "beforeChunk"));
+        assertTrue(batchListenerRecorder.isListenerMethodExecuted(MyChunkListener.class, "afterChunk"));
+
+        assertTrue(batchListenerRecorder.isListenerMethodExecuted(MyItemReadListener.class, "beforeRead"));
+        assertTrue(batchListenerRecorder.isListenerMethodExecuted(MyItemReadListener.class, "afterRead"));
+        assertTrue(batchListenerRecorder.isListenerMethodExecuted(MyItemWriteListener.class, "beforeWrite"));
+        assertTrue(batchListenerRecorder.isListenerMethodExecuted(MyItemWriteListener.class, "afterWrite"));
+        assertTrue(batchListenerRecorder.isListenerMethodExecuted(MyItemProcessorListener.class, "beforeProcess"));
+        assertTrue(batchListenerRecorder.isListenerMethodExecuted(MyItemProcessorListener.class, "afterProcess"));
+
+        assertEquals(jobExecution.getBatchStatus(), BatchStatus.COMPLETED);
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -50,11 +50,13 @@`
`50`	`50`	`public class MyChunkListener extends AbstractChunkListener {`
`51`	`51`
`52`	`52`	`@Override`
	`53`	`+ @BatchListener`
`53`	`54`	`public void beforeChunk() throws Exception {`
`54`	`55`	`System.out.println("MyChunkListener.beforeChunk");`
`55`	`56`	`}`
`56`	`57`
`57`	`58`	`@Override`
	`59`	`+ @BatchListener`
`58`	`60`	`public void afterChunk() throws Exception {`
`59`	`61`	`System.out.println("MyChunkListener.afterChunk");`
`60`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,18 +50,20 @@`
`50`	`50`	`public class MyItemProcessorListener extends AbstractItemProcessListener {`
`51`	`51`
`52`	`52`	`@Override`
	`53`	`+ @BatchListener`
`53`	`54`	`public void beforeProcess(Object item) throws Exception {`
`54`	`55`	`System.out.println("MyItemProcessorListener.beforeProcess: " + item);`
`55`	`56`	`}`
`56`	`57`
`57`	`58`	`@Override`
	`59`	`+ @BatchListener`
`58`	`60`	`public void afterProcess(Object item, Object result) throws Exception {`
`59`	`61`	`System.out.println("MyItemProcessorListener.afterProcess: " + item + ", " + result);`
`60`	`62`	`}`
`61`	`63`
`62`	`64`	`@Override`
	`65`	`+ @BatchListener`
`63`	`66`	`public void onProcessError(Object item, Exception ex) throws Exception {`
`64`	`67`	`System.out.println("MyItemProcessorListener.onProcessError: " + item + ", " + ex.getLocalizedMessage());`
`65`	`68`	`}`
`66`		`-`
`67`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,19 +50,20 @@`
`50`	`50`	`public class MyItemReadListener extends AbstractItemReadListener {`
`51`	`51`
`52`	`52`	`@Override`
	`53`	`+ @BatchListener`
`53`	`54`	`public void beforeRead() throws Exception {`
`54`	`55`	`System.out.println("MyItemReadListener.beforeRead");`
`55`	`56`	`}`
`56`	`57`
`57`	`58`	`@Override`
	`59`	`+ @BatchListener`
`58`	`60`	`public void afterRead(Object item) throws Exception {`
`59`	`61`	`System.out.println("MyItemReadListener.afterRead: " + item);`
`60`	`62`	`}`
`61`	`63`
`62`	`64`	`@Override`
	`65`	`+ @BatchListener`
`63`	`66`	`public void onReadError(Exception ex) throws Exception {`
`64`	`67`	`System.out.println("MyItemReadListener.onReadError: " + ex.getLocalizedMessage());`
`65`	`68`	`}`
`66`		`-`
`67`		`-`
`68`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,18 +51,20 @@`
`51`	`51`	`public class MyItemWriteListener extends AbstractItemWriteListener {`
`52`	`52`
`53`	`53`	`@Override`
	`54`	`+ @BatchListener`
`54`	`55`	`public void beforeWrite(List items) throws Exception {`
`55`	`56`	`System.out.println("MyItemWriteListener.beforeWrite: " + items);`
`56`	`57`	`}`
`57`	`58`
`58`	`59`	`@Override`
	`60`	`+ @BatchListener`
`59`	`61`	`public void afterWrite(List items) throws Exception {`
`60`	`62`	`System.out.println("MyItemWriteListener.afterWrite: " + items);`
`61`	`63`	`}`
`62`	`64`
`63`	`65`	`@Override`
	`66`	`+ @BatchListener`
`64`	`67`	`public void onWriteError(List items, Exception ex) throws Exception {`
`65`	`68`	`System.out.println("MyItemWriteListener.onError: " + items + ", " + ex.getLocalizedMessage());`
`66`	`69`	`}`
`67`		`-`
`68`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,13 +50,14 @@`
`50`	`50`	`public class MyJobListener extends AbstractJobListener {`
`51`	`51`
`52`	`52`	`@Override`
	`53`	`+ @BatchListener`
`53`	`54`	`public void beforeJob() {`
`54`	`55`	`System.out.println("MyJobListener.beforeJob");`
`55`	`56`	`}`
`56`	`57`
`57`	`58`	`@Override`
	`59`	`+ @BatchListener`
`58`	`60`	`public void afterJob() {`
`59`	`61`	`System.out.println("MyJobListener.afterJob");`
`60`	`62`	`}`
`61`		`-`
`62`	`63`	`}`