Update to version 2.0. Instead of injectionMap, use @InjectSource. Allow for multiple fields to be annotated @Injectmocks. Add @PostConstruct support.

Author: exabrial

README.md

@@ -4,7 +4,7 @@ Inject Strings (or other objects) into your `@InjectMocks` targets [objects unde
 
 ## Problem
 
-Take this Spring Controller (or if you're using the far superior and modern CDI framework, imagine this is `@AppplicationScoped`)
+Take this Spring Controller (or if you're using the far superior and modern CDI framework, think `@AppplicationScoped` instead of `@Controller` and `@Inject` instead of `@Autowired`)
 
 ```
 @Controller
@@ -40,7 +40,7 @@ public class MyControllerTest {
   
   public void testDoSomething() throws Exception {
    myController.doSomething();
-   // results in NPE
+   // results in NPE because myController.securityEnabled is null
   }
  }
 ```
@@ -56,41 +56,60 @@ This JUnit5 extension allows you to arbitrarily set any field on your `@InjectMo
 import com.github.exabrial.junit5.injectmap.InjectionMap;
 import com.github.exabrial.junit5.injectmap.InjectMapExtension;
 
-@TestInstance(Lifecycle.PER_METHOD)
-@ExtendWith({ MockitoExtension.class, InjectMapExtension.class })
+@TestInstance(Lifecycle.PER_CLASS)
+@ExtendWith({ MockitoExtension.class, InjectExtension.class })
 public class MyControllerTest {
  @InjectMocks
  private MyController myController;
  @Mock
  private Logger log;
  @Mock
  private Authenticator auther;
- @InjectionMap
- private Map<String, Object> injectionMap = new HashMap<>();
+ @InjectionSource
+ private Boolean securityEnabled;
  
- @BeforeEach
- public void beforeEach() throws Exception {
-  injectionMap.put("securityEnabled", Boolean.TRUE);
- }
-
- @AfterEach
- public void afterEach() throws Exception {
-  injectionMap.clear();
- }
-  
  public void testDoSomething_secEnabled() throws Exception {
+  securityEnabled = Boolean.TRUE;
   myController.doSomething();
   // wahoo no NPE! Test the "if then" half of the branch
  }
   
  public void testDoSomething_secDisabled() throws Exception {
-  injectionMap.put("securityEnabled", Boolean.FALSE);
+  securityEnabled = Boolean.FALSE;
   myController.doSomething();
   // wahoo no NPE! Test the "if else" half of branch
  }
 }
 ```
 
+## PostConstruct invocation
+
+CDI and SpringFramework allow the use of `@PostConstruct`. This is like a constructor, except the method annotated will be invoked _after_ dependency injection is complete. This extension can be commanded to invoke the method annotated with `@PostConstruct` like so:
+
+
+```
+@ApplicationScoped
+public class MyController {
+ @Inject
+ private Logger log; 
+ 
+ @PostConstruct
+ private void postConstruct() {
+  log.info("initializing myController...");
+  ... some initialization code
+ }
+}
+```
+
+```
+ @InjectMocks
+ @InvokePostConstruct
+ private MyController myController;
+```
+
+Ref: https://docs.oracle.com/javaee/7/api/javax/annotation/PostConstruct.html
+
+
 ## License
 
 All files are licensed Apache Source License 2.0. Please consider contributing any improvements you make back to the project.
@@ -103,19 +122,19 @@ Maven Coordinates:
 <dependency>
  <groupId>org.junit.jupiter</groupId>
  <artifactId>junit-jupiter-api</artifactId>
- <version>5.3.1</version>
+ <version>5.6.2</version>
  <scope>test</scope>
 </dependency>
 <dependency>
  <groupId>org.mockito</groupId>
  <artifactId>mockito-core</artifactId>
- <version>2.23.4</version>
+ <version>3.5.0</version>
  <scope>test</scope>
 </dependency>
 <dependency>
  <groupId>com.github.exabrial</groupId>
  <artifactId>mockito-object-injection</artifactId>
- <version>1.0.4</version>
+ <version>2.0.0</version>
  <scope>test</scope>
 </dependency>
 ```

pom.xml

@@ -3,7 +3,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>com.github.exabrial</groupId>
 	<artifactId>mockito-object-injection</artifactId>
-	<version>1.0.5-SNAPSHOT</version>
+	<version>2.0.0-SNAPSHOT</version>
 	<packaging>jar</packaging>
 	<description>Mockito Object Injection</description>
 	<name>${project.artifactId}</name>
@@ -43,13 +43,13 @@
 		<dependency>
 			<groupId>org.junit.jupiter</groupId>
 			<artifactId>junit-jupiter-api</artifactId>
-			<version>5.3.1</version>
+			<version>5.6.2</version>
 			<scope>provided</scope>
 		</dependency>
 		<dependency>
 			<groupId>org.mockito</groupId>
 			<artifactId>mockito-core</artifactId>
-			<version>2.23.0</version>
+			<version>3.5.0</version>
 			<scope>provided</scope>
 		</dependency>
 		<dependency>

src/main/java/com/github/exabrial/junit5/injectmap/InjectExtension.java

@@ -0,0 +1,111 @@
+package com.github.exabrial.junit5.injectmap;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.PostConstruct;
+
+import org.junit.jupiter.api.extension.BeforeTestExecutionCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.mockito.InjectMocks;
+
+import javassist.util.proxy.MethodFilter;
+import javassist.util.proxy.MethodHandler;
+import javassist.util.proxy.Proxy;
+import javassist.util.proxy.ProxyFactory;
+
+public class InjectExtension implements BeforeTestExecutionCallback {
+	@Override
+	public void beforeTestExecution(ExtensionContext context) throws Exception {
+		Object testInstance = context.getTestInstance().get();
+		if (testInstance != null) {
+			final Map<String, Field> injectMap = new HashMap<>();
+			for (Field testClassField : testInstance.getClass().getDeclaredFields()) {
+				if (testClassField.getAnnotation(InjectMocks.class) != null) {
+					testClassField.setAccessible(true);
+					final Object injectionTarget = testClassField.get(testInstance);
+					final ProxyFactory proxyFactory = new ProxyFactory();
+					proxyFactory.setSuperclass(injectionTarget.getClass());
+					proxyFactory.setFilter(createMethodFilter());
+					final Class<?> proxyClass = proxyFactory.createClass();
+					final Object proxy = proxyClass.newInstance();
+					final Map<String, List<Field>> fieldMap = createFieldMap(injectionTarget.getClass());
+					Method postConstructMethod;
+					if (testClassField.getAnnotation(InvokePostConstruct.class) != null) {
+						postConstructMethod = findPostConstructMethod(injectionTarget);
+					} else {
+						postConstructMethod = null;
+					}
+					final MethodHandler handler = createMethodHandler(injectMap, injectionTarget, fieldMap, testInstance, postConstructMethod);
+					((Proxy) proxy).setHandler(handler);
+					testClassField.set(testInstance, proxy);
+				} else if (testClassField.getAnnotation(InjectionSource.class) != null) {
+					injectMap.put(testClassField.getName(), testClassField);
+				}
+			}
+		}
+	}
+
+	private Method findPostConstructMethod(Object injectionTarget) {
+		for (Method method : injectionTarget.getClass().getDeclaredMethods()) {
+			if (method.isAnnotationPresent(PostConstruct.class)) {
+				return method;
+			}
+		}
+		throw new RuntimeException(
+				"@InvokePostConstruct is delcared on:" + injectionTarget + " however no method annotated with @PostConstruct found");
+	}
+
+	private Map<String, List<Field>> createFieldMap(Class<? extends Object> targetClass) {
+		if (targetClass == Object.class) {
+			return new HashMap<>();
+		} else {
+			Map<String, List<Field>> fieldMap = createFieldMap(targetClass.getSuperclass());
+			for (Field field : targetClass.getDeclaredFields()) {
+				List<Field> fieldList = fieldMap.get(field.getName());
+				if (fieldList == null) {
+					fieldList = new LinkedList<>();
+					fieldMap.put(field.getName(), fieldList);
+				}
+				fieldList.add(field);
+			}
+			return fieldMap;
+		}
+	}
+
+	private MethodHandler createMethodHandler(final Map<String, Field> injectMap, final Object injectionTarget,
+			final Map<String, List<Field>> fieldMap, final Object testInstance, final Method postConstructMethod) {
+		return (proxy, invokedMethod, proceedMethod, args) -> {
+			invokedMethod.setAccessible(true);
+			for (String fieldName : injectMap.keySet()) {
+				for (Field field : fieldMap.get(fieldName)) {
+					field.setAccessible(true);
+					field.set(injectionTarget, injectMap.get(fieldName).get(testInstance));
+				}
+			}
+			if (postConstructMethod != null) {
+				postConstructMethod.setAccessible(true);
+				postConstructMethod.invoke(injectionTarget);
+			}
+			try {
+				return invokedMethod.invoke(injectionTarget, args);
+			} catch (InvocationTargetException itEx) {
+				if (null != itEx.getCause()) {
+					throw itEx.getCause();
+				} else {
+					throw itEx;
+				}
+			}
+		};
+	}
+
+	private MethodFilter createMethodFilter() {
+		return method -> !Modifier.isPrivate(method.getModifiers());
+	}
+}

src/main/java/com/github/exabrial/junit5/injectmap/InjectMapExtension.java

@@ -8,5 +8,5 @@
 
 @Retention(RUNTIME)
 @Target(FIELD)
-public @interface InjectionMap {
+public @interface InjectionSource {
 }

src/main/java/com/github/exabrial/junit5/injectmap/InjectionMap.java src/main/java/com/github/exabrial/junit5/injectmap/InjectionSource.java

@@ -0,0 +1,12 @@
+package com.github.exabrial.junit5.injectmap;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+@Retention(RUNTIME)
+@Target(FIELD)
+public @interface InvokePostConstruct {
+}