Migrate all tests to mockk

CHANGELOG

  * Added TargetedEvent, a subclass of IrcEvent, for all events that are
    targeted to a user or channel
  * (Internal) Added annotation to track removal of deprecated methods
+ * (Internal) Migrate unit tests to use Mockk instead of Mockito
 
 v0.9.0
 

build.gradle.kts

     implementation("io.ktor:ktor-network:1.1.2")
     implementation("io.ktor:ktor-network-tls:1.1.2")
 
-    testImplementation("com.nhaarman.mockitokotlin2:mockito-kotlin:2.1.0")
     testImplementation("org.junit.jupiter:junit-jupiter-api:5.4.0")
     testImplementation("org.junit.jupiter:junit-jupiter-params:5.4.0")
-    testImplementation("io.mockk:mockk:1.9")
+    testImplementation("io.mockk:mockk:1.9.1")
     testRuntime("org.junit.jupiter:junit-jupiter-engine:5.4.0")
 }
 

src/test/kotlin/com/dmdirc/ktirc/IrcClientImplTest.kt

 import com.dmdirc.ktirc.model.*
 import com.dmdirc.ktirc.util.currentTimeProvider
 import com.dmdirc.ktirc.util.generateLabel
-import com.nhaarman.mockitokotlin2.*
 import io.ktor.util.KtorExperimentalAPI
 import io.mockk.*
 import kotlinx.coroutines.*
     private val readLineChannel = Channel<ByteArray>(Channel.UNLIMITED)
     private val sendLineChannel = Channel<ByteArray>(Channel.UNLIMITED)
 
-    private val mockSocket = mock<LineBufferedSocket> {
-        on { receiveChannel } doReturn readLineChannel
-        on { sendChannel } doReturn sendLineChannel
+    private val mockSocket = mockk<LineBufferedSocket> {
+        every { receiveChannel } returns readLineChannel
+        every { sendChannel } returns sendLineChannel
     }
 
-    private val mockSocketFactory = mock<(CoroutineScope, String, Int, Boolean) -> LineBufferedSocket> {
-        on { invoke(any(), eq(HOST), eq(PORT), any()) } doReturn mockSocket
+    private val mockSocketFactory = mockk<(CoroutineScope, String, Int, Boolean) -> LineBufferedSocket> {
+        every { this@mockk.invoke(any(), eq(HOST), eq(PORT), any()) } returns mockSocket
     }
 
-    private val mockEventHandler = mock<(IrcEvent) -> Unit>()
+    private val mockEventHandler = mockk<(IrcEvent) -> Unit> {
+        every { this@mockk.invoke(any()) } just Runs
+    }
 
     private val profileConfig = ProfileConfig().apply {
         nickname = NICK
         client.socketFactory = mockSocketFactory
         client.connect()
 
-        verify(mockSocketFactory, timeout(500)).invoke(client, HOST, PORT, false)
+        verify(timeout = 500) { mockSocketFactory(client, HOST, PORT, false) }
     }
 
     @Test
         client.socketFactory = mockSocketFactory
         client.connect()
 
-        verify(mockSocketFactory, timeout(500)).invoke(client, HOST, PORT, true)
+        verify(timeout = 500) { mockSocketFactory(client, HOST, PORT, true) }
     }
 
     @Test
     @Test
     fun `emits connection events with local time`() = runBlocking {
         currentTimeProvider = { TestConstants.time }
+
+        val connectingSlot = slot<ServerConnecting>()
+        val connectedSlot = slot<ServerConnected>()
+
+        every { mockEventHandler.invoke(capture(connectingSlot)) } just Runs
+        every { mockEventHandler.invoke(capture(connectedSlot)) } just Runs
+
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
         client.onEvent(mockEventHandler)
         client.connect()
 
-        val captor = argumentCaptor<IrcEvent>()
-        verify(mockEventHandler, timeout(500).atLeast(2)).invoke(captor.capture())
-
-        assertTrue(captor.firstValue is ServerConnecting)
-        assertEquals(TestConstants.time, captor.firstValue.metadata.time)
+        verify(timeout = 500) {
+            mockEventHandler(ofType<ServerConnecting>())
+            mockEventHandler(ofType<ServerConnected>())
+        }
 
-        assertTrue(captor.secondValue is ServerConnected)
-        assertEquals(TestConstants.time, captor.secondValue.metadata.time)
+        assertEquals(TestConstants.time, connectingSlot.captured.metadata.time)
+        assertEquals(TestConstants.time, connectedSlot.captured.metadata.time)
     }
 
     @Test
 
         client.connect()
 
-        verify(mockEventHandler, timeout(500)).invoke(isA<ServerWelcome>())
+        verify(timeout = 500) {
+            mockEventHandler(ofType<ServerWelcome>())
+        }
     }
 
     @Test
         client.onEvent(mockEventHandler)
         client.send("PRIVMSG", "#thegibson", "Mess with the best, die like the rest")
 
-        verify(mockEventHandler, never()).invoke(isA<MessageReceived>())
+        verify(inverse = true) {
+            mockEventHandler(ofType<MessageReceived>())
+        }
     }
 
     @Test
         client.onEvent(mockEventHandler)
         client.send("PRIVMSG", "#thegibson", "Mess with the best, die like the rest")
 
-        verify(mockEventHandler, never()).invoke(isA<MessageReceived>())
-    }
+        verify(inverse = true) {
+            mockEventHandler(ofType<MessageReceived>())
+        }    }
 
     @Test
     fun `sends structured text to socket with tags`() = runBlocking {
 
         client.disconnect()
 
-        verify(mockSocket, timeout(500)).disconnect()
+        verify(timeout = 500) {
+            mockSocket.disconnect()
+        }
     }
 
     @Test
 
     @Test
     fun `sends connect error when host is unresolvable`() = runBlocking {
-        whenever(mockSocket.connect()).doThrow(UnresolvedAddressException())
+        every { mockSocket.connect() } throws UnresolvedAddressException()
         with(IrcClientImpl(normalConfig)) {
             socketFactory = mockSocketFactory
             withTimeout(500) {
 
     @Test
     fun `sends connect error when tls certificate is bad`() = runBlocking {
-        whenever(mockSocket.connect()).doThrow(CertificateException("Boooo"))
+        every { mockSocket.connect() } throws CertificateException("Boooo")
         with(IrcClientImpl(normalConfig)) {
             socketFactory = mockSocketFactory
             withTimeout(500) {

src/test/kotlin/com/dmdirc/ktirc/io/MessageHandlerTest.kt

 import com.dmdirc.ktirc.events.mutators.EventMutator
 import com.dmdirc.ktirc.messages.MessageProcessor
 import com.dmdirc.ktirc.model.IrcMessage
-import com.nhaarman.mockitokotlin2.*
+import io.mockk.*
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.Test
 
 internal class MessageHandlerTest {
 
-    private val ircClient = mock<IrcClient>()
+    private val ircClient = mockk<IrcClient>()
 
-    private val nickProcessor = mock<MessageProcessor> {
-        on { commands } doReturn arrayOf("FOO", "NICK")
+    private val nickProcessor = mockk<MessageProcessor> {
+        every { commands } returns arrayOf("FOO", "NICK")
+        every { process(any()) } returns emptyList()
     }
 
-    private val joinProcessor = mock<MessageProcessor> {
-        on { commands } doReturn arrayOf("BAR", "JOIN")
+    private val joinProcessor = mockk<MessageProcessor> {
+        every { commands } returns arrayOf("BAR", "JOIN")
+        every { process(any()) } returns emptyList()
     }
 
+    private val eventHandler1 = mockk<EventHandler>()
+    private val eventHandler2 = mockk<EventHandler>()
+
     @Test
-    fun `passes message on to correct processor`() = runBlocking<Unit> {
+    fun `passes message on to correct processor`() = runBlocking {
         val handler = MessageHandler(listOf(joinProcessor, nickProcessor), emptyList(), mutableListOf())
         val message = IrcMessage(emptyMap(), null, "JOIN", emptyList())
 
             handler.processMessages(ircClient, this)
         }
 
-        verify(joinProcessor).process(message)
+        verify {
+            joinProcessor.process(message)
+        }
     }
 
     @Test
-    fun `reads multiple messages`() = runBlocking<Unit> {
+    fun `reads multiple messages`() = runBlocking {
         val handler = MessageHandler(listOf(joinProcessor, nickProcessor), emptyList(), mutableListOf())
         val joinMessage = IrcMessage(emptyMap(), null, "JOIN", emptyList())
         val nickMessage = IrcMessage(emptyMap(), null, "NICK", emptyList())
             handler.processMessages(ircClient, this)
         }
 
-        with(inOrder(joinProcessor, nickProcessor)) {
-            verify(joinProcessor).process(joinMessage)
-            verify(nickProcessor).process(nickMessage)
+        verifyOrder {
+            joinProcessor.process(joinMessage)
+            nickProcessor.process(nickMessage)
         }
     }
 
     @Test
     fun `invokes all event handler with all returned events`() = runBlocking {
-        val eventHandler1 = mock<EventHandler>()
-        val eventHandler2 = mock<EventHandler>()
         val handler = MessageHandler(listOf(joinProcessor, nickProcessor), emptyList(), mutableListOf(eventHandler1, eventHandler2))
         val joinMessage = IrcMessage(emptyMap(), null, "JOIN", emptyList())
-        whenever(joinProcessor.process(any())).thenReturn(listOf(ServerConnected(EventMetadata(TestConstants.time)), ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn")))
+
+        every { joinProcessor.process(any()) } returns listOf(ServerConnected(EventMetadata(TestConstants.time)), ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
 
         with(Channel<IrcMessage>(1)) {
             send(joinMessage)
             handler.processMessages(ircClient, this)
         }
 
-        verify(eventHandler1).processEvent(same(ircClient), isA<ServerConnected>())
-        verify(eventHandler1).processEvent(same(ircClient), isA<ServerWelcome>())
-        verify(eventHandler2).processEvent(same(ircClient), isA<ServerConnected>())
-        verify(eventHandler2).processEvent(same(ircClient), isA<ServerWelcome>())
+        verify {
+            eventHandler1.processEvent(refEq(ircClient), ofType<ServerConnected>())
+            eventHandler1.processEvent(refEq(ircClient), ofType<ServerWelcome>())
+            eventHandler2.processEvent(refEq(ircClient), ofType<ServerConnected>())
+            eventHandler2.processEvent(refEq(ircClient), ofType<ServerWelcome>())
+        }
     }
 
     @Test
     fun `sends custom events to all handlers`() {
-        val eventHandler1 = mock<EventHandler>()
-        val eventHandler2 = mock<EventHandler>()
         val handler = MessageHandler(emptyList(), emptyList(), mutableListOf(eventHandler1, eventHandler2))
         handler.handleEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
 
-        verify(eventHandler1).processEvent(same(ircClient), isA<ServerWelcome>())
-        verify(eventHandler2).processEvent(same(ircClient), isA<ServerWelcome>())
+        verify {
+            eventHandler1.processEvent(refEq(ircClient), ofType<ServerWelcome>())
+            eventHandler2.processEvent(refEq(ircClient), ofType<ServerWelcome>())
+        }
     }
 
     @Test
     fun `sends custom events to all emitters`() {
         val handler = MessageHandler(emptyList(), emptyList(), emptyList())
-        val emitter1 = mock<(IrcEvent) -> Unit>()
-        val emitter2 = mock<(IrcEvent) -> Unit>()
+        val emitter1 = mockk<(IrcEvent) -> Unit> {
+            every { this@mockk(any<IrcEvent>()) } just Runs
+        }
+        val emitter2 = mockk<(IrcEvent) -> Unit>  {
+            every { this@mockk(any<IrcEvent>()) } just Runs
+        }
         handler.addEmitter(emitter1)
         handler.addEmitter(emitter2)
         handler.handleEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
 
-        verify(emitter1).invoke(isA<ServerWelcome>())
-        verify(emitter2).invoke(isA<ServerWelcome>())
+        verify {
+            emitter1(ofType<ServerWelcome>())
+            emitter2(ofType<ServerWelcome>())
+        }
     }
 
     @Test
     fun `sends events to handlers but not mutators or emitters if process only is true`() {
-        val mutator = mock<EventMutator>()
-        val eventHandler1 = mock<EventHandler>()
-        val eventHandler2 = mock<EventHandler>()
+        val mutator = mockk<EventMutator>()
         val handler = MessageHandler(emptyList(), listOf(mutator), listOf(eventHandler1, eventHandler2))
-        val emitter = mock<(IrcEvent) -> Unit>()
+        val emitter = mockk<(IrcEvent) -> Unit>()
         handler.addEmitter(emitter)
 
         handler.handleEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"), true)
 
-        verify(eventHandler1).processEvent(same(ircClient), isA<ServerWelcome>())
-        verify(eventHandler2).processEvent(same(ircClient), isA<ServerWelcome>())
-        verify(emitter, never()).invoke(any())
-        verify(mutator, never()).mutateEvent(any(), any(), any())
+        verify {
+            eventHandler1.processEvent(refEq(ircClient), ofType<ServerWelcome>())
+            eventHandler2.processEvent(refEq(ircClient), ofType<ServerWelcome>())
+        }
+        verify(inverse = true) {
+            emitter.invoke(any())
+            mutator.mutateEvent(any(), any(), any())
+        }
     }
 
     @Test
     fun `mutates events in order`() {
-        val eventMutator1 = mock<EventMutator> {
-            on { mutateEvent(any(), any(), isA<ServerWelcome>()) } doReturn listOf(ServerReady(EventMetadata(TestConstants.time)))
+        val eventMutator1 = mockk<EventMutator> {
+            every { mutateEvent(any(), any(), ofType<ServerWelcome>()) } returns listOf(ServerReady(EventMetadata(TestConstants.time)))
         }
-        val eventMutator2 = mock<EventMutator> {
-            on { mutateEvent(any(), any(), isA<ServerReady>()) } doReturn listOf(ServerConnected(EventMetadata(TestConstants.time)))
+        val eventMutator2 = mockk<EventMutator> {
+            every { mutateEvent(any(), any(), ofType<ServerReady>()) } returns  listOf(ServerConnected(EventMetadata(TestConstants.time)))
         }
-        val eventHandler = mock<EventHandler>()
+        val eventHandler = mockk<EventHandler>()
 
         val handler = MessageHandler(emptyList(), listOf(eventMutator1, eventMutator2), mutableListOf(eventHandler))
         handler.handleEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
 
-        verify(eventMutator1).mutateEvent(same(ircClient), same(handler), isA<ServerWelcome>())
-        verify(eventMutator2).mutateEvent(same(ircClient), same(handler), isA<ServerReady>())
-        verify(eventHandler).processEvent(same(ircClient), isA<ServerConnected>())
-        verifyNoMoreInteractions(eventHandler)
+        verifyAll {
+            eventMutator1.mutateEvent(refEq(ircClient), refEq(handler), ofType<ServerWelcome>())
+            eventMutator2.mutateEvent(refEq(ircClient), refEq(handler), ofType<ServerReady>())
+            eventHandler.processEvent(refEq(ircClient), ofType<ServerConnected>())
+        }
     }
 
     @Test
     fun `allows mutators to fan out events`() {
-        val eventMutator1 = mock<EventMutator> {
-            on { mutateEvent(any(), any(), isA<ServerWelcome>()) } doReturn listOf(
+        val eventMutator1 = mockk<EventMutator> {
+            every { mutateEvent(any(), any(), ofType<ServerWelcome>()) } returns listOf(
                     ServerReady(EventMetadata(TestConstants.time)),
                     ServerConnected(EventMetadata(TestConstants.time))
             )
         }
-        val eventMutator2 = mock<EventMutator> {
-            on { mutateEvent(any(), any(), isA<ServerReady>()) } doReturn listOf(ServerReady(EventMetadata(TestConstants.time)))
-            on { mutateEvent(any(), any(), isA<ServerConnected>()) } doReturn listOf(ServerConnected(EventMetadata(TestConstants.time)))
+        val eventMutator2 = mockk<EventMutator> {
+            every { mutateEvent(any(), any(), ofType<ServerReady>()) } returns listOf(ServerReady(EventMetadata(TestConstants.time)))
+            every { mutateEvent(any(), any(), ofType<ServerConnected>()) } returns listOf(ServerConnected(EventMetadata(TestConstants.time)))
         }
-        val eventHandler = mock<EventHandler>()
+        val eventHandler = mockk<EventHandler>()
 
         val handler = MessageHandler(emptyList(), listOf(eventMutator1, eventMutator2), mutableListOf(eventHandler))
         handler.handleEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
 
-        with(inOrder(eventMutator2, eventHandler)) {
-            verify(eventMutator2).mutateEvent(same(ircClient), same(handler), isA<ServerReady>())
-            verify(eventMutator2).mutateEvent(same(ircClient), same(handler), isA<ServerConnected>())
-            verify(eventHandler).processEvent(same(ircClient), isA<ServerReady>())
-            verify(eventHandler).processEvent(same(ircClient), isA<ServerConnected>())
+        verifyOrder {
+            eventMutator2.mutateEvent(refEq(ircClient), refEq(handler), ofType<ServerReady>())
+            eventMutator2.mutateEvent(refEq(ircClient), refEq(handler), ofType<ServerConnected>())
+            eventHandler.processEvent(refEq(ircClient), ofType<ServerReady>())
+            eventHandler.processEvent(refEq(ircClient), ofType<ServerConnected>())
         }
     }
 
     @Test
     fun `allows mutators to suppress events`() {
-        val eventMutator1 = mock<EventMutator> {
-            on { mutateEvent(any(), any(), isA<ServerWelcome>()) } doReturn emptyList()
+        val eventMutator1 = mockk<EventMutator> {
+            every { mutateEvent(any(), any(), ofType<ServerWelcome>()) } returns emptyList()
         }
-        val eventMutator2 = mock<EventMutator>()
-        val eventHandler = mock<EventHandler>()
+        val eventMutator2 = mockk<EventMutator>()
+        val eventHandler = mockk<EventHandler>()
 
         val handler = MessageHandler(emptyList(), listOf(eventMutator1, eventMutator2), mutableListOf(eventHandler))
         handler.handleEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
 
-        verify(eventMutator2, never()).mutateEvent(any(), same(handler), any())
-        verify(eventHandler, never()).processEvent(any(), any())
+        verify(inverse = true) {
+            eventMutator2.mutateEvent(any(), refEq(handler), any())
+            eventHandler.processEvent(any(), any())
+        }
     }
 
 }

src/test/kotlin/com/dmdirc/ktirc/messages/MessageBuildersTest.kt

 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.model.MessageTag
-import com.nhaarman.mockitokotlin2.mock
-import com.nhaarman.mockitokotlin2.verify
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.jupiter.api.Test
 
 internal class MessageBuildersTest {
 
-    private val mockClient = mock<IrcClient>()
+    private val mockClient = mockk<IrcClient>()
 
     @Test
     fun `sendCapabilityRequest sends CAP REQ message with single argument`() {
         mockClient.sendCapabilityRequest(listOf("a"))
-        verify(mockClient).send("CAP", "REQ", "a")
+        verify { mockClient.send("CAP", "REQ", "a") }
     }
 
     @Test
     fun `sendCapabilityRequest sends CAP REQ message with multiple args`() {
         mockClient.sendCapabilityRequest(listOf("a b c"))
-        verify(mockClient).send("CAP", "REQ", "a b c")
+        verify { mockClient.send("CAP", "REQ", "a b c") }
     }
 
     @Test
     fun `sendJoin sends correct JOIN message`() {
         mockClient.sendJoin("#TheGibson")
-        verify(mockClient).send("JOIN", "#TheGibson")
+        verify { mockClient.send("JOIN", "#TheGibson") }
     }
 
     @Test
     fun `sendModeRequest sends correct MODE message`() {
         mockClient.sendModeRequest("#TheGibson")
-        verify(mockClient).send("MODE", "#TheGibson")
+        verify { mockClient.send("MODE", "#TheGibson") }
     }
 
     @Test
     fun `sendNickChange sends correct NICK message`() {
         mockClient.sendNickChange("AcidBurn")
-        verify(mockClient).send("NICK", "AcidBurn")
+        verify { mockClient.send("NICK", "AcidBurn") }
     }
 
     @Test
     fun `sendPassword sends correct PASS message`() {
         mockClient.sendPassword("hacktheplanet")
-        verify(mockClient).send("PASS", "hacktheplanet")
+        verify { mockClient.send("PASS", "hacktheplanet") }
     }
 
     @Test
     fun `sendPong sends correct PONG message`() {
         mockClient.sendPong("abcdef".toByteArray())
-        verify(mockClient).send("PONG", "abcdef")
+        verify { mockClient.send("PONG", "abcdef") }
     }
 
     @Test
     fun `sendMessage sends correct PRIVMSG message`() {
         mockClient.sendMessage("acidBurn", "Hack the planet!")
-        verify(mockClient).send(tagMap(), "PRIVMSG", "acidBurn", "Hack the planet!")
+        verify { mockClient.send(tagMap(), "PRIVMSG", "acidBurn", "Hack the planet!") }
     }
 
     @Test
     fun `sendMessage sends correct PRIVMSG message with reply to tag`() {
         mockClient.sendMessage("acidBurn", "Hack the planet!", "abc123")
-        verify(mockClient).send(tagMap(MessageTag.Reply to "abc123"), "PRIVMSG", "acidBurn", "Hack the planet!")
+        verify { mockClient.send(tagMap(MessageTag.Reply to "abc123"), "PRIVMSG", "acidBurn", "Hack the planet!") }
     }
 
     @Test
     fun `sendCtcp sends correct CTCP message with no arguments`() {
         mockClient.sendCtcp("acidBurn", "ping")
-        verify(mockClient).send(tagMap(), "PRIVMSG", "acidBurn", "\u0001PING\u0001")
+        verify { mockClient.send(tagMap(), "PRIVMSG", "acidBurn", "\u0001PING\u0001") }
     }
 
     @Test
     fun `sendCtcp sends correct CTCP message with arguments`() {
         mockClient.sendCtcp("acidBurn", "ping", "12345")
-        verify(mockClient).send(tagMap(), "PRIVMSG", "acidBurn", "\u0001PING 12345\u0001")
+        verify { mockClient.send(tagMap(), "PRIVMSG", "acidBurn", "\u0001PING 12345\u0001") }
     }
 
     @Test
     fun `sendAction sends correct action`() {
         mockClient.sendAction("acidBurn", "hacks the planet")
-        verify(mockClient).send(tagMap(), "PRIVMSG", "acidBurn", "\u0001ACTION hacks the planet\u0001")
+        verify { mockClient.send(tagMap(), "PRIVMSG", "acidBurn", "\u0001ACTION hacks the planet\u0001") }
     }
 
     @Test
     fun `sendUser sends correct USER message`() {
-        mockClient.sendUser("AcidBurn","Kate")
-        verify(mockClient).send("USER", "AcidBurn", "0", "*", "Kate")
+        mockClient.sendUser("AcidBurn", "Kate")
+        verify { mockClient.send("USER", "AcidBurn", "0", "*", "Kate") }
     }
 
     @Test
     fun `sendUser sends correct AUTHENTICATE message`() {
         mockClient.sendAuthenticationMessage("SCRAM-MD5")
-        verify(mockClient).send("AUTHENTICATE", "SCRAM-MD5")
+        verify { mockClient.send("AUTHENTICATE", "SCRAM-MD5") }
     }
 
     @Test
     fun `sendUser sends correct blank AUTHENTICATE message`() {
         mockClient.sendAuthenticationMessage()
-        verify(mockClient).send("AUTHENTICATE", "+")
+        verify { mockClient.send("AUTHENTICATE", "+") }
     }
 
     @Test
     fun `sendTagMessage sends tags`() {
         val tags = mapOf(MessageTag.MessageId to "id", MessageTag.AccountName to "foo")
         mockClient.sendTagMessage("#thegibson", tags)
-        verify(mockClient).send(tags, "TAGMSG", "#thegibson")
+        verify { mockClient.send(tags, "TAGMSG", "#thegibson") }
     }
 
     @Test
     fun `sendTagMessage sends tags with reply ID`() {
         val tags = mapOf(MessageTag.MessageId to "id", MessageTag.AccountName to "foo")
         mockClient.sendTagMessage("#thegibson", tags, "otherId")
-        verify(mockClient).send(tags + (MessageTag.Reply to "otherId"), "TAGMSG", "#thegibson")
+        verify { mockClient.send(tags + (MessageTag.Reply to "otherId"), "TAGMSG", "#thegibson") }
     }
 
 }

src/test/kotlin/com/dmdirc/ktirc/model/SaslStateTest.kt

 package com.dmdirc.ktirc.model
 
 import com.dmdirc.ktirc.sasl.SaslMechanism
-import com.nhaarman.mockitokotlin2.doReturn
-import com.nhaarman.mockitokotlin2.mock
+import io.mockk.every
+import io.mockk.mockk
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
 internal class SaslStateTest {
 
-    private val mech1 = mock<SaslMechanism> {
-        on { priority } doReturn 1
-        on { ircName } doReturn "mech1"
+    private val mech1 = mockk<SaslMechanism> {
+        every { priority } returns 1
+        every { ircName } returns "mech1"
     }
 
-    private val mech2 = mock<SaslMechanism> {
-        on { priority } doReturn 2
-        on { ircName } doReturn "mech2"
+    private val mech2 = mockk<SaslMechanism> {
+        every { priority } returns 2
+        every { ircName } returns "mech2"
     }
 
-    private val mech3 = mock<SaslMechanism> {
-        on { priority } doReturn 3
-        on { ircName } doReturn "mech3"
+    private val mech3 = mockk<SaslMechanism> {
+        every { priority } returns 3
+        every { ircName } returns "mech3"
     }
 
     private val mechanisms = listOf(mech1, mech2, mech3)

src/test/kotlin/com/dmdirc/ktirc/sasl/ExternalMechanismTest.kt

 package com.dmdirc.ktirc.sasl
 
 import com.dmdirc.ktirc.IrcClient
-import com.nhaarman.mockitokotlin2.mock
-import com.nhaarman.mockitokotlin2.verify
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.jupiter.api.Test
 
 internal class ExternalMechanismTest {
     @Test
     fun `sends + when receiving server message`() {
         val mechanism = ExternalMechanism()
-        val client = mock<IrcClient>()
+        val client = mockk<IrcClient>()
 
         mechanism.handleAuthenticationEvent(client, null)
 
-        verify(client).send("AUTHENTICATE", "+")
+        verify { client.send("AUTHENTICATE", "+") }
     }
 
 }

src/test/kotlin/com/dmdirc/ktirc/sasl/PlainMechanismTest.kt

 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.SaslConfig
 import com.dmdirc.ktirc.model.ServerState
-import com.nhaarman.mockitokotlin2.*
+import io.mockk.*
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 
 internal class PlainMechanismTest {
 
-    private val serverState = ServerState("", "")
-    private val ircClient = mock<IrcClient> {
-        on { serverState } doReturn serverState
+    private val fakeServerState = ServerState("", "")
+    private val ircClient = mockk<IrcClient> {
+        every { serverState } returns fakeServerState
     }
 
     private val mechanism = PlainMechanism(SaslConfig().apply {
 
     @Test
     fun `sends encoded username and password when first message received`() {
+        val slot = slot<String>()
+        every { ircClient.send(eq("AUTHENTICATE"), capture(slot)) } just Runs
         mechanism.handleAuthenticationEvent(ircClient, null)
 
-        val captor = argumentCaptor<String>()
-        verify(ircClient).send(eq("AUTHENTICATE"), captor.capture())
-        val data = String(captor.firstValue.fromBase64()).split('\u0000')
+        val data = String(slot.captured.fromBase64()).split('\u0000')
         assertEquals("acidB", data[0])
         assertEquals("acidB", data[1])
         assertEquals("HackThePlan3t!", data[2])

src/test/kotlin/com/dmdirc/ktirc/sasl/SaslMechanismTest.kt

 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.SaslConfig
-import com.nhaarman.mockitokotlin2.inOrder
-import com.nhaarman.mockitokotlin2.mock
-import com.nhaarman.mockitokotlin2.times
-import com.nhaarman.mockitokotlin2.verify
+import io.mockk.mockk
+import io.mockk.verify
+import io.mockk.verifyOrder
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 
 internal class SaslMechanismTest {
 
+    private val client = mockk<IrcClient>()
+
     @Test
     fun `creates sasl mechanisms by name`() {
         val mechanisms = SaslConfig().apply { mechanisms("PLAIN", "EXTERNAL") }.createSaslMechanism()
 
     @Test
     fun `base64 encodes authentication data`() {
-        val client = mock<IrcClient>()
         client.sendAuthenticationData("abcdef")
-        verify(client).send("AUTHENTICATE", "YWJjZGVm")
+        verify { client.send("AUTHENTICATE", "YWJjZGVm") }
     }
 
     @Test
     fun `chunks authentication data into 400 byte lines`() {
-        val client = mock<IrcClient>()
         client.sendAuthenticationData("abcdef".repeat(120))
-        with (inOrder(client)) {
-            verify(client, times(2)).send("AUTHENTICATE", "YWJjZGVm".repeat(50))
-            verify(client).send("AUTHENTICATE", "YWJjZGVm".repeat(20))
+        verifyOrder {
+            client.send("AUTHENTICATE", "YWJjZGVm".repeat(50))
+            client.send("AUTHENTICATE", "YWJjZGVm".repeat(50))
+            client.send("AUTHENTICATE", "YWJjZGVm".repeat(20))
         }
     }
 
     @Test
     fun `sends blank line if data is exactly 400 bytes`() {
-        val client = mock<IrcClient>()
         client.sendAuthenticationData("abcdef".repeat(50))
-        with (inOrder(client)) {
-            verify(client).send("AUTHENTICATE", "YWJjZGVm".repeat(50))
-            verify(client).send("AUTHENTICATE", "+")
+        verifyOrder {
+            client.send("AUTHENTICATE", "YWJjZGVm".repeat(50))
+            client.send("AUTHENTICATE", "+")
         }
     }
 

src/test/kotlin/com/dmdirc/ktirc/sasl/ScramMechanismTest.kt

 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.SaslConfig
 import com.dmdirc.ktirc.model.ServerState
-import com.nhaarman.mockitokotlin2.doReturn
-import com.nhaarman.mockitokotlin2.mock
-import com.nhaarman.mockitokotlin2.verify
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 
 internal class ScramMechanismTest {
 
-    private val serverState = ServerState("", "")
-    private val ircClient = mock<IrcClient> {
-        on { serverState } doReturn serverState
+    private val fakeServerState = ServerState("", "")
+    private val ircClient = mockk<IrcClient> {
+        every { serverState } returns fakeServerState
     }
 
     @Test
 
         mechanism.handleAuthenticationEvent(ircClient, "+".toByteArray())
 
-        val nonce = (serverState.sasl.mechanismState as ScramState).clientNonce
-        verify(ircClient).send("AUTHENTICATE", "n,,n=user,r=$nonce".toByteArray().toBase64())
+        val nonce = (fakeServerState.sasl.mechanismState as ScramState).clientNonce
+        verify { ircClient.send("AUTHENTICATE", "n,,n=user,r=$nonce".toByteArray().toBase64()) }
     }
 
     @Test
             password = "pencil"
         })
 
-        serverState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage)
+        fakeServerState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage)
 
         mechanism.handleAuthenticationEvent(ircClient, "m=future".toByteArray())
 
-        verify(ircClient).send("AUTHENTICATE", "*")
+        verify { ircClient.send("AUTHENTICATE", "*") }
     }
 
     @Test
             password = "pencil"
         })
 
-        serverState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage)
+        fakeServerState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage)
 
         mechanism.handleAuthenticationEvent(ircClient, "e=whoops".toByteArray())
 
-        verify(ircClient).send("AUTHENTICATE", "*")
+        verify { ircClient.send("AUTHENTICATE", "*") }
     }
 
     @Test
             password = "pencil"
         })
 
-        serverState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage)
+        fakeServerState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage)
 
         mechanism.handleAuthenticationEvent(ircClient, "r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,s=QSXCR+Q6sek8bf92".toByteArray())
 
-        verify(ircClient).send("AUTHENTICATE", "*")
+        verify { ircClient.send("AUTHENTICATE", "*") }
     }
 
     @Test
             password = "pencil"
         })
 
-        serverState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage)
+        fakeServerState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage)
 
         mechanism.handleAuthenticationEvent(ircClient, "r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,s=QSXCR+Q6sek8bf92,i=leet".toByteArray())
 
-        verify(ircClient).send("AUTHENTICATE", "*")
+        verify { ircClient.send("AUTHENTICATE", "*") }
     }
 
     @Test
             password = "pencil"
         })
 
-        serverState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage)
+        fakeServerState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage)
 
         mechanism.handleAuthenticationEvent(ircClient, "rs=QSXCR+Q6sek8bf92,i=4096".toByteArray())
 
-        verify(ircClient).send("AUTHENTICATE", "*")
+        verify { ircClient.send("AUTHENTICATE", "*") }
     }
 
     @Test
             password = "pencil"
         })
 
-        serverState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage)
+        fakeServerState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage)
 
         mechanism.handleAuthenticationEvent(ircClient, "r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,i=4096".toByteArray())
 
-        verify(ircClient).send("AUTHENTICATE", "*")
+        verify { ircClient.send("AUTHENTICATE", "*") }
     }
 
     @Test
             password = "pencil"
         })
 
-        serverState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage, clientNonce = "fyko+d2lbbFgONRv9qkxdawL")
+        fakeServerState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage, clientNonce = "fyko+d2lbbFgONRv9qkxdawL")
 
         mechanism.handleAuthenticationEvent(ircClient, "r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,s=QSXCR+Q6sek8bf92,i=4096".toByteArray())
 
-        (serverState.sasl.mechanismState as ScramState).let {
+        (fakeServerState.sasl.mechanismState as ScramState).let {
             assertEquals(ScramStage.Finishing, it.scramStage)
             assertEquals("fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j", it.serverNonce)
             assertEquals(4096, it.iterCount)
             password = "pencil"
         })
 
-        serverState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage, clientNonce = "fyko+d2lbbFgONRv9qkxdawL")
+        fakeServerState.sasl.mechanismState = ScramState(scramStage = ScramStage.SendingSecondMessage, clientNonce = "fyko+d2lbbFgONRv9qkxdawL")
 
         mechanism.handleAuthenticationEvent(ircClient, "r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,s=QSXCR+Q6sek8bf92,i=4096".toByteArray())
 
-        verify(ircClient).send("AUTHENTICATE", "c=biws,r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,p=v0X8v3Bz2T0CJGbJQyF0X+HI4Ts=".toByteArray().toBase64())
+        verify { ircClient.send("AUTHENTICATE", "c=biws,r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,p=v0X8v3Bz2T0CJGbJQyF0X+HI4Ts=".toByteArray().toBase64()) }
     }
 
     @Test
             password = "pencil"
         })
 
-        serverState.sasl.mechanismState = ScramState(scramStage = ScramStage.Finishing)
+        fakeServerState.sasl.mechanismState = ScramState(scramStage = ScramStage.Finishing)
 
         mechanism.handleAuthenticationEvent(ircClient, "m=future".toByteArray())
 
-        verify(ircClient).send("AUTHENTICATE", "*")
+        verify { ircClient.send("AUTHENTICATE", "*") }
     }
 
     @Test
             password = "pencil"
         })
 
-        serverState.sasl.mechanismState = ScramState(scramStage = ScramStage.Finishing)
+        fakeServerState.sasl.mechanismState = ScramState(scramStage = ScramStage.Finishing)
 
         mechanism.handleAuthenticationEvent(ircClient, "e=whoops".toByteArray())
 
-        verify(ircClient).send("AUTHENTICATE", "*")
+        verify { ircClient.send("AUTHENTICATE", "*") }
     }
 
     @Test
             password = "pencil"
         })
 
-        serverState.sasl.mechanismState = ScramState(
+        fakeServerState.sasl.mechanismState = ScramState(
                 scramStage = ScramStage.Finishing,
                 saltedPassword = "HZbuOlKbWl+eR8AfIposuKbhX30=".fromBase64(),
                 authMessage = "n=user,r=fyko+d2lbbFgONRv9qkxdawL,r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,s=QSXCR+Q6sek8bf92,i=4096,c=biws,r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j".toByteArray())
 
         mechanism.handleAuthenticationEvent(ircClient, "".toByteArray())
 
-        verify(ircClient).send("AUTHENTICATE", "*")
+        verify { ircClient.send("AUTHENTICATE", "*") }
     }
 
     @Test
             password = "pencil"
         })
 
-        serverState.sasl.mechanismState = ScramState(
+        fakeServerState.sasl.mechanismState = ScramState(
                 scramStage = ScramStage.Finishing,
                 saltedPassword = "HZbuOlKbWl+eR8AfIposuKbhX30=".fromBase64(),
                 authMessage = "n=user,r=fyko+d2lbbFgONRv9qkxdawL,r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,s=QSXCR+Q6sek8bf92,i=4096,c=biws,r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j".toByteArray())
 
         mechanism.handleAuthenticationEvent(ircClient, "v=rmF9pqV8S7suAoZWja4dJRkF=".toByteArray())
 
-        verify(ircClient).send("AUTHENTICATE", "*")
+        verify { ircClient.send("AUTHENTICATE", "*") }
     }
 
     @Test
             password = "pencil"
         })
 
-        serverState.sasl.mechanismState = ScramState(
+        fakeServerState.sasl.mechanismState = ScramState(
                 scramStage = ScramStage.Finishing,
                 saltedPassword = "HZbuOlKbWl+eR8AfIposuKbhX30=".fromBase64(),
                 authMessage = "n=user,r=fyko+d2lbbFgONRv9qkxdawL,r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,s=QSXCR+Q6sek8bf92,i=4096,c=biws,r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j".toByteArray())
 
         mechanism.handleAuthenticationEvent(ircClient, "v=rmF9pqV8S7suAoZWja4dJRkFsKQ=".toByteArray())
 
-        verify(ircClient).send("AUTHENTICATE", "+")
+        verify { ircClient.send("AUTHENTICATE", "+") }
     }
 
 }