Expose message time in events

src/main/kotlin/com/dmdirc/ktirc/events/Events.kt

-@file:Suppress("ArrayInDataClass")
-
 package com.dmdirc.ktirc.events
 
 import com.dmdirc.ktirc.model.Capability
 import com.dmdirc.ktirc.model.ServerFeatureMap
 import com.dmdirc.ktirc.model.User
+import java.time.LocalDateTime
 
-sealed class IrcEvent
+sealed class IrcEvent(val time: LocalDateTime)
 
 /** Raised when the server initially welcomes us to the IRC network. */
-data class ServerWelcome(val localNick: String) : IrcEvent()
+class ServerWelcome(time: LocalDateTime, val localNick: String) : IrcEvent(time)
 
 /** Raised when the features supported by the server have changed. This may occur numerous times. */
-data class ServerFeaturesUpdated(val serverFeatures: ServerFeatureMap) : IrcEvent()
+class ServerFeaturesUpdated(time: LocalDateTime, val serverFeatures: ServerFeatureMap) : IrcEvent(time)
 
 /** Raised when the connection to the server has been established, configuration information has been received, etc. */
 // TODO: Implement
-object ServerConnected : IrcEvent()
+class ServerConnected(time: LocalDateTime) : IrcEvent(time)
 
 /** Raised whenever a PING is received from the server. */
-data class PingReceived(val nonce: ByteArray) : IrcEvent()
+class PingReceived(time: LocalDateTime, val nonce: ByteArray) : IrcEvent(time)
 
 /** Raised when a user joins a channel. */
-data class ChannelJoined(val user: User, val channel: String) : IrcEvent()
+class ChannelJoined(time: LocalDateTime, val user: User, val channel: String) : IrcEvent(time)
 
 /** Raised when a user leaves a channel. */
-data class ChannelParted(val user: User, val channel: String, val reason: String = "") : IrcEvent()
+class ChannelParted(time: LocalDateTime, val user: User, val channel: String, val reason: String = "") : IrcEvent(time)
 
 /** Raised when a batch of the channel's member list has been received. More batches may follow. */
-data class ChannelNamesReceived(val channel: String, val names: List<String>) : IrcEvent()
+class ChannelNamesReceived(time: LocalDateTime, val channel: String, val names: List<String>) : IrcEvent(time)
 
 /** Raised when the entirety of the channel's member list has been received. */
-data class ChannelNamesFinished(val channel: String) : IrcEvent()
+class ChannelNamesFinished(time: LocalDateTime, val channel: String) : IrcEvent(time)
 
 /** Raised when a message is received. */
-data class MessageReceived(val user: User, val target: String, val message: String) : IrcEvent()
+class MessageReceived(time: LocalDateTime, val user: User, val target: String, val message: String) : IrcEvent(time)
 
 /** Raised when a user quits. */
-data class UserQuit(val user: User, val reason: String = "") : IrcEvent()
+class UserQuit(time: LocalDateTime, val user: User, val reason: String = "") : IrcEvent(time)
 
 /** Raised when available server capabilities are received. More batches may follow. */
-data class ServerCapabilitiesReceived(val capabilities: Map<Capability, String>): IrcEvent()
+class ServerCapabilitiesReceived(time: LocalDateTime, val capabilities: Map<Capability, String>) : IrcEvent(time)
 
 /** Raised when our requested capabilities are acknowledged. More batches may follow. */
-data class ServerCapabilitiesAcknowledged(val capabilities: Map<Capability, String>): IrcEvent()
+class ServerCapabilitiesAcknowledged(time: LocalDateTime, val capabilities: Map<Capability, String>) : IrcEvent(time)
 
 /** Raised when the server has finished sending us capabilities. */
-object ServerCapabilitiesFinished : IrcEvent()
+class ServerCapabilitiesFinished(time: LocalDateTime) : IrcEvent(time)

src/main/kotlin/com/dmdirc/ktirc/messages/CapabilityProcessor.kt

 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.capabilities
 import com.dmdirc.ktirc.util.logger
+import java.time.LocalDateTime
 
 class CapabilityProcessor : MessageProcessor {
 
     override val commands = arrayOf("CAP")
 
     override fun process(message: IrcMessage) = when (message.subCommand) {
-        "LS" -> handleList(message.subCommandArguments)
-        "ACK" -> listOf(ServerCapabilitiesAcknowledged(message.params.capabilities))
+        "LS" -> handleList(message.time, message.subCommandArguments)
+        "ACK" -> listOf(ServerCapabilitiesAcknowledged(message.time, message.params.capabilities))
         else -> emptyList()
     }
 
-    private fun handleList(lsParams: List<ByteArray>) = sequence {
-        yield(ServerCapabilitiesReceived(lsParams.capabilities))
+    private fun handleList(time: LocalDateTime, lsParams: List<ByteArray>) = sequence {
+        yield(ServerCapabilitiesReceived(time, lsParams.capabilities))
         if (lsParams.size < 2 || String(lsParams[0]) != "*") {
-            yield(ServerCapabilitiesFinished)
+            yield(ServerCapabilitiesFinished(time))
         }
     }.toList()
 

src/main/kotlin/com/dmdirc/ktirc/messages/ISupportProcessor.kt

 
     override val commands = arrayOf("005")
 
-    override fun process(message: IrcMessage) = listOf(ServerFeaturesUpdated(ServerFeatureMap().apply {
+    override fun process(message: IrcMessage) = listOf(ServerFeaturesUpdated(message.time, ServerFeatureMap().apply {
         // Ignore the first (nickname) and last ("are supported by this server") params
         for (i in 1 until message.params.size - 1) {
             parseParam(message.params[i])

src/main/kotlin/com/dmdirc/ktirc/messages/JoinProcessor.kt

 
     override val commands = arrayOf("JOIN")
 
-    override fun process(message: IrcMessage) = message.prefix?.let { listOf(ChannelJoined(it.asUser(), String(message.params[0]))) } ?: emptyList()
+    override fun process(message: IrcMessage) = message.prefix?.let {
+        listOf(ChannelJoined(message.time, it.asUser(), String(message.params[0])))
+    } ?: emptyList()
 
 }

src/main/kotlin/com/dmdirc/ktirc/messages/NamesProcessor.kt

     override val commands = arrayOf("353", "366")
 
     override fun process(message: IrcMessage) = when (message.command) {
-        "353" -> listOf(ChannelNamesReceived(String(message.params[2]), String(message.params[3]).split(' ')))
-        "366" -> listOf(ChannelNamesFinished(String(message.params[1])))
+        "353" -> listOf(ChannelNamesReceived(message.time, String(message.params[2]), String(message.params[3]).split(' ')))
+        "366" -> listOf(ChannelNamesFinished(message.time, String(message.params[1])))
         else -> emptyList()
     }
 

src/main/kotlin/com/dmdirc/ktirc/messages/PartProcessor.kt

     override val commands = arrayOf("PART")
 
     override fun process(message: IrcMessage) = message.prefix?.let {
-        listOf(ChannelParted(it.asUser(), message.channel, message.reason))
+        listOf(ChannelParted(message.time, it.asUser(), message.channel, message.reason))
     } ?: emptyList()
 
     private val IrcMessage.channel

src/main/kotlin/com/dmdirc/ktirc/messages/PingProcessor.kt

 
     override val commands = arrayOf("PING")
 
-    override fun process(message: IrcMessage) = listOf(PingReceived(message.params[0]))
+    override fun process(message: IrcMessage) = listOf(PingReceived(message.time, message.params[0]))
 
 }

src/main/kotlin/com/dmdirc/ktirc/messages/PrivmsgProcessor.kt

     override val commands = arrayOf("PRIVMSG")
 
     override fun process(message: IrcMessage) = message.prefix?.let {
-        listOf(MessageReceived(it.asUser(), String(message.params[0]), String(message.params[1])))
+        listOf(MessageReceived(message.time, it.asUser(), String(message.params[0]), String(message.params[1])))
     } ?: emptyList()
 
 }

src/main/kotlin/com/dmdirc/ktirc/messages/QuitProcessor.kt

     override val commands = arrayOf("QUIT")
 
     override fun process(message: IrcMessage) = message.prefix?.let {
-        listOf(UserQuit(it.asUser(), message.reason))
+        listOf(UserQuit(message.time, it.asUser(), message.reason))
     } ?: emptyList()
 
     private val IrcMessage.reason

src/main/kotlin/com/dmdirc/ktirc/messages/WelcomeProcessor.kt

 
     override val commands = arrayOf("001")
 
-    override fun process(message: IrcMessage) = listOf(ServerWelcome(String(message.params[0])))
+    override fun process(message: IrcMessage) = listOf(ServerWelcome(message.time, String(message.params[0])))
 
 }

src/main/kotlin/com/dmdirc/ktirc/model/IrcMessage.kt

 package com.dmdirc.ktirc.model
 
-class IrcMessage(val tags: Map<MessageTag, String>, val prefix: ByteArray?, val command: String, val params: List<ByteArray>)
+import java.time.Instant
+import java.time.LocalDateTime
+import java.time.ZoneId
+
+class IrcMessage(val tags: Map<MessageTag, String>, val prefix: ByteArray?, val command: String, val params: List<ByteArray>) {
+
+    companion object {
+        internal var currentTimeZoneProvider = { ZoneId.systemDefault() }
+        internal var currentTimeProvider = { LocalDateTime.now(currentTimeZoneProvider()) }
+    }
+
+    val time: LocalDateTime = if (MessageTag.ServerTime in tags) {
+        LocalDateTime.ofInstant(Instant.parse(tags[MessageTag.ServerTime]), currentTimeZoneProvider())
+    } else {
+        currentTimeProvider()
+    }
+
+}
 
 sealed class MessageTag(val name: String) {
-    object AccountName: MessageTag("account")
+    object AccountName : MessageTag("account")
     object ServerTime : MessageTag("time")
 }
 

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

 import com.dmdirc.ktirc.events.ServerWelcome
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.io.LineBufferedSocket
-import com.dmdirc.ktirc.model.Profile
-import com.dmdirc.ktirc.model.Server
-import com.dmdirc.ktirc.model.ServerFeature
-import com.dmdirc.ktirc.model.User
+import com.dmdirc.ktirc.model.*
 import com.nhaarman.mockitokotlin2.*
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 
 
     private val mockEventHandler = mock<EventHandler>()
 
+    @BeforeEach
+    fun setUp() {
+        IrcMessage.currentTimeProvider = { TestConstants.time }
+    }
+
     @Test
     fun `IrcClientImpl uses socket factory to create a new socket on connect`() {
         runBlocking {
 
             client.connect()
 
-            verify(mockEventHandler).processEvent(client, ServerWelcome("acidBurn"))
+            verify(mockEventHandler).processEvent(same(client), isA<ServerWelcome>())
         }
     }
 
 
             client.connect()
 
-            verify(mockEventHandler, never()).processEvent(client, ServerWelcome("acidBurn"))
+            verify(mockEventHandler, never()).processEvent(client, ServerWelcome(TestConstants.time, "acidBurn"))
         }
     }
 
 
             client.connect()
 
-            verify(mockEventHandler, never()).processEvent(client, ServerWelcome("acidBurn"))
+            verify(mockEventHandler, never()).processEvent(client, ServerWelcome(TestConstants.time, "acidBurn"))
         }
     }
 

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

+package com.dmdirc.ktirc
+
+import java.time.LocalDateTime
+
+object TestConstants {
+    val time: LocalDateTime = LocalDateTime.parse("1995-09-15T09:00:00")
+}

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

 package com.dmdirc.ktirc.events
 
 import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.CapabilitiesNegotiationState
 import com.dmdirc.ktirc.model.Capability
 import com.dmdirc.ktirc.model.ServerState
     @Test
     fun `CapabilitiesHandler adds new capabilities to the state`() {
         runBlocking {
-            handler.processEvent(ircClient, ServerCapabilitiesReceived(hashMapOf(
+            handler.processEvent(ircClient, ServerCapabilitiesReceived(TestConstants.time, hashMapOf(
                     Capability.EchoMessages to "",
                     Capability.HostsInNamesReply to "123"
             )))
     @Test
     fun `CapabilitiesHandler updates negotiation state when capabilities finished`() {
         runBlocking {
-            handler.processEvent(ircClient, ServerCapabilitiesFinished)
+            handler.processEvent(ircClient, ServerCapabilitiesFinished(TestConstants.time))
 
             assertEquals(CapabilitiesNegotiationState.AWAITING_ACK, serverState.capabilities.negotiationState)
         }
             serverState.capabilities.advertisedCapabilities[Capability.EchoMessages] = ""
             serverState.capabilities.advertisedCapabilities[Capability.AccountChangeMessages] = ""
 
-            handler.processEvent(ircClient, ServerCapabilitiesFinished)
+            handler.processEvent(ircClient, ServerCapabilitiesFinished(TestConstants.time))
 
             verify(ircClient).send(argThat { equals("CAP REQ :echo-message account-notify") || equals("CAP REQ :account-notify echo-message") })
         }
     @Test
     fun `CapabilitiesHandler sends END when capabilities acknowledged`() {
         runBlocking {
-            handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(hashMapOf(
+            handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
                     Capability.EchoMessages to "",
                     Capability.HostsInNamesReply to "123"
             )))
     @Test
     fun `CapabilitiesHandler updates negotiation state when capabilities acknowledged`() {
         runBlocking {
-            handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(hashMapOf(
+            handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
                     Capability.EchoMessages to "",
                     Capability.HostsInNamesReply to "123"
             )))
     @Test
     fun `CapabilitiesHandler stores enabled caps when capabilities acknowledged`() {
         runBlocking {
-            handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(hashMapOf(
+            handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
                     Capability.EchoMessages to "",
                     Capability.HostsInNamesReply to "123"
             )))

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

 package com.dmdirc.ktirc.events
 
 import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.model.*
 import com.nhaarman.mockitokotlin2.doReturn
 
     @Test
     fun `ChannelStateHandler creates new state object for local joins`() = runBlocking {
-        handler.processEvent(ircClient, ChannelJoined(User("acidburn", "libby", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("acidburn", "libby", "root.localhost"), "#thegibson"))
         assertTrue("#thegibson" in channelStateMap)
     }
 
     @Test
     fun `ChannelStateHandler does not create new state object for remote joins`() = runBlocking {
-        handler.processEvent(ircClient, ChannelJoined(User("zerocool", "dade", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#thegibson"))
         assertFalse("#thegibson" in channelStateMap)
     }
 
     fun `ChannelStateHandler adds joiners to channel state`() = runBlocking {
         channelStateMap += ChannelState("#thegibson") { CaseMapping.Rfc }
 
-        handler.processEvent(ircClient, ChannelJoined(User("zerocool", "dade", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#thegibson"))
 
         assertTrue("zerocool" in channelStateMap["#thegibson"]?.users!!)
     }
         channel.users += ChannelUser("thePlague")
         channelStateMap += channel
 
-        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("zeroCool")))
+        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("zeroCool")))
 
         assertEquals(1, channel.users.count())
         assertNotNull(channel.users["zeroCool"])
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
 
-        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("zeroCool")))
-        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("acidBurn")))
-        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("thePlague")))
+        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("zeroCool")))
+        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("acidBurn")))
+        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("thePlague")))
 
         assertEquals(3, channel.users.count())
         assertNotNull(channel.users["zeroCool"])
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
 
-        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("zeroCool")))
-        handler.processEvent(ircClient, ChannelNamesFinished("#thegibson"))
-        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("acidBurn")))
-        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("thePlague")))
+        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("zeroCool")))
+        handler.processEvent(ircClient, ChannelNamesFinished(TestConstants.time, "#thegibson"))
+        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("acidBurn")))
+        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("thePlague")))
 
         assertEquals(2, channel.users.count())
         assertNotNull(channel.users["acidBurn"])
         channelStateMap += channel
         serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
 
-        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("@zeroCool", "@+acidBurn", "+thePlague", "cerealKiller")))
-        handler.processEvent(ircClient, ChannelNamesFinished("#thegibson"))
+        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("@zeroCool", "@+acidBurn", "+thePlague", "cerealKiller")))
+        handler.processEvent(ircClient, ChannelNamesFinished(TestConstants.time, "#thegibson"))
 
         assertEquals(4, channel.users.count())
         assertEquals("o", channel.users["zeroCool"]?.modes)
         channelStateMap += channel
         serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
 
-        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("@zeroCool!dade@root.localhost", "+acidBurn!libby@root.localhost")))
-        handler.processEvent(ircClient, ChannelNamesFinished("#thegibson"))
+        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("@zeroCool!dade@root.localhost", "+acidBurn!libby@root.localhost")))
+        handler.processEvent(ircClient, ChannelNamesFinished(TestConstants.time, "#thegibson"))
 
         assertEquals(2, channel.users.count())
         assertEquals("o", channel.users["zeroCool"]?.modes)
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
 
-        handler.processEvent(ircClient, ChannelParted(User("acidburn", "libby", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("acidburn", "libby", "root.localhost"), "#thegibson"))
 
         assertFalse("#thegibson" in channelStateMap)
     }
         channel.users += ChannelUser("ZeroCool")
         channelStateMap += channel
 
-        handler.processEvent(ircClient, ChannelParted(User("zerocool", "dade", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#thegibson"))
 
         assertFalse("zerocool" in channel.users)
     }
             channelStateMap += this
         }
 
-        handler.processEvent(ircClient, UserQuit(User("zerocool", "dade", "root.localhost")))
+        handler.processEvent(ircClient, UserQuit(TestConstants.time, User("zerocool", "dade", "root.localhost")))
 
         assertFalse("zerocool" in channelStateMap["#thegibson"]!!.users)
         assertFalse("zerocool" in channelStateMap["#dumpsterdiving"]!!.users)

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

 package com.dmdirc.ktirc.events
 
 import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.TestConstants
 import com.nhaarman.mockitokotlin2.mock
 import com.nhaarman.mockitokotlin2.verify
 import kotlinx.coroutines.runBlocking
 
     @Test
     fun `PingHandler responses to pings with a pong`() = runBlocking {
-        handler.processEvent(ircClient, PingReceived("the_plague".toByteArray()))
+        handler.processEvent(ircClient, PingReceived(TestConstants.time, "the_plague".toByteArray()))
         verify(ircClient).send("PONG :the_plague")
     }
 

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

 package com.dmdirc.ktirc.events
 
 import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.ServerFeature
 import com.dmdirc.ktirc.model.ServerFeatureMap
 import com.dmdirc.ktirc.model.ServerState
 
     @Test
     fun `ServerStateHandler sets local nickname on welcome event`() = runBlocking {
-        handler.processEvent(ircClient, ServerWelcome("acidBurn"))
+        handler.processEvent(ircClient, ServerWelcome(TestConstants.time, "acidBurn"))
         assertEquals("acidBurn", serverState.localNickname)
     }
 
         features[ServerFeature.ChannelModes] = "abc"
         features[ServerFeature.WhoxSupport] = true
 
-        handler.processEvent(ircClient, ServerFeaturesUpdated(features))
+        handler.processEvent(ircClient, ServerFeaturesUpdated(TestConstants.time, features))
 
         assertEquals("abc", serverState.features[ServerFeature.ChannelModes])
         assertEquals(true, serverState.features[ServerFeature.WhoxSupport])

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

 package com.dmdirc.ktirc.io
 
 import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.events.EventHandler
 import com.dmdirc.ktirc.events.ServerConnected
 import com.dmdirc.ktirc.events.ServerWelcome
         val eventHandler2 = mock<EventHandler>()
         val handler = MessageHandler(listOf(joinProcessor, nickProcessor), mutableListOf(eventHandler1, eventHandler2))
         val joinMessage = IrcMessage(emptyMap(), null, "JOIN", emptyList())
-        whenever(joinProcessor.process(any())).thenReturn(listOf(ServerConnected, ServerWelcome("abc")))
+        whenever(joinProcessor.process(any())).thenReturn(listOf(ServerConnected(TestConstants.time), ServerWelcome(TestConstants.time, "abc")))
 
         with(Channel<IrcMessage>(1)) {
             send(joinMessage)
             handler.processMessages(ircClient, this)
         }
 
-        verify(eventHandler1).processEvent(ircClient, ServerConnected)
-        verify(eventHandler1).processEvent(ircClient, ServerWelcome("abc"))
-        verify(eventHandler2).processEvent(ircClient, ServerConnected)
-        verify(eventHandler2).processEvent(ircClient, ServerWelcome("abc"))
+        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>())
     }
 
 }

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

     }
 
     @Test
-    fun `Parses tags without values`() {
-        val parsed = MessageParser().parse("@time;account= :zeroCool!dade@root.localhost PRIVMSG #chat :Hack the planet!".toByteArray())
+    fun `Parses tag without values`() {
+        val parsed = MessageParser().parse("@account= :zeroCool!dade@root.localhost PRIVMSG #chat :Hack the planet!".toByteArray())
 
-        assertEquals(2, parsed.tags.size)
-        assertEquals("", parsed.tags[MessageTag.ServerTime])
+        assertEquals(1, parsed.tags.size)
         assertEquals("", parsed.tags[MessageTag.AccountName])
     }
 

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

 package com.dmdirc.ktirc.messages
 
-import com.dmdirc.ktirc.events.ChannelJoined
+import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 
 internal class JoinProcessorTest {
 
+    @BeforeEach
+    fun setUp() {
+        IrcMessage.currentTimeProvider = { TestConstants.time }
+    }
+
     @Test
     fun `JoinProcessor raises join event`() {
         val events = JoinProcessor().process(
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "JOIN", listOf("#crashandburn".toByteArray())))
         assertEquals(1, events.size)
-        assertEquals(ChannelJoined(User("acidburn", "libby", "root.localhost"), "#crashandburn"), events[0])
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
+        assertEquals("#crashandburn", events[0].channel)
     }
 
     @Test

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

 package com.dmdirc.ktirc.messages
 
-import com.dmdirc.ktirc.events.ChannelParted
+import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
-import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 
 internal class PartProcessorTest {
 
+    @BeforeEach
+    fun setUp() {
+        IrcMessage.currentTimeProvider = { TestConstants.time }
+    }
+
     @Test
     fun `PartProcessor raises part event without message`() {
         val events = PartProcessor().process(
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PART", listOf("#crashandburn".toByteArray())))
-        Assertions.assertEquals(1, events.size)
-        Assertions.assertEquals(ChannelParted(User("acidburn", "libby", "root.localhost"), "#crashandburn"), events[0])
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
+        assertEquals("#crashandburn", events[0].channel)
+        assertEquals("", events[0].reason)
     }
 
     @Test
     fun `PartProcessor raises part event with message`() {
         val events = PartProcessor().process(
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PART", listOf("#crashandburn".toByteArray(), "Hack the planet!".toByteArray())))
-        Assertions.assertEquals(1, events.size)
-        Assertions.assertEquals(ChannelParted(User("acidburn", "libby", "root.localhost"), "#crashandburn", "Hack the planet!"), events[0])
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
+        assertEquals("#crashandburn", events[0].channel)
+        assertEquals("Hack the planet!", events[0].reason)
     }
 
     @Test
     fun `PartProcessor does nothing if prefix missing`() {
         val events = JoinProcessor().process(
                 IrcMessage(emptyMap(), null, "PART", listOf("#crashandburn".toByteArray())))
-        Assertions.assertEquals(0, events.size)
+        assertEquals(0, events.size)
     }
 
 }

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

 package com.dmdirc.ktirc.messages
 
-import com.dmdirc.ktirc.events.MessageReceived
+import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
-import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 
 internal class PrivmsgProcessorTest {
 
+    @BeforeEach
+    fun setUp() {
+        IrcMessage.currentTimeProvider = { TestConstants.time }
+    }
+
     @Test
     fun `PrivsgProcessor raises message received event`() {
         val events = PrivmsgProcessor().process(
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "hack the planet!".toByteArray())))
-        Assertions.assertEquals(1, events.size)
-        Assertions.assertEquals(MessageReceived(User("acidburn", "libby", "root.localhost"), "#crashandburn", "hack the planet!"), events[0])
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
+        assertEquals("#crashandburn", events[0].target)
+        assertEquals("hack the planet!", events[0].message)
     }
 
     @Test
     fun `PrivsgProcessor does nothing if prefix missing`() {
         val events = PrivmsgProcessor().process(
                 IrcMessage(emptyMap(), null, "PRIVMSG", listOf("#crashandburn".toByteArray(), "hack the planet!".toByteArray())))
-        Assertions.assertEquals(0, events.size)
+        assertEquals(0, events.size)
     }
 }

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

 package com.dmdirc.ktirc.messages
 
-import com.dmdirc.ktirc.events.UserQuit
+import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
-import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 
 internal class QuitProcessorTest {
 
+    @BeforeEach
+    fun setUp() {
+        IrcMessage.currentTimeProvider = { TestConstants.time }
+    }
+
     @Test
     fun `QuitProcessor raises quit event without message`() {
         val events = QuitProcessor().process(
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "QUIT", emptyList()))
-        Assertions.assertEquals(1, events.size)
-        Assertions.assertEquals(UserQuit(User("acidburn", "libby", "root.localhost")), events[0])
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
+        assertEquals("", events[0].reason)
     }
 
     @Test
     fun `QuitProcessor raises quit event with message`() {
         val events = QuitProcessor().process(
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "QUIT", listOf("Hack the planet!".toByteArray())))
-        Assertions.assertEquals(1, events.size)
-        Assertions.assertEquals(UserQuit(User("acidburn", "libby", "root.localhost"), "Hack the planet!"), events[0])
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
+        assertEquals("Hack the planet!", events[0].reason)
     }
 
     @Test
     fun `QuitProcessor does nothing if prefix missing`() {
         val events = QuitProcessor().process(
                 IrcMessage(emptyMap(), null, "QUIT", listOf("Hack the planet!".toByteArray())))
-        Assertions.assertEquals(0, events.size)
+        assertEquals(0, events.size)
     }
 
 }

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

 package com.dmdirc.ktirc.messages
 
-import com.dmdirc.ktirc.events.IrcEvent
-import com.dmdirc.ktirc.events.ServerWelcome
+import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 
 internal class WelcomeProcessorTest {
 
     private val processor = WelcomeProcessor()
 
+    @BeforeEach
+    fun setUp() {
+        IrcMessage.currentTimeProvider = { TestConstants.time }
+    }
+
     @Test
     fun `WelcomeProcessor can handle 001s`() {
         assertTrue(processor.commands.contains("001")) { "WelcomeProcessor should handle 001 messages" }
         val events = processor.process(IrcMessage(emptyMap(), ":thegibson.com".toByteArray(), "001", listOf(
                 "acidBurn".toByteArray(),
                 "Welcome to the Internet Relay Network, acidBurn!burn@hacktheplanet.com".toByteArray())))
-        assertEquals(listOf<IrcEvent>(ServerWelcome("acidBurn")), events)
+        assertEquals(1, events.size)
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals("acidBurn", events[0].localNick)
     }
 
 }

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

+package com.dmdirc.ktirc.model
+
+import com.dmdirc.ktirc.TestConstants
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import java.time.LocalDateTime
+import java.time.ZoneId
+
+internal class IrcMessageTest {
+
+    @Test
+    fun `Gets UTC time from ServerTime tag if present`() {
+        IrcMessage.currentTimeZoneProvider = { ZoneId.of("Z") }
+        val message = IrcMessage(hashMapOf(MessageTag.ServerTime to "1995-09-15T09:00:00.0000Z"), null, "", emptyList())
+        assertEquals(LocalDateTime.parse("1995-09-15T09:00:00"), message.time)
+    }
+
+    @Test
+    fun `Converts time in ServerTime tag to local timezone`() {
+        IrcMessage.currentTimeZoneProvider = { ZoneId.of("America/New_York") }
+        val message = IrcMessage(hashMapOf(MessageTag.ServerTime to "1995-09-15T09:00:00.0000Z"), null, "", emptyList())
+        assertEquals(LocalDateTime.parse("1995-09-15T05:00:00"), message.time)
+    }
+
+    @Test
+    fun `Uses current local time if no tag present`() {
+        IrcMessage.currentTimeProvider = { TestConstants.time }
+        val message = IrcMessage(emptyMap(), null, "", emptyList())
+        assertEquals(LocalDateTime.parse("1995-09-15T09:00:00"), message.time)
+    }
+
+}