Convert event tests to use mockk

src/test/kotlin/com/dmdirc/ktirc/events/EventUtilsTest.kt

 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.messages.tagMap
 import com.dmdirc.ktirc.model.*
-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.BeforeEach
 import org.junit.jupiter.api.Test
 
 internal class EventUtilsTest {
 
-    private val serverState = ServerState("", "")
-    private val ircClient = mock<IrcClient> {
-        on { serverState } doReturn serverState
-        on { caseMapping } doReturn CaseMapping.Ascii
+    private val fakeServerState = ServerState("", "")
+    private val ircClient = mockk<IrcClient> {
+        every { serverState } returns fakeServerState
+        every { caseMapping } returns CaseMapping.Ascii
     }
 
     @BeforeEach
     fun setUp() {
-        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
+        fakeServerState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
     }
 
     @Test
 
     @Test
     fun `reply sends response to user when message is private`() {
-        serverState.localNickname = "zeroCool"
+        fakeServerState.localNickname = "zeroCool"
         val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "Zerocool", "Hack the planet!")
 
         ircClient.reply(message, "OK")
-        verify(ircClient).send(tagMap(), "PRIVMSG", "acidBurn", "OK")
+        verify {
+            ircClient.send(tagMap(), "PRIVMSG", "acidBurn", "OK")
+        }
     }
 
     @Test
         val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "#TheGibson", "Hack the planet!")
 
         ircClient.reply(message, "OK")
-        verify(ircClient).send(tagMap(), "PRIVMSG", "#TheGibson", "OK")
+        verify {
+            ircClient.send(tagMap(), "PRIVMSG", "#TheGibson", "OK")
+        }
     }
 
     @Test
         val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "#TheGibson", "Hack the planet!")
 
         ircClient.reply(message, "OK", prefixWithNickname = true)
-        verify(ircClient).send(tagMap(), "PRIVMSG", "#TheGibson", "acidBurn: OK")
+        verify {
+            ircClient.send(tagMap(), "PRIVMSG", "#TheGibson", "acidBurn: OK")
+        }
     }
 
     @Test
     fun `reply sends response with message ID to user when message is private`() {
-        serverState.localNickname = "zeroCool"
+        fakeServerState.localNickname = "zeroCool"
         val message = MessageReceived(EventMetadata(TestConstants.time, messageId = "abc123"), User("acidBurn"), "Zerocool", "Hack the planet!")
 
         ircClient.reply(message, "OK")
-        verify(ircClient).send(tagMap(MessageTag.Reply to "abc123"), "PRIVMSG", "acidBurn", "OK")
+        verify {
+            ircClient.send(tagMap(MessageTag.Reply to "abc123"), "PRIVMSG", "acidBurn", "OK")
+        }
     }
 
     @Test
         val message = MessageReceived(EventMetadata(TestConstants.time, messageId = "abc123"), User("acidBurn"), "#TheGibson", "Hack the planet!")
 
         ircClient.reply(message, "OK")
-        verify(ircClient).send(tagMap(MessageTag.Reply to "abc123"), "PRIVMSG", "#TheGibson", "OK")
+        verify {
+            ircClient.send(tagMap(MessageTag.Reply to "abc123"), "PRIVMSG", "#TheGibson", "OK")
+        }
     }
 
     @Test
         val message = MessageReceived(EventMetadata(TestConstants.time, messageId = "abc123"), User("acidBurn"), "#TheGibson", "Hack the planet!")
 
         ircClient.reply(message, "OK", prefixWithNickname = true)
-        verify(ircClient).send(tagMap(MessageTag.Reply to "abc123"), "PRIVMSG", "#TheGibson", "acidBurn: OK")
+        verify {
+            ircClient.send(tagMap(MessageTag.Reply to "abc123"), "PRIVMSG", "#TheGibson", "acidBurn: OK")
+        }
     }
 
 
     @Test
     fun `react sends response to user when message is private`() {
-        serverState.localNickname = "zeroCool"
+        fakeServerState.localNickname = "zeroCool"
         val message = MessageReceived(EventMetadata(TestConstants.time, messageId = "msgId"), User("acidBurn"), "Zerocool", "Hack the planet!")
 
         ircClient.react(message, ":P")
-        verify(ircClient).send(tagMap(MessageTag.React to ":P", MessageTag.Reply to "msgId"), "TAGMSG", "acidBurn")
+        verify {
+            ircClient.send(tagMap(MessageTag.React to ":P", MessageTag.Reply to "msgId"), "TAGMSG", "acidBurn")
+        }
     }
 
     @Test
         val message = MessageReceived(EventMetadata(TestConstants.time, messageId = "msgId"), User("acidBurn"), "#TheGibson", "Hack the planet!")
 
         ircClient.react(message, ":P")
-        verify(ircClient).send(tagMap(MessageTag.React to ":P", MessageTag.Reply to "msgId"), "TAGMSG", "#TheGibson")
+        verify {
+            ircClient.send(tagMap(MessageTag.React to ":P", MessageTag.Reply to "msgId"), "TAGMSG", "#TheGibson")
+        }
     }
 
 }

src/test/kotlin/com/dmdirc/ktirc/events/handlers/CapabilitiesHandlerTest.kt

 import com.dmdirc.ktirc.sasl.SaslMechanism
 import com.dmdirc.ktirc.sasl.fromBase64
 import com.dmdirc.ktirc.sasl.toBase64
-import com.nhaarman.mockitokotlin2.*
+import io.mockk.*
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
 internal class CapabilitiesHandlerTest {
 
-    private val saslMech1 = mock<SaslMechanism> {
-        on { priority } doReturn 1
-        on { ircName } doReturn "mech1"
+    private val saslMech1 = mockk<SaslMechanism> {
+        every { priority } returns 1
+        every { ircName } returns "mech1"
     }
 
-    private val saslMech2 = mock<SaslMechanism> {
-        on { priority } doReturn 2
-        on { ircName } doReturn "mech2"
+    private val saslMech2 = mockk<SaslMechanism> {
+        every { priority } returns 2
+        every { ircName } returns "mech2"
     }
 
-    private val saslMech3 = mock<SaslMechanism> {
-        on { priority } doReturn 3
-        on { ircName } doReturn "mech3"
+    private val saslMech3 = mockk<SaslMechanism> {
+        every { priority } returns 3
+        every { ircName } returns "mech3"
     }
 
     private val handler = CapabilitiesHandler()
-    private val serverState = ServerState("", "", null)
-    private val ircClient = mock<IrcClient> {
-        on { serverState } doReturn serverState
+    private val fakeServerState = ServerState("", "", null)
+    private val ircClient = mockk<IrcClient> {
+        every { serverState } returns fakeServerState
     }
 
     @Test
                 Capability.HostsInNamesReply.names[0] to "123"
         )))
 
-        assertEquals(2, serverState.capabilities.advertisedCapabilities.size)
-        assertEquals("", serverState.capabilities.advertisedCapabilities[Capability.EchoMessages.names[0]])
-        assertEquals("123", serverState.capabilities.advertisedCapabilities[Capability.HostsInNamesReply.names[0]])
+        assertEquals(2, fakeServerState.capabilities.advertisedCapabilities.size)
+        assertEquals("", fakeServerState.capabilities.advertisedCapabilities[Capability.EchoMessages.names[0]])
+        assertEquals("123", fakeServerState.capabilities.advertisedCapabilities[Capability.HostsInNamesReply.names[0]])
     }
 
     @Test
     fun `updates negotiation state when capabilities finished`() {
-        serverState.capabilities.advertisedCapabilities[Capability.EchoMessages.names[0]] = ""
+        fakeServerState.capabilities.advertisedCapabilities[Capability.EchoMessages.names[0]] = ""
 
         handler.processEvent(ircClient, ServerCapabilitiesFinished(EventMetadata(TestConstants.time)))
 
-        assertEquals(CapabilitiesNegotiationState.AWAITING_ACK, serverState.capabilities.negotiationState)
+        assertEquals(CapabilitiesNegotiationState.AWAITING_ACK, fakeServerState.capabilities.negotiationState)
     }
 
     @Test
     fun `sends REQ when capabilities received`() {
-        serverState.capabilities.advertisedCapabilities[Capability.EchoMessages.names[0]] = ""
-        serverState.capabilities.advertisedCapabilities[Capability.AccountChangeMessages.names[0]] = ""
+        fakeServerState.capabilities.advertisedCapabilities[Capability.EchoMessages.names[0]] = ""
+        fakeServerState.capabilities.advertisedCapabilities[Capability.AccountChangeMessages.names[0]] = ""
 
         handler.processEvent(ircClient, ServerCapabilitiesFinished(EventMetadata(TestConstants.time)))
 
-        verify(ircClient).send(eq("CAP"), eq("REQ"), argThat { equals("echo-message account-notify") || equals("account-notify echo-message") })
+        verify {
+            ircClient.send(eq("CAP"), eq("REQ"), or(eq("echo-message account-notify"), eq("account-notify echo-message")))
+        }
     }
 
     @Test
     fun `sends END when blank capabilities received`() {
         handler.processEvent(ircClient, ServerCapabilitiesFinished(EventMetadata(TestConstants.time)))
 
-        verify(ircClient).send("CAP", "END")
+        verify {
+            ircClient.send("CAP", "END")
+        }
     }
 
     @Test
     fun `updates negotiation when blank capabilities received`() {
         handler.processEvent(ircClient, ServerCapabilitiesFinished(EventMetadata(TestConstants.time)))
 
-        assertEquals(CapabilitiesNegotiationState.FINISHED, serverState.capabilities.negotiationState)
+        assertEquals(CapabilitiesNegotiationState.FINISHED, fakeServerState.capabilities.negotiationState)
     }
 
     @Test
                 Capability.HostsInNamesReply.names[0] to ""
         )))
 
-        verify(ircClient).send("CAP", "END")
+        verify {
+            ircClient.send("CAP", "END")
+        }
     }
 
     @Test
     fun `sends END when capabilities acknowledged and no sasl state`() {
-        serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
+        fakeServerState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.EchoMessages.names[0] to "",
                 Capability.HostsInNamesReply.names[0] to ""
         )))
 
-        verify(ircClient).send("CAP", "END")
+        verify {
+            ircClient.send("CAP", "END")
+        }
     }
 
     @Test
     fun `sends END when capabilities acknowledged and no shared mechanism`() {
-        serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = "fake1,fake2"
+        fakeServerState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
+        fakeServerState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = "fake1,fake2"
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.SaslAuthentication.names[0] to "",
                 Capability.HostsInNamesReply.names[0] to ""
         )))
 
-        verify(ircClient).send("CAP", "END")
+        verify {
+            ircClient.send("CAP", "END")
+        }
     }
 
     @Test
     fun `sets current SASL mechanism when capabilities acknowledged with shared mechanism`() {
-        serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = "mech1,fake2"
+        fakeServerState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
+        fakeServerState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = "mech1,fake2"
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.SaslAuthentication.names[0] to "",
                 Capability.HostsInNamesReply.names[0] to ""
         )))
 
-        assertSame(saslMech1, serverState.sasl.currentMechanism)
+        assertSame(saslMech1, fakeServerState.sasl.currentMechanism)
     }
 
     @Test
     fun `sets current SASL mechanism when capabilities acknowledged with no declared mechanisms`() {
-        serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = ""
+        fakeServerState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
+        fakeServerState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = ""
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.SaslAuthentication.names[0] to "",
                 Capability.HostsInNamesReply.names[0] to ""
         )))
 
-        assertSame(saslMech3, serverState.sasl.currentMechanism)
+        assertSame(saslMech3, fakeServerState.sasl.currentMechanism)
     }
 
     @Test
     fun `sends authenticate when capabilities acknowledged with shared mechanism`() {
-        serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = "mech1,fake2"
+        fakeServerState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
+        fakeServerState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = "mech1,fake2"
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.SaslAuthentication.names[0] to "",
                 Capability.HostsInNamesReply.names[0] to ""
         )))
 
-        verify(ircClient).send("AUTHENTICATE", "mech1")
+        verify {
+            ircClient.send("AUTHENTICATE", "mech1")
+        }
     }
 
     @Test
     fun `sends authenticate when capabilities acknowledged with no declared mechanisms`() {
-        serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = ""
+        fakeServerState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
+        fakeServerState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = ""
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.SaslAuthentication.names[0] to "",
                 Capability.HostsInNamesReply.names[0] to ""
         )))
 
-        verify(ircClient).send("AUTHENTICATE", "mech3")
+        verify {
+            ircClient.send("AUTHENTICATE", "mech3")
+        }
     }
 
     @Test
     fun `updates negotiation state when capabilities acknowledged with shared mechanism`() {
-        serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = "mech1,fake2"
+        fakeServerState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
+        fakeServerState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = "mech1,fake2"
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.SaslAuthentication.names[0] to "",
                 Capability.HostsInNamesReply.names[0] to ""
         )))
 
-        assertEquals(CapabilitiesNegotiationState.AUTHENTICATING, serverState.capabilities.negotiationState)
+        assertEquals(CapabilitiesNegotiationState.AUTHENTICATING, fakeServerState.capabilities.negotiationState)
     }
 
     @Test
                 Capability.HostsInNamesReply.names[0] to "123"
         )))
 
-        assertEquals(CapabilitiesNegotiationState.FINISHED, serverState.capabilities.negotiationState)
+        assertEquals(CapabilitiesNegotiationState.FINISHED, fakeServerState.capabilities.negotiationState)
     }
 
     @Test
                 Capability.HostsInNamesReply.names[0] to "123"
         )))
 
-        assertEquals(2, serverState.capabilities.enabledCapabilities.size)
-        assertEquals("", serverState.capabilities.enabledCapabilities[Capability.EchoMessages])
-        assertEquals("123", serverState.capabilities.enabledCapabilities[Capability.HostsInNamesReply])
+        assertEquals(2, fakeServerState.capabilities.enabledCapabilities.size)
+        assertEquals("", fakeServerState.capabilities.enabledCapabilities[Capability.EchoMessages])
+        assertEquals("123", fakeServerState.capabilities.enabledCapabilities[Capability.HostsInNamesReply])
     }
 
     @Test
     fun `aborts authentication attempt if not expecting one`() {
-        serverState.sasl.currentMechanism = null
+        fakeServerState.sasl.currentMechanism = null
         handler.processEvent(ircClient, AuthenticationMessage(EventMetadata(TestConstants.time), "+"))
 
-        verify(ircClient).send("AUTHENTICATE", "*")
+        verify {
+            ircClient.send("AUTHENTICATE", "*")
+        }
     }
 
     @Test
     fun `passes authentication message to mechanism if in auth process`() {
-        serverState.sasl.currentMechanism = saslMech1
+        fakeServerState.sasl.currentMechanism = saslMech1
 
         val argument = "ABC"
         handler.processEvent(ircClient, AuthenticationMessage(EventMetadata(TestConstants.time), argument))
 
-        verify(saslMech1).handleAuthenticationEvent(ircClient, argument.fromBase64())
+        verify {
+            saslMech1.handleAuthenticationEvent(ircClient, argument.fromBase64())
+        }
     }
 
     @Test
     fun `stores partial authentication message if it's 400 bytes long`() {
-        serverState.sasl.currentMechanism = saslMech1
+        fakeServerState.sasl.currentMechanism = saslMech1
 
         val argument = "A".repeat(400)
         handler.processEvent(ircClient, AuthenticationMessage(EventMetadata(TestConstants.time), argument))
 
-        assertEquals(argument, serverState.sasl.saslBuffer)
-        verify(saslMech1, never()).handleAuthenticationEvent(any(), any())
+        assertEquals(argument, fakeServerState.sasl.saslBuffer)
+        verify(inverse = true) {
+            saslMech1.handleAuthenticationEvent(any(), any())
+        }
     }
 
     @Test
     fun `appends authentication messages if it's 400 bytes long and data already exists`() {
-        serverState.sasl.currentMechanism = saslMech1
+        fakeServerState.sasl.currentMechanism = saslMech1
 
-        serverState.sasl.saslBuffer = "A".repeat(400)
+        fakeServerState.sasl.saslBuffer = "A".repeat(400)
         handler.processEvent(ircClient, AuthenticationMessage(EventMetadata(TestConstants.time), "B".repeat(400)))
 
-        assertEquals("A".repeat(400) + "B".repeat(400), serverState.sasl.saslBuffer)
-        verify(saslMech1, never()).handleAuthenticationEvent(any(), any())
+        assertEquals("A".repeat(400) + "B".repeat(400), fakeServerState.sasl.saslBuffer)
+        verify(inverse = true) {
+            saslMech1.handleAuthenticationEvent(any(), any())
+        }
     }
 
     @Test
     fun `reconstructs partial authentication message to mechanism if data stored and partial received`() {
-        serverState.sasl.currentMechanism = saslMech1
+        fakeServerState.sasl.currentMechanism = saslMech1
+        fakeServerState.sasl.saslBuffer = "A".repeat(400)
 
-        serverState.sasl.saslBuffer = "A".repeat(400)
+        val slot = slot<ByteArray>()
+        every { saslMech1.handleAuthenticationEvent(eq(ircClient), capture(slot)) } just Runs
 
         val argument = "ABCD"
         handler.processEvent(ircClient, AuthenticationMessage(EventMetadata(TestConstants.time), argument))
 
-        val captor = argumentCaptor<ByteArray>()
-        verify(saslMech1).handleAuthenticationEvent(same(ircClient), captor.capture())
-        assertEquals("A".repeat(400) + "ABCD", captor.firstValue.toBase64())
+        assertEquals("A".repeat(400) + "ABCD", slot.captured.toBase64())
     }
 
     @Test
     fun `reconstructs partial authentication message to mechanism if data stored and null received`() {
-        serverState.sasl.currentMechanism = saslMech1
+        fakeServerState.sasl.currentMechanism = saslMech1
+        fakeServerState.sasl.saslBuffer = "A".repeat(400)
 
-        serverState.sasl.saslBuffer = "A".repeat(400)
+        val slot = slot<ByteArray>()
+        every { saslMech1.handleAuthenticationEvent(eq(ircClient), capture(slot)) } just Runs
 
         handler.processEvent(ircClient, AuthenticationMessage(EventMetadata(TestConstants.time), null))
 
-        val captor = argumentCaptor<ByteArray>()
-        verify(saslMech1).handleAuthenticationEvent(same(ircClient), captor.capture())
-        assertEquals("A".repeat(400), captor.firstValue.toBase64())
+        assertEquals("A".repeat(400), slot.captured.toBase64())
     }
 
     @Test
     fun `sends END when SASL auth finished`() {
         handler.processEvent(ircClient, SaslFinished(EventMetadata(TestConstants.time), true))
 
-        verify(ircClient).send("CAP", "END")
+        verify {
+            ircClient.send("CAP", "END")
+        }
     }
 
     @Test
     fun `sets negotiation state when SASL auth finished`() {
         handler.processEvent(ircClient, SaslFinished(EventMetadata(TestConstants.time), true))
 
-        assertEquals(CapabilitiesNegotiationState.FINISHED, serverState.capabilities.negotiationState)
+        assertEquals(CapabilitiesNegotiationState.FINISHED, fakeServerState.capabilities.negotiationState)
     }
 
     @Test
     fun `resets SASL state when SASL auth finished`() {
-        with (serverState.sasl) {
+        with (fakeServerState.sasl) {
             currentMechanism = saslMech1
             saslBuffer = "HackThePlanet"
             mechanismState = "root@thegibson"
 
         handler.processEvent(ircClient, SaslFinished(EventMetadata(TestConstants.time), true))
 
-        with (serverState.sasl) {
+        with (fakeServerState.sasl) {
             assertNull(currentMechanism)
             assertEquals("", saslBuffer)
             assertNull(mechanismState)
 
     @Test
     fun `sends a new authenticate request when sasl mechanism rejected and new one is acceptable`() {
-        serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
+        fakeServerState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
         handler.processEvent(ircClient, SaslMechanismNotAvailableError(EventMetadata(TestConstants.time), listOf("mech1", "fake2")))
 
-        verify(ircClient).send("AUTHENTICATE", "mech1")
+        verify {
+            ircClient.send("AUTHENTICATE", "mech1")
+        }
     }
 
     @Test
     fun `sends cap end when sasl mechanism rejected and no new one is acceptable`() {
-        serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
+        fakeServerState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
         handler.processEvent(ircClient, SaslMechanismNotAvailableError(EventMetadata(TestConstants.time), listOf("fake1", "fake2")))
 
-        verify(ircClient).send("CAP", "END")
+        verify {
+            ircClient.send("CAP", "END")
+        }
     }
 
     @Test
     fun `sets negotiation state when sasl mechanism rejected and no new one is acceptable`() {
-        serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
+        fakeServerState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
         handler.processEvent(ircClient, SaslMechanismNotAvailableError(EventMetadata(TestConstants.time), listOf("fake1", "fake2")))
 
-        assertEquals(CapabilitiesNegotiationState.FINISHED, serverState.capabilities.negotiationState)
+        assertEquals(CapabilitiesNegotiationState.FINISHED, fakeServerState.capabilities.negotiationState)
     }
 
 }

src/test/kotlin/com/dmdirc/ktirc/events/handlers/ChannelStateHandlerTest.kt

 import com.dmdirc.ktirc.events.*
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.model.*
-import com.nhaarman.mockitokotlin2.doReturn
-import com.nhaarman.mockitokotlin2.mock
-import com.nhaarman.mockitokotlin2.never
-import com.nhaarman.mockitokotlin2.verify
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
 internal class ChannelStateHandlerTest {
 
     private val handler = ChannelStateHandler()
-    private val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
-    private val serverState = ServerState("", "")
-    private val behaviour = BehaviourConfig()
-    private val ircClient = mock<IrcClient> {
-        on { serverState } doReturn serverState
-        on { channelState } doReturn channelStateMap
-        on { behaviour } doReturn behaviour
-        on { isLocalUser(User("acidburn", "libby", "root.localhost")) } doReturn true
-        on { isLocalUser("acidburn") } doReturn  true
+    private val fakeChannelState = ChannelStateMap { CaseMapping.Rfc }
+    private val fakeServerState = ServerState("", "")
+    private val behaviourConfig = BehaviourConfig()
+    private val ircClient = mockk<IrcClient> {
+        every { serverState } returns fakeServerState
+        every { channelState } returns fakeChannelState
+        every { behaviour } returns behaviourConfig
+        every { isLocalUser(any<User>()) } answers { arg<User>(0) == User("acidburn", "libby", "root.localhost") }
+        every { isLocalUser(any<String>()) } answers { arg<String>(0) == "acidburn" }
     }
 
     @Test
     fun `creates new state object for local joins`() {
         handler.processEvent(ircClient, ChannelJoined(EventMetadata(TestConstants.time), User("acidburn", "libby", "root.localhost"), "#thegibson"))
-        assertTrue("#thegibson" in channelStateMap)
+        assertTrue("#thegibson" in fakeChannelState)
     }
 
     @Test
     fun `does not create new state object for remote joins`() {
         handler.processEvent(ircClient, ChannelJoined(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "#thegibson"))
-        assertFalse("#thegibson" in channelStateMap)
+        assertFalse("#thegibson" in fakeChannelState)
     }
 
     @Test
     fun `adds joiners to channel state`() {
-        channelStateMap += ChannelState("#thegibson") { CaseMapping.Rfc }
+        fakeChannelState += ChannelState("#thegibson") { CaseMapping.Rfc }
 
         handler.processEvent(ircClient, ChannelJoined(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "#thegibson"))
 
-        assertTrue("zerocool" in channelStateMap["#thegibson"]?.users!!)
+        assertTrue("zerocool" in fakeChannelState["#thegibson"]?.users!!)
     }
 
     @Test
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channel.users += ChannelUser("acidBurn")
         channel.users += ChannelUser("thePlague")
-        channelStateMap += channel
+        fakeChannelState += channel
 
         handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("zeroCool")))
 
     @Test
     fun `adds users from multiple name received events`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += channel
+        fakeChannelState += channel
 
         handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("zeroCool")))
         handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("acidBurn")))
     @Test
     fun `clears and readds users on additional names received`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += channel
+        fakeChannelState += channel
 
         handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("zeroCool")))
         handler.processEvent(ircClient, ChannelNamesFinished(EventMetadata(TestConstants.time), "#thegibson"))
     @Test
     fun `adds users with mode prefixes`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += channel
-        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
+        fakeChannelState += channel
+        fakeServerState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
 
         handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("@zeroCool", "@+acidBurn", "+thePlague", "cerealKiller")))
         handler.processEvent(ircClient, ChannelNamesFinished(EventMetadata(TestConstants.time), "#thegibson"))
     @Test
     fun `adds users with full hosts`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += channel
-        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
+        fakeChannelState += channel
+        fakeServerState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
 
         handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("@zeroCool!dade@root.localhost", "+acidBurn!libby@root.localhost")))
         handler.processEvent(ircClient, ChannelNamesFinished(EventMetadata(TestConstants.time), "#thegibson"))
     @Test
     fun `updates receiving user list state`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += channel
-        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
+        fakeChannelState += channel
+        fakeServerState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
 
         handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("@zeroCool!dade@root.localhost", "+acidBurn!libby@root.localhost")))
 
     @Test
     fun `requests modes on end of names if configured and undiscovered`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += channel
-        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
-        behaviour.requestModesOnJoin = true
+        fakeChannelState += channel
+        fakeServerState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
+        behaviourConfig.requestModesOnJoin = true
 
         handler.processEvent(ircClient, ChannelNamesFinished(EventMetadata(TestConstants.time), "#thegibson"))
 
-        verify(ircClient).send("MODE", "#thegibson")
+        verify {
+            ircClient.send("MODE", "#thegibson")
+        }
     }
 
     @Test
     fun `does not request modes on end of names if already discovered`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += channel
-        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
-        behaviour.requestModesOnJoin = true
+        fakeChannelState += channel
+        fakeServerState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
+        behaviourConfig.requestModesOnJoin = true
         channel.modesDiscovered = true
 
         handler.processEvent(ircClient, ChannelNamesFinished(EventMetadata(TestConstants.time), "#thegibson"))
 
-        verify(ircClient, never()).send("MODE", "#thegibson")
+        verify(inverse = true) {
+            ircClient.send("MODE", "#thegibson")
+        }
     }
 
     @Test
     fun `does not request modes on end of names if not configured`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += channel
-        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
-        behaviour.requestModesOnJoin = false
+        fakeChannelState += channel
+        fakeServerState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
+        behaviourConfig.requestModesOnJoin = false
 
         handler.processEvent(ircClient, ChannelNamesFinished(EventMetadata(TestConstants.time), "#thegibson"))
 
-        verify(ircClient, never()).send("MODE", "#thegibson")
+        verify(inverse = true) {
+            ircClient.send("MODE", "#thegibson")
+        }
     }
 
     @Test
     fun `removes state object for local parts`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += channel
+        fakeChannelState += channel
 
         handler.processEvent(ircClient, ChannelParted(EventMetadata(TestConstants.time), User("acidburn", "libby", "root.localhost"), "#thegibson"))
 
-        assertFalse("#thegibson" in channelStateMap)
+        assertFalse("#thegibson" in fakeChannelState)
     }
 
     @Test
     fun `removes user from channel member list for remote parts`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channel.users += ChannelUser("ZeroCool")
-        channelStateMap += channel
+        fakeChannelState += channel
 
         handler.processEvent(ircClient, ChannelParted(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "#thegibson"))
 
     @Test
     fun `removes state object for local kicks`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += channel
+        fakeChannelState += channel
 
         handler.processEvent(ircClient, ChannelUserKicked(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "#thegibson", "acidburn", "Bye!"))
 
-        assertFalse("#thegibson" in channelStateMap)
+        assertFalse("#thegibson" in fakeChannelState)
     }
 
     @Test
     fun `removes user from channel member list for remote kicks`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channel.users += ChannelUser("ZeroCool")
-        channelStateMap += channel
+        fakeChannelState += channel
 
         handler.processEvent(ircClient, ChannelUserKicked(EventMetadata(TestConstants.time), User("acidburn", "libby", "root.localhost"), "#thegibson", "zerocool", "Bye!"))
 
     fun `removes user from channel member lists for quits`() {
         with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool")
-            channelStateMap += this
+            fakeChannelState += this
         }
 
         with (ChannelState("#dumpsterdiving") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool")
-            channelStateMap += this
+            fakeChannelState += this
         }
 
         with (ChannelState("#chat") { CaseMapping.Rfc }) {
             users += ChannelUser("AcidBurn")
-            channelStateMap += this
+            fakeChannelState += this
         }
 
         handler.processEvent(ircClient, ChannelQuit(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "#thegibson"))
         handler.processEvent(ircClient, ChannelQuit(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "#dumpsterdiving"))
 
-        assertFalse("zerocool" in channelStateMap["#thegibson"]!!.users)
-        assertFalse("zerocool" in channelStateMap["#dumpsterdiving"]!!.users)
-        assertFalse("zerocool" in channelStateMap["#chat"]!!.users)
-        assertTrue("acidburn" in channelStateMap["#chat"]!!.users)
+        assertFalse("zerocool" in fakeChannelState["#thegibson"]!!.users)
+        assertFalse("zerocool" in fakeChannelState["#dumpsterdiving"]!!.users)
+        assertFalse("zerocool" in fakeChannelState["#chat"]!!.users)
+        assertTrue("acidburn" in fakeChannelState["#chat"]!!.users)
     }
 
     @Test
     fun `renames user in channel member list for nick changes`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channel.users += ChannelUser("acidBurn")
-        channelStateMap += channel
+        fakeChannelState += channel
 
         handler.processEvent(ircClient, ChannelNickChanged(EventMetadata(TestConstants.time), User("acidburn", "libby", "root.localhost"), "#thegibson", "acidB"))
         handler.processEvent(ircClient, ChannelNickChanged(EventMetadata(TestConstants.time), User("acidburn", "libby", "root.localhost"), "#dumpsterdiving", "acidB"))
     @Test
     fun `sets mode discovered flag when discovered mode event received`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += channel
-        serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
+        fakeChannelState += channel
+        fakeServerState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
 
         handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+", emptyArray(), true))
 
     @Test
     fun `adds modes when discovered mode event received`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += channel
-        serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
+        fakeChannelState += channel
+        fakeServerState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
 
         handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+ceg", arrayOf("CCC", "EEE"), true))
 
         channel.modes['c'] = "CCC"
         channel.modes['e'] = "EEE"
         channel.modes['h'] = ""
-        channelStateMap += channel
-        serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
+        fakeChannelState += channel
+        fakeServerState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
 
         handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "-c+d-eh+fg", arrayOf("CCC", "DDD", "FFF"), true))
 
     fun `handles unprivileged user gaining new mode`() {
         with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool")
-            channelStateMap += this
+            fakeChannelState += this
         }
 
         handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+o", arrayOf("zeroCool")))
 
-        assertEquals("o", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
+        assertEquals("o", fakeChannelState["#thegibson"]?.users?.get("zeroCool")?.modes)
     }
 
     @Test
     fun `handles privileged user gaining lesser mode`() {
         with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool", "o")
-            channelStateMap += this
+            fakeChannelState += this
         }
 
         handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+v", arrayOf("zeroCool")))
 
-        assertEquals("ov", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
+        assertEquals("ov", fakeChannelState["#thegibson"]?.users?.get("zeroCool")?.modes)
     }
 
     @Test
     fun `handles privileged user gaining greater mode`() {
         with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool", "v")
-            channelStateMap += this
+            fakeChannelState += this
         }
 
         handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+o", arrayOf("zeroCool")))
 
-        assertEquals("ov", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
+        assertEquals("ov", fakeChannelState["#thegibson"]?.users?.get("zeroCool")?.modes)
     }
 
     @Test
     fun `handles user gaining multiple modes`() {
         with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool")
-            channelStateMap += this
+            fakeChannelState += this
         }
 
         handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+vo", arrayOf("zeroCool", "zeroCool")))
 
-        assertEquals("ov", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
+        assertEquals("ov", fakeChannelState["#thegibson"]?.users?.get("zeroCool")?.modes)
     }
 
     @Test
     fun `handles user losing multiple modes`() {
         with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool", "ov")
-            channelStateMap += this
+            fakeChannelState += this
         }
 
         handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "-vo", arrayOf("zeroCool", "zeroCool")))
 
-        assertEquals("", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
+        assertEquals("", fakeChannelState["#thegibson"]?.users?.get("zeroCool")?.modes)
     }
 
     @Test
     fun `handles mixture of user modes and normal modes`() {
         with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool", "v")
-            channelStateMap += this
+            fakeChannelState += this
         }
-        serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
+        fakeServerState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
 
         handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "oa-v+b", arrayOf("zeroCool", "aaa", "zeroCool", "bbb")))
 
-        assertEquals("o", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
-        assertEquals("aaa", channelStateMap["#thegibson"]?.modes?.get('a'))
-        assertEquals("bbb", channelStateMap["#thegibson"]?.modes?.get('b'))
+        assertEquals("o", fakeChannelState["#thegibson"]?.users?.get("zeroCool")?.modes)
+        assertEquals("aaa", fakeChannelState["#thegibson"]?.modes?.get('a'))
+        assertEquals("bbb", fakeChannelState["#thegibson"]?.modes?.get('b'))
     }
 
     @Test
     fun `updates topic state when it's discovered for the first time`() {
         val state = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += state
+        fakeChannelState += state
 
         handler.processEvent(ircClient, ChannelTopicDiscovered(EventMetadata(TestConstants.time), "#thegibson", "Hack the planet!"))
         handler.processEvent(ircClient, ChannelTopicMetadataDiscovered(EventMetadata(TestConstants.time), "#thegibson", User("acidBurn"), TestConstants.otherTime))
     @Test
     fun `updates topic state when no topic is discovered for the first time`() {
         val state = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += state
+        fakeChannelState += state
 
         handler.processEvent(ircClient, ChannelTopicDiscovered(EventMetadata(TestConstants.time), "#thegibson", null))
 
         val state = ChannelState("#thegibson") { CaseMapping.Rfc }
         state.topic = ChannelTopic("Hack the planet!", User("acidBurn"), TestConstants.otherTime)
         state.topicDiscovered = true
-        channelStateMap += state
+        fakeChannelState += state
 
         handler.processEvent(ircClient, ChannelTopicDiscovered(EventMetadata(TestConstants.time), "#thegibson", "Hack the planet"))
         handler.processEvent(ircClient, ChannelTopicMetadataDiscovered(EventMetadata(TestConstants.time), "#thegibson", User("zeroCool"), TestConstants.time))
     @Test
     fun `updates topic state when the topic is changed`() {
         val state = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += state
+        fakeChannelState += state
 
         handler.processEvent(ircClient, ChannelTopicChanged(EventMetadata(TestConstants.time), User("acidBurn"), "#thegibson", "Hack the planet!"))
 
     @Test
     fun `updates topic state when the topic is unset`() {
         val state = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += state
+        fakeChannelState += state
 
         handler.processEvent(ircClient, ChannelTopicChanged(EventMetadata(TestConstants.time), User("acidBurn"), "#thegibson", null))
 
     @Test
     fun `ignores topic change when channel doesn't exist`() {
         val state = ChannelState("#thegibson") { CaseMapping.Rfc }
-        channelStateMap += state
+        fakeChannelState += state
 
         handler.processEvent(ircClient, ChannelTopicChanged(EventMetadata(TestConstants.time), User("acidBurn"), "#dumpsterdiving", "Hack the planet!"))
 

src/test/kotlin/com/dmdirc/ktirc/events/handlers/PingHandlerTest.kt

 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.events.EventMetadata
 import com.dmdirc.ktirc.events.PingReceived
-import com.nhaarman.mockitokotlin2.mock
-import com.nhaarman.mockitokotlin2.verify
-import kotlinx.coroutines.runBlocking
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.jupiter.api.Test
 
 internal class PingHandlerTest {
 
-    private val ircClient = mock<IrcClient>()
+    private val ircClient = mockk<IrcClient>()
 
     private val handler = PingHandler()
 
     @Test
-    fun `PingHandler responses to pings with a pong`() = runBlocking {
+    fun `responses to pings with a pong`() {
         handler.processEvent(ircClient, PingReceived(EventMetadata(TestConstants.time), "the_plague".toByteArray()))
-        verify(ircClient).send("PONG", "the_plague")
+        verify {
+            ircClient.send("PONG", "the_plague")
+        }
     }
 
 }

src/test/kotlin/com/dmdirc/ktirc/events/handlers/ServerStateHandlerTest.kt

 import com.dmdirc.ktirc.model.ServerFeatureMap
 import com.dmdirc.ktirc.model.ServerState
 import com.dmdirc.ktirc.model.ServerStatus
-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 ServerStateHandlerTest {
 
-    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 handler = ServerStateHandler()
     @Test
     fun `sets local nickname on welcome event`() {
         handler.processEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
-        assertEquals("acidBurn", serverState.localNickname)
+        assertEquals("acidBurn", fakeServerState.localNickname)
     }
 
     @Test
     fun `sets server name on welcome event`() {
         handler.processEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
-        assertEquals("the.gibson", serverState.serverName)
+        assertEquals("the.gibson", fakeServerState.serverName)
     }
 
     @Test
     fun `sets receivedWelcome on welcome event`() {
         handler.processEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
-        assertTrue(serverState.receivedWelcome)
+        assertTrue(fakeServerState.receivedWelcome)
     }
 
     @Test
     fun `sets state to connecting on event`() {
         handler.processEvent(ircClient, ServerConnecting(EventMetadata(TestConstants.time)))
-        assertEquals(ServerStatus.Connecting, serverState.status)
+        assertEquals(ServerStatus.Connecting, fakeServerState.status)
     }
 
     @Test
     fun `sets state to disconnected on event`() {
-        serverState.status = ServerStatus.Ready
+        fakeServerState.status = ServerStatus.Ready
         handler.processEvent(ircClient, ServerDisconnected(EventMetadata(TestConstants.time)))
-        assertEquals(ServerStatus.Disconnected, serverState.status)
+        assertEquals(ServerStatus.Disconnected, fakeServerState.status)
     }
 
     @Test
     fun `sets state to negotiating on connected`() {
         handler.processEvent(ircClient, ServerConnected(EventMetadata(TestConstants.time)))
-        assertEquals(ServerStatus.Negotiating, serverState.status)
+        assertEquals(ServerStatus.Negotiating, fakeServerState.status)
     }
 
     @Test
     fun `sets state to ready on ServerReady`() {
         handler.processEvent(ircClient, ServerReady(EventMetadata(TestConstants.time)))
-        assertEquals(ServerStatus.Ready, serverState.status)
+        assertEquals(ServerStatus.Ready, fakeServerState.status)
     }
 
     @Test
 
         handler.processEvent(ircClient, ServerFeaturesUpdated(EventMetadata(TestConstants.time), features))
 
-        assertArrayEquals(arrayOf("abc", "def"), serverState.features[ServerFeature.ChannelModes])
-        assertEquals(true, serverState.features[ServerFeature.WhoxSupport])
+        assertArrayEquals(arrayOf("abc", "def"), fakeServerState.features[ServerFeature.ChannelModes])
+        assertEquals(true, fakeServerState.features[ServerFeature.WhoxSupport])
     }
 
 }

src/test/kotlin/com/dmdirc/ktirc/events/handlers/UserStateHandlerTest.kt

 import com.dmdirc.ktirc.events.*
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.model.*
-import com.nhaarman.mockitokotlin2.argForWhich
-import com.nhaarman.mockitokotlin2.doReturn
-import com.nhaarman.mockitokotlin2.mock
-import com.nhaarman.mockitokotlin2.whenever
+import io.mockk.every
+import io.mockk.mockk
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 
 internal class UserStateHandlerTest {
 
-    private val serverState = ServerState("", "")
-    private val userState = UserState { CaseMapping.Rfc }
+    private val fakeServerState = ServerState("", "")
+    private val fakeUserState = UserState { CaseMapping.Rfc }
 
-    private val ircClient = mock<IrcClient> {
-        on { serverState } doReturn serverState
-        on { userState } doReturn userState
-        on { isLocalUser(argForWhich<User> { nickname == "zeroCool" }) } doReturn true
-        on { isLocalUser("zeroCool") } doReturn true
+    private val ircClient = mockk<IrcClient> {
+        every { serverState } returns fakeServerState
+        every { userState } returns fakeUserState
+        every { isLocalUser(any<User>()) } answers { arg<User>(0).nickname == "zeroCool" }
+        every { isLocalUser(any<String>()) } answers { arg<String>(0) == "zeroCool" }
     }
 
     private val handler = UserStateHandler()
 
     @BeforeEach
     fun setUp() {
-        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
+        fakeServerState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
     }
 
     @Test
     fun `adds channel to user on join`() {
-        userState += User("acidBurn")
+        fakeUserState += User("acidBurn")
 
         handler.processEvent(ircClient, ChannelJoined(EventMetadata(TestConstants.time), User("acidBurn", "libby", "root.localhost"), "#thegibson"))
 
-        assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
+        assertEquals(listOf("#thegibson"), fakeUserState["acidBurn"]?.channels?.toList())
     }
 
     @Test
     fun `updates user info on join`() {
-        userState += User("acidBurn")
+        fakeUserState += User("acidBurn")
 
         handler.processEvent(ircClient, ChannelJoined(EventMetadata(TestConstants.time), User("acidBurn", "libby", "root.localhost"), "#thegibson"))
 
-        val details = userState["acidBurn"]?.details!!
+        val details = fakeUserState["acidBurn"]?.details!!
         assertEquals("libby", details.ident)
         assertEquals("root.localhost", details.hostname)
     }
 
     @Test
     fun `removes channel from user on part`() {
-        userState += User("acidBurn")
-        userState.addToChannel(User("acidBurn"), "#thegibson")
-        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        fakeUserState += User("acidBurn")
+        fakeUserState.addToChannel(User("acidBurn"), "#thegibson")
+        fakeUserState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
         handler.processEvent(ircClient, ChannelParted(EventMetadata(TestConstants.time), User("acidBurn", "libby", "root.localhost"), "#dumpsterdiving"))
 
-        assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
+        assertEquals(listOf("#thegibson"), fakeUserState["acidBurn"]?.channels?.toList())
     }
 
     @Test
     fun `removes user on part from last channel`() {
-        userState += User("acidBurn")
-        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        fakeUserState += User("acidBurn")
+        fakeUserState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
         handler.processEvent(ircClient, ChannelParted(EventMetadata(TestConstants.time), User("acidBurn", "libby", "root.localhost"), "#dumpsterdiving"))
 
-        assertNull(userState["acidBurn"])
+        assertNull(fakeUserState["acidBurn"])
     }
 
     @Test
     fun `removes channel from all users on local part`() {
-        userState += User("acidBurn")
-        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
-        userState.addToChannel(User("acidBurn"), "#thegibson")
+        fakeUserState += User("acidBurn")
+        fakeUserState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        fakeUserState.addToChannel(User("acidBurn"), "#thegibson")
 
-        userState += User("zeroCool")
-        userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
-        userState.addToChannel(User("zeroCool"), "#thegibson")
+        fakeUserState += User("zeroCool")
+        fakeUserState.addToChannel(User("zeroCool"), "#dumpsterdiving")
+        fakeUserState.addToChannel(User("zeroCool"), "#thegibson")
 
         handler.processEvent(ircClient, ChannelParted(EventMetadata(TestConstants.time), User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
 
-        assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
-        assertEquals(listOf("#thegibson"), userState["zeroCool"]?.channels?.toList())
+        assertEquals(listOf("#thegibson"), fakeUserState["acidBurn"]?.channels?.toList())
+        assertEquals(listOf("#thegibson"), fakeUserState["zeroCool"]?.channels?.toList())
     }
 
     @Test
     fun `removes remote users with no remaining channels on local part`() {
-        userState += User("acidBurn")
-        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        fakeUserState += User("acidBurn")
+        fakeUserState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
         handler.processEvent(ircClient, ChannelParted(EventMetadata(TestConstants.time), User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
 
-        assertNull(userState["acidBurn"])
+        assertNull(fakeUserState["acidBurn"])
     }
 
     @Test
     fun `keeps local user with no remaining channels after local part`() {
-        userState += User("zeroCool")
-        userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
+        fakeUserState += User("zeroCool")
+        fakeUserState.addToChannel(User("zeroCool"), "#dumpsterdiving")
 
         handler.processEvent(ircClient, ChannelParted(EventMetadata(TestConstants.time), User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
 
-        assertNotNull(userState["zeroCool"])
+        assertNotNull(fakeUserState["zeroCool"])
     }
 
 
     @Test
     fun `removes channel from user on kick`() {
-        userState += User("acidBurn")
-        userState.addToChannel(User("acidBurn"), "#thegibson")
-        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        fakeUserState += User("acidBurn")
+        fakeUserState.addToChannel(User("acidBurn"), "#thegibson")
+        fakeUserState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
         handler.processEvent(ircClient, ChannelUserKicked(EventMetadata(TestConstants.time), User("thePlague"), "#dumpsterdiving", "acidBurn"))
 
-        assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
+        assertEquals(listOf("#thegibson"), fakeUserState["acidBurn"]?.channels?.toList())
     }
 
     @Test
     fun `removes user on kick from last channel`() {
-        userState += User("acidBurn")
-        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        fakeUserState += User("acidBurn")
+        fakeUserState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
         handler.processEvent(ircClient, ChannelUserKicked(EventMetadata(TestConstants.time), User("thePlague"), "#dumpsterdiving", "acidBurn"))
 
-        assertNull(userState["acidBurn"])
+        assertNull(fakeUserState["acidBurn"])
     }
 
     @Test
     fun `removes channel from all users on local kick`() {
-        userState += User("acidBurn")
-        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
-        userState.addToChannel(User("acidBurn"), "#thegibson")
+        fakeUserState += User("acidBurn")
+        fakeUserState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        fakeUserState.addToChannel(User("acidBurn"), "#thegibson")
 
-        userState += User("zeroCool")
-        userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
-        userState.addToChannel(User("zeroCool"), "#thegibson")
+        fakeUserState += User("zeroCool")
+        fakeUserState.addToChannel(User("zeroCool"), "#dumpsterdiving")
+        fakeUserState.addToChannel(User("zeroCool"), "#thegibson")
 
         handler.processEvent(ircClient, ChannelUserKicked(EventMetadata(TestConstants.time), User("thePlague"), "#dumpsterdiving", "zeroCool"))
 
-        assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
-        assertEquals(listOf("#thegibson"), userState["zeroCool"]?.channels?.toList())
+        assertEquals(listOf("#thegibson"), fakeUserState["acidBurn"]?.channels?.toList())
+        assertEquals(listOf("#thegibson"), fakeUserState["zeroCool"]?.channels?.toList())
     }
 
     @Test
     fun `removes remote users with no remaining channels on local kick`() {
-        userState += User("acidBurn")
-        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        fakeUserState += User("acidBurn")
+        fakeUserState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
         handler.processEvent(ircClient, ChannelUserKicked(EventMetadata(TestConstants.time), User("thePlague"), "#dumpsterdiving", "zeroCool"))
 
-        assertNull(userState["acidBurn"])
+        assertNull(fakeUserState["acidBurn"])
     }
 
     @Test
     fun `keeps local user with no remaining channels after local kick`() {
-        userState += User("zeroCool")
-        userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
+        fakeUserState += User("zeroCool")
+        fakeUserState.addToChannel(User("zeroCool"), "#dumpsterdiving")
 
         handler.processEvent(ircClient, ChannelUserKicked(EventMetadata(TestConstants.time), User("thePlague"), "#dumpsterdiving", "zeroCool"))
 
-        assertNotNull(userState["zeroCool"])
+        assertNotNull(fakeUserState["zeroCool"])
     }
 
     @Test
     fun `removes user entirely on quit`() {
-        userState += User("acidBurn")
-        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        fakeUserState += User("acidBurn")
+        fakeUserState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
         handler.processEvent(ircClient, UserQuit(EventMetadata(TestConstants.time), User("acidBurn", "libby", "root.localhost")))
 
-        assertNull(userState["acidBurn"])
+        assertNull(fakeUserState["acidBurn"])
     }
 
     @Test
     fun `adds users to channels on names received`() {
-        userState += User("acidBurn")
-        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        fakeUserState += User("acidBurn")
+        fakeUserState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
         handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("@acidBurn")))
 
-        assertEquals(listOf("#dumpsterdiving", "#thegibson"), userState["acidBurn"]?.channels?.toList())
+        assertEquals(listOf("#dumpsterdiving", "#thegibson"), fakeUserState["acidBurn"]?.channels?.toList())
     }
 
     @Test
     fun `updates user details on names received`() {
-        userState += User("acidBurn")
-        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        fakeUserState += User("acidBurn")
+        fakeUserState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
         handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("@acidBurn!libby@root.localhost")))
 
-        val details = userState["acidBurn"]?.details!!
+        val details = fakeUserState["acidBurn"]?.details!!
         assertEquals("libby", details.ident)
         assertEquals("root.localhost", details.hostname)
     }
 
     @Test
     fun `updates user info on account change`() {
-        userState += User("acidBurn")
+        fakeUserState += User("acidBurn")
 
         handler.processEvent(ircClient, UserAccountChanged(EventMetadata(TestConstants.time), User("acidBurn", "libby", "root.localhost"), "acidBurn"))
 
-        val details = userState["acidBurn"]?.details!!
+        val details = fakeUserState["acidBurn"]?.details!!
         assertEquals("acidBurn", details.account)
     }
 
     @Test
     fun `updates local nickname for local nick changes`() {
-        val user = User("acidBurn", "libby", "root.localhost")
-        whenever(ircClient.isLocalUser(user)).doReturn(true)
+        val user = User("zeroCool", "dade", "root.localhost")
 
-        handler.processEvent(ircClient, UserNickChanged(EventMetadata(TestConstants.time), user, "acid~"))
+        handler.processEvent(ircClient, UserNickChanged(EventMetadata(TestConstants.time), user, "crashOverride"))
 
-        assertEquals("acid~", serverState.localNickname)
+        assertEquals("crashOverride", fakeServerState.localNickname)
     }
 
     @Test
     fun `updates nickname for remote nick changes`() {
         val user = User("acidBurn", "libby", "root.localhost")
-        userState += User("AcidBurn")
+        fakeUserState += User("AcidBurn")
 
         handler.processEvent(ircClient, UserNickChanged(EventMetadata(TestConstants.time), user, "acid~"))
 
-        assertNotNull(userState["acid~"])
-        assertNull(userState["AcidBurn"])
-        assertEquals("acid~", userState["acid~"]?.details?.nickname)
+        assertNotNull(fakeUserState["acid~"])
+        assertNull(fakeUserState["AcidBurn"])
+        assertEquals("acid~", fakeUserState["acid~"]?.details?.nickname)
     }
 
     @Test
     fun `updates details for remote host changes`() {
         val user = User("acidBurn", "libby", "root.localhost")
-        userState += User("AcidBurn")
+        fakeUserState += User("AcidBurn")
 
         handler.processEvent(ircClient, UserHostChanged(EventMetadata(TestConstants.time), user, "burn", "root.gibson"))
 
-        assertEquals("burn", userState["acidBurn"]?.details?.ident)
-        assertEquals("root.gibson", userState["acidBurn"]?.details?.hostname)
+        assertEquals("burn", fakeUserState["acidBurn"]?.details?.ident)
+        assertEquals("root.gibson", fakeUserState["acidBurn"]?.details?.hostname)
     }
 
 }

src/test/kotlin/com/dmdirc/ktirc/events/mutators/BatchMutatorTest.kt

 import com.dmdirc.ktirc.model.Batch
 import com.dmdirc.ktirc.model.ServerState
 import com.dmdirc.ktirc.model.User
-import com.nhaarman.mockitokotlin2.*
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
 
     private val mutator = BatchMutator()
 
-    private val serverState = ServerState("", "")
-    private val messageEmitter = mock<MessageEmitter>()
-    private val ircClient = mock<IrcClient> {
-        on { serverState } doReturn serverState
+    private val messageEmitter = mockk<MessageEmitter>()
+    private val fakeServerState = ServerState("", "")
+    private val ircClient = mockk<IrcClient> {
+        every { serverState } returns fakeServerState
     }
 
     @Test
         val events = mutator.mutateEvent(ircClient, messageEmitter, event)
 
         assertTrue(events.isEmpty())
-        assertNotNull(serverState.batches["abcdef"])
-        serverState.batches["abcdef"]?.let {
+        assertNotNull(fakeServerState.batches["abcdef"])
+        fakeServerState.batches["abcdef"]?.let {
             assertEquals(listOf("foo", "bar"), it.arguments)
             assertEquals("netsplit", it.type)
             assertTrue(it.events.isEmpty())
 
     @Test
     fun `adds to batch when event has a batch ID`() {
-        serverState.batches["abcdef"] = Batch("netsplit", emptyList(), EventMetadata(TestConstants.time))
+        fakeServerState.batches["abcdef"] = Batch("netsplit", emptyList(), EventMetadata(TestConstants.time))
 
         val event = UserNickChanged(EventMetadata(TestConstants.time, "abcdef"), User("zeroCool"), "crashOverride")
         mutator.mutateEvent(ircClient, messageEmitter, event)
 
-        assertEquals(listOf(event), serverState.batches["abcdef"]!!.events)
+        assertEquals(listOf(event), fakeServerState.batches["abcdef"]!!.events)
     }
 
     @Test
     fun `suppresses event when it has a batch ID`() {
-        serverState.batches["abcdef"] = Batch("netsplit", emptyList(), EventMetadata(TestConstants.time))
+        fakeServerState.batches["abcdef"] = Batch("netsplit", emptyList(), EventMetadata(TestConstants.time))
 
         val event = UserNickChanged(EventMetadata(TestConstants.time, "abcdef"), User("zeroCool"), "crashOverride")
         val events = mutator.mutateEvent(ircClient, messageEmitter, event)
 
     @Test
     fun `passes event for processing only when it has a batch ID`() {
-        serverState.batches["abcdef"] = Batch("netsplit", emptyList(), EventMetadata(TestConstants.time))
+        fakeServerState.batches["abcdef"] = Batch("netsplit", emptyList(), EventMetadata(TestConstants.time))
 
         val event = UserNickChanged(EventMetadata(TestConstants.time, "abcdef"), User("zeroCool"), "crashOverride")
         mutator.mutateEvent(ircClient, messageEmitter, event)
 
-        verify(messageEmitter).handleEvent(any(), same(event), eq(true))
+        verify {
+            messageEmitter.handleEvent(any(), refEq(event), eq(true))
+        }
     }
 
     @Test
     fun `sends a batch when it finishes and the parent is null`() {
-        serverState.batches["abcdef"] = Batch("netsplit", listOf("p1", "p2"), EventMetadata(TestConstants.time), events = mutableListOf(ServerConnected(EventMetadata(TestConstants.time, "abcdef"))))
+        fakeServerState.batches["abcdef"] = Batch("netsplit", listOf("p1", "p2"), EventMetadata(TestConstants.time), events = mutableListOf(ServerConnected(EventMetadata(TestConstants.time, "abcdef"))))
 
         val events = mutator.mutateEvent(ircClient, messageEmitter, BatchFinished(EventMetadata(TestConstants.time), "abcdef"))
 
 
     @Test
     fun `adds a batch to its parent when it finishes`() {
-        serverState.batches["12345"] = Batch("history", emptyList(), EventMetadata(TestConstants.time))
-        serverState.batches["abcdef"] = Batch("netsplit", emptyList(), EventMetadata(TestConstants.time, batchId = "12345"), mutableListOf(ServerConnected(EventMetadata(TestConstants.time, "abcdef"))))
+        fakeServerState.batches["12345"] = Batch("history", emptyList(), EventMetadata(TestConstants.time))
+        fakeServerState.batches["abcdef"] = Batch("netsplit", emptyList(), EventMetadata(TestConstants.time, batchId = "12345"), mutableListOf(ServerConnected(EventMetadata(TestConstants.time, "abcdef"))))
 
         val events = mutator.mutateEvent(ircClient, messageEmitter, BatchFinished(EventMetadata(TestConstants.time), "abcdef"))
 
         assertEquals(0, events.size)
 
-        val parent = serverState.batches["12345"]?.events
+        val parent = fakeServerState.batches["12345"]?.events
         assertEquals(1, parent?.size)
 
         val event = parent?.get(0) as BatchReceived
 
     @Test
     fun `deletes batch when it finishes`() {
-        serverState.batches["abcdef"] = Batch("netsplit", emptyList(), EventMetadata(TestConstants.time), events = mutableListOf(ServerConnected(EventMetadata(TestConstants.time, "abcdef"))))
+        fakeServerState.batches["abcdef"] = Batch("netsplit", emptyList(), EventMetadata(TestConstants.time), events = mutableListOf(ServerConnected(EventMetadata(TestConstants.time, "abcdef"))))
 
         mutator.mutateEvent(ircClient, messageEmitter, BatchFinished(EventMetadata(TestConstants.time), "abcdef"))
 
-        assertNull(serverState.batches["abcdef"])
+        assertNull(fakeServerState.batches["abcdef"])
     }
 
 }

src/test/kotlin/com/dmdirc/ktirc/events/mutators/ChannelFanOutMutatorTest.kt

 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.io.MessageEmitter
 import com.dmdirc.ktirc.model.*
-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.Assertions.*
 import org.junit.jupiter.api.Test
 
 internal class ChannelFanOutMutatorTest {
 
     private val mutator = ChannelFanOutMutator()
-    private val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
-    private val serverState = ServerState("", "")
-    private val behaviour = BehaviourConfig()
-    private val messageEmitter = mock<MessageEmitter>()
-    private val ircClient = mock<IrcClient> {
-        on { serverState } doReturn serverState
-        on { channelState } doReturn channelStateMap
-        on { behaviour } doReturn behaviour
-        on { isLocalUser(User("acidburn", "libby", "root.localhost")) } doReturn true
-        on { isLocalUser("acidburn") } doReturn  true
+    private val fakeServerState = ServerState("", "")
+    private val fakeChannelStateMap = ChannelStateMap { CaseMapping.Rfc }
+    private val fakeBehaviour = BehaviourConfig()
+    private val messageEmitter = mockk<MessageEmitter>()
+    private val ircClient = mockk<IrcClient> {
+        every { serverState } returns fakeServerState
+        every { channelState } returns fakeChannelStateMap
+        every { behaviour } returns fakeBehaviour
+        every { isLocalUser(any<User>()) } answers { arg<User>(0) == User("acidburn", "libby", "root.localhost") }
+        every { isLocalUser(any<String>()) } answers { arg<String>(0) == "acidburn" }
     }
 
     @Test
     fun `raises ChannelQuit event for each channel a user quits from`() {
         with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool")
-            channelStateMap += this
+            fakeChannelStateMap += this
         }
 
         with (ChannelState("#dumpsterdiving") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool")
-            channelStateMap += this
+            fakeChannelStateMap += this
         }
 
         with (ChannelState("#chat") { CaseMapping.Rfc }) {
             users += ChannelUser("AcidBurn")
-            channelStateMap += this
+            fakeChannelStateMap += this
         }
 
         val quitEvent = UserQuit(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "Hack the planet!")
         val events = mutator.mutateEvent(ircClient, messageEmitter, quitEvent)
 
         val names = mutableListOf<String>()
-        Assertions.assertEquals(3, events.size)
-        Assertions.assertSame(quitEvent, events[0])
+        assertEquals(3, events.size)
+        assertSame(quitEvent, events[0])
         events.subList(1, events.size).forEach { event ->
             (event as ChannelQuit).let {
-                Assertions.assertEquals(TestConstants.time, it.metadata.time)
-                Assertions.assertEquals("zerocool", it.user.nickname)
-                Assertions.assertEquals("Hack the planet!", it.reason)
+                assertEquals(TestConstants.time, it.metadata.time)
+                assertEquals("zerocool", it.user.nickname)
+                assertEquals("Hack the planet!", it.reason)
                 names.add(it.target)
             }
         }
 
-        Assertions.assertTrue("#thegibson" in names)
-        Assertions.assertTrue("#dumpsterdiving" in names)
+        assertTrue("#thegibson" in names)
+        assertTrue("#dumpsterdiving" in names)
     }
 
     @Test
     fun `raises ChannelNickChanged event for each channel a user changes nicks in`() {
         with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool")
-            channelStateMap += this
+            fakeChannelStateMap += this
         }
 
         with (ChannelState("#dumpsterdiving") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool")
-            channelStateMap += this
+            fakeChannelStateMap += this
         }
 
         with (ChannelState("#chat") { CaseMapping.Rfc }) {
             users += ChannelUser("AcidBurn")
-            channelStateMap += this
+            fakeChannelStateMap += this
         }
 
         val nickEvent = UserNickChanged(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "zer0c00l")
         val events = mutator.mutateEvent(ircClient, messageEmitter, nickEvent)
 
         val names = mutableListOf<String>()
-        Assertions.assertEquals(3, events.size)
-        Assertions.assertSame(nickEvent, events[0])
+        assertEquals(3, events.size)
+        assertSame(nickEvent, events[0])
         events.subList(1, events.size).forEach { event ->
             (event as ChannelNickChanged).let {
                 Assertions.assertEquals(TestConstants.time, it.metadata.time)
             }
         }
 
-        Assertions.assertTrue("#thegibson" in names)
-        Assertions.assertTrue("#dumpsterdiving" in names)
+        assertTrue("#thegibson" in names)
+        assertTrue("#dumpsterdiving" in names)
     }
 }

src/test/kotlin/com/dmdirc/ktirc/events/mutators/ServerReadyMutatorTest.kt

 import com.dmdirc.ktirc.model.ServerState
 import com.dmdirc.ktirc.model.ServerStatus
 import com.dmdirc.ktirc.model.User
-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 ServerReadyMutatorTest {
 
-    private val serverState = ServerState("", "")
-    private val messageEmitter = mock<MessageEmitter>()
-    private val ircClient = mock<IrcClient> {
-        on { serverState } doReturn serverState
+    private val messageEmitter = mockk<MessageEmitter>()
+    private val fakeServerState = ServerState("", "")
+    private val ircClient = mockk<IrcClient> {
+        every { serverState } returns fakeServerState
     }
 
     private val mutator = ServerReadyMutator()

src/test/resources/io/mockk/settings.properties

+relaxUnitFun=true