ParameterRule for Arquillian junit tests

kubamarchwicki · kubamarchwicki · commit e15ffd5baa17 · 2015-06-05T23:18:04.000+02:00
As described here: http://www.poolik.com/2014/02/how-to-run-parameterized-junit-arquillian-tests/ where the credits should go
diff --git a/test-utils/pom.xml b/test-utils/pom.xml
@@ -10,4 +10,16 @@
     </parent>
     <artifactId>test-utils</artifactId>
     <name>Java EE 7 Sample: javaee7-samples - test-utils</name>
-</project>
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.11</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jboss.arquillian.container</groupId>
+            <artifactId>arquillian-container-test-api</artifactId>
+        </dependency>
+    </dependencies>
+</project>
diff --git a/test-utils/src/main/java/org/javaee7/Parameter.java b/test-utils/src/main/java/org/javaee7/Parameter.java
@@ -0,0 +1,12 @@
+package org.javaee7;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD})
+public @interface Parameter {
+}
+
diff --git a/test-utils/src/main/java/org/javaee7/ParameterRule.java b/test-utils/src/main/java/org/javaee7/ParameterRule.java
@@ -0,0 +1,103 @@
+package org.javaee7;
+
+import org.jboss.arquillian.container.test.api.Deployment;
+
+import org.junit.rules.MethodRule;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.List;
+
+/**
+ * Helper class for Parametrized tests as described here:
+ * http://blog.schauderhaft.de/2012/12/16/writing-parameterized-tests-with-junit-rules/
+ *
+ * @param <T>
+ */
+public class ParameterRule<T> implements MethodRule {
+    private final List<T> params;
+
+    public ParameterRule(List<T> params) {
+        if (params == null || params.size() == 0) {
+            throw new IllegalArgumentException("'params' must be specified and have more then zero length!");
+        }
+        this.params = params;
+    }
+
+    @Override
+    public Statement apply(final Statement base, final FrameworkMethod method, final Object target) {
+        return new Statement() {
+            @Override
+            public void evaluate() throws Throwable {
+                boolean runInContainer = getDeploymentMethod(target).getAnnotation(Deployment.class).testable();
+                if (runInContainer) {
+                    evaluateParametersInContainer(base, target);
+                } else {
+                    evaluateParametersInClient(base, target);
+                }
+            }
+        };
+    }
+
+    private Method getDeploymentMethod(Object target) throws NoSuchMethodException {
+        Method[] methods = target.getClass().getDeclaredMethods();
+        for (Method method : methods) {
+            if (method.getAnnotation(Deployment.class) != null) return method;
+        }
+        throw new IllegalStateException("No method with @Deployment annotation found!");
+    }
+
+    private void evaluateParametersInContainer(Statement base, Object target) throws Throwable {
+        if (isRunningInContainer()) {
+            evaluateParamsToTarget(base, target);
+        } else {
+            ignoreStatementExecution(base);
+        }
+    }
+
+    private void evaluateParametersInClient(Statement base, Object target) throws Throwable {
+        if (isRunningInContainer()) {
+            ignoreStatementExecution(base);
+        } else {
+            evaluateParamsToTarget(base, target);
+        }
+    }
+
+    private boolean isRunningInContainer() {
+        try {
+            new InitialContext().lookup("java:comp/env");
+            return true;
+        } catch (NamingException e) {
+            return false;
+        }
+    }
+
+    private void evaluateParamsToTarget(Statement base, Object target) throws Throwable {
+        for (Object param : params) {
+            Field targetField = getTargetField(target);
+            if (!targetField.isAccessible()) {
+                targetField.setAccessible(true);
+            }
+            targetField.set(target, param);
+            base.evaluate();
+        }
+    }
+
+    private Field getTargetField(Object target) throws NoSuchFieldException {
+        Field[] allFields = target.getClass().getDeclaredFields();
+        for (Field field : allFields) {
+            if (field.getAnnotation(Parameter.class) != null) return field;
+        }
+        throw new IllegalStateException("No field with @Parameter annotation found! Forgot to add it?");
+    }
+
+    private void ignoreStatementExecution(Statement base) {
+        try {
+            base.evaluate();
+        } catch (Throwable ignored) {}
+    }
+}
