How to use InjectMocks class of org.mockito package
Best Mockito code snippet using org.mockito.InjectMocks
Source:MockInjectionUsingConstructorTest.java 
...10import org.junit.internal.TextListener;11import org.junit.rules.ExpectedException;12import org.junit.runner.JUnitCore;13import org.junit.runner.RunWith;14import org.mockito.InjectMocks;15import org.mockito.Mock;16import org.mockito.MockitoAnnotations;17import org.mockito.Spy;18import org.mockito.exceptions.base.MockitoException;19import org.mockito.internal.util.MockUtil;20import org.mockito.junit.MockitoJUnitRunner;21import org.mockitousage.IMethods;22import org.mockitousage.examples.use.ArticleCalculator;23import org.mockitousage.examples.use.ArticleDatabase;24import org.mockitousage.examples.use.ArticleManager;25import java.util.AbstractCollection;26import java.util.List;27import java.util.Set;28import java.util.concurrent.TimeUnit;29import static org.assertj.core.api.Assertions.assertThat;30import static org.junit.Assert.*;31import static org.mockito.Mockito.when;32import static org.mockito.MockitoAnnotations.initMocks;33public class MockInjectionUsingConstructorTest {34 @Mock private ArticleCalculator calculator;35 @Mock private ArticleDatabase database;36 @InjectMocks private ArticleManager articleManager;37 @Spy @InjectMocks private ArticleManager spiedArticleManager;38 @Rule39 public ExpectedException exception = ExpectedException.none();40 @Before public void before() {41 MockitoAnnotations.initMocks(this);42 }43 @Test44 public void shouldNotFailWhenNotInitialized() {45 assertNotNull(articleManager);46 }47 @Test(expected = IllegalArgumentException.class)48 public void innerMockShouldRaiseAnExceptionThatChangesOuterMockBehavior() {49 when(calculator.countArticles("new")).thenThrow(new IllegalArgumentException());50 articleManager.updateArticleCounters("new");51 }52 @Test53 public void mockJustWorks() {54 articleManager.updateArticleCounters("new");55 }56 @Test57 public void constructor_is_called_for_each_test_in_test_class() throws Exception {58 // given59 junit_test_with_3_tests_methods.constructor_instantiation = 0;60 JUnitCore jUnitCore = new JUnitCore();61 jUnitCore.addListener(new TextListener(System.out));62 // when63 jUnitCore.run(junit_test_with_3_tests_methods.class);64 // then65 assertThat(junit_test_with_3_tests_methods.constructor_instantiation).isEqualTo(3);66 }67 @Test68 public void objects_created_with_constructor_initialization_can_be_spied() throws Exception {69 assertFalse(MockUtil.isMock(articleManager));70 assertTrue(MockUtil.isMock(spiedArticleManager));71 }72 @Test73 public void should_report_failure_only_when_object_initialization_throws_exception() throws Exception {74 try {75 MockitoAnnotations.initMocks(new ATest());76 fail();77 } catch (MockitoException e) {78 assertThat(e.getMessage()).contains("failingConstructor").contains("constructor").contains("threw an exception");79 assertThat(e.getCause()).isInstanceOf(IllegalStateException.class);80 }81 }82 @RunWith(MockitoJUnitRunner.class)83 public static class junit_test_with_3_tests_methods {84 private static int constructor_instantiation = 0;85 @Mock List<?> some_collaborator;86 @InjectMocks some_class_with_parametered_constructor should_be_initialized_3_times;87 @Test public void test_1() { }88 @Test public void test_2() { }89 @Test public void test_3() { }90 private static class some_class_with_parametered_constructor {91 public some_class_with_parametered_constructor(List<?> collaborator) {92 constructor_instantiation++;93 }94 }95 }96 private static class FailingConstructor {97 FailingConstructor(Set<?> set) {98 throw new IllegalStateException("always fail");99 }100 }101 @Ignore("don't run this code in the test runner")102 private static class ATest {103 @Mock Set<?> set;104 @InjectMocks FailingConstructor failingConstructor;105 }106 @Test107 public void injectMocksMustFailWithInterface() throws Exception {108 class TestCase {109 @InjectMocks110 IMethods f;111 }112 exception.expect(MockitoException.class);113 exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'IMethods' is an interface");114 initMocks(new TestCase());115 }116 @Test117 public void injectMocksMustFailWithEnum() throws Exception {118 class TestCase {119 @InjectMocks120 TimeUnit f;121 }122 exception.expect(MockitoException.class);123 exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'TimeUnit' is an enum");124 initMocks(new TestCase());125 }126 @Test127 public void injectMocksMustFailWithAbstractClass() throws Exception {128 class TestCase {129 @InjectMocks130 AbstractCollection<?> f;131 }132 exception.expect(MockitoException.class);133 exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'AbstractCollection' is an abstract class");134 initMocks(new TestCase());135 }136 @Test137 public void injectMocksMustFailWithNonStaticInnerClass() throws Exception {138 class TestCase {139 class InnerClass {}140 @InjectMocks141 InnerClass f;142 }143 exception.expect(MockitoException.class);144 exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'InnerClass' is an inner non static class");145 initMocks(new TestCase());146 }147 static class StaticInnerClass {}148 @Test149 public void injectMocksMustSucceedWithStaticInnerClass() throws Exception {150 class TestCase {151 @InjectMocks152 StaticInnerClass f;153 }154 TestCase testClass = new TestCase();155 initMocks(testClass);156 assertThat(testClass.f).isInstanceOf(StaticInnerClass.class);157 }158 @Test159 public void injectMocksMustSucceedWithInstance() throws Exception {160 class TestCase {161 @InjectMocks162 StaticInnerClass f = new StaticInnerClass();163 }164 TestCase testClass = new TestCase();165 StaticInnerClass original = testClass.f;166 initMocks(testClass);167 assertThat(testClass.f).isSameAs(original);168 }169}...
Source:MockInjectionUsingSetterOrPropertyTest.java
...5package org.mockitousage.annotation;6import org.assertj.core.api.Assertions;7import org.junit.Before;8import org.junit.Test;9import org.mockito.InjectMocks;10import org.mockito.Mock;11import org.mockito.MockitoAnnotations;12import org.mockito.Spy;13import org.mockito.exceptions.base.MockitoException;14import org.mockito.internal.util.MockUtil;15import org.mockitousage.IMethods;16import org.mockitoutil.TestBase;17import java.util.List;18import java.util.Map;19import java.util.Set;20import java.util.TreeSet;21import static junit.framework.TestCase.*;22@SuppressWarnings({"unchecked", "unused"})23public class MockInjectionUsingSetterOrPropertyTest extends TestBase {24 private SuperUnderTesting superUnderTestWithoutInjection = new SuperUnderTesting();25 @InjectMocks private SuperUnderTesting superUnderTest = new SuperUnderTesting();26 @InjectMocks private BaseUnderTesting baseUnderTest = new BaseUnderTesting();27 @InjectMocks private SubUnderTesting subUnderTest = new SubUnderTesting();28 @InjectMocks private OtherBaseUnderTesting otherBaseUnderTest = new OtherBaseUnderTesting();29 @InjectMocks private HasTwoFieldsWithSameType hasTwoFieldsWithSameType = new HasTwoFieldsWithSameType();30 private BaseUnderTesting baseUnderTestingInstance = new BaseUnderTesting();31 @InjectMocks private BaseUnderTesting initializedBase = baseUnderTestingInstance;32 @InjectMocks private BaseUnderTesting notInitializedBase;33 @Spy @InjectMocks private SuperUnderTesting initializedSpy = new SuperUnderTesting();34 @Spy @InjectMocks private SuperUnderTesting notInitializedSpy;35 @Mock private Map<?, ?> map;36 @Mock private List<?> list;37 @Mock private Set<?> histogram1;38 @Mock private Set<?> histogram2;39 @Mock private IMethods candidate2;40 @Spy private TreeSet<String> searchTree = new TreeSet<String>();41 @Before42 public void enforces_new_instances() {43 // initMocks called in TestBase Before method, so instances are not the same44 MockitoAnnotations.initMocks(this);45 }46 @Test47 public void should_keep_same_instance_if_field_initialized() {48 assertSame(baseUnderTestingInstance, initializedBase);49 }50 @Test51 public void should_initialize_annotated_field_if_null() {52 assertNotNull(notInitializedBase);53 }54 @Test55 public void should_inject_mocks_in_spy() {56 assertNotNull(initializedSpy.getAList());57 assertTrue(MockUtil.isMock(initializedSpy));58 }59 @Test60 public void should_initialize_spy_if_null_and_inject_mocks() {61 assertNotNull(notInitializedSpy);62 assertNotNull(notInitializedSpy.getAList());63 assertTrue(MockUtil.isMock(notInitializedSpy));64 }65 @Test66 public void should_inject_mocks_if_annotated() {67 MockitoAnnotations.initMocks(this);68 assertSame(list, superUnderTest.getAList());69 }70 @Test71 public void should_not_inject_if_not_annotated() {72 MockitoAnnotations.initMocks(this);73 assertNull(superUnderTestWithoutInjection.getAList());74 }75 @Test76 public void should_inject_mocks_for_class_hierarchy_if_annotated() {77 MockitoAnnotations.initMocks(this);78 assertSame(list, baseUnderTest.getAList());79 assertSame(map, baseUnderTest.getAMap());80 }81 @Test82 public void should_inject_mocks_by_name() {83 MockitoAnnotations.initMocks(this);84 assertSame(histogram1, subUnderTest.getHistogram1());85 assertSame(histogram2, subUnderTest.getHistogram2());86 }87 @Test88 public void should_inject_spies() {89 MockitoAnnotations.initMocks(this);90 assertSame(searchTree, otherBaseUnderTest.getSearchTree());91 }92 @Test93 public void should_insert_into_field_with_matching_name_when_multiple_fields_of_same_type_exists_in_injectee() {94 MockitoAnnotations.initMocks(this);95 assertNull("not injected, no mock named 'candidate1'", hasTwoFieldsWithSameType.candidate1);96 assertNotNull("injected, there's a mock named 'candidate2'", hasTwoFieldsWithSameType.candidate2);97 }98 @Test99 public void should_instantiate_inject_mock_field_if_possible() throws Exception {100 assertNotNull(notInitializedBase);101 }102 @Test103 public void should_keep_instance_on_inject_mock_field_if_present() throws Exception {104 assertSame(baseUnderTestingInstance, initializedBase);105 }106 @Test107 public void should_report_nicely() throws Exception {108 Object failing = new Object() {109 @InjectMocks ThrowingConstructor failingConstructor;110 };111 try {112 MockitoAnnotations.initMocks(failing);113 fail();114 } catch (MockitoException e) {115 Assertions.assertThat(e.getMessage()).contains("failingConstructor").contains("constructor").contains("threw an exception");116 Assertions.assertThat(e.getCause()).isInstanceOf(RuntimeException.class);117 }118 }119 static class ThrowingConstructor {120 ThrowingConstructor() { throw new RuntimeException("aha"); }121 }122 static class SuperUnderTesting {123 private List<?> aList;...
Source:UserEurekaApplicationTests.java
...9import org.junit.Before;10import org.junit.Rule;11import org.junit.Test;12import org.junit.runner.RunWith;13import org.mockito.InjectMocks;14import org.mockito.Mock;15import org.mockito.Mockito;16import org.mockito.MockitoAnnotations;17import org.mockito.junit.MockitoJUnit;18import org.mockito.junit.VerificationCollector;19import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;20import com.cg.sprint.dao.CityDao;21import com.cg.sprint.dao.LanguagesDao;22import com.cg.sprint.dao.MoviesDao;23import com.cg.sprint.dao.PaymentDao;24import com.cg.sprint.dao.SeatsDao;25import com.cg.sprint.dao.ShowsDao;26import com.cg.sprint.dao.TheatreDao;27import com.cg.sprint.entity.City;28import com.cg.sprint.entity.Languages;29import com.cg.sprint.entity.Movies;30import com.cg.sprint.entity.Payments;31import com.cg.sprint.entity.Seats;32import com.cg.sprint.entity.Shows;33import com.cg.sprint.entity.Theatre;34import com.cg.sprint.service.UserService;35@SuppressWarnings("unused")36@RunWith(SpringJUnit4ClassRunner.class)37public class UserEurekaApplicationTests {38 @Rule39 public VerificationCollector verificationCollector = MockitoJUnit.collector();40 @Mock41 private CityDao cityDao;42 @InjectMocks43 private UserService userService;44 @Before45 public void setup(){46 MockitoAnnotations.initMocks(this);47 }48 @Test49 public void testCityNames(){50 List<City> cityNames = new ArrayList<City>();51 cityNames.add(new City(11,101,"hyderabad"));52 cityNames.add(new City(21,102,"pune"));53 when(cityDao.findAll()).thenReturn(cityNames);54 List<City> result = cityDao.getCityNames();55 assertEquals(2, cityNames.size());56 }57 @Mock58 private MoviesDao movieDao;59 @InjectMocks60 private UserService userService1;61 private Optional<Movies> Movies;62 @Before63 public void setup1(){64 MockitoAnnotations.initMocks(this);65 }66 @Test67 public void testGetMovieNames(){68 List<Movies> Movie = new ArrayList<Movies>();69 Movie.add(new Movies(11,"mvrmall","hyderabad"));70 Movie.add(new Movies(21,"balaji","pune"));71 when(movieDao.findAll()).thenReturn(Movie);72 List<Movies> result = movieDao.findAll();73 assertEquals(2, Movie.size());74 }75 @Mock76 private TheatreDao theatreDao;77 @InjectMocks78 private UserService userService2;79 @Before80 public void setup2(){81 MockitoAnnotations.initMocks(this);82 }83 @Test84 public void testTheatreNames(){85 List<Theatre> TheatreNames = new ArrayList<Theatre>();86 TheatreNames.add(new Theatre(11,"srinivasa","siddipet"));87 TheatreNames.add(new Theatre(24,"asian","pune"));88 when(theatreDao.findAll()).thenReturn(TheatreNames);89 List<Theatre> result = theatreDao.findAll();90 assertEquals(2, TheatreNames.size());91 }92 @Mock93 private ShowsDao showsDao;94 @InjectMocks95 private UserService userService3;96 @Before97 public void setup3(){98 MockitoAnnotations.initMocks(this);99 }100 @Test101 public void testGetShowsNames(){102 List<Shows> showNames = new ArrayList<Shows>();103 showNames.add(new Shows(24,"asian","matniee"));104 when(showsDao.findAll()).thenReturn(showNames);105 List<Shows> result = showsDao.getShows();106 assertEquals(1, showNames.size());107 }108 @Mock109 private SeatsDao seatsDao;110 @InjectMocks111 private UserService userService4;112 @Before113 public void setup4(){114 MockitoAnnotations.initMocks(this);115 }116 @Test117 public void testGetAllSeats(){118 List<Seats> seatList = new ArrayList<Seats>();119 seatList.add(new Seats(11,"gold",101,32));120 when(seatsDao.findAll()).thenReturn(seatList);121 List<Seats> result = seatsDao.findAll();122 assertEquals(1,seatList.size());123 }124 125 @Test126 public void updateSeats() {127 Seats seats = new Seats(25,"gold",67,112);128 seatsDao.findById(25);129 seatsDao.save(seats);130 verify(seatsDao, Mockito.times(1)).save(seats);131 }132 @Test133 public void deleteSeats(){134 Seats seats = new Seats(11,"gold",101,32);135 seatsDao.deleteById(11);136 verify(seatsDao, times(1)).deleteById(11);137 }138 @Mock139 private LanguagesDao languagesDao;140 @InjectMocks141 private UserService userService5;142 @Before143 public void setup5(){144 MockitoAnnotations.initMocks(this);145 }146 @Test147 public void testGetAllLanguages(){148 List<Languages> LanguagesList = new ArrayList<Languages>();149 LanguagesList.add(new Languages(11,"telugu"));150 //seatList.add(new Seats(21,102,"pune",21,87));151 when(languagesDao.findAll()).thenReturn(LanguagesList);152 List<Languages> result = languagesDao.findAll();153 assertEquals(1,LanguagesList.size());154 }155 156 @Mock157 private PaymentDao paymentDao;158 @InjectMocks159 private UserService UserService6;160 @Before161 public void setup6(){162 MockitoAnnotations.initMocks(this);163 }164 @Test165 public void testaddPayments() {166 Payments payments=new Payments(12,34,112,65, "malkajgiri",78,"src");167 payments.setBookingId(1432);168 payments.setAccountNo(76512);169 payments.setMoneyCollected(500);170 payments.setSeatsBooked(2);171 payments.setSeatType("bolcony");172 payments.setRefund(250);...
Source:TypersiIntegrationTest.java
...14import org.apache.commons.logging.Log;15import org.apache.commons.logging.LogFactory;16import org.junit.Before;17import org.junit.Test;18import org.mockito.InjectMocks;19import org.mockito.Mockito;20import org.mockito.Spy;21import java.io.IOException;22import java.net.URISyntaxException;23import java.nio.file.Files;24import java.nio.file.Path;25import java.nio.file.Paths;26import java.util.List;27import static org.hamcrest.Matchers.greaterThan;28import static org.hamcrest.Matchers.greaterThanOrEqualTo;29import static org.junit.Assert.assertNotNull;30import static org.junit.Assert.assertThat;31/**32 * Created by KK on 2017-08-07.33 */34public class TypersiIntegrationTest extends AbstractEntityManagerBasedTest {35 private static Log log = LogFactory.getLog(TypersiIntegrationTest.class);36 private static final long TYPERSI_HISTORY_LENGTH_IN_MONTHS = 60L;37 private static final int MINIMAL_NUMBER_OF_FOUND_TYPERSI_PROPOSALS = 3;38 @Spy39 private Cleanser cleanser;40 @Spy41 private WebPageBrowser browser;42 @Spy43 private TypersiBetProposalParser typersiBetProposalParser;44 @Spy45 private TypersiHistoryParser typersiHistoryParser;46 @InjectMocks47 private TypersiHistoryEntryDao typersiHistoryEntryDao = Mockito.spy(TypersiHistoryEntryDao.class);48 @InjectMocks49 private TypersiRawDao typersiRawDao = Mockito.spy(TypersiRawDao.class);50 @InjectMocks51 private MatchDao matchDao = Mockito.spy(MatchDao.class);52 @InjectMocks53 private BettingProposalSourceDao bettingProposalSourceDao = Mockito.spy(BettingProposalSourceDao.class);54 @InjectMocks55 private BettingProposalSourceMatchDao bettingProposalSourceMatchDao = Mockito.spy(BettingProposalSourceMatchDao.class);56 @InjectMocks57 private BookmakerDao bookmakerDao = Mockito.spy(BookmakerDao.class);58 @InjectMocks59 private MatchOddDao matchOddDao = Mockito.spy(MatchOddDao.class);60 @InjectMocks61 private TeamDao teamDao = Mockito.spy(TeamDao.class);62 @InjectMocks63 private ProposedMatchMappingDao proposedMatchMappingDao = Mockito.spy(ProposedMatchMappingDao.class);64 @InjectMocks65 private TypersiBetProposalService typersiBetProposalService = Mockito.spy(TypersiBetProposalService.class);66 @InjectMocks67 private MappingService mappingService = Mockito.spy(MappingService.class);68 @InjectMocks69 private TeamMatcher teamMatcher = Mockito.spy(TeamMatcher.class);70 @InjectMocks71 private MatchMatcher matchMatcher = Mockito.spy(MatchMatcher.class);72 @InjectMocks73 private TypersiHistoryAnalyzer typersiHistoryAnalyzer = Mockito.spy(TypersiHistoryAnalyzer.class);74 @InjectMocks75 private TypersiHistoryService typersiHistoryService = Mockito.spy(TypersiHistoryService.class);76 @InjectMocks77 private BetExplorerCollector betExplorerCollector = Mockito.spy(BetExplorerCollector.class);78 @InjectMocks79 private TypersiLogic typersiLogic = new TypersiLogic();80 @Before81 public void init() throws IOException, URISyntaxException {82 startTransaction();83 BettingProposalSource bps = new BettingProposalSource();84 bps.setLogicImpClass(TypersiLogic.class.getName());85 bps.setActive(true);86 bps.setScheduleExpression("-");87 bettingProposalSourceDao.persist(bps);88 typersiLogic.init(Lists.newArrayList(), bps);89 typersiHistoryService.updateTypersiHistory(TYPERSI_HISTORY_LENGTH_IN_MONTHS);90 loadKnownTeams();91 betExplorerCollector.findAndInsertNewMatches();92 mappingService.loadTeams();...
Source:InjectingAnnotationEngine.java
...9import java.util.HashSet;10import java.util.Set;1112import org.mockito.Captor;13import org.mockito.InjectMocks;14import org.mockito.Mock;15import org.mockito.MockitoAnnotations;16import org.mockito.Spy;17import org.mockito.configuration.AnnotationEngine;18import org.mockito.exceptions.Reporter;19import org.mockito.exceptions.base.MockitoException;20import org.mockito.internal.util.reflection.FieldReader;2122/**23 * See {@link MockitoAnnotations}24 */25@SuppressWarnings({"deprecation", "unchecked"})26public class InjectingAnnotationEngine implements AnnotationEngine {27 28 AnnotationEngine delegate = new DefaultAnnotationEngine();29 AnnotationEngine spyAnnotationEngine = new SpyAnnotationEngine();30 31 /* (non-Javadoc)32 * @see org.mockito.AnnotationEngine#createMockFor(java.lang.annotation.Annotation, java.lang.reflect.Field)33 */ 34 public Object createMockFor(Annotation annotation, Field field) {35 return delegate.createMockFor(annotation, field);36 }37 38 @Override39 public void process(Class<?> context, Object testClass) {40 //this will create @Mocks, @Captors, etc:41 delegate.process(context, testClass);42 //this will create @Spies:43 spyAnnotationEngine.process(context, testClass);44 45 //this injects mocks46 Field[] fields = context.getDeclaredFields();47 for (Field field : fields) {48 if (field.isAnnotationPresent(InjectMocks.class)) {49 assertNoAnnotations(field, Mock.class, org.mockito.MockitoAnnotations.Mock.class, Captor.class);50 injectMocks(testClass);51 }52 }53 } 54 55 void assertNoAnnotations(Field field, Class ... annotations) {56 for (Class annotation : annotations) {57 if (field.isAnnotationPresent(annotation)) {58 new Reporter().unsupportedCombinationOfAnnotations(annotation.getSimpleName(), InjectMocks.class.getSimpleName());59 }60 } 61 }6263 /**64 * Initializes mock/spies dependencies for objects annotated with65 * @InjectMocks for given testClass.66 * <p>67 * See examples in javadoc for {@link MockitoAnnotations} class.68 * 69 * @param testClass70 * Test class, usually <code>this</code>71 */72 public void injectMocks(Object testClass) { 73 Class<?> clazz = testClass.getClass();74 Set<Field> mockDependents = new HashSet<Field>();75 Set<Object> mocks = new HashSet<Object>();76 77 while (clazz != Object.class) {78 mockDependents.addAll(scanForInjection(testClass, clazz));79 mocks.addAll(scanMocks(testClass, clazz));80 clazz = clazz.getSuperclass();81 }82 83 new DefaultInjectionEngine().injectMocksOnFields(mockDependents, mocks, testClass);84 }8586 private static Set<Field> scanForInjection(Object testClass, Class<?> clazz) {87 Set<Field> testedFields = new HashSet<Field>();88 Field[] fields = clazz.getDeclaredFields();89 for (Field field : fields) {90 if (null != field.getAnnotation(InjectMocks.class)) {91 if(new FieldReader(testClass, field).isNull()) {92 new Reporter().injectMockAnnotationFieldIsNull(field.getName());93 }94 testedFields.add(field);95 }96 }9798 return testedFields;99 }100101 private static Set<Object> scanMocks(Object testClass, Class<?> clazz) {102 Set<Object> mocks = new HashSet<Object>();103 for (Field field : clazz.getDeclaredFields()) {104 // mock or spies only
...
Source:OrderRepositoryImplTest.java
...16import java.util.Optional;17import org.junit.jupiter.api.Test;18import org.junit.jupiter.api.extension.ExtendWith;19import org.mapstruct.factory.Mappers;20import org.mockito.InjectMocks;21import org.mockito.Mock;22import org.mockito.Mockito;23import org.mockito.junit.jupiter.MockitoExtension;24@ExtendWith(MockitoExtension.class)25public class OrderRepositoryImplTest {26 @InjectMocks private OrderRepositoryImpl orderRepository;27 @InjectMocks private OrderItemDomainDbMapper orderItemDomainDbMapper = Mockito.spy(Mappers.getMapper(OrderItemDomainDbMapper.class));28 @InjectMocks private CustomerDomainDbMapper customerDomainDbMapper = Mockito.spy(Mappers.getMapper(CustomerDomainDbMapper.class));29 @InjectMocks private StoreDomainDbMapper storeDomainDbMapper = Mockito.spy(Mappers.getMapper(StoreDomainDbMapper.class));30 @InjectMocks private OrderDomainDbMapper orderDomainDbMapper = Mockito.spy(Mappers.getMapper(OrderDomainDbMapper.class));;31 @InjectMocks private CousineDomainDbMapper cousineDomainDbMapper = Mockito.spy(Mappers.getMapper(CousineDomainDbMapper.class));;32 @InjectMocks private ProductDomainDbMapper productDomainDbMapper = Mockito.spy(Mappers.getMapper(ProductDomainDbMapper.class));;33 @Mock private DbOrderRepository jpaRepository;34 @Test35 public void getByIdReturnOrderData() {36 // given37 Order expected = TestCoreEntityGenerator.randomOrder();38 OrderDb toBeReturned = orderDomainDbMapper.mapToDb(expected);39 // and40 doReturn(Optional.of(toBeReturned))41 .when(jpaRepository)42 .findById(eq(expected.getId().getNumber()));43 // when44 Optional<Order> actual = orderRepository.getById(expected.getId());45 // then46 assertThat(actual.isPresent()).isTrue();...
Source:InjectMocksAnnotationMockitoRuleSpec.java
1package mockito;2import a.DaoA;3import a.ServiceA;4import org.mockito.InjectMocks;5import org.mockito.Mock;6import org.mockito.junit.MockitoJUnit;7import org.mockito.junit.MockitoRule;8import org.specnaz.junit.SpecnazJUnit;9import org.specnaz.junit.rules.Rule;10import static org.assertj.core.api.Assertions.assertThat;11import static org.mockito.Mockito.when;12/**13 * Shows how the {@link MockitoRule} allows you to leverage the {@link InjectMocks}14 * annotation.15 * <p>16 * There is one subtlety that needs attention: fields annotated with {@link InjectMocks}17 * need to be re-set after each test in a {@link org.specnaz.SpecBuilder#endsEach} method18 * (see below for an explanation why).19 */20public class InjectMocksAnnotationMockitoRuleSpec extends SpecnazJUnit {21 // Mockito Rules are not meant to be used22 @SuppressWarnings("unused")23 public Rule<MockitoRule> mockitoRule = Rule.of(() -> MockitoJUnit.rule());24 @Mock25 DaoA daoA;26 @InjectMocks27 ServiceA serviceA;28 {29 describes("Using the JUnit Mockito Rule in Specnaz", it -> {30 it.should("work correctly with @InjectMocks", () -> {31 when(daoA.getA()).thenReturn("Mock");32 assertThat(serviceA.findA()).isEqualTo("ServiceA:Mock");33 });34 it.should("re-set the injected field in each test", () -> {35 when(daoA.getA()).thenReturn("Mock2");36 assertThat(serviceA.findA()).isEqualTo("ServiceA:Mock2");37 });38 it.endsEach(() -> {39 // Needed in order for the Mockito rule to work correctly -40 // otherwise, the daoA mock will be re-set after the first test,41 // however the serviceA real object will be not (as it's already non-null).42 // The Rule works the way it does because in 'vanilla' JUnit,43 // you get a different instance of the test class for each test,44 // meaning serviceA will be null again....
Source:InjectMocksScanner.java
...3 * This program is made available under the terms of the MIT License.4 */5package org.mockito.internal.configuration.injection.scanner;6import org.mockito.Captor;7import org.mockito.InjectMocks;8import org.mockito.Mock;9import org.mockito.MockitoAnnotations;10import org.mockito.exceptions.Reporter;11import java.lang.reflect.Field;12import java.util.HashSet;13import java.util.Set;14/**15 * Scan field for injection.16 */17@SuppressWarnings("deprecation")18public class InjectMocksScanner {19 private final Class<?> clazz;20 /**21 * Create a new InjectMocksScanner for the given clazz on the given instance22 *23 * @param clazz Current class in the hierarchy of the test24 */25 public InjectMocksScanner(Class<?> clazz) {26 this.clazz = clazz;27 }28 /**29 * Add the fields annotated by @{@link InjectMocks}30 *31 * @param mockDependentFields Set of fields annotated by @{@link InjectMocks}32 */33 public void addTo(Set<Field> mockDependentFields) {34 mockDependentFields.addAll(scan());35 }36 /**37 * Scan fields annotated by @InjectMocks38 *39 * @return Fields that depends on Mock40 */41 private Set<Field> scan() {42 Set<Field> mockDependentFields = new HashSet<Field>();43 Field[] fields = clazz.getDeclaredFields();44 for (Field field : fields) {45 if (null != field.getAnnotation(InjectMocks.class)) {46 assertNoAnnotations(field, Mock.class, MockitoAnnotations.Mock.class, Captor.class);47 mockDependentFields.add(field);48 }49 }50 return mockDependentFields;51 }52 void assertNoAnnotations(final Field field, final Class... annotations) {53 for (Class annotation : annotations) {54 if (field.isAnnotationPresent(annotation)) {55 new Reporter().unsupportedCombinationOfAnnotations(annotation.getSimpleName(), InjectMocks.class.getSimpleName());56 }57 }58 }59}
InjectMocks
Using AI Code Generation
1import org.junit.Test;2import org.junit.runner.RunWith;3import org.mockito.InjectMocks;4import org.mockito.Mock;5import org.mockito.runners.MockitoJUnitRunner;6import java.util.ArrayList;7import java.util.List;8import static org.junit.Assert.assertEquals;9import static org.mockito.Mockito.when;10@RunWith(MockitoJUnitRunner.class)11public class InjectMocksTest {12 List mockList = new ArrayList();13 List mockList1 = new ArrayList();14 public void test() {15 when(mockList.get(0)).thenReturn("Hello");16 when(mockList1.get(0)).thenReturn("Hello");17 assertEquals("Hello", mockList.get(0));18 assertEquals("Hello", mockList1.get(0));19 }20}
InjectMocks
Using AI Code Generation
1package com.automationrhapsody.mockito;2import org.junit.Test;3import org.junit.runner.RunWith;4import org.mockito.InjectMocks;5import org.mockito.Mock;6import org.mockito.runners.MockitoJUnitRunner;7@RunWith(MockitoJUnitRunner.class)8public class InjectMockTest {9 private Collaborator collaborator;10 private ClassTested classTested;11 public void test() {12 classTested.doSomething();13 }14}15package com.automationrhapsody.mockito;16import static org.mockito.Mockito.mock;17import static org.mockito.Mockito.verify;18import org.junit.Before;19import org.junit.Test;20public class MockTest {21 private Collaborator collaborator;22 private ClassTested classTested;23 public void setUp() {24 collaborator = mock(Collaborator.class);25 classTested = new ClassTested(collaborator);26 }27 public void test() {28 classTested.doSomething();29 verify(collaborator).doSomething();30 }31}32package com.automationrhapsody.mockito;33import static org.mockito.Mockito.spy;34import static org.mockito.Mockito.verify;35import org.junit.Before;36import org.junit.Test;37public class SpyTest {38 private Collaborator collaborator;39 private ClassTested classTested;40 public void setUp() {41 collaborator = spy(Collaborator.class);42 classTested = new ClassTested(collaborator);43 }44 public void test() {45 classTested.doSomething();46 verify(collaborator).doSomething();47 }48}49package com.automationrhapsody.mockito;50import org.junit.Before;51import org.junit.Test;52import org.mockito.Mock;53import org.mockito.MockitoAnnotations;54public class MockitoAnnotationsTest {55 private Collaborator collaborator;56 private ClassTested classTested;57 public void setUp() {58 MockitoAnnotations.initMocks(this);59 classTested = new ClassTested(collaborator);60 }61 public void test() {62 classTested.doSomething();63 }64}
InjectMocks
Using AI Code Generation
1package com.example;2import org.mockito.InjectMocks;3import org.mockito.Mock;4import org.mockito.MockitoAnnotations;5import org.testng.annotations.BeforeMethod;6import org.testng.annotations.Test;7import static org.mockito.Mockito.when;8import static org.testng.Assert.assertEquals;9public class TestNGTest {10private MathApplication mathApplication;11private CalculatorService calcService;12public void setUp() {13MockitoAnnotations.initMocks(this);14}15public void testAdd() {16when(calcService.add(10.0,20.0)).thenReturn(30.0);17assertEquals(mathApplication.add(10.0, 20.0),30.0,0);18}19}
InjectMocks
Using AI Code Generation
1import org.mockito.InjectMocks;2import org.mockito.Mock;3import org.mockito.MockitoAnnotations;4import org.mockito.Spy;5import org.testng.annotations.BeforeMethod;6import org.testng.annotations.Test;7public class TestClass {8 private ClassUnderTest classUnderTest;9 private Dependency dependency;10 private Dependency dependencySpy;11 public void setUp() throws Exception {12 MockitoAnnotations.initMocks(this);13 }14 public void test() {15 classUnderTest.methodCall();16 }17}
InjectMocks
Using AI Code Generation
1package org.mockito;2import org.junit.runner.RunWith;3import org.mockito.junit.MockitoJUnitRunner;4import org.mockito.Mock;5import org.mockito.InjectMocks;6import org.junit.Test;7import static org.junit.Assert.assertEquals;8@RunWith(MockitoJUnitRunner.class)9public class Test1 {10 private Test2 test2;11 private Test3 test3;12 public void test() {13 String result = test3.testMethod();14 assertEquals("Mockito", result);15 }16}17package org.mockito;18public class Test2 {19 public String testMethod() {20 return "Mockito";21 }22}23package org.mockito;24public class Test3 {25 private Test2 test2;26 public String testMethod() {27 return test2.testMethod();28 }29}
InjectMocks
Using AI Code Generation
1import org.mockito.InjectMocks;2import org.mockito.Mock;3import org.mockito.MockitoAnnotations;4import org.mockito.Spy;5import org.testng.annotations.BeforeMethod;6import org.testng.annotations.Test;7public class Class1 {8 private Class2 class2;9 private Class3 class3;10 private Class4 class4;11 private Class5 class5;12 public void setUp() {13 MockitoAnnotations.initMocks(this);14 }15 public void test1() {16 class5.method1();17 }18}19import org.mockito.Mockito;20import org.testng.annotations.Test;21public class Class2 {22 public void test2() {23 Class3 class3 = Mockito.mock(Class3.class);24 class3.method2();25 }26}27import org.mockito.Mockito;28import org.testng.annotations.Test;29public class Class3 {30 public void test3() {31 Class4 class4 = Mockito.mock(Class4.class);32 class4.method3();33 }34}35import org.mockito.Mockito;36import org.testng.annotations.Test;37public class Class4 {38 public void test4() {39 Class5 class5 = Mockito.mock(Class5.class);40 class5.method4();41 }42}43import org.mockito.Mockito;44import org.testng.annotations.Test;45public class Class5 {46 public void test5() {47 Class6 class6 = Mockito.mock(Class6.class);48 class6.method5();49 }50}51import org.mockito.Mockito;52import org.testng.annotations.Test;53public class Class6 {54 public void test6() {55 Class7 class7 = Mockito.mock(Class7.class);56 class7.method6();57 }58}59import org.mockito.Mockito;60import org.testng.annotations.Test;61public class Class7 {
InjectMocks
Using AI Code Generation
1import org.mockito.InjectMocks;2import org.mockito.Mock;3import org.mockito.MockitoAnnotations;4import org.junit.Before;5import org.junit.Test;6import static org.mockito.Mockito.*;7import static org.junit.Assert.*;8class Employee{9 private String name;10 private int age;11 public Employee(String name, int age){12 this.name = name;13 this.age = age;14 }15 public String getName(){16 return name;17 }18 public int getAge(){19 return age;20 }21}22class Department{23 private String name;24 private Employee employee;25 public Department(String name, Employee employee){26 this.name = name;27 this.employee = employee;28 }29 public String getName(){30 return name;31 }32 public Employee getEmployee(){33 return employee;34 }35}36class Company{37 private String name;38 private Department department;39 public Company(String name, Department department){40 this.name = name;41 this.department = department;42 }43 public String getName(){44 return name;45 }46 public Department getDepartment(){47 return department;48 }49}50class EmployeeService{51 private Company company;52 public EmployeeService(Company company){53 this.company = company;54 }55 public String getEmployeeName(){56 return company.getDepartment().getEmployee().getName();57 }58 public int getEmployeeAge(){59 return company.getDepartment().getEmployee().getAge();60 }61}62class DepartmentService{63 private Company company;64 public DepartmentService(Company company){65 this.company = company;66 }67 public String getDepartmentName(){68 return company.getDepartment().getName();69 }70}71class CompanyService{72 private Company company;73 public CompanyService(Company company){74 this.company = company;75 }76 public String getCompanyName(){77 return company.getName();78 }79}80class EmployeeServiceTest{81 private Company company;82 private Department department;83 private Employee employee;84 private EmployeeService employeeService;85 public void setUp(){86 MockitoAnnotations.initMocks(this);87 }88 public void getEmployeeNameTest(){89 when(employee.getName()).thenReturn("John");
InjectMocks
Using AI Code Generation
1import org.mockito.InjectMocks;2import org.mockito.Mock;3import org.mockito.MockitoAnnotations;4public class MyTest {5 private MyClass myClass;6 private MyService myService;7 public void initMocks() {8 MockitoAnnotations.initMocks(this);9 }10 public void test() {11 myService.doSomething();12 verify(myClass).doSomething();13 }14}15import org.junit.runner.RunWith;16import org.mockito.InjectMocks;17import org.mockito.Mock;18import org.mockito.runners.MockitoJUnitRunner;19@RunWith(MockitoJUnitRunner.class)20public class MyTest {21 private MyClass myClass;22 private MyService myService;23 public void test() {24 myService.doSomething();25 verify(myClass).doSomething();26 }27}28import org.junit.Rule;29import org.junit.Test;30import org.mockito.InjectMocks;31import org.mockito.Mock;32import org.mockito.junit.MockitoJUnit;33import org.mockito.junit.MockitoRule;34public class MyTest {35 private MyClass myClass;36 private MyService myService;37 public MockitoRule mockitoRule = MockitoJUnit.rule();38 public void test() {39 myService.doSomething();40 verify(myClass).doSomething();41 }42}43import org.junit.Test;44import org.mockito.InjectMocks;45import org.mockito.Mock;46import org.mockito.MockitoAnnotations;47public class MyTest {48 private MyClass myClass;49 private MyService myService;50 public MyTest() {51 MockitoAnnotations.initMocks(this);52 }53 public void test() {54 myService.doSomething();55 verify(myClass).doSomething();56 }57}58import org.junit.Test;59import org.mockito.InjectMocks;60import org.mockito.Mock;61import org.mockito.MockitoAnnotations;62public class MyTest {63 private MyClass myClass;
InjectMocks
Using AI Code Generation
1package com.javatpoint;2import static org.mockito.Mockito.*;3import org.mockito.InjectMocks;4import org.mockito.Mock;5import org.mockito.MockitoAnnotations;6import org.junit.Before;7import org.junit.Test;8public class Test1 {9 Calculation calculation;10 Calculator calculator = new Calculator();11 public void setup(){12 MockitoAnnotations.initMocks(this);13 }14 public void test(){15 when(calculation.add(10, 20)).thenReturn(30);16 System.out.println(calculator.add(10, 20));17 verify(calculation).add(10, 20);18 }19}
InjectMocks
Using AI Code Generation
1package org.mockito;2import org.junit.runner.RunWith;3import org.mockito.junit.MockitoJUnitRunner;4import org.mockito.Mock;5import org.mockito.InjectMocks;6import org.junit.Test;7import static org.junit.Assert.assertEquals;8@RunWith(MockitoJUnitRunner.class)9public class Test1 {10 private Test2 test2;11 private Test3 test3;12 public void test() {13 String result = test3.testMethod();14 assertEquals("Mockito", result);15 }16}17package org.mockito;18public class Test2 {19 public String testMethod() {20 return "Mockito";21 }22}23package org.mockito;24public class Test3 {25 private Test2 test2;26 public String testMethod() {27 return test2.testMethod();28 }29}
InjectMocks
Using AI Code Generation
1import org.mockito.InjectMocks;2import org.mockito.Mock;3import org.mockito.MockitoAnnotations;4import org.junit.Before;5import org.junit.Test;6import static org.mockito.Mockito.*;7import static org.junit.Assert.*;8class Employee{9 private String name;10 private int age;11 public Employee(String name, int age){12 this.name = name;13 this.age = age;14 }15 public String getName(){16 return name;17 }18 public int getAge(){19 return age;20 }21}22class Department{23 private String name;24 private Employee employee;25 public Department(String name, Employee employee){26 this.name = name;27 this.employee = employee;28 }29 public String getName(){30 return name;31 }32 public Employee getEmployee(){33 return employee;34 }35}36class Company{37 private String name;38 private Department department;39 public Company(String name, Department department){40 this.name = name;41 this.department = department;42 }43 public String getName(){44 return name;45 }46 public Department getDepartment(){47 return department;48 }49}50class EmployeeService{51 private Company company;52 public EmployeeService(Company company){53 this.company = company;54 }55 public String getEmployeeName(){56 return company.getDepartment().getEmployee().getName();57 }58 public int getEmployeeAge(){59 return company.getDepartment().getEmployee().getAge();60 }61}62class DepartmentService{63 private Company company;64 public DepartmentService(Company company){65 this.company = company;66 }67 public String getDepartmentName(){68 return company.getDepartment().getName();69 }70}71class CompanyService{72 private Company company;73 public CompanyService(Company company){74 this.company = company;75 }76 public String getCompanyName(){77 return company.getName();78 }79}80class EmployeeServiceTest{81 private Company company;82 private Department department;83 private Employee employee;84 private EmployeeService employeeService;85 public void setUp(){86 MockitoAnnotations.initMocks(this);87 }88 public void getEmployeeNameTest(){89 when(employee.getName()).thenReturn("John");
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run Mockito automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Most used methods in InjectMocks
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
