For the future I would recommend Eran Harel’s answer (refactoring moving new to factory that can be mocked). But if you don’t want to change the original source code, use very handy and unique feature: spies. From the documentation: You can create spies of real objects. When you use the spy then the real methods … Read more
I think the reason may be that mock object libraries typically create mocks by dynamically creating classes at runtime (using cglib). This means they either implement an interface at runtime (that’s what EasyMock does if I’m not mistaken), or they inherit from the class to mock (that’s what Mockito does if I’m not mistaken). Both … Read more
If you really don’t have a choice for refactoring you can mock/stub everything in the super method call e.g. class BaseService { public void validate(){ fail(” I must not be called”); } public void save(){ //Save method of super will still be called. validate(); } } class ChildService extends BaseService{ public void load(){} public void … Read more
Mockito matchers are static methods and calls to those methods, which stand in for arguments during calls to when and verify. Hamcrest matchers (archived version) (or Hamcrest-style matchers) are stateless, general-purpose object instances that implement Matcher<T> and expose a method matches(T) that returns true if the object matches the Matcher’s criteria. They are intended to … Read more
The following suggestion let’s you test abstract classes without creating a “real” subclass – the Mock is the subclass. use Mockito.mock(My.class, Mockito.CALLS_REAL_METHODS), then mock any abstract methods that are invoked. Example: public abstract class My { public Result methodUnderTest() { … } protected abstract void methodIDontCareAbout(); } public class MyTest { @Test public void shouldFailOnNullIdentifiers() … Read more
I don’t see a problem here. With the following code using the Mockito API, I managed to do just that : public class CodeWithPrivateMethod { public void meaningfulPublicApi() { if (doTheGamble(“Whatever”, 1 << 3)) { throw new RuntimeException(“boom”); } } private boolean doTheGamble(String whatever, int binary) { Random random = new Random(System.nanoTime()); boolean gamble = … Read more
The two syntaxes for stubbing are roughly equivalent. However, you can always use doReturn/when for stubbing; but there are cases where you can’t use when/thenReturn. Stubbing void methods is one such. Others include use with Mockito spies, and stubbing the same method more than once. One thing that when/thenReturn gives you, that doReturn/when doesn’t, is … Read more
@Mock creates a mock. @InjectMocks creates an instance of the class and injects the mocks that are created with the @Mock (or @Spy) annotations into this instance. Note you must use @RunWith(MockitoJUnitRunner.class) or Mockito.initMocks(this) to initialize these mocks and inject them (JUnit 4). With JUnit 5, you must use @ExtendWith(MockitoExtension.class). @RunWith(MockitoJUnitRunner.class) // JUnit 4 // … Read more
To directly answer your question, yes, you can mock some methods without mocking others. This is called a partial mock. See the Mockito documentation on partial mocks for more information. For your example, you can do something like the following, in your test: Stock stock = mock(Stock.class); when(stock.getPrice()).thenReturn(100.00); // Mock implementation when(stock.getQuantity()).thenReturn(200); // Mock implementation … Read more
What you want to do is a combination of part of 1 and all of 2. You need to use the PowerMockito.mockStatic to enable static mocking for all static methods of a class. This means make it possible to stub them using the when-thenReturn syntax. But the 2-argument overload of mockStatic you are using supplies … Read more