How to test a static method using mock() and spy()

Question

the below posted method in the code section contains a static method which is "with()". I want to test the code in below, so I coded the test of this method as shown in the testing section.

i tried to test the method using both of "spy()" and "mock()" but the test fails alwyas.

please let me know how can I test a method returns void?

code

 public RequestCreator requestCreatorFromUrl(String picUrl) {
    return Picasso.with(mCtx).load(picUrl);
}

testing:

public class ValidationTest {
@Mock
private Context mCtx = null;
@Rule
public MockitoRule mockitoRule = MockitoJUnit.rule();

@Before
public void setUp() throws Exception {
    mCtx = Mockito.mock(Context.class);
    Assert.assertNotNull("Context is not null", mCtx);
}

 @Test
public void whenRequestCreatorFromUrlTest() throws Exception {
    Picasso picasso = Picasso.with(mCtx);
    Picasso spyPicasso = spy(picasso);
    Uri mockUri = mock(Uri.class);
    RequestCreator requestCreator = Picasso.with(mCtx).load(mockUri);
    RequestCreator spyRequestCreator = spy(requestCreator);

    doReturn(spyRequestCreator).when(spyPicasso.load(mockUri));
    //when(spyPicasso.load(mockUri)).thenReturn(spyRequestCreator);
    RequestCreator actual = spyPicasso.load(mockUri);

    Assert.assertEquals(requestCreator, actual);
}

Answer 1

Usually, if you end up using PowerMock, that’s a good sign that you most possibly are on the wrong way.

What if instead of directly referring to Picasso, you create a component, whose responsibility will be to load an image, let's say class ImageLoader. What will this give to you?

• Separation of concerns: if tomorrow you decide to move to Glide, you shouldn't change each and every class where you were using Picasso, you will just change implementation of ImageLoader. Other components are non-wiser of these changes, because they are dependent on an abstraction, not on implementation

• Seam: this will allow you easily mock dependencies in order to perform unit testing

This will be our abstraction:

    interface ImageLoader {
        RequestCreator load(String url);
    }

Let’s provide an implementation:

    class ImageLoaderImpl implements ImageLoader {
        
        private final Picasso picasso;
    
        public ImageLoaderImpl(Context context) {
            this.picasso = Picasso.with(context);
        }
    
        @Override
        public RequestCreator load(String url) {
            return picasso.load(url);
        }
    }

Now, in your components whenever you need Picasso use ImageLoader instead.

Thus, your method becomes following:

    public static RequestCreator requestCreatorFromUrl(String picUrl) {
        return imageLoader.load(picUrl);
    }

Then your test will look like this:

    @Test
    public void test() {
        ImageLoaderImpl imageLoader = Mockito.mock(ImageLoaderImpl.class);
        RequestCreator expected = Mockito.mock(RequestCreator.class);
        String TEST_URL = "https://www.some.url/img.jpg";
    
        when(imageLoader.load(TEST_URL)).thenReturn(expexted);
    
        RequestCreator actual = clazzToTest.requestCreatorFromUrl(TEST_URL);
    
        assertEquals(expected, actual);
    }

No mocking of static method, no PowerMock needed.

Answer 2

From the Mockito's FAQ:

What are the limitations of Mockito

...

Cannot mock static methods

Use PowerMock instead. Here you will find the detailed instruction about how to mock the static methods.

Update

In order to apply the PowerMock to your test you need to:

• Add @PrepareForTest at test class level:

  @PrepareForTest(Picasso.class) public class ValidationTest { ... }

• Call PowerMockito.mockStatic() to mock a static class

  PowerMockito.mockStatic(Picasso.class);

• Just use Mockito.when() to setup your expectation:

  Mockito.when(Picasso.with(mCtx)).thenReturn(requestCreator);

The same set of steps is applicable for the RequestCreator.class.

P.S. I can make mistakes because I do not know the API of 3rd party library you use.

Answer 3

Forget PowerMockito. With mockito-inline version > 4.2.0 you can use it by @Mock annotation. I haven't test your code, but you can have some insights with this answer.

You can check the use in my conclusion work of university (Github).

class Test {
    @Mock
    MockedStatic<Picasso> picasso;

    @BeforeEach
    public void beforeEach() {
       doNothing().when(Picasso..with(any()));
    }
}

There's another approach that consist to mock static manually, which I don't prefer, but work fine. You can find the example in Baeldung website

Answer 4

try (MockedStatic<SOMECLASS> instantMockedStatic = Mockito.mockStatic(SOMECLASS.class, Mockito.CALLS_REAL_METHODS)) {
            instantMockedStatic.when(SOME_CLASS::SOME_STATIC_METHOD).thenReturn(startValue);
   // some validation logic here, including methods that call real class...
}

e.g.

final Instant startValue = Instant.ofEpochSecond(0);
try (MockedStatic<Instant> instantMockedStatic = Mockito.mockStatic(Instant.class, Mockito.CALLS_REAL_METHODS)) {
    instantMockedStatic.when(Instant::now).thenReturn(startValue);

    Assertions.assertEquals(startValue.plus(Duration.ofSeconds(1)) , somethingThatUsesInstantNowAndAdds1Sec());