class ViewModel {

	fun loadSomeStuff() {
		myObject.asyncOperation(object : Callback {
			//callback methods implementation
		})
	}
}

verify(exactly = 1) { mView.loadUser(user is {name = "sergio"}) }

verify(exactly = 1) { mView.loadUser(user)}

Instant.parse("2017-11-01T11:04:56Z")

mockkStatic

verify(exactly = 1)

BehaviorSpec

Given

Given("foo") {
  every { persistentSource.getAccessToken() } returns IO.raiseError(exception)
  When("") {
    [...] Then [...]
  }
}
Given("foo2") {
  every { persistentSource.getAccessToken() } returns IO { smartphonePersistedAccessToken }
  When("") {
    [...]
    Then("") {
      verify(exactly = 1) { persistentSource.getAccessToken() }
    }
  }
}

class CouponListInteractor(
    private val isCouponSelectedUseCase: IsCouponSelectedUseCase
) {

    suspend fun isCouponSelected(uuid: String) = isCouponSelectedUseCase.execute(uuid)
}

object CouponListInteractorTest : Spek(
    {
        val isCouponSelectedUseCase by memoized {
            mockk<IsCouponSelectedUseCase> {
                coEvery { execute(any()) } returns false
                coEvery { execute("uuid") } returns true
            }
        }
        
        val interactor = CouponListInteractor(
            isCouponSelectedUseCase
        )

        describe("CouponListInteractor") {

        context("isCouponSelected") {

            it("should return coupon selected state") {
                runBlockingTest {
                    interactor.isCouponSelected("uuid") shouldEqual true
                }

                coVerify {
                    // ERROR: Bad recording sequence. State: AnsweringState 
                    isCouponSelectedUseCase.execute("uuid")
                }
            }
        }
    }
}

coVerify

Bad recording sequence. State: AnsweringState

interactor.isCouponSelected("uuid") shouldEqual true

isCouponSelectedUseCase.execute("uuid") shouldEqual true

isCouponSelected()

open

class MockkCaptorTest {

    @Test
    fun `verify mockk captor behavior`() {
        val simpleMockk = mockk<Simple> {
            every { hello(any(), any()) } answers { "Mocked response for ${arg<String>(0)}, age: ${arg<Int>(1)}" }
        }

        simpleMockk.hello("Bob", 2)
        simpleMockk.hello("Alice", 1)

        val bobsAge = slot<Int>()
        verify {
            simpleMockk.hello("Bob", capture(bobsAge))
        }
        assertEquals(2, bobsAge.captured)
    }
}

class Simple {
    fun hello(name: String, age: Int) = "Hello $name, age: $age"
}

Alice

verify(exactly = 1, verifyBlock = { mock.method{ lambdaArgument() } })

attachView

detachView

loadData

loadData

foo

bar

mockkConstructor()

ServiceLocator()

Foo()

Bar()

MyClass

val slot1 = slot<InvoiceLateFeeEntry>()
        verify {
            repo.save(capture(slot1))
        }
        val slot2 = slot<InvoiceLateFeeEntry>()
        verify {
            repo.save(capture(slot2))
        }

repo.save()

confirmVerified

private val dummyPacket = mockk<RtpPacket> {
        every { this@mockk getProperty "payloadType" } returns originalPayloadType
        every { this@mockk getProperty "ssrc" } returns originalSsrc
    }

val fn: () -> String? = mockk {
    // not working since "invoke()" clashes with invoke() function from MockK
    every { invoke() } returnsMany "hello", null
}

mockkObject

fun updateParticipant(participant: Participant, update: Participant.() -> Unit)

val participantOrchestrationService: ParticipantOrchestrationService = mockk(relaxed = true)
val dummy = Participant()
val update = slot<Participant.() -> Unit>()
every { participantOrchestrationService.updateParticipant(dummy) { capture(update) } } just Runs
update.captured(dummy)
dummy should {
	it.state == State.inactive
}

kotlin.UninitializedPropertyAccessException: lateinit property captured has not been initialized