Mock static java methods using Mockk

Question

We are currently working with java with kotlin project, slowly migrating the whole code to the latter.

Is it possible to mock static methods like Uri.parse() using Mockk?

How would the sample code look like?

Answer 1

After mockk 1.8.1:

Mockk version 1.8.1 deprecated the solution below. After that version you should do:

@Before
fun mockAllUriInteractions() {
    mockkStatic(Uri::class)
    val uriMock = mockk<Uri>() 
    every { Uri.parse("test/path") } returns uriMock
}

mockkStatic will be cleared everytime it's called, so you don't need to unmock it before using it again.

However, if that static namespace will be shared across tests it will share the mocked behavior. To avoid it, make sure to unmockkStatic after your suite is done.

---

DEPRECATED:

If you need that mocked behaviour to always be there, not only in a single test case, you can mock it using @Before and @After:

@Before
fun mockAllUriInteractions() {
    staticMockk<Uri>().mock()
    every { Uri.parse("http://test/path") } returns Uri("http", "test", "path")    //This line can also be in any @Test case
}

@After
fun unmockAllUriInteractions() {
    staticMockk<Uri>().unmock()
}

This way, if you expect more pieces of your class to use the Uri class, you may mock it in a single place, instead of polluting your code with .use everywhere.

Answer 2

Beware

If you call mockkSatic() without a block, do not forget to call unmockkStatic() after the mocked method is called. The method is not unmocked automatically and you will still get the mocked value even in different test classes which do not call mockkStatic(), but use the static method.

Another option is to execute the mocked method inside a block, then it will be automatically unmocked:

mockkStatic(Uri::class) {
    every { Uri.parse("http://test/path") } returns Uri("http", "test", "path")
    val uri = Uri.parse("http://test/path")
}

Answer 3

MockK allows mocking static Java methods. The main purpose for it is mocking of Kotlin extension functions, so it is not as powerful as PowerMock, but still does it's job even for Java static methods.

The syntax would be following:

staticMockk<Uri>().use {
    every { Uri.parse("http://test/path") } returns Uri("http", "test", "path")

    assertEquals(Uri("http", "test", "path"), Uri.parse("http://test/path"))

    verify { Uri.parse("http://test/path") }  
}

More details here: http://mockk.io/#extension-functions

Answer 4

Additionally to the accepted answer:

You can't create an Uri like that, you gonna have to mock the Uri instance as well. Something like:

private val mockUri = mockk<Uri>()

@Before
fun mockAllUriInteractions() {
    mockkStatic(Uri::class)
    every { Uri.parse("http://test/path") } returns mockUri
    // or just every { Uri.parse("http://test/path") } returns mockk<Uri>()
}

Answer 5

If we are going to mock static, like: mockkStatic(Klass::class)

then we definitely have to unmock it, like: unmockkStatic(Klass::class)

I would suggest to unmock it in the method annotated @After.

A full example would be:

class SomeTest {
  private late var viewMode: SomeViewModel

  @Before
  fun setUp() {
    viewMode = SomeViewModel()
    mockkStatic(OurClassWithStaticMethods::class)       
  }

  @After
  fun tearDown() {
    unmockkStatic(OurClassWithStaticMethods::class)
  }

  @Test
  fun `Check that static method get() in the class OurClassWithStaticMethods was called`() {
    //Given
    every { OurClassWithStaticMethods.get<Any>(any()) } returns "dummyString"

    //When
    viewModel.doSomethingWhereStaticMethodIsCalled()

    //Then
    verify(exactly = 1) { 
       OurClassWithStaticMethods.get<Any>(any()) 
    }
  }
}

This example is written with the mocking library "Mockk" v.1.12.0

Answer 6

As mentioned in multiple answers above, you'll have to ensure to invoke the unmockkStatic - otherwise you'll end up with flaky tests (since the mocked object/function will be available across test classes.

In my scenario - I had a module-wide extension function in kotlin and to mock that I used a companion object like below:

class SampleTest {

companion object {
    @BeforeAll
    @JvmStatic
    fun setup() {
        mockkStatic("packagename.filenameKt")
    }

    @AfterAll
    @JvmStatic
    fun teardown() {
        unmockkStatic("packagename.filenameKt")
    }
}}

Answer 7

// Add @RunWith(RobolectricTestRunner::class) on top of 
// your class since it provides access to Android framework APIs.

// Test case written inside the `mockkStatic` method to 
// verify the behavior of a method that involves a static method call in Kotlin
        
            @Test
            fun `my test case`() = runBlocking {
                // Mocking the Log class
                mockkStatic(Log::class) {
                    // Test case to verify the behavior of a method 
                    // that involves a log method call
                }
            }




// OR just use `mockkObject(Log)` without any block