Add user parameter to mode changed event

CHANGELOG

  * Added ChannelJoinFailed event
  * Added ChannelMembershipAdjustment interface for events that concern
    users joining/leaving channels
+ * Added missing user parameter to ModeChangedEvent
 
 v0.10.3
 

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

  * and the given modes are thus exhaustive. Otherwise, the modes are a sequence of changes to apply to the existing
  * state.
  */
-class ModeChanged(metadata: EventMetadata, target: String, val modes: String, val arguments: Array<String>, val discovered: Boolean = false) : TargetedEvent(metadata, target)
+class ModeChanged(metadata: EventMetadata, override val user: User, target: String, val modes: String, val arguments: Array<String>, val discovered: Boolean = false)
+    : TargetedEvent(metadata, target), SourcedEvent
 
 /** Raised when an AUTHENTICATION message is received. [argument] is `null` if the server sent an empty reply ("+") */
 class AuthenticationMessage(metadata: EventMetadata, val argument: String?) : IrcEvent(metadata)

src/main/kotlin/com/dmdirc/ktirc/messages/processors/ModeProcessor.kt

 import com.dmdirc.ktirc.messages.RPL_CHANNELMODEIS
 import com.dmdirc.ktirc.messages.RPL_UMODEIS
 import com.dmdirc.ktirc.model.IrcMessage
+import com.dmdirc.ktirc.model.User
 import com.dmdirc.ktirc.util.logger
 
 internal class ModeProcessor : MessageProcessor {
 
         return listOf(ModeChanged(
                 message.metadata,
+                user = message.sourceUser ?: User("*"),
                 target = String(message.params[paramOffset]),
                 modes = String(message.params[paramOffset + 1]),
                 arguments = message.params.takeLast(message.params.size - paramOffset - 2).map { String(it) }.toTypedArray(),

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

         fakeChannelState += channel
         fakeServerState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
 
-        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+", emptyArray(), true))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), User("acidBurn"), "#thegibson", "+", emptyArray(), true))
 
         assertTrue(channel.modesDiscovered)
     }
         fakeChannelState += channel
         fakeServerState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
 
-        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+ceg", arrayOf("CCC", "EEE"), true))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), User("acidBurn"), "#thegibson", "+ceg", arrayOf("CCC", "EEE"), true))
 
         assertEquals("CCC", channel.modes['c'])
         assertEquals("EEE", channel.modes['e'])
         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))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), User("acidBurn"), "#thegibson", "-c+d-eh+fg", arrayOf("CCC", "DDD", "FFF"), true))
 
         assertNull(channel.modes['c'])
         assertEquals("DDD", channel.modes['d'])
             fakeChannelState += this
         }
 
-        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+o", arrayOf("zeroCool")))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), User("acidBurn"), "#thegibson", "+o", arrayOf("zeroCool")))
 
         assertEquals("o", fakeChannelState["#thegibson"]?.users?.get("zeroCool")?.modes)
     }
             fakeChannelState += this
         }
 
-        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+v", arrayOf("zeroCool")))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), User("acidBurn"), "#thegibson", "+v", arrayOf("zeroCool")))
 
         assertEquals("ov", fakeChannelState["#thegibson"]?.users?.get("zeroCool")?.modes)
     }
             fakeChannelState += this
         }
 
-        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+o", arrayOf("zeroCool")))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), User("acidBurn"), "#thegibson", "+o", arrayOf("zeroCool")))
 
         assertEquals("ov", fakeChannelState["#thegibson"]?.users?.get("zeroCool")?.modes)
     }
             fakeChannelState += this
         }
 
-        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+vo", arrayOf("zeroCool", "zeroCool")))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), User("acidBurn"), "#thegibson", "+vo", arrayOf("zeroCool", "zeroCool")))
 
         assertEquals("ov", fakeChannelState["#thegibson"]?.users?.get("zeroCool")?.modes)
     }
             fakeChannelState += this
         }
 
-        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "-vo", arrayOf("zeroCool", "zeroCool")))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), User("acidBurn"), "#thegibson", "-vo", arrayOf("zeroCool", "zeroCool")))
 
         assertEquals("", fakeChannelState["#thegibson"]?.users?.get("zeroCool")?.modes)
     }
         }
         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")))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), User("acidBurn"), "#thegibson", "oa-v+b", arrayOf("zeroCool", "aaa", "zeroCool", "bbb")))
 
         assertEquals("o", fakeChannelState["#thegibson"]?.users?.get("zeroCool")?.modes)
         assertEquals("aaa", fakeChannelState["#thegibson"]?.modes?.get('a'))

src/test/kotlin/com/dmdirc/ktirc/messages/processors/ModeProcessorTest.kt

 
 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
+import com.dmdirc.ktirc.model.User
 import com.dmdirc.ktirc.params
 import com.dmdirc.ktirc.util.currentTimeProvider
 import org.junit.jupiter.api.Assertions.*
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].metadata.time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals("acidBurn", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(0, events[0].arguments.size)
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].metadata.time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals("acidBurn", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(2, events[0].arguments.size)
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].metadata.time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals("acidBurn", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(0, events[0].arguments.size)
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].metadata.time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals("acidBurn", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(2, events[0].arguments.size)
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].metadata.time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
+        assertEquals("#thegibson", events[0].target)
+        assertEquals("+hax", events[0].modes)
+        assertEquals(0, events[0].arguments.size)
+        assertTrue(events[0].discovered)
+    }
+
+    @Test
+    fun `raises event for channel mode discovery with no params and no prefix`() {
+        val events = ModeProcessor().process(
+                IrcMessage(emptyMap(), null, "324", params("acidBurn", "#thegibson", "+hax")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].metadata.time)
+        assertEquals(User("*"), events[0].user)
         assertEquals("#thegibson", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(0, events[0].arguments.size)
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].metadata.time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals("#thegibson", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(2, events[0].arguments.size)
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].metadata.time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals("#thegibson", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(0, events[0].arguments.size)
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].metadata.time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals("#thegibson", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(2, events[0].arguments.size)