Add some more test cases and bugfixes to queuing

- Make `to` parameter optional in remove range command

music/build.gradle.kts

@@ -1,3 +1,3 @@
 subprojects {
-    version = "3.5.11-SNAPSHOT"
+    version = "3.5.12-SNAPSHOT"
 }

music/commands/src/main/kotlin/dev/schlaubi/mikmusic/commands/RemoveCommand.kt

@@ -6,6 +6,7 @@ import com.kotlindiscord.kord.extensions.commands.application.slash.EphemeralSla
 import com.kotlindiscord.kord.extensions.commands.application.slash.EphemeralSlashCommandContext
 import com.kotlindiscord.kord.extensions.commands.application.slash.ephemeralSubCommand
 import com.kotlindiscord.kord.extensions.commands.converters.impl.int
+import com.kotlindiscord.kord.extensions.commands.converters.impl.optionalInt
 import dev.kord.common.entity.Snowflake
 import dev.schlaubi.mikbot.plugin.api.util.safeGuild
 import dev.schlaubi.mikmusic.core.MusicModule
@@ -25,7 +26,7 @@ class RemoveRangeSongArguments : Arguments() {
         name = "from"
         description = "commands.remove.arguments.from.description"
     }
-    val to by int {
+    val to by optionalInt {
         name = "to"
         description = "commands.remove.arguments.to.description"
     }
@@ -76,10 +77,11 @@ suspend fun MusicModule.removeCommand() = ephemeralControlSlashCommand {
         description = "commands.remove.range.description"
 
         doRemove {
-            if (arguments.to < arguments.from) {
+            val to = arguments.to ?: arguments.from
+            if (to < arguments.from) {
                 throw DiscordRelayedException(translate("commands.remove.range.invalid_range_end"))
             }
-            val range = arguments.from..arguments.to
+            val range = arguments.from..to
 
             musicPlayer.queue.removeQueueEntries(range)
         }

music/player/src/main/kotlin/dev/schlaubi/mikmusic/player/Queue.kt

@@ -58,11 +58,11 @@ class Queue(private var tracksList: MutableList<QueuedTrack> = mutableListOf())
         val song = tracksList.getOrNull(fromIndex) ?: return null
         if (swap) {
             val toValue = tracksList.getOrNull(toIndex) ?: return null
-            tracksList[to] = song
-            tracksList[from] = toValue
+            tracksList[toIndex] = song
+            tracksList[fromIndex] = toValue
         } else {
-            tracksList.add(to, song)
-            tracksList.removeAt(from)
+            tracksList.add(toIndex, song)
+            tracksList.removeAt(fromIndex)
         }
 
         return song.track
@@ -72,16 +72,18 @@ class Queue(private var tracksList: MutableList<QueuedTrack> = mutableListOf())
         val trackIndex = runCatching {
             order.removeAt(index)
         }.getOrNull() ?: return null
+        if (trackIndex <= nextIndex) nextIndex--
         return tracksList[trackIndex].track
     }
 
     fun removeQueueEntries(range: IntRange): Int {
         val queueSize = order.size
         if (range.first >= 0 && range.last <= order.size) {
             val before = order.subList(0, range.first - 1) // inclusive
-            val after = order.subList(range.last, queueSize)
+            val after = order.subList(range.last + 1, queueSize) // inclusive
             val combined = before + after
             order = LinkedList(combined)
+            if (range.last <= nextIndex) nextIndex -= range.count() + 1
         }
 
         return queueSize - order.size

music/player/src/test/kotlin/QueueTest.kt

@@ -74,17 +74,88 @@ class QueueTest {
         queue.shuffle = false
         assertEquals(newTracks + tracks, queue.tracks)
     }
+
+    @Test
+    fun `test removal of tracks`() {
+        val queue = makeMockQueue()
+        val tracks = queue.tracks.toList()
+
+        queue.removeQueueEntry(5)
+        assertEquals(tracks.filterIndexed { index, _ -> index != 5 }, queue.tracks, "Track was not removed")
+
+        val track = mockTrack(11)
+        queue.addTracks(track)
+        repeat(queue.tracks.size - 1) { queue.poll() }
+        assertEquals(track, queue.poll())
+    }
+
+    @Test
+    fun `test removal of tracks in range`() {
+        val queue = makeMockQueue()
+        val tracks = queue.tracks.toList()
+
+        queue.removeQueueEntries(5..8)
+        // removeQueueEntries is inclusive
+        assertEquals(tracks.filterIndexed { index, _ -> index !in 4..8 }, queue.tracks, "Track was not removed")
+
+        val track = mockTrack(11)
+        queue.addTracks(track)
+        repeat(queue.tracks.size - 1) { queue.poll() }
+        assertEquals(track, queue.poll())
+    }
+
+    @Test
+    fun `test swap of tracks`() {
+        val queue = makeMockQueue()
+        val tracks = queue.tracks.toList()
+
+        queue.moveQueuedEntry(5, 7, swap = true)
+        assertEquals(tracks[7], queue.tracks[5])
+        assertEquals(tracks[5], queue.tracks[7])
+    }
+
+    @Test
+    fun `test move of tracks`() {
+        val queue = makeMockQueue()
+        val tracks = queue.tracks.toList()
+
+        queue.moveQueuedEntry(5, 7, swap = false)
+        assertEquals(tracks[5], queue.tracks[6])
+    }
+
+    @Test
+    fun `test swap of tracks in shuffle`() {
+        val queue = makeMockQueue()
+        queue.shuffle = true
+        queue.addTracks(MutableList(10) { mockTrack(it + 11) })
+        val tracks = queue.tracks.toList()
+
+        queue.moveQueuedEntry(5, 7, swap = true)
+        assertEquals(tracks[7], queue.tracks[5])
+        assertEquals(tracks[5], queue.tracks[7])
+    }
+
+    @Test
+    fun `test move of tracks in shuffle`() {
+        val queue = makeMockQueue()
+        queue.shuffle = true
+        queue.addTracks(MutableList(10) { mockTrack(it + 11) })
+        val tracks = queue.tracks.toList()
+
+        queue.moveQueuedEntry(5, 7, swap = false)
+        assertEquals(tracks[5], queue.tracks[6])
+    }
 }
 
 private fun makeMockQueue() = Queue(MutableList(10, ::mockTrack))
 
-private fun mockTrack(num: Int): SimpleQueuedTrack {
+private fun mockTrack(num: Int, author: Snowflake = Snowflake.min): SimpleQueuedTrack {
     val track = Track(
         "$num",
         TrackInfo("", false, "", 0, false, 0, "$num", null, "", null, null),
         emptyJsonObject(),
         emptyJsonObject()
     )
 
-    return SimpleQueuedTrack(track, Snowflake.min)
+    return SimpleQueuedTrack(track, author)
 }