Suggestion about verifyXxx extensions

[alexxRizz]

Hi! How about adding such extensions? I think code would be cleaner with such extensions. I'm already using them in my own projects.

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

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

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

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

Maybe i could make a pull request with such extensions if needed.

[Raibaz]

I like them, thanks for the idea!

I just have a change I'd make: I don't think they would need parameters for atLeast and atMost if these are meant to verify that the inner block is being executed exactly once or exactly zero times.

The API I would implement, then, is like this:

fun verifyOnce(
	ordering: Ordering = Ordering.UNORDERED,
	inverse: Boolean = false,
	timeout: Long = 0,
	verifyBlock: MockKVerificationScope.() -> Unit
) {
	verify(ordering, inverse, 1, 1, 1, timeout, verifyBlock)
}

fun verifyNever(
	ordering: Ordering = Ordering.UNORDERED,
	inverse: Boolean = false,
	timeout: Long = 0,
	verifyBlock: MockKVerificationScope.() -> Unit
) {
	verify(ordering, inverse, 0, 0, 0, timeout, verifyBlock)
}

fun coVerifyOnce(
	ordering: Ordering = Ordering.UNORDERED,
	inverse: Boolean = false,
	timeout: Long = 0,
	verifyBlock: suspend MockKVerificationScope.() -> Unit
) {
	coVerify(ordering, inverse, 1, 1, 1, timeout, verifyBlock)
}

fun coVerifyNever(
	ordering: Ordering = Ordering.UNORDERED,
	inverse: Boolean = false,
	timeout: Long = 0,
	verifyBlock: suspend MockKVerificationScope.() -> Unit
) {
	coVerify(ordering, inverse, 0, 0, 0, timeout, verifyBlock)
}

In fact, MockK already ignores atLeast and atMost if exactly is being passed, so there's no need to expose them here.

What do you think?

[alexxRizz]

Of course, you are right. I've missed atLeast and atMost are redundant in these cases (copy pasted from original signatures).

[alexxRizz]

I think it is better like this:

fun verifyOnce(
  ordering: Ordering = Ordering.UNORDERED,
  inverse: Boolean = false,
  timeout: Long = 0,
  verifyBlock: MockKVerificationScope.() -> Unit
) =
  verify(ordering, inverse, exactly = 1, timeout = timeout, verifyBlock = verifyBlock)

fun verifyNever(
  ordering: Ordering = Ordering.UNORDERED,
  inverse: Boolean = false,
  timeout: Long = 0,
  verifyBlock: MockKVerificationScope.() -> Unit
) =
  verify(ordering, inverse, exactly = 0, timeout = timeout, verifyBlock = verifyBlock)

fun coVerifyOnce(
  ordering: Ordering = Ordering.UNORDERED,
  inverse: Boolean = false,
  timeout: Long = 0,
  verifyBlock: suspend MockKVerificationScope.() -> Unit
) =
  coVerify(ordering, inverse, exactly = 1, timeout = timeout, verifyBlock = verifyBlock)

fun coVerifyNever(
  ordering: Ordering = Ordering.UNORDERED,
  inverse: Boolean = false,
  timeout: Long = 0,
  verifyBlock: suspend MockKVerificationScope.() -> Unit
) =
  coVerify(ordering, inverse, exactly = 0, timeout = timeout, verifyBlock = verifyBlock)

And maybe useful another little verify helpers:

fun verifyWasNotCalled(mock: Any) =
  verify { mock wasNot called }

fun verifyWasNotCalled(vararg mocks: Any) =
  mocks.forEach {
    verify { it wasNot called }
  }

[Raibaz]

Yep your suggestion about the *Once and *Never functions definitely makes sense, thanks.

Not entirely sure about the wasNotCalled functions though: the first one does not seem much more concise than verify { mock wasNot called } and has the downside of not being usable in other verify blocks.

Plus, I'm a bit worried about the idea of providing two different but still pretty similar ways to do the same thing, I'm wondering if it could be confusing for users.

The second one makes more sense to me :)

[Raibaz]

(Also, thanks a lot for taking the time to think about this!)

[tomaszrykala]

I came here to suggest verifyNever and coVerifyNever looking exactly like that myself so a 👍🏻 from me.

Also, although beyond the scope of verify:

/**
 * relaxUnitFun = true
 */
inline fun <reified T : Any> mockkR(
    name: String? = null,
    vararg moreInterfaces: KClass<*>,
    block: T.() -> Unit = {}
) = mockk(
    name = name,
    relaxed = false,
    moreInterfaces = moreInterfaces,
    relaxUnitFun = true,
    block = block
)

[tomaszrykala]

Is there a PR for verifyXxx already?