org.mockito.InjectMocks Maven / Gradle / Ivy
Show all versions of mockito-all Show documentation
/*
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
package org.mockito;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.FIELD;
/**
*
* - Allows shorthand mock and spy injection.
* - Minimizes repetitive mock and spy injection.
*
*
* Mockito will try to inject mocks only either by constructor injection,
* setter injection, or property injection in order and as described below.
* If any of the following strategy fail, then Mockito won't report failure;
* i.e. you will have to provide dependencies yourself.
*
* - Constructor injection; the biggest constructor is chosen,
* then arguments are resolved with mocks declared in the test only.
*
Note: If arguments can not be found, then null is passed.
* If non-mockable types are wanted, then constructor injection won't happen.
* In these cases, you will have to satisfy dependencies yourself.
*
* - Property setter injection; mocks will first be resolved by type,
* then (using name if there is several property of the same type).
*
Note: If @InjectMocks instance wasn't initialized before and have a no-arg constructor,
* then it will be initialized with this constructor.
*
* - Field injection; mocks will first be resolved by type,
* then (using name if there is several property of the same type).
*
Note: If @InjectMocks instance wasn't initialized before and have a no-arg constructor,
* then it will be initialized with this constructor.
*
*
*
*
* Example:
*
* public class ArticleManagerTest extends SampleBaseTestCase {
*
* @Mock private ArticleCalculator calculator;
* @Mock private ArticleDatabase database;
* @Spy private UserProvider userProvider = new ConsumerUserProvider();
*
* @InjectMocks private ArticleManager manager;
*
* @Test public void shouldDoSomething() {
* manager.initiateArticle();
* verify(database).addListener(any(ArticleListener.class));
* }
* }
*
* public class SampleBaseTestCase {
*
* @Before public void initMocks() {
* MockitoAnnotations.initMocks(this);
* }
* }
*
*
*
*
* In the above example the field ArticleManager annotated with @InjectMocks can have
* a parameterized constructor only or a no-arg constructor only, or both.
* All these constructors can be package protected, protected or private, however
* Mockito cannot instantiate inner classes, local classes, abstract classes and of course interfaces.
*
*
The same stands for setters or fields, they can be declared with private
* visibility, Mockito will see them through reflection.
* However fields that are static or final will be ignored.
*
* So on the field that needs injection, for example constructor injection will happen here :
*
* public class ArticleManager {
* ArticleManager(ArticleCalculator calculator, ArticleDatabase database) {
* // parameterized constructor
* }
* }
*
*
* Property setter injection will happen here :
*
* public class ArticleManager {
* ArticleManager() {
* // no-arg constructor
* }
*
* void setDatabase(ArticleDatabase database) {
* // setter
* }
* }
*
*
* Field injection will be used here :
*
* public class ArticleManager {
* private ArticleDatabase database;
* private ArticleCalculator calculator;
* }
*
*
*
* And finally, no injection will happen on the type in this case:
*
* public class ArticleManager {
* private ArticleDatabase database;
* private ArticleCalculator calculator;
*
* ArticleManager(ArticleObserver observer, boolean flag) {
* // observer is not declared in the test above.
* // flag is not mockable anyway
* }
* }
*
*
*
*
*
* Again, note that @InjectMocks will only inject mocks/spies created using the @Spy or @Mock annotation.
*
*
*
* MockitoAnnotations.initMocks(this) method has to called to initialize annotated objects.
* A MockitoJUnitRunner can also be used to initialize mocks instead of the @Before approach.
*
*
*
* In above example, initMocks() is called in @Before (JUnit4) method of test's base class.
* For JUnit3 initMocks() can go to setup() method of a base class.
* You can also put initMocks() in your JUnit runner (@RunWith) or use built-in runners: {@link org.mockito.runners.MockitoJUnitRunner}
*
*/
@Documented
@Target( { FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface InjectMocks {}