Thanks for the report

Did you find a work around for this?

same issue here ... any way to work around this?

Same issue Kotlin version: 1.3.50

Hello. Same here. Any update on this?

Had the same issue. For now I had to stop using mockk altogether for KMP as I don't know any workaround.

Is there any update?

Thanks!

Same issue with Kotlin multiplatform-1.4.0. Except new update to fix it.

Same Issue, someone has an update for this?

Thanks!

Any workaround available?

I think basically mockk has no support for Kotlin Multiplatform so it is not possible to use this library with it.

I think basically mockk has no support for Kotlin Multiplatform so it is not possible to use this library with it.

probably soon it could be supported

Same issue here :(

I just started playing with Kotlin Multiplatform recently so I am not too familiar with it yet, but today I tried adding MockK to one of my commonTest tests and it seems to be working.

I'm using
Windows 10
IntelliJ IDEA 2020.3 (Ultimate Edition)
Kotlin 1.4.21
MockK: I tried both 1.10.3 and 1.10.3-jdk8

val atomicfuVersion = "0.14.4"
val mockkVersion = "1.10.3-jdk8"

plugins {
    kotlin("multiplatform") version "1.4.21"
}

group = "com.example"
version = "1.0-SNAPSHOT"

repositories {
    mavenCentral()
}

kotlin {
    explicitApi()
    jvm {
        compilations.all {
            kotlinOptions.jvmTarget = "1.8"
        }
        testRuns["test"].executionTask.configure {
            useJUnitPlatform()
        }
    }
    js(LEGACY) {
        browser {
            testTask {
                useKarma {
                    useChromeHeadless()
                }
            }
        }
    }
    val hostOs = System.getProperty("os.name")
    val isMingwX64 = hostOs.startsWith("Windows")
    val nativeTarget = when {
        hostOs == "Mac OS X" -> macosX64("native")
        hostOs == "Linux" -> linuxX64("native")
        isMingwX64 -> mingwX64("native")
        else -> throw GradleException("Host OS is not supported in Kotlin/Native.")
    }

    
    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation("org.jetbrains.kotlinx:atomicfu:$atomicfuVersion")
            }
        }
        val commonTest by getting {
            dependencies {
                implementation(kotlin("test-common"))
                implementation(kotlin("test-annotations-common"))
                implementation("io.mockk:mockk-common:$mockkVersion")
                implementation("io.mockk:mockk:$mockkVersion")
            }
        }
        val jvmMain by getting
        val jvmTest by getting {
            dependencies {
                implementation(kotlin("test-junit5"))
                implementation("org.junit.jupiter:junit-jupiter-api:5.6.0")
                runtimeOnly("org.junit.jupiter:junit-jupiter-engine:5.6.0")
            }
        }
        val jsMain by getting
        val jsTest by getting {
            dependencies {
                implementation(kotlin("test-js"))
            }
        }
        val nativeMain by getting
        val nativeTest by getting
    }
}

Here is my test file under commonTest

import io.mockk.*
import io.mockk.impl.annotations.MockK
import kotlin.test.AfterTest
import kotlin.test.BeforeTest
import kotlin.test.Test
import kotlin.test.assertEquals

interface Car {
    fun drive(direction: Direction) : Outcome
}

enum class Direction { NORTH, SOUTH }

enum class Outcome { GOING_NORTH, GOING_SOUTH }

class CarTest {

    @MockK
    private lateinit var annotatedCar: Car

    @BeforeTest
    fun setUp() {
        MockKAnnotations.init(this)
    }

    @AfterTest
    fun tearDown() {
        unmockkAll()
    }

    @Test
    fun mockkCar() {
        val mockkCar = mockk<Car>()
        every { mockkCar.drive(Direction.NORTH) } returns Outcome.GOING_NORTH
        every { mockkCar.drive(Direction.SOUTH) } returns Outcome.GOING_SOUTH

        assertEquals(Outcome.GOING_SOUTH, mockkCar.drive(Direction.SOUTH))
        assertEquals(Outcome.GOING_NORTH, mockkCar.drive(Direction.NORTH))

        verify { mockkCar.drive(Direction.NORTH) }
        verify { mockkCar.drive(Direction.SOUTH) }

        confirmVerified(mockkCar)
    }

    @Test
    fun annotatedCar() {
        every { annotatedCar.drive(Direction.NORTH) } returns Outcome.GOING_NORTH
        every { annotatedCar.drive(Direction.SOUTH) } returns Outcome.GOING_SOUTH

        assertEquals(Outcome.GOING_SOUTH, annotatedCar.drive(Direction.SOUTH))
        assertEquals(Outcome.GOING_NORTH, annotatedCar.drive(Direction.NORTH))

        verify { annotatedCar.drive(Direction.NORTH) }
        verify { annotatedCar.drive(Direction.SOUTH) }

        confirmVerified(annotatedCar)
    }
}

One thing I noticed is the default gradle tasks executed when I select a test on my commonTest module and run are cleanIosX64Test and iosX64Test.

I am not sure why those are the defaults for this module, but if I instead run testDebugUnitTest or testReleaseUnitTest, then my commonTest tests run properly... but I still don't have any tests on my iosTest, so I don't know how this would behave

Reproduces in Kotlin 1.4.32

Probably found the workaround. Instead of just adding:
implementation("io.mockk:mockk-common:$mockkVersion")
add also:
implementation("io.mockk:mockk:$mockkVersion")

Works like a charm for my project

@ILikeYourHat Thank you, that worked for me too.

Unfortunately the solution of adding implementation("io.mockk:mockk:$mockkVersion") breaks the gradle project sync, see #513.

I do not know how but after appliying this, now my files see mockk dependency and kmm project structure also not broken:

   val commonTest by getting {
        dependencies {
            implementation(kotlin("test-common"))
            implementation(kotlin("test-annotations-common"))
            implementation("io.mockk:mockk-common:1.11.0")
        }
    }

    val androidTest by getting {
        dependencies {
            implementation(kotlin("test"))
            implementation(kotlin("test-junit"))
            implementation("junit:junit:4.13.2")
            implementation("io.mockk:mockk:1.11.0")

        }
    }

Same issue here. When using Mock we can run the test in commonTest but when trying to run the test in iosTest folder it fails on :compileTestKotlinIosX64 task

there's an effective and easy workaround for this issue if your goal is to use mockk in commonTest and run your tests using jvm.

if that's your case, here's my tip: create stub implementations of io.mockk inside iosTest directory.

if you want to use verify in your commonTest, just create a file, e.g: Mockk.kt, within the correct package structure (io.mockk) and create your stubbed verify:

fun verify(
    ordering: Ordering = Ordering.UNORDERED,
    inverse: Boolean = false,
    atLeast: Int = 1,
    atMost: Int = Int.MAX_VALUE,
    exactly: Int = -1,
    timeout: Long = 0,
    verifyBlock: MockKVerificationScope.() -> Unit
) = {
    TODO()
}

another tip to make your life easier is to open mockk method implementation using your IDE and just copy the signature and paste on your stubbed mockk 😄

attention that you only have to create these stubs inside iosTest source set.

disclaimer: I'm not providing an elegant way or the best solution ever. For now, it's the easiest way that I found to solve my problems. 🍻

It looks like all of the "solutions" here are workarounds to get the tests building and running on something other than the native Apple-compatible code. That part we have working no problem. No one seems to be able to get mockk tests running natively on a Mac.

It looks like all of the "solutions" here are workarounds to get the tests building and running on a non-Mac machine. That part we have working no problem. No one seems to be able to get mockk tests running natively on a Mac.

yes, you are right about the workarounds and stuff! actually the solution I've mentioned above works on mac machines 😃

@leocabral but aren't you running the tests using the JVM, which is not how the code would execute on an iOS simulator or a real iOS device?

I want to verify the functionality of the code when compiled for iOS itself (or least simulator), not the JVM.

@silverhammermba yes, I am! so indeed, your need cannot be accomplished by mockk.

Hi. Any news about this issue? I can not publish my KMP library due to this issue during JS test task.

Unresolved reference: mockk
Unresolved reference: mockkStatic
Unresolved reference: every
Unresolved reference. None of the following candidates is applicable because of receiver type mismatch:

Hi @ComBatVision , you can just change the name of your directory from commonTest to jvmTest, as well as your gradle section to something like this:

val jvmTest by getting { dependencies { implementation(kotlin("test-junit")) implementation("io.mockk:mockk:1.9.3") } }

I think basically mockk has no support for Kotlin Multiplatform so it is not possible to use this library with it.

probably soon it could be supported

Almost 3 years, how soon? LOL

Unfortunately the solution of adding implementation("io.mockk:mockk:$mockkVersion") breaks the gradle project sync, see #513.

See @YKakdas's answer. It works