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?

Resignation

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.

Yellowlegs

Your response ("After mockk 1.8.1") is more accurate than the chosen response. Thanks! – Guillema

The accepted answer was written before mockk 1.8.1, that's why this became more accurate – Yellowlegs

This is an excellent solution to mock the Crashlytics.log and similar functions called from Java libraries when writing local unit tests! – Trask

@Yellowlegs how is your solution supposed to work when i immediately get an compile error on Uri("http", "test", "path") with messages "Cannot create an instance of abstract class" and "Too many arguments for public/*package*/ constructor Uri() defined in android.net.Uri"? I'm using mockk 1.10.0 – Dichotomize

The latest Uri is missing Uri("http", "test", "path") signature. – Floodlight

@Floodlight Just use val uriMock = mockk<Uri>() – Lewellen

how using that mockk will solve the issue of the Uri method? – Historic

Uri constructor is private. How do you make this work? Can you please help? – Magnus

I don't understand how this answer is 73 upvotes, while using Uri() constructor which is A) private and B) the class is abstract... – Reproachless

@Reproachless Because the URI constructor isn't important to he answer. And having that Uri as extension function is something likely to happen. The important part of the answer is how to use mockk to mock a static method, and it's clear in that sense. – Yellowlegs

Beware in some cases after 1.8.1 you still need to call unmockkStatic(). See Tomas Rohovsky answer here: https://mcmap.net/q/321674/-mock-static-java-methods-using-mockk – Overshadow

To help people with the Uri constructor, the answer by @Yellowlegs can be improved in this way: ` mockkStatic(Uri::class) val uriMock = mockk<Uri>() every { Uri.parse("test/path") } returns uriMock ` – Taciturn

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")
}

Innings

This should be added to the accepted answer. Just found the source of our flaky tests after searching for 8 hours! Thanks Tomas! – Overshadow

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

Fugate

Note: staticMockk is deprecated and replaced with: "mockkStatic(T::class)" – Loire

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>()
}

Jeane

This should be the accepted answer—you cannot construct Uri as described in the other answers because the constructor is private. mockUri = mockk<Uri>() is perfect, thank you. – Adley

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

Juta

we need to unmock! resolved answer is not right – Freely

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")
    }
}}

Resort

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 

Cataclysm