feat: update dependencies and add extensive test coverage

- Upgraded Spring Boot, Ktor, and Kotlin Wrappers dependencies to newer versions for improved stability and features.
- Introduced comprehensive unit tests for `ServerAddress`, `FairPriorityQueue`, `QueueTimeoutService`, and `FastFairPriorityQueue`.
- Added `HelpCommand` implementation for better command-line usage guidance.
- Refactored standalone build script to streamline library handling and remove outdated comments/code.

Author: twisti-dev

build.gradle.kts

@@ -40,7 +40,7 @@ allprojects {
 
         implementation(platform(project(":surf-cloud-bom")))
 
-        compileOnly("org.springframework.boot:spring-boot-configuration-processor:3.5.4")
+        compileOnly("org.springframework.boot:spring-boot-configuration-processor:3.5.6")
         //    "kapt"("org.springframework.boot:spring-boot-configuration-processor:3.4.3")
 
         testImplementation(kotlin("test"))

buildSrc/src/main/kotlin/core-convention.gradle.kts

@@ -12,11 +12,11 @@ repositories {
 }
 
 dependencies {
-    implementation(platform("org.springframework.boot:spring-boot-dependencies:3.5.4"))
-    implementation(platform("io.ktor:ktor-bom:3.2.1"))
-    implementation(platform("org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom:2025.7.8"))
+    implementation(platform("org.springframework.boot:spring-boot-dependencies:3.5.6"))
+    implementation(platform("io.ktor:ktor-bom:3.3.0"))
+    implementation(platform("org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom:2025.9.8"))
 
 
-    compileOnly("org.springframework.boot:spring-boot-configuration-processor:3.5.3")
+    compileOnly("org.springframework.boot:spring-boot-configuration-processor:3.5.6")
 //    "kapt"("org.springframework.boot:spring-boot-configuration-processor:3.4.3")
 }

surf-cloud-bom/build.gradle.kts

@@ -10,9 +10,9 @@ javaPlatform {
 }
 
 dependencies {
-    api(platform("org.springframework.boot:spring-boot-dependencies:3.5.4"))
-    api(platform("io.ktor:ktor-bom:3.2.3"))
-    api(platform("org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom:2025.8.10"))
+    api(platform("org.springframework.boot:spring-boot-dependencies:3.5.6"))
+    api(platform("io.ktor:ktor-bom:3.3.0"))
+    api(platform("org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom:2025.9.8"))
 }
 
 configurations.all {

surf-cloud-core/surf-cloud-core-common/src/test/kotlin/dev/slne/surf/cloud/core/common/util/ServerAddressTest.kt

@@ -0,0 +1,62 @@
+package dev.slne.surf.cloud.core.common.util
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertThrows
+import org.junit.jupiter.api.Test
+import java.net.InetSocketAddress
+
+class ServerAddressTest {
+
+    @Test
+    fun `parses host and port from string`() {
+        val serverAddress = "example.com:1234".toServerAddress()
+
+        assertEquals("example.com", serverAddress.host)
+        assertEquals(1234, serverAddress.port)
+    }
+
+    @Test
+    fun `uses default port when not provided`() {
+        val serverAddress = "example.com".toServerAddress()
+
+        assertEquals("example.com", serverAddress.host)
+        assertEquals(25566, serverAddress.port)
+    }
+
+    @Test
+    fun `converts unicode host to ascii`() {
+        val serverAddress = "☃.com:4040".toServerAddress()
+
+        assertEquals("xn--n3h.com", serverAddress.host)
+        assertEquals(4040, serverAddress.port)
+    }
+
+    @Test
+    fun `throws when parsing invalid server address`() {
+        val exception = assertThrows(IllegalArgumentException::class.java) {
+            "invalid-port:abc".toServerAddress()
+        }
+
+        assertEquals("Invalid server address: invalid-port:abc", exception.message)
+    }
+
+    @Test
+    fun `host falls back to empty string when ascii conversion fails`() {
+        val host = "a".repeat(64)
+        val serverAddress = ServerAddress(host, 25565)
+
+        assertEquals("", serverAddress.host)
+        assertEquals(25565, serverAddress.port)
+    }
+
+    @Test
+    fun `creates InetSocketAddress`() {
+        val serverAddress = "example.net:1337".toServerAddress()
+
+        val socketAddress = InetSocketAddress(serverAddress)
+
+        assertEquals("example.net", socketAddress.hostString)
+        assertEquals(1337, socketAddress.port)
+        assertEquals(InetSocketAddress("example.net", 1337), socketAddress)
+    }
+}

surf-cloud-standalone/build.gradle.kts

@@ -21,18 +21,15 @@ val sanitizeLibs by tasks.registering {
         outDir.mkdirs()
 
         fileTree("libs").matching { include("*.jar") }.files.forEach { inJar ->
-            // Nur dann neu packen, wenn das JAR den Provider wirklich enthält
             val hasProvider = ZipFile(inJar).use { zf ->
                 zf.getEntry("META-INF/services/org.slf4j.spi.SLF4JServiceProvider") != null ||
                         zf.getEntry("org/slf4j/simple/SimpleServiceProvider.class") != null
             }
 
             val dest = outDir.resolve(inJar.name)
             if (!hasProvider) {
-                // unverändert kopieren
                 inJar.copyTo(dest, overwrite = true)
             } else {
-                // entpacken -> problematische Einträge ausschließen -> wieder zippen
                 val tmp = layout.buildDirectory.dir("tmp/sanitize/${inJar.nameWithoutExtension}").get().asFile
                 tmp.deleteRecursively(); tmp.mkdirs()
 
@@ -74,14 +71,19 @@ dependencies {
     }
 
 //    implementation(fileTree("libs/**/*.jar")) // Include all JARs in libs directory
-    implementation(fileTree(sanitizedLibsDir) { include("*.jar") })
+//    implementation(fileTree(sanitizedLibsDir) { include("*.jar") })
+    implementation(fileTree(sanitizedLibsDir) { include("*.jar") }.builtBy(sanitizeLibs))
 }
 
 tasks {
-    assemble {
-        dependsOn(sanitizeLibs)
-        inputs.files(sanitizeLibs)
-    }
+//    assemble {
+//        dependsOn(sanitizeLibs)
+//        inputs.files(sanitizeLibs)
+//    }
+//
+//    build {
+//        dependsOn(sanitizeLibs)
+//    }
 
     bootJar {
         mainClass.set("dev.slne.surf.cloud.standalone.Bootstrap")

surf-cloud-standalone/src/main/kotlin/dev/slne/surf/cloud/standalone/commands/impl/HelpCommand.kt

@@ -0,0 +1,47 @@
+package dev.slne.surf.cloud.standalone.commands.impl
+
+import com.mojang.brigadier.Command
+import com.mojang.brigadier.CommandDispatcher
+import dev.slne.surf.cloud.api.server.command.AbstractConsoleCommand
+import dev.slne.surf.cloud.api.server.command.CommandSource
+import dev.slne.surf.cloud.api.server.command.ConsoleCommand
+import dev.slne.surf.cloud.api.server.command.literal
+import dev.slne.surf.surfapi.core.api.messages.adventure.buildText
+import net.kyori.adventure.text.Component
+import net.kyori.adventure.text.JoinConfiguration
+
+@ConsoleCommand
+class HelpCommand : AbstractConsoleCommand() {
+    override fun register(dispatcher: CommandDispatcher<CommandSource>) {
+        dispatcher.register(literal("help") {
+            executes { ctx ->
+                val smartUsage = dispatcher.getSmartUsage(dispatcher.root, ctx.source)
+
+                val message = buildText {
+                    info("Available commands:")
+                    appendNewline()
+                    append(
+                        Component.join(
+                            JoinConfiguration.newlines(),
+                            smartUsage.values.map { usage ->
+                                buildText {
+                                    val commandParts = usage.split(" ")
+                                    val commandKey = commandParts[0]
+                                    val arguments = commandParts.drop(1).joinToString(" ")
+
+                                    variableKey(commandKey)
+                                    appendSpace()
+                                    spacer(arguments)
+                                }
+                            }
+                        )
+                    )
+                }
+
+                ctx.source.sendMessage(message)
+
+                Command.SINGLE_SUCCESS
+            }
+        })
+    }
+}

surf-cloud-standalone/src/test/java/dev/slne/surf/cloud/api/common/util/queue/FairPriorityQueueTest.kt

@@ -0,0 +1,58 @@
+package dev.slne.surf.cloud.api.common.util.queue
+
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+
+class FairPriorityQueueTest {
+    @Test
+    fun `fifo order is preserved when priorities match`() {
+        val queue = FairPriorityQueue<Int> { _, _ -> 0 }
+        queue.offer(1)
+        queue.offer(2)
+        queue.offer(3)
+
+        val order = listOf(queue.poll(), queue.poll(), queue.poll())
+
+        assertEquals(listOf(1, 2, 3), order)
+        assertNull(queue.poll())
+    }
+
+
+    @Test
+    fun `addFirst inserts element before others`() {
+        val queue = FairPriorityQueue<Int>(Comparator.naturalOrder())
+        queue.offer(5)
+        queue.offer(10)
+
+        queue.addFirst(1)
+
+        assertEquals(listOf(1, 5, 10), queue.snapshot().toList())
+        assertEquals(3, queue.size)
+    }
+
+    @Test
+    fun `offer null does not modify queue`() {
+        val queue = FairPriorityQueue<Int>(Comparator.naturalOrder())
+
+        assertFalse(queue.offer(null))
+        assertEquals(0, queue.size)
+        assertNull(queue.peek())
+    }
+
+    @Test
+    fun `iterator removal updates backing storage`() {
+        val queue = FairPriorityQueue<Int>(Comparator.naturalOrder())
+        queue.offer(3)
+        queue.offer(1)
+        queue.offer(2)
+
+        val iterator = queue.iterator()
+        assertTrue(iterator.hasNext())
+        assertEquals(1, iterator.next())
+
+        iterator.remove()
+
+        assertEquals(listOf(2, 3), queue.snapshot().toList())
+        assertEquals(2, queue.size)
+    }
+}

surf-cloud-standalone/src/test/java/dev/slne/surf/cloud/api/common/util/queue/FastFairPriorityQueueTest.kt

@@ -1,6 +1,6 @@
 package dev.slne.surf.cloud.api.common.util.queue
 
-import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
 class FastFairPriorityQueueTest {
@@ -41,4 +41,52 @@ class FastFairPriorityQueueTest {
         assertEquals(listOf(1, 2, 3), queue.snapshot().toList())
     }
 
+    @Test
+    fun `offer null is ignored`() {
+        val queue = FastFairPriorityQueue<Int>(Comparator.naturalOrder())
+
+        assertFalse(queue.offer(null))
+        assertEquals(0, queue.size)
+        assertNull(queue.peek())
+    }
+
+    @Test
+    fun `poll on empty queue returns null`() {
+        val queue = FastFairPriorityQueue<Int>(Comparator.naturalOrder())
+
+        assertNull(queue.poll())
+        assertEquals(0, queue.size)
+    }
+
+    @Test
+    fun `peek does not remove element`() {
+        val queue = FastFairPriorityQueue<Int>(Comparator.naturalOrder())
+        queue.offer(4)
+        queue.offer(2)
+
+        val peeked = queue.peek()
+
+        assertEquals(2, peeked)
+        assertEquals(2, queue.size)
+        assertEquals(2, queue.poll())
+    }
+
+    @Test
+    fun `iterator provides snapshot view`() {
+        val queue = FastFairPriorityQueue<Int>(Comparator.naturalOrder())
+        queue.offer(5)
+        queue.offer(1)
+
+        val iterator = queue.iterator()
+
+        queue.offer(3)
+
+        val iterated = mutableListOf<Int>()
+        while (iterator.hasNext()) {
+            iterated += iterator.next()
+        }
+
+        assertEquals(listOf(1, 5), iterated)
+        assertEquals(listOf(1, 3, 5), queue.snapshot().toList())
+    }
 }