diff options
16 files changed, 1973 insertions, 111 deletions
diff --git a/.github/scripts/post-test-results.sh b/.github/scripts/post-test-results.sh deleted file mode 100755 index f8fbdf2..0000000 --- a/.github/scripts/post-test-results.sh +++ /dev/null @@ -1,101 +0,0 @@ -#!/bin/bash -set -e - -MARKER="<!-- test-results-comment -->" - -TOTAL_TESTS=0 -PASSED_TESTS=0 -FAILED_TESTS=0 -SKIPPED_TESTS=0 -FAILED_TEST_NAMES="" - -for xml_file in */build/test-results/test/*.xml; do - if [ -f "$xml_file" ]; then - tests=$(sed -n 's/.*tests="\([0-9]*\)".*/\1/p' "$xml_file" | head -n1) - failures=$(sed -n 's/.*failures="\([0-9]*\)".*/\1/p' "$xml_file" | head -n1) - skipped=$(sed -n 's/.*skipped="\([0-9]*\)".*/\1/p' "$xml_file" | head -n1) - - tests=${tests:-0} - failures=${failures:-0} - skipped=${skipped:-0} - - TOTAL_TESTS=$((TOTAL_TESTS + tests)) - FAILED_TESTS=$((FAILED_TESTS + failures)) - SKIPPED_TESTS=$((SKIPPED_TESTS + skipped)) - - if [ "$failures" -gt 0 ]; then - failed_names=$(sed -n 's/.*<testcase name="\([^"]*\)".*<failure.*/\1/p' "$xml_file" || echo "") - if [ -n "$failed_names" ]; then - FAILED_TEST_NAMES="${FAILED_TEST_NAMES}${failed_names}\n" - fi - fi - fi -done - -PASSED_TESTS=$((TOTAL_TESTS - FAILED_TESTS - SKIPPED_TESTS)) - -if [ "$FAILED_TESTS" -gt 0 ]; then - STATUS="❌ Failed" - STATUS_EMOJI="❌" -else - STATUS="✅ Passed" - STATUS_EMOJI="✅" -fi - -COMMENT_BODY="${MARKER} -## ${STATUS_EMOJI} Test Results - -| Status | Count | -|--------|-------| -| ✅ Passed | ${PASSED_TESTS} | -| ❌ Failed | ${FAILED_TESTS} | -| ⏭️ Skipped | ${SKIPPED_TESTS} | -| **Total** | **${TOTAL_TESTS}** | - -**Overall Status:** ${STATUS} -" - -if [ "$FAILED_TESTS" -gt 0 ] && [ -n "$FAILED_TEST_NAMES" ]; then - COMMENT_BODY="${COMMENT_BODY} - -<details> -<summary>❌ Failed Tests</summary> - -$(echo -e "$FAILED_TEST_NAMES" | sed 's/^/- /') - -</details> -" -fi - -COMMENT_BODY="${COMMENT_BODY} - ---- -*Updated at $(date -u '+%Y-%m-%d %H:%M:%S UTC')*" - -echo "$COMMENT_BODY" > /tmp/test-comment.md - -PR_NUMBER="${GITHUB_REF#refs/pull/}" -PR_NUMBER="${PR_NUMBER%/merge}" - -if [ -z "$PR_NUMBER" ] || [ "$PR_NUMBER" = "$GITHUB_REF" ]; then - echo "Not a pull request, skipping comment" - exit 0 -fi - -EXISTING_COMMENT_ID=$(gh api \ - "repos/$GITHUB_REPOSITORY/issues/${PR_NUMBER}/comments" \ - --jq ".[] | select(.body | contains(\"$MARKER\")) | .id" \ - | head -n 1 || echo "") - -if [ -n "$EXISTING_COMMENT_ID" ]; then - echo "Updating existing comment (ID: $EXISTING_COMMENT_ID)" - gh api \ - "repos/$GITHUB_REPOSITORY/issues/comments/${EXISTING_COMMENT_ID}" \ - -X PATCH \ - -f body="$(cat /tmp/test-comment.md)" -else - echo "Creating new comment" - gh pr comment "$PR_NUMBER" --body-file /tmp/test-comment.md -fi - -echo "Test results comment posted successfully" diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index 2f3a9e8..7ab33b6 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -29,16 +29,18 @@ jobs: run: ./gradlew ktlintCheck --no-daemon - name: Run tests - run: ./gradlew test --no-daemon - continue-on-error: true - - - name: Post test results to PR - if: github.event_name == 'pull_request' && always() - env: - GH_TOKEN: ${{ github.token }} - GITHUB_REPOSITORY: ${{ github.repository }} - GITHUB_REF: ${{ github.ref }} - run: .github/scripts/post-test-results.sh + run: ./gradlew test jacocoTestReport --no-daemon + + - name: Upload coverage to Codecov + if: always() + uses: codecov/codecov-action@v5 + with: + token: ${{ secrets.CODECOV_TOKEN }} + files: | + engine/build/reports/jacoco/test/jacocoTestReport.xml, + platform-paper/build/reports/jacoco/test/jacocoTestReport.xml, + platform-velocity/build/reports/jacoco/test/jacocoTestReport.xml + fail_ci_if_error: false - name: Build with shadowJar run: ./gradlew :platform-paper:shadowJar :platform-velocity:shadowJar --parallel --no-daemon diff --git a/build.gradle.kts b/build.gradle.kts index 36906c9..d2bd265 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1,3 +1,4 @@ +import org.gradle.testing.jacoco.tasks.JacocoReport import org.jetbrains.dokka.gradle.DokkaExtension import org.jetbrains.kotlin.gradle.dsl.JvmTarget import org.jetbrains.kotlin.gradle.tasks.KotlinCompile @@ -27,6 +28,7 @@ subprojects { apply(plugin = "org.jetbrains.kotlin.jvm") apply(plugin = "org.jlleitschuh.gradle.ktlint") apply(plugin = "org.jetbrains.dokka") + apply(plugin = "jacoco") tasks.withType<KotlinCompile> { compilerOptions { @@ -36,6 +38,15 @@ subprojects { tasks.withType<Test> { useJUnitPlatform() + finalizedBy(tasks.named("jacocoTestReport")) + } + + tasks.withType<JacocoReport> { + dependsOn(tasks.withType<Test>()) + reports { + xml.required.set(true) + html.required.set(false) + } } configure<DokkaExtension> { diff --git a/codecov.yml b/codecov.yml new file mode 100644 index 0000000..dcf139a --- /dev/null +++ b/codecov.yml @@ -0,0 +1,15 @@ +coverage: + status: + project: + default: + target: auto + threshold: 1% + patch: + default: + target: 80% +comment: + layout: "condensed_header, condensed_files, condensed_footer" + behavior: default + require_changes: false +ignore: + - "dokka/**" diff --git a/engine/build.gradle.kts b/engine/build.gradle.kts index c178870..0f4e419 100644 --- a/engine/build.gradle.kts +++ b/engine/build.gradle.kts @@ -12,4 +12,6 @@ dependencies { // Adventure API (provided by platform implementations) compileOnly("net.kyori:adventure-api:4.26.1") + + testImplementation("net.kyori:adventure-api:4.26.1") } diff --git a/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/chat/ChatModeTest.kt b/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/chat/ChatModeTest.kt new file mode 100644 index 0000000..5656a14 --- /dev/null +++ b/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/chat/ChatModeTest.kt @@ -0,0 +1,33 @@ +package dev.m1sk9.lunaticChat.engine.chat + +import kotlin.test.Test +import kotlin.test.assertEquals + +class ChatModeTest { + @Test + fun `toggle should switch GLOBAL to CHANNEL`() { + assertEquals(ChatMode.CHANNEL, ChatMode.GLOBAL.toggle()) + } + + @Test + fun `toggle should switch CHANNEL to GLOBAL`() { + assertEquals(ChatMode.GLOBAL, ChatMode.CHANNEL.toggle()) + } + + @Test + fun `DEFAULT should be GLOBAL`() { + assertEquals(ChatMode.GLOBAL, ChatMode.DEFAULT) + } + + @Test + fun `double toggle should return original mode`() { + assertEquals(ChatMode.GLOBAL, ChatMode.GLOBAL.toggle().toggle()) + assertEquals(ChatMode.CHANNEL, ChatMode.CHANNEL.toggle().toggle()) + } + + @Test + fun `enum should have exactly two values`() { + assertEquals(2, ChatMode.entries.size) + assertEquals(setOf(ChatMode.GLOBAL, ChatMode.CHANNEL), ChatMode.entries.toSet()) + } +} diff --git a/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/chat/channel/ChannelTest.kt b/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/chat/channel/ChannelTest.kt new file mode 100644 index 0000000..b24e169 --- /dev/null +++ b/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/chat/channel/ChannelTest.kt @@ -0,0 +1,139 @@ +package dev.m1sk9.lunaticChat.engine.chat.channel + +import kotlinx.serialization.json.Json +import java.util.UUID +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith +import kotlin.test.assertFalse +import kotlin.test.assertNull +import kotlin.test.assertTrue + +class ChannelTest { + private val testOwnerId = UUID.fromString("00000001-0000-0000-0000-000000000000") + private val json = Json { ignoreUnknownKeys = true } + + @Test + fun `valid channel ID should be accepted`() { + val channel = Channel(id = "test-channel", name = "Test", ownerId = testOwnerId) + assertEquals("test-channel", channel.id) + } + + @Test + fun `channel ID with underscores and hyphens should be accepted`() { + val channel = Channel(id = "my_test-channel", name = "Test", ownerId = testOwnerId) + assertEquals("my_test-channel", channel.id) + } + + @Test + fun `channel ID with exactly 3 characters should be accepted`() { + val channel = Channel(id = "abc", name = "Test", ownerId = testOwnerId) + assertEquals("abc", channel.id) + } + + @Test + fun `channel ID with exactly 30 characters should be accepted`() { + val id = "a".repeat(30) + val channel = Channel(id = id, name = "Test", ownerId = testOwnerId) + assertEquals(id, channel.id) + } + + @Test + fun `channel ID with less than 3 characters should be rejected`() { + assertFailsWith<IllegalArgumentException> { + Channel(id = "ab", name = "Test", ownerId = testOwnerId) + } + } + + @Test + fun `channel ID with more than 30 characters should be rejected`() { + assertFailsWith<IllegalArgumentException> { + Channel(id = "a".repeat(31), name = "Test", ownerId = testOwnerId) + } + } + + @Test + fun `channel ID with spaces should be rejected`() { + assertFailsWith<IllegalArgumentException> { + Channel(id = "test channel", name = "Test", ownerId = testOwnerId) + } + } + + @Test + fun `channel ID with special characters should be rejected`() { + assertFailsWith<IllegalArgumentException> { + Channel(id = "test@channel", name = "Test", ownerId = testOwnerId) + } + } + + @Test + fun `empty channel ID should be rejected`() { + assertFailsWith<IllegalArgumentException> { + Channel(id = "", name = "Test", ownerId = testOwnerId) + } + } + + @Test + fun `blank channel name should be rejected`() { + assertFailsWith<IllegalArgumentException> { + Channel(id = "valid-id", name = " ", ownerId = testOwnerId) + } + } + + @Test + fun `empty channel name should be rejected`() { + assertFailsWith<IllegalArgumentException> { + Channel(id = "valid-id", name = "", ownerId = testOwnerId) + } + } + + @Test + fun `default values should be correct`() { + val channel = Channel(id = "test-ch", name = "Test Channel", ownerId = testOwnerId) + assertNull(channel.description) + assertFalse(channel.isPrivate) + assertTrue(channel.bannedPlayers.isEmpty()) + } + + @Test + fun `serialization round-trip should preserve all fields`() { + val bannedPlayer = UUID.fromString("00000002-0000-0000-0000-000000000000") + val original = + Channel( + id = "test-channel", + name = "Test Channel", + description = "A test channel", + isPrivate = true, + ownerId = testOwnerId, + createdAt = 1000L, + bannedPlayers = setOf(bannedPlayer), + ) + + val jsonString = json.encodeToString(Channel.serializer(), original) + val decoded = json.decodeFromString(Channel.serializer(), jsonString) + + assertEquals(original.id, decoded.id) + assertEquals(original.name, decoded.name) + assertEquals(original.description, decoded.description) + assertEquals(original.isPrivate, decoded.isPrivate) + assertEquals(original.ownerId, decoded.ownerId) + assertEquals(original.createdAt, decoded.createdAt) + assertEquals(original.bannedPlayers, decoded.bannedPlayers) + } + + @Test + fun `CHANNEL_ID_PATTERN should match valid patterns`() { + assertTrue("abc".matches(Channel.CHANNEL_ID_PATTERN)) + assertTrue("test-123".matches(Channel.CHANNEL_ID_PATTERN)) + assertTrue("my_channel".matches(Channel.CHANNEL_ID_PATTERN)) + assertTrue("ABC123".matches(Channel.CHANNEL_ID_PATTERN)) + } + + @Test + fun `CHANNEL_ID_PATTERN should reject invalid patterns`() { + assertFalse("ab".matches(Channel.CHANNEL_ID_PATTERN)) + assertFalse("".matches(Channel.CHANNEL_ID_PATTERN)) + assertFalse("test channel".matches(Channel.CHANNEL_ID_PATTERN)) + assertFalse("test@ch".matches(Channel.CHANNEL_ID_PATTERN)) + } +} diff --git a/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/command/CommandResultTest.kt b/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/command/CommandResultTest.kt new file mode 100644 index 0000000..b80f116 --- /dev/null +++ b/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/command/CommandResultTest.kt @@ -0,0 +1,54 @@ +package dev.m1sk9.lunaticChat.engine.command + +import net.kyori.adventure.text.Component +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertIs + +class CommandResultTest { + @Test + fun `Success toBrigadierResult should return 1`() { + assertEquals(1, CommandResult.Success.toBrigadierResult()) + } + + @Test + fun `SuccessWithMessage toBrigadierResult should return 1`() { + val result = CommandResult.SuccessWithMessage(Component.text("ok")) + assertEquals(1, result.toBrigadierResult()) + } + + @Test + fun `Failure toBrigadierResult should return 0`() { + val result = CommandResult.Failure(Component.text("error")) + assertEquals(0, result.toBrigadierResult()) + } + + @Test + fun `InvalidUsage toBrigadierResult should return 0`() { + val result = CommandResult.InvalidUsage("/cmd <arg>") + assertEquals(0, result.toBrigadierResult()) + } + + @Test + fun `SuccessWithMessage should preserve message`() { + val message = Component.text("Test message") + val result = CommandResult.SuccessWithMessage(message) + assertIs<CommandResult.SuccessWithMessage>(result) + assertEquals(message, result.message) + } + + @Test + fun `Failure should preserve message`() { + val message = Component.text("Error message") + val result = CommandResult.Failure(message) + assertIs<CommandResult.Failure>(result) + assertEquals(message, result.message) + } + + @Test + fun `InvalidUsage should preserve usage hint`() { + val result = CommandResult.InvalidUsage("/lc setting <key> <on|off>") + assertIs<CommandResult.InvalidUsage>(result) + assertEquals("/lc setting <key> <on|off>", result.usageHint) + } +} diff --git a/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/protocol/PluginMessageCodecTest.kt b/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/protocol/PluginMessageCodecTest.kt new file mode 100644 index 0000000..c792aad --- /dev/null +++ b/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/protocol/PluginMessageCodecTest.kt @@ -0,0 +1,233 @@ +package dev.m1sk9.lunaticChat.engine.protocol + +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith +import kotlin.test.assertIs + +class PluginMessageCodecTest { + @Test + fun `encode and decode Handshake round-trip`() { + val original = + PluginMessage.Handshake( + pluginVersion = "0.10.0", + protocolMajor = 1, + protocolMinor = 0, + protocolPatch = 0, + ) + + val encoded = PluginMessageCodec.encode(original) + val decoded = PluginMessageCodec.decode(encoded) + + assertIs<PluginMessage.Handshake>(decoded) + assertEquals(original.pluginVersion, decoded.pluginVersion) + assertEquals(original.protocolMajor, decoded.protocolMajor) + assertEquals(original.protocolMinor, decoded.protocolMinor) + assertEquals(original.protocolPatch, decoded.protocolPatch) + } + + @Test + fun `encode and decode HandshakeResponse compatible round-trip`() { + val original = + PluginMessage.HandshakeResponse( + compatible = true, + velocityVersion = "0.10.0", + error = null, + ) + + val encoded = PluginMessageCodec.encode(original) + val decoded = PluginMessageCodec.decode(encoded) + + assertIs<PluginMessage.HandshakeResponse>(decoded) + assertEquals(original.compatible, decoded.compatible) + assertEquals(original.velocityVersion, decoded.velocityVersion) + assertEquals(original.error, decoded.error) + } + + @Test + fun `encode and decode HandshakeResponse incompatible round-trip`() { + val original = + PluginMessage.HandshakeResponse( + compatible = false, + velocityVersion = "0.10.0", + error = "Version mismatch", + ) + + val encoded = PluginMessageCodec.encode(original) + val decoded = PluginMessageCodec.decode(encoded) + + assertIs<PluginMessage.HandshakeResponse>(decoded) + assertEquals(false, decoded.compatible) + assertEquals("Version mismatch", decoded.error) + } + + @Test + fun `encode and decode StatusRequest round-trip`() { + val original = PluginMessage.StatusRequest + + val encoded = PluginMessageCodec.encode(original) + val decoded = PluginMessageCodec.decode(encoded) + + assertIs<PluginMessage.StatusRequest>(decoded) + } + + @Test + fun `encode and decode StatusResponse round-trip`() { + val original = + PluginMessage.StatusResponse( + velocityVersion = "0.10.0", + protocolVersion = "1.0.0", + online = true, + ) + + val encoded = PluginMessageCodec.encode(original) + val decoded = PluginMessageCodec.decode(encoded) + + assertIs<PluginMessage.StatusResponse>(decoded) + assertEquals(original.velocityVersion, decoded.velocityVersion) + assertEquals(original.protocolVersion, decoded.protocolVersion) + assertEquals(original.online, decoded.online) + } + + @Test + fun `encode and decode GlobalChatMessage round-trip`() { + val original = + PluginMessage.GlobalChatMessage( + messageId = "test-id-123", + serverName = "lobby", + playerId = "00000001-0000-0000-0000-000000000000", + playerName = "TestPlayer", + message = "Hello, world!", + timestamp = 1000L, + ) + + val encoded = PluginMessageCodec.encode(original) + val decoded = PluginMessageCodec.decode(encoded) + + assertIs<PluginMessage.GlobalChatMessage>(decoded) + assertEquals(original.messageId, decoded.messageId) + assertEquals(original.serverName, decoded.serverName) + assertEquals(original.playerId, decoded.playerId) + assertEquals(original.playerName, decoded.playerName) + assertEquals(original.message, decoded.message) + assertEquals(original.timestamp, decoded.timestamp) + } + + @Test + fun `decode should throw on unknown sub-channel`() { + val out = java.io.ByteArrayOutputStream() + val dataOut = java.io.DataOutputStream(out) + dataOut.writeUTF("unknown_channel") + dataOut.writeUTF("{}") + + assertFailsWith<IllegalArgumentException> { + PluginMessageCodec.decode(out.toByteArray()) + } + } + + @Test + fun `decode should throw on empty data`() { + assertFailsWith<Exception> { + PluginMessageCodec.decode(byteArrayOf()) + } + } + + @Test + fun `encode and decode GlobalChatMessage with special characters`() { + val original = + PluginMessage.GlobalChatMessage( + messageId = "msg-special", + serverName = "survival", + playerId = "00000002-0000-0000-0000-000000000000", + playerName = "Player_With-Dash", + message = "Hello! こんにちは 🎉 \"quotes\" & <tags>", + timestamp = 2000L, + ) + + val encoded = PluginMessageCodec.encode(original) + val decoded = PluginMessageCodec.decode(encoded) + + assertIs<PluginMessage.GlobalChatMessage>(decoded) + assertEquals(original.message, decoded.message) + } + + @Test + fun `SubChannel constants should have correct values`() { + assertEquals("handshake", PluginMessageCodec.SubChannel.HANDSHAKE) + assertEquals("handshake_response", PluginMessageCodec.SubChannel.HANDSHAKE_RESPONSE) + assertEquals("status_request", PluginMessageCodec.SubChannel.STATUS_REQUEST) + assertEquals("status_response", PluginMessageCodec.SubChannel.STATUS_RESPONSE) + assertEquals("global_chat", PluginMessageCodec.SubChannel.GLOBAL_CHAT) + } + + @Test + fun `encode should produce non-empty byte array for all message types`() { + val messages = + listOf( + PluginMessage.Handshake("1.0.0", 1, 0, 0), + PluginMessage.HandshakeResponse(true, "1.0.0"), + PluginMessage.StatusRequest, + PluginMessage.StatusResponse("1.0.0", "1.0.0", true), + PluginMessage.GlobalChatMessage("id", "srv", "pid", "name", "msg", 0L), + ) + + messages.forEach { message -> + val encoded = PluginMessageCodec.encode(message) + assert(encoded.isNotEmpty()) { "Encoded ${message::class.simpleName} should not be empty" } + } + } + + @Test + fun `StatusResponse with online false round-trip`() { + val original = + PluginMessage.StatusResponse( + velocityVersion = "0.10.0", + protocolVersion = "1.0.0", + online = false, + ) + + val encoded = PluginMessageCodec.encode(original) + val decoded = PluginMessageCodec.decode(encoded) + + assertIs<PluginMessage.StatusResponse>(decoded) + assertEquals(false, decoded.online) + } + + @Test + fun `Handshake with various protocol versions round-trip`() { + val original = + PluginMessage.Handshake( + pluginVersion = "2.5.3", + protocolMajor = 99, + protocolMinor = 42, + protocolPatch = 7, + ) + + val encoded = PluginMessageCodec.encode(original) + val decoded = PluginMessageCodec.decode(encoded) + + assertIs<PluginMessage.Handshake>(decoded) + assertEquals(99, decoded.protocolMajor) + assertEquals(42, decoded.protocolMinor) + assertEquals(7, decoded.protocolPatch) + } + + @Test + fun `GlobalChatMessage with empty message round-trip`() { + val original = + PluginMessage.GlobalChatMessage( + messageId = "msg-empty", + serverName = "lobby", + playerId = "00000003-0000-0000-0000-000000000000", + playerName = "Player", + message = "", + timestamp = 3000L, + ) + + val encoded = PluginMessageCodec.encode(original) + val decoded = PluginMessageCodec.decode(encoded) + + assertIs<PluginMessage.GlobalChatMessage>(decoded) + assertEquals("", decoded.message) + } +} diff --git a/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/protocol/ProtocolVersionTest.kt b/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/protocol/ProtocolVersionTest.kt new file mode 100644 index 0000000..7f05039 --- /dev/null +++ b/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/protocol/ProtocolVersionTest.kt @@ -0,0 +1,57 @@ +package dev.m1sk9.lunaticChat.engine.protocol + +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertTrue + +class ProtocolVersionTest { + @Test + fun `version string should match MAJOR MINOR PATCH format`() { + assertEquals("${ProtocolVersion.MAJOR}.${ProtocolVersion.MINOR}.${ProtocolVersion.PATCH}", ProtocolVersion.version) + } + + @Test + fun `isCompatible with matching major and minor should return true`() { + assertTrue(ProtocolVersion.isCompatible(ProtocolVersion.MAJOR, ProtocolVersion.MINOR)) + } + + @Test + fun `isCompatible with different major should return false`() { + assertFalse(ProtocolVersion.isCompatible(ProtocolVersion.MAJOR + 1, ProtocolVersion.MINOR)) + } + + @Test + fun `isCompatible with different minor should return false`() { + assertFalse(ProtocolVersion.isCompatible(ProtocolVersion.MAJOR, ProtocolVersion.MINOR + 1)) + } + + @Test + fun `isCompatible string with matching version should return true`() { + assertTrue(ProtocolVersion.isCompatible("${ProtocolVersion.MAJOR}.${ProtocolVersion.MINOR}.0")) + } + + @Test + fun `isCompatible string with different patch should return true`() { + assertTrue(ProtocolVersion.isCompatible("${ProtocolVersion.MAJOR}.${ProtocolVersion.MINOR}.99")) + } + + @Test + fun `isCompatible string with different major should return false`() { + assertFalse(ProtocolVersion.isCompatible("${ProtocolVersion.MAJOR + 1}.${ProtocolVersion.MINOR}.0")) + } + + @Test + fun `isCompatible string with malformed version should return false`() { + assertFalse(ProtocolVersion.isCompatible("invalid")) + assertFalse(ProtocolVersion.isCompatible("1.0")) + assertFalse(ProtocolVersion.isCompatible("")) + assertFalse(ProtocolVersion.isCompatible("a.b.c")) + assertFalse(ProtocolVersion.isCompatible("1.0.0.0")) + } + + @Test + fun `isCompatible string with two parts should return false`() { + assertFalse(ProtocolVersion.isCompatible("1.0")) + } +} diff --git a/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/settings/UUIDSerializerTest.kt b/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/settings/UUIDSerializerTest.kt new file mode 100644 index 0000000..599a372 --- /dev/null +++ b/engine/src/test/kotlin/dev/m1sk9/lunaticChat/engine/settings/UUIDSerializerTest.kt @@ -0,0 +1,100 @@ +package dev.m1sk9.lunaticChat.engine.settings + +import kotlinx.serialization.Serializable +import kotlinx.serialization.json.Json +import java.util.UUID +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith + +class UUIDSerializerTest { + private val json = Json + + @Serializable + private data class UUIDHolder( + @Serializable(with = UUIDSerializer::class) + val uuid: UUID, + ) + + @Serializable + private data class UUIDAsStringHolder( + @Serializable(with = UUIDASStringSerializer::class) + val uuid: UUID, + ) + + @Test + fun `UUIDSerializer should serialize UUID to string`() { + val uuid = UUID.fromString("12345678-1234-1234-1234-123456789abc") + val holder = UUIDHolder(uuid) + + val jsonString = json.encodeToString(UUIDHolder.serializer(), holder) + + assert(jsonString.contains("12345678-1234-1234-1234-123456789abc")) + } + + @Test + fun `UUIDSerializer should deserialize string to UUID`() { + val jsonString = """{"uuid":"12345678-1234-1234-1234-123456789abc"}""" + val holder = json.decodeFromString(UUIDHolder.serializer(), jsonString) + + assertEquals(UUID.fromString("12345678-1234-1234-1234-123456789abc"), holder.uuid) + } + + @Test + fun `UUIDSerializer round-trip should preserve UUID`() { + val originalUuid = UUID.randomUUID() + val holder = UUIDHolder(originalUuid) + + val jsonString = json.encodeToString(UUIDHolder.serializer(), holder) + val decoded = json.decodeFromString(UUIDHolder.serializer(), jsonString) + + assertEquals(originalUuid, decoded.uuid) + } + + @Test + fun `UUIDASStringSerializer should serialize UUID to string`() { + val uuid = UUID.fromString("abcdef01-2345-6789-abcd-ef0123456789") + val holder = UUIDAsStringHolder(uuid) + + val jsonString = json.encodeToString(UUIDAsStringHolder.serializer(), holder) + + assert(jsonString.contains("abcdef01-2345-6789-abcd-ef0123456789")) + } + + @Test + fun `UUIDASStringSerializer should deserialize string to UUID`() { + val jsonString = """{"uuid":"abcdef01-2345-6789-abcd-ef0123456789"}""" + val holder = json.decodeFromString(UUIDAsStringHolder.serializer(), jsonString) + + assertEquals(UUID.fromString("abcdef01-2345-6789-abcd-ef0123456789"), holder.uuid) + } + + @Test + fun `UUIDASStringSerializer round-trip should preserve UUID`() { + val originalUuid = UUID.randomUUID() + val holder = UUIDAsStringHolder(originalUuid) + + val jsonString = json.encodeToString(UUIDAsStringHolder.serializer(), holder) + val decoded = json.decodeFromString(UUIDAsStringHolder.serializer(), jsonString) + + assertEquals(originalUuid, decoded.uuid) + } + + @Test + fun `UUIDSerializer should fail on invalid UUID string`() { + val jsonString = """{"uuid":"not-a-valid-uuid"}""" + + assertFailsWith<Exception> { + json.decodeFromString(UUIDHolder.serializer(), jsonString) + } + } + + @Test + fun `UUIDASStringSerializer should fail on invalid UUID string`() { + val jsonString = """{"uuid":"not-a-valid-uuid"}""" + + assertFailsWith<Exception> { + json.decodeFromString(UUIDAsStringHolder.serializer(), jsonString) + } + } +} diff --git a/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/chat/channel/ChannelManagerTest.kt b/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/chat/channel/ChannelManagerTest.kt new file mode 100644 index 0000000..acf610f --- /dev/null +++ b/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/chat/channel/ChannelManagerTest.kt @@ -0,0 +1,513 @@ +package dev.m1sk9.lunaticChat.paper.chat.channel + +import dev.m1sk9.lunaticChat.engine.chat.channel.ChannelData +import dev.m1sk9.lunaticChat.engine.chat.channel.ChannelMember +import dev.m1sk9.lunaticChat.engine.chat.channel.ChannelRole +import dev.m1sk9.lunaticChat.engine.exception.ChannelLimitExceededException +import dev.m1sk9.lunaticChat.engine.exception.ChannelMemberLimitExceededException +import dev.m1sk9.lunaticChat.engine.exception.ChannelNoOwnerPermissionException +import dev.m1sk9.lunaticChat.engine.exception.ChannelNotFoundException +import dev.m1sk9.lunaticChat.engine.exception.ChannelPlayerAlreadyBannedException +import dev.m1sk9.lunaticChat.engine.exception.ChannelPlayerNotBannedException +import dev.m1sk9.lunaticChat.paper.TestUtils +import dev.m1sk9.lunaticChat.paper.TestUtils.createTestChannel +import dev.m1sk9.lunaticChat.paper.TestUtils.createTestUUID +import dev.m1sk9.lunaticChat.paper.config.key.ChannelChatFeatureConfig +import io.mockk.every +import io.mockk.mockk +import io.mockk.verify +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertIs +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.test.assertTrue + +class ChannelManagerTest { + private fun createManager( + initialData: ChannelData = ChannelData(), + maxChannelsPerServer: Int = 10, + maxMembersPerChannel: Int = 50, + ): Triple<ChannelManager, ChannelStorage, TestUtils.TestLogger> { + val logger = TestUtils.TestLogger() + val storage = mockk<ChannelStorage>(relaxed = true) + val config = + ChannelChatFeatureConfig( + enabled = true, + maxChannelsPerServer = maxChannelsPerServer, + maxMembersPerChannel = maxMembersPerChannel, + ) + + every { storage.loadFromDisk() } returns initialData + + val manager = ChannelManager(storage, logger, config) + return Triple(manager, storage, logger) + } + + @Test + fun `initialize should load channels from storage`() { + val ownerId = createTestUUID(1) + val channel = createTestChannel(id = "test-ch", name = "Test", ownerId = ownerId) + val members = + listOf( + ChannelMember(channelId = "test-ch", playerId = ownerId, role = ChannelRole.OWNER), + ) + val data = + ChannelData( + channels = mapOf("test-ch" to channel), + members = mapOf("test-ch" to members), + ) + + val (manager, _, logger) = createManager(initialData = data) + manager.initialize() + + val result = manager.getChannel("test-ch") + assertTrue(result.isSuccess) + assertEquals("test-ch", result.getOrThrow().id) + assertTrue(logger.infoMessages.any { it.contains("1 channels") }) + } + + @Test + fun `createChannel should succeed for new channel`() { + val (manager, storage, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + val channel = createTestChannel(id = "new-ch", name = "New Channel", ownerId = ownerId) + + val result = manager.createChannel(channel) + + assertTrue(result.isSuccess) + assertEquals("new-ch", result.getOrThrow().id) + verify(atLeast = 1) { storage.queueAsyncSave(any()) } + } + + @Test + fun `createChannel should auto-add owner as member`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + val channel = createTestChannel(id = "new-ch", name = "New Channel", ownerId = ownerId) + manager.createChannel(channel) + + val members = manager.getChannelMembers("new-ch") + assertTrue(members.isSuccess) + assertEquals(1, members.getOrThrow().size) + assertEquals(ownerId, members.getOrThrow()[0].playerId) + assertEquals(ChannelRole.OWNER, members.getOrThrow()[0].role) + } + + @Test + fun `createChannel should set owner active channel`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + val channel = createTestChannel(id = "new-ch", name = "New Channel", ownerId = ownerId) + manager.createChannel(channel) + + assertEquals("new-ch", manager.getPlayerChannel(ownerId)) + } + + @Test + fun `createChannel should fail for duplicate ID`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + val channel = createTestChannel(id = "dup-ch", name = "Channel", ownerId = ownerId) + manager.createChannel(channel) + + val result = manager.createChannel(channel) + assertTrue(result.isFailure) + assertIs<ChannelNotFoundException>(result.exceptionOrNull()) + } + + @Test + fun `createChannel should fail when limit reached`() { + val (manager, _, _) = createManager(maxChannelsPerServer = 1) + manager.initialize() + + val owner1 = createTestUUID(1) + val owner2 = createTestUUID(2) + manager.createChannel(createTestChannel(id = "ch1", name = "Ch1", ownerId = owner1)) + + val result = manager.createChannel(createTestChannel(id = "ch2", name = "Ch2", ownerId = owner2)) + assertTrue(result.isFailure) + assertIs<ChannelLimitExceededException>(result.exceptionOrNull()) + } + + @Test + fun `createChannel with unlimited limit should allow many channels`() { + val (manager, _, _) = createManager(maxChannelsPerServer = 0) + manager.initialize() + + repeat(5) { i -> + val result = + manager.createChannel( + createTestChannel(id = "ch-$i", name = "Channel $i", ownerId = createTestUUID(i)), + ) + assertTrue(result.isSuccess) + } + } + + @Test + fun `deleteChannel should succeed for owner`() { + val (manager, storage, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + manager.createChannel(createTestChannel(id = "del-ch", name = "To Delete", ownerId = ownerId)) + + val result = manager.deleteChannel("del-ch", ownerId) + assertTrue(result.isSuccess) + + val getResult = manager.getChannel("del-ch") + assertTrue(getResult.isFailure) + } + + @Test + fun `deleteChannel should fail for non-owner without bypass`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + val otherId = createTestUUID(2) + manager.createChannel(createTestChannel(id = "del-ch", name = "Channel", ownerId = ownerId)) + + val result = manager.deleteChannel("del-ch", otherId) + assertTrue(result.isFailure) + assertIs<ChannelNoOwnerPermissionException>(result.exceptionOrNull()) + } + + @Test + fun `deleteChannel should succeed for non-owner with bypass permission`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + val adminId = createTestUUID(2) + manager.createChannel(createTestChannel(id = "del-ch", name = "Channel", ownerId = ownerId)) + + val result = manager.deleteChannel("del-ch", adminId, hasBypassPermission = true) + assertTrue(result.isSuccess) + } + + @Test + fun `deleteChannel should fail for nonexistent channel`() { + val (manager, _, _) = createManager() + manager.initialize() + + val result = manager.deleteChannel("nonexistent", createTestUUID(1)) + assertTrue(result.isFailure) + assertIs<ChannelNotFoundException>(result.exceptionOrNull()) + } + + @Test + fun `deleteChannel should clear active channels for affected players`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + manager.createChannel(createTestChannel(id = "del-ch", name = "Channel", ownerId = ownerId)) + assertEquals("del-ch", manager.getPlayerChannel(ownerId)) + + manager.deleteChannel("del-ch", ownerId) + assertNull(manager.getPlayerChannel(ownerId)) + } + + @Test + fun `getChannel should return channel when exists`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + manager.createChannel(createTestChannel(id = "get-ch", name = "Get Channel", ownerId = ownerId)) + + val result = manager.getChannel("get-ch") + assertTrue(result.isSuccess) + assertEquals("Get Channel", result.getOrThrow().name) + } + + @Test + fun `getChannel should fail for nonexistent channel`() { + val (manager, _, _) = createManager() + manager.initialize() + + val result = manager.getChannel("nonexistent") + assertTrue(result.isFailure) + assertIs<ChannelNotFoundException>(result.exceptionOrNull()) + } + + @Test + fun `getAllChannels should return all channels`() { + val (manager, _, _) = createManager() + manager.initialize() + + manager.createChannel(createTestChannel(id = "ch1", name = "Ch1", ownerId = createTestUUID(1))) + manager.createChannel(createTestChannel(id = "ch2", name = "Ch2", ownerId = createTestUUID(2))) + + val result = manager.getAllChannels() + assertTrue(result.isSuccess) + assertEquals(2, result.getOrThrow().size) + } + + @Test + fun `getPublicChannels should exclude private channels`() { + val (manager, _, _) = createManager() + manager.initialize() + + manager.createChannel(createTestChannel(id = "public-ch", name = "Public", ownerId = createTestUUID(1))) + manager.createChannel( + createTestChannel(id = "private-ch", name = "Private", ownerId = createTestUUID(2), isPrivate = true), + ) + + val result = manager.getPublicChannels() + assertTrue(result.isSuccess) + assertEquals(1, result.getOrThrow().size) + assertEquals("public-ch", result.getOrThrow()[0].id) + } + + @Test + fun `addMember should add member to channel`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + val memberId = createTestUUID(2) + manager.createChannel(createTestChannel(id = "mem-ch", name = "Channel", ownerId = ownerId)) + + val result = manager.addMember("mem-ch", memberId, ChannelRole.MEMBER) + assertTrue(result.isSuccess) + + val members = manager.getChannelMembers("mem-ch").getOrThrow() + assertEquals(2, members.size) + assertTrue(members.any { it.playerId == memberId }) + } + + @Test + fun `addMember should fail when member limit reached`() { + val (manager, _, _) = createManager(maxMembersPerChannel = 1) + manager.initialize() + + val ownerId = createTestUUID(1) + manager.createChannel(createTestChannel(id = "lim-ch", name = "Channel", ownerId = ownerId)) + + val result = manager.addMember("lim-ch", createTestUUID(2), ChannelRole.MEMBER) + assertTrue(result.isFailure) + assertIs<ChannelMemberLimitExceededException>(result.exceptionOrNull()) + } + + @Test + fun `addMember should fail for nonexistent channel`() { + val (manager, _, _) = createManager() + manager.initialize() + + val result = manager.addMember("nonexistent", createTestUUID(1), ChannelRole.MEMBER) + assertTrue(result.isFailure) + assertIs<ChannelNotFoundException>(result.exceptionOrNull()) + } + + @Test + fun `removeMember should remove member from channel`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + val memberId = createTestUUID(2) + manager.createChannel(createTestChannel(id = "rem-ch", name = "Channel", ownerId = ownerId)) + manager.addMember("rem-ch", memberId, ChannelRole.MEMBER) + + val result = manager.removeMember("rem-ch", memberId) + assertTrue(result.isSuccess) + + val members = manager.getChannelMembers("rem-ch").getOrThrow() + assertFalse(members.any { it.playerId == memberId }) + } + + @Test + fun `banPlayer should add to banned list and remove from members`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + val bannedId = createTestUUID(2) + manager.createChannel(createTestChannel(id = "ban-ch", name = "Channel", ownerId = ownerId)) + manager.addMember("ban-ch", bannedId, ChannelRole.MEMBER) + + val result = manager.banPlayer("ban-ch", bannedId) + assertTrue(result.isSuccess) + assertTrue(result.getOrThrow().bannedPlayers.contains(bannedId)) + + val members = manager.getChannelMembers("ban-ch").getOrThrow() + assertFalse(members.any { it.playerId == bannedId }) + } + + @Test + fun `banPlayer should clear active channel for banned player`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + val bannedId = createTestUUID(2) + manager.createChannel(createTestChannel(id = "ban-ch", name = "Channel", ownerId = ownerId)) + manager.addMember("ban-ch", bannedId, ChannelRole.MEMBER) + manager.setPlayerChannel(bannedId, "ban-ch") + + manager.banPlayer("ban-ch", bannedId) + assertNull(manager.getPlayerChannel(bannedId)) + } + + @Test + fun `banPlayer should fail if already banned`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + val bannedId = createTestUUID(2) + manager.createChannel(createTestChannel(id = "ban-ch", name = "Channel", ownerId = ownerId)) + manager.banPlayer("ban-ch", bannedId) + + val result = manager.banPlayer("ban-ch", bannedId) + assertTrue(result.isFailure) + assertIs<ChannelPlayerAlreadyBannedException>(result.exceptionOrNull()) + } + + @Test + fun `unbanPlayer should remove from banned list`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + val bannedId = createTestUUID(2) + manager.createChannel(createTestChannel(id = "unban-ch", name = "Channel", ownerId = ownerId)) + manager.banPlayer("unban-ch", bannedId) + + val result = manager.unbanPlayer("unban-ch", bannedId) + assertTrue(result.isSuccess) + assertFalse(result.getOrThrow().bannedPlayers.contains(bannedId)) + } + + @Test + fun `unbanPlayer should fail if not banned`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + manager.createChannel(createTestChannel(id = "unban-ch", name = "Channel", ownerId = ownerId)) + + val result = manager.unbanPlayer("unban-ch", createTestUUID(2)) + assertTrue(result.isFailure) + assertIs<ChannelPlayerNotBannedException>(result.exceptionOrNull()) + } + + @Test + fun `isPlayerBanned should return true for banned player`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + val bannedId = createTestUUID(2) + manager.createChannel(createTestChannel(id = "ban-ch", name = "Channel", ownerId = ownerId)) + manager.banPlayer("ban-ch", bannedId) + + assertTrue(manager.isPlayerBanned("ban-ch", bannedId).getOrThrow()) + } + + @Test + fun `isPlayerBanned should return false for non-banned player`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + manager.createChannel(createTestChannel(id = "ban-ch", name = "Channel", ownerId = ownerId)) + + assertFalse(manager.isPlayerBanned("ban-ch", createTestUUID(2)).getOrThrow()) + } + + @Test + fun `updateMemberRole should change member role`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + val memberId = createTestUUID(2) + manager.createChannel(createTestChannel(id = "role-ch", name = "Channel", ownerId = ownerId)) + manager.addMember("role-ch", memberId, ChannelRole.MEMBER) + + val result = manager.updateMemberRole("role-ch", memberId, ChannelRole.MODERATOR) + assertTrue(result.isSuccess) + + val members = manager.getChannelMembers("role-ch").getOrThrow() + val updatedMember = members.find { it.playerId == memberId } + assertNotNull(updatedMember) + assertEquals(ChannelRole.MODERATOR, updatedMember.role) + } + + @Test + fun `updateChannelOwner should transfer ownership`() { + val (manager, _, _) = createManager() + manager.initialize() + + val oldOwnerId = createTestUUID(1) + val newOwnerId = createTestUUID(2) + manager.createChannel(createTestChannel(id = "own-ch", name = "Channel", ownerId = oldOwnerId)) + manager.addMember("own-ch", newOwnerId, ChannelRole.MEMBER) + + val result = manager.updateChannelOwner("own-ch", newOwnerId) + assertTrue(result.isSuccess) + assertEquals(newOwnerId, result.getOrThrow().ownerId) + + val members = manager.getChannelMembers("own-ch").getOrThrow() + assertEquals(ChannelRole.OWNER, members.find { it.playerId == newOwnerId }?.role) + assertEquals(ChannelRole.MODERATOR, members.find { it.playerId == oldOwnerId }?.role) + } + + @Test + fun `setPlayerChannel should set and clear active channel`() { + val (manager, _, _) = createManager() + manager.initialize() + + val playerId = createTestUUID(1) + + manager.setPlayerChannel(playerId, "test-ch") + assertEquals("test-ch", manager.getPlayerChannel(playerId)) + + manager.setPlayerChannel(playerId, null) + assertNull(manager.getPlayerChannel(playerId)) + } + + @Test + fun `getPlayerChannelContext should return context for active channel`() { + val (manager, _, _) = createManager() + manager.initialize() + + val ownerId = createTestUUID(1) + manager.createChannel(createTestChannel(id = "ctx-ch", name = "Context Channel", ownerId = ownerId)) + + val context = manager.getPlayerChannelContext(ownerId) + assertNotNull(context) + assertEquals("ctx-ch", context.channelId) + assertEquals("Context Channel", context.channel.name) + } + + @Test + fun `getPlayerChannelContext should return null for no active channel`() { + val (manager, _, _) = createManager() + manager.initialize() + + assertNull(manager.getPlayerChannelContext(createTestUUID(99))) + } + + @Test + fun `saveToDisk should call storage saveToDisk`() { + val (manager, storage, _) = createManager() + manager.initialize() + + manager.saveToDisk() + + verify { storage.saveToDisk(any()) } + } +} diff --git a/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/chat/channel/ChannelMembershipManagerTest.kt b/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/chat/channel/ChannelMembershipManagerTest.kt new file mode 100644 index 0000000..1fcc39b --- /dev/null +++ b/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/chat/channel/ChannelMembershipManagerTest.kt @@ -0,0 +1,384 @@ +package dev.m1sk9.lunaticChat.paper.chat.channel + +import dev.m1sk9.lunaticChat.engine.chat.channel.ChannelData +import dev.m1sk9.lunaticChat.engine.chat.channel.ChannelRole +import dev.m1sk9.lunaticChat.engine.exception.ChannelAlreadyActiveException +import dev.m1sk9.lunaticChat.engine.exception.ChannelMemberAlreadyException +import dev.m1sk9.lunaticChat.engine.exception.ChannelNotFoundException +import dev.m1sk9.lunaticChat.engine.exception.ChannelNotMemberException +import dev.m1sk9.lunaticChat.engine.exception.ChannelPlayerBannedException +import dev.m1sk9.lunaticChat.engine.exception.ChannelPlayerMembershipLimitExceededException +import dev.m1sk9.lunaticChat.engine.exception.ChannelPrivateRequiresInvitationException +import dev.m1sk9.lunaticChat.paper.TestUtils +import dev.m1sk9.lunaticChat.paper.TestUtils.createTestChannel +import dev.m1sk9.lunaticChat.paper.TestUtils.createTestUUID +import dev.m1sk9.lunaticChat.paper.config.key.ChannelChatFeatureConfig +import io.mockk.every +import io.mockk.mockk +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertIs +import kotlin.test.assertNull +import kotlin.test.assertTrue + +class ChannelMembershipManagerTest { + private fun createManagers( + initialData: ChannelData = ChannelData(), + maxChannelsPerServer: Int = 10, + maxMembersPerChannel: Int = 50, + maxMembershipPerPlayer: Int = 5, + ): Triple<ChannelMembershipManager, ChannelManager, TestUtils.TestLogger> { + val logger = TestUtils.TestLogger() + val storage = mockk<ChannelStorage>(relaxed = true) + val config = + ChannelChatFeatureConfig( + enabled = true, + maxChannelsPerServer = maxChannelsPerServer, + maxMembersPerChannel = maxMembersPerChannel, + maxMembershipPerPlayer = maxMembershipPerPlayer, + ) + + every { storage.loadFromDisk() } returns initialData + + val channelManager = ChannelManager(storage, logger, config) + channelManager.initialize() + + val membershipManager = ChannelMembershipManager(channelManager, logger, config) + return Triple(membershipManager, channelManager, logger) + } + + @Test + fun `joinChannel should succeed for public channel`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + val playerId = createTestUUID(2) + channelManager.createChannel(createTestChannel(id = "pub-ch", name = "Public", ownerId = ownerId)) + + val result = membership.joinChannel(playerId, "pub-ch") + assertTrue(result.isSuccess) + } + + @Test + fun `joinChannel should set channel as active`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + val playerId = createTestUUID(2) + channelManager.createChannel(createTestChannel(id = "pub-ch", name = "Public", ownerId = ownerId)) + + membership.joinChannel(playerId, "pub-ch") + assertEquals("pub-ch", channelManager.getPlayerChannel(playerId)) + } + + @Test + fun `joinChannel should fail for nonexistent channel`() { + val (membership, _, _) = createManagers() + + val result = membership.joinChannel(createTestUUID(1), "nonexistent") + assertTrue(result.isFailure) + assertIs<ChannelNotFoundException>(result.exceptionOrNull()) + } + + @Test + fun `joinChannel should fail if channel is already active`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + channelManager.createChannel(createTestChannel(id = "active-ch", name = "Active", ownerId = ownerId)) + + // Owner already has this as active channel after creation + val result = membership.joinChannel(ownerId, "active-ch") + assertTrue(result.isFailure) + assertIs<ChannelAlreadyActiveException>(result.exceptionOrNull()) + } + + @Test + fun `joinChannel should fail if player is banned`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + val bannedId = createTestUUID(2) + channelManager.createChannel(createTestChannel(id = "ban-ch", name = "Channel", ownerId = ownerId)) + channelManager.banPlayer("ban-ch", bannedId) + + val result = membership.joinChannel(bannedId, "ban-ch") + assertTrue(result.isFailure) + assertIs<ChannelPlayerBannedException>(result.exceptionOrNull()) + } + + @Test + fun `joinChannel should fail for private channel without bypass`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + val playerId = createTestUUID(2) + channelManager.createChannel( + createTestChannel(id = "priv-ch", name = "Private", ownerId = ownerId, isPrivate = true), + ) + + val result = membership.joinChannel(playerId, "priv-ch") + assertTrue(result.isFailure) + assertIs<ChannelPrivateRequiresInvitationException>(result.exceptionOrNull()) + } + + @Test + fun `joinChannel should succeed for private channel with bypass`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + val playerId = createTestUUID(2) + channelManager.createChannel( + createTestChannel(id = "priv-ch", name = "Private", ownerId = ownerId, isPrivate = true), + ) + + val result = membership.joinChannel(playerId, "priv-ch", bypassPrivateCheck = true) + assertTrue(result.isSuccess) + } + + @Test + fun `joinChannel should fail if already a member`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + val playerId = createTestUUID(2) + channelManager.createChannel(createTestChannel(id = "mem-ch", name = "Channel", ownerId = ownerId)) + membership.joinChannel(playerId, "mem-ch") + + // Switch active to another channel first so we can try joining again + channelManager.createChannel(createTestChannel(id = "other-ch", name = "Other", ownerId = createTestUUID(3))) + channelManager.setPlayerChannel(playerId, "other-ch") + + val result = membership.joinChannel(playerId, "mem-ch") + assertTrue(result.isFailure) + assertIs<ChannelMemberAlreadyException>(result.exceptionOrNull()) + } + + @Test + fun `joinChannel should fail when membership limit reached`() { + val (membership, channelManager, _) = createManagers(maxMembershipPerPlayer = 1) + + val ownerId1 = createTestUUID(1) + val ownerId2 = createTestUUID(2) + val playerId = createTestUUID(3) + + channelManager.createChannel(createTestChannel(id = "ch1", name = "Ch1", ownerId = ownerId1)) + channelManager.createChannel(createTestChannel(id = "ch2", name = "Ch2", ownerId = ownerId2)) + + membership.joinChannel(playerId, "ch1") + + // Clear active channel to try joining second + channelManager.setPlayerChannel(playerId, null) + + val result = membership.joinChannel(playerId, "ch2") + assertTrue(result.isFailure) + assertIs<ChannelPlayerMembershipLimitExceededException>(result.exceptionOrNull()) + } + + @Test + fun `leaveChannel should remove from membership and clear active`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + val playerId = createTestUUID(2) + channelManager.createChannel(createTestChannel(id = "leave-ch", name = "Channel", ownerId = ownerId)) + membership.joinChannel(playerId, "leave-ch") + + val result = membership.leaveChannel(playerId) + assertTrue(result.isSuccess) + assertNull(channelManager.getPlayerChannel(playerId)) + } + + @Test + fun `leaveChannel should fail if no active channel`() { + val (membership, _, _) = createManagers() + + val result = membership.leaveChannel(createTestUUID(99)) + assertTrue(result.isFailure) + assertIs<ChannelNotMemberException>(result.exceptionOrNull()) + } + + @Test + fun `switchChannel should switch to another member channel`() { + val (membership, channelManager, _) = createManagers() + + val ownerId1 = createTestUUID(1) + val ownerId2 = createTestUUID(2) + val playerId = createTestUUID(3) + + channelManager.createChannel(createTestChannel(id = "ch1", name = "Ch1", ownerId = ownerId1)) + channelManager.createChannel(createTestChannel(id = "ch2", name = "Ch2", ownerId = ownerId2)) + + membership.joinChannel(playerId, "ch1") + // Now switch active to ch2 first by joining + channelManager.setPlayerChannel(playerId, null) + membership.joinChannel(playerId, "ch2") + + // Switch back to ch1 + val result = membership.switchChannel(playerId, "ch1") + assertTrue(result.isSuccess) + assertEquals("ch1", channelManager.getPlayerChannel(playerId)) + } + + @Test + fun `switchChannel should fail for nonexistent channel`() { + val (membership, _, _) = createManagers() + + val result = membership.switchChannel(createTestUUID(1), "nonexistent") + assertTrue(result.isFailure) + assertIs<ChannelNotFoundException>(result.exceptionOrNull()) + } + + @Test + fun `switchChannel should fail if already active`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + val playerId = createTestUUID(2) + channelManager.createChannel(createTestChannel(id = "sw-ch", name = "Channel", ownerId = ownerId)) + membership.joinChannel(playerId, "sw-ch") + + val result = membership.switchChannel(playerId, "sw-ch") + assertTrue(result.isFailure) + assertIs<ChannelAlreadyActiveException>(result.exceptionOrNull()) + } + + @Test + fun `switchChannel should fail if not a member`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + val playerId = createTestUUID(2) + channelManager.createChannel(createTestChannel(id = "sw-ch", name = "Channel", ownerId = ownerId)) + + val result = membership.switchChannel(playerId, "sw-ch") + assertTrue(result.isFailure) + assertIs<ChannelNotMemberException>(result.exceptionOrNull()) + } + + @Test + fun `isMember should return true for members`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + channelManager.createChannel(createTestChannel(id = "mem-ch", name = "Channel", ownerId = ownerId)) + + assertTrue(membership.isMember(ownerId, "mem-ch").getOrThrow()) + } + + @Test + fun `isMember should return false for non-members`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + channelManager.createChannel(createTestChannel(id = "mem-ch", name = "Channel", ownerId = ownerId)) + + assertFalse(membership.isMember(createTestUUID(2), "mem-ch").getOrThrow()) + } + + @Test + fun `getMemberRole should return role for member`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + channelManager.createChannel(createTestChannel(id = "role-ch", name = "Channel", ownerId = ownerId)) + + assertEquals(ChannelRole.OWNER, membership.getMemberRole(ownerId, "role-ch").getOrThrow()) + } + + @Test + fun `getMemberRole should fail for non-member`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + channelManager.createChannel(createTestChannel(id = "role-ch", name = "Channel", ownerId = ownerId)) + + val result = membership.getMemberRole(createTestUUID(2), "role-ch") + assertTrue(result.isFailure) + assertIs<ChannelNotMemberException>(result.exceptionOrNull()) + } + + @Test + fun `getMemberRoleOrNull should return null for non-member`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + channelManager.createChannel(createTestChannel(id = "role-ch", name = "Channel", ownerId = ownerId)) + + assertNull(membership.getMemberRoleOrNull(createTestUUID(2), "role-ch")) + } + + @Test + fun `hasRole OWNER should return true only for owner`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + val memberId = createTestUUID(2) + channelManager.createChannel(createTestChannel(id = "has-ch", name = "Channel", ownerId = ownerId)) + channelManager.addMember("has-ch", memberId, ChannelRole.MEMBER) + + assertTrue(membership.hasRole(ownerId, "has-ch", ChannelRole.OWNER).getOrThrow()) + assertFalse(membership.hasRole(memberId, "has-ch", ChannelRole.OWNER).getOrThrow()) + } + + @Test + fun `hasRole MODERATOR should return true for moderator and owner`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + val modId = createTestUUID(2) + val memberId = createTestUUID(3) + channelManager.createChannel(createTestChannel(id = "has-ch", name = "Channel", ownerId = ownerId)) + channelManager.addMember("has-ch", modId, ChannelRole.MODERATOR) + channelManager.addMember("has-ch", memberId, ChannelRole.MEMBER) + + assertTrue(membership.hasRole(ownerId, "has-ch", ChannelRole.MODERATOR).getOrThrow()) + assertTrue(membership.hasRole(modId, "has-ch", ChannelRole.MODERATOR).getOrThrow()) + assertFalse(membership.hasRole(memberId, "has-ch", ChannelRole.MODERATOR).getOrThrow()) + } + + @Test + fun `hasRole MEMBER should return true for all members`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + val memberId = createTestUUID(2) + channelManager.createChannel(createTestChannel(id = "has-ch", name = "Channel", ownerId = ownerId)) + channelManager.addMember("has-ch", memberId, ChannelRole.MEMBER) + + assertTrue(membership.hasRole(ownerId, "has-ch", ChannelRole.MEMBER).getOrThrow()) + assertTrue(membership.hasRole(memberId, "has-ch", ChannelRole.MEMBER).getOrThrow()) + } + + @Test + fun `hasRole should return false for non-member`() { + val (membership, channelManager, _) = createManagers() + + val ownerId = createTestUUID(1) + channelManager.createChannel(createTestChannel(id = "has-ch", name = "Channel", ownerId = ownerId)) + + assertFalse(membership.hasRole(createTestUUID(99), "has-ch", ChannelRole.MEMBER).getOrThrow()) + } + + @Test + fun `getPlayerChannels should return all channels player is member of`() { + val (membership, channelManager, _) = createManagers() + + val ownerId1 = createTestUUID(1) + val ownerId2 = createTestUUID(2) + val playerId = createTestUUID(3) + + channelManager.createChannel(createTestChannel(id = "ch1", name = "Ch1", ownerId = ownerId1)) + channelManager.createChannel(createTestChannel(id = "ch2", name = "Ch2", ownerId = ownerId2)) + + membership.joinChannel(playerId, "ch1") + channelManager.setPlayerChannel(playerId, null) + membership.joinChannel(playerId, "ch2") + + val channels = membership.getPlayerChannels(playerId).getOrThrow() + assertEquals(2, channels.size) + assertTrue(channels.contains("ch1")) + assertTrue(channels.contains("ch2")) + } +} diff --git a/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingKeyTest.kt b/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingKeyTest.kt new file mode 100644 index 0000000..635d7e1 --- /dev/null +++ b/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingKeyTest.kt @@ -0,0 +1,50 @@ +package dev.m1sk9.lunaticChat.paper.command.setting + +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertIs +import kotlin.test.assertNull + +class SettingKeyTest { + @Test + fun `fromString should resolve japanese key`() { + val result = SettingKey.fromString("japanese") + assertIs<SettingKey.Japanese>(result) + } + + @Test + fun `fromString should resolve notice key`() { + val result = SettingKey.fromString("notice") + assertIs<SettingKey.Notice>(result) + } + + @Test + fun `fromString should resolve chNotice key`() { + val result = SettingKey.fromString("chNotice") + assertIs<SettingKey.ChNotice>(result) + } + + @Test + fun `fromString should be case insensitive`() { + assertIs<SettingKey.Japanese>(SettingKey.fromString("JAPANESE")) + assertIs<SettingKey.Notice>(SettingKey.fromString("NOTICE")) + assertIs<SettingKey.ChNotice>(SettingKey.fromString("CHNOTICE")) + assertIs<SettingKey.Japanese>(SettingKey.fromString("Japanese")) + } + + @Test + fun `fromString should return null for unknown key`() { + assertNull(SettingKey.fromString("unknown")) + assertNull(SettingKey.fromString("")) + assertNull(SettingKey.fromString("invalid")) + } + + @Test + fun `values should return all setting keys`() { + val values = SettingKey.values() + assertEquals(3, values.size) + assertIs<SettingKey.Japanese>(values[0]) + assertIs<SettingKey.Notice>(values[1]) + assertIs<SettingKey.ChNotice>(values[2]) + } +} diff --git a/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/settings/PlayerSettingsManagerTest.kt b/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/settings/PlayerSettingsManagerTest.kt new file mode 100644 index 0000000..bc716c9 --- /dev/null +++ b/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/settings/PlayerSettingsManagerTest.kt @@ -0,0 +1,159 @@ +package dev.m1sk9.lunaticChat.paper.settings + +import dev.m1sk9.lunaticChat.engine.settings.PlayerChatSettings +import dev.m1sk9.lunaticChat.engine.settings.PlayerSettingsData +import dev.m1sk9.lunaticChat.paper.TestUtils +import dev.m1sk9.lunaticChat.paper.TestUtils.createTestUUID +import io.mockk.every +import io.mockk.mockk +import io.mockk.verify +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertTrue + +class PlayerSettingsManagerTest { + private fun createManager( + initialData: PlayerSettingsData = PlayerSettingsData(), + ): Triple<PlayerSettingsManager, YamlPlayerSettingsStorage, TestUtils.TestLogger> { + val logger = TestUtils.TestLogger() + val storage = mockk<YamlPlayerSettingsStorage>(relaxed = true) + + every { storage.loadFromDisk() } returns initialData + + val manager = PlayerSettingsManager(storage, logger) + return Triple(manager, storage, logger) + } + + @Test + fun `initialize should load settings from storage`() { + val playerId = createTestUUID(1) + val data = + PlayerSettingsData( + japaneseConversion = mapOf(playerId to false), + directMessageNotification = mapOf(playerId to false), + channelMessageNotification = mapOf(playerId to false), + ) + + val (manager, _, logger) = createManager(initialData = data) + manager.initialize() + + val settings = manager.getSettings(playerId) + assertFalse(settings.japaneseConversionEnabled) + assertFalse(settings.directMessageNotificationEnabled) + assertFalse(settings.channelMessageNotificationEnabled) + assertTrue(logger.infoMessages.any { it.contains("1 players") }) + } + + @Test + fun `getSettings should return defaults for unknown player`() { + val (manager, _, _) = createManager() + manager.initialize() + + val settings = manager.getSettings(createTestUUID(99)) + + assertTrue(settings.japaneseConversionEnabled) + assertTrue(settings.directMessageNotificationEnabled) + assertTrue(settings.channelMessageNotificationEnabled) + } + + @Test + fun `updateSettings should update cache and queue save`() { + val (manager, storage, _) = createManager() + manager.initialize() + + val playerId = createTestUUID(1) + val settings = + PlayerChatSettings( + uuid = playerId, + japaneseConversionEnabled = false, + directMessageNotificationEnabled = false, + channelMessageNotificationEnabled = true, + ) + + manager.updateSettings(settings) + + val retrieved = manager.getSettings(playerId) + assertFalse(retrieved.japaneseConversionEnabled) + assertFalse(retrieved.directMessageNotificationEnabled) + assertTrue(retrieved.channelMessageNotificationEnabled) + + verify(exactly = 1) { storage.queueAsyncSave(any()) } + } + + @Test + fun `updateSettings should overwrite existing settings`() { + val playerId = createTestUUID(1) + val data = + PlayerSettingsData( + japaneseConversion = mapOf(playerId to true), + directMessageNotification = mapOf(playerId to true), + channelMessageNotification = mapOf(playerId to true), + ) + + val (manager, _, _) = createManager(initialData = data) + manager.initialize() + + manager.updateSettings( + PlayerChatSettings( + uuid = playerId, + japaneseConversionEnabled = false, + directMessageNotificationEnabled = false, + channelMessageNotificationEnabled = false, + ), + ) + + val settings = manager.getSettings(playerId) + assertFalse(settings.japaneseConversionEnabled) + assertFalse(settings.directMessageNotificationEnabled) + assertFalse(settings.channelMessageNotificationEnabled) + } + + @Test + fun `getSettings should return correct UUID`() { + val (manager, _, _) = createManager() + manager.initialize() + + val playerId = createTestUUID(1) + val settings = manager.getSettings(playerId) + + assertEquals(playerId, settings.uuid) + } + + @Test + fun `saveToDisk should call storage saveToDisk`() { + val (manager, storage, _) = createManager() + manager.initialize() + + manager.saveToDisk() + + verify(exactly = 1) { storage.saveToDisk(any()) } + } + + @Test + fun `multiple players should have independent settings`() { + val (manager, _, _) = createManager() + manager.initialize() + + val player1 = createTestUUID(1) + val player2 = createTestUUID(2) + + manager.updateSettings( + PlayerChatSettings(uuid = player1, japaneseConversionEnabled = false), + ) + manager.updateSettings( + PlayerChatSettings(uuid = player2, japaneseConversionEnabled = true), + ) + + assertFalse(manager.getSettings(player1).japaneseConversionEnabled) + assertTrue(manager.getSettings(player2).japaneseConversionEnabled) + } + + @Test + fun `initialize with empty data should work`() { + val (manager, _, logger) = createManager(PlayerSettingsData()) + manager.initialize() + + assertTrue(logger.infoMessages.any { it.contains("0 players") }) + } +} diff --git a/platform-velocity/src/test/kotlin/dev/m1sk9/lunaticChat/velocity/messaging/PluginMessageHandlerTest.kt b/platform-velocity/src/test/kotlin/dev/m1sk9/lunaticChat/velocity/messaging/PluginMessageHandlerTest.kt new file mode 100644 index 0000000..876eec6 --- /dev/null +++ b/platform-velocity/src/test/kotlin/dev/m1sk9/lunaticChat/velocity/messaging/PluginMessageHandlerTest.kt @@ -0,0 +1,211 @@ +package dev.m1sk9.lunaticChat.velocity.messaging + +import com.velocitypowered.api.event.connection.PluginMessageEvent +import com.velocitypowered.api.proxy.ProxyServer +import com.velocitypowered.api.proxy.ServerConnection +import com.velocitypowered.api.proxy.messages.ChannelIdentifier +import com.velocitypowered.api.proxy.messages.ChannelMessageSink +import com.velocitypowered.api.proxy.messages.ChannelMessageSource +import com.velocitypowered.api.proxy.messages.MinecraftChannelIdentifier +import com.velocitypowered.api.proxy.server.RegisteredServer +import com.velocitypowered.api.proxy.server.ServerInfo +import dev.m1sk9.lunaticChat.engine.protocol.PluginMessage +import dev.m1sk9.lunaticChat.engine.protocol.PluginMessageCodec +import dev.m1sk9.lunaticChat.engine.protocol.ProtocolVersion +import io.mockk.every +import io.mockk.mockk +import io.mockk.verify +import org.slf4j.Logger +import kotlin.test.Test + +class PluginMessageHandlerTest { + private val channel = MinecraftChannelIdentifier.create("lunaticchat", "main") + + private fun createHandler(pluginVersion: String = "0.10.0"): Triple<PluginMessageHandler, ProxyServer, CrossServerChatRelay> { + val plugin = Any() + val server = mockk<ProxyServer>(relaxed = true) + val logger = mockk<Logger>(relaxed = true) + val relay = mockk<CrossServerChatRelay>(relaxed = true) + + val handler = PluginMessageHandler(plugin, server, logger, pluginVersion, relay) + return Triple(handler, server, relay) + } + + private fun createServerConnection(serverName: String = "lobby"): ServerConnection { + val connection = mockk<ServerConnection>(relaxed = true) + val serverInfo = mockk<ServerInfo>(relaxed = true) + val registeredServer = mockk<RegisteredServer>(relaxed = true) + every { serverInfo.name } returns serverName + every { connection.serverInfo } returns serverInfo + every { connection.server } returns registeredServer + return connection + } + + private fun createPluginMessageEvent( + source: ChannelMessageSource, + target: ChannelMessageSink, + identifier: ChannelIdentifier, + data: ByteArray, + ): PluginMessageEvent = PluginMessageEvent(source, target, identifier, data) + + @Test + fun `onPluginMessage should handle successful handshake`() { + val (handler, _, _) = createHandler(pluginVersion = "0.10.0") + val connection = createServerConnection() + + val handshake = + PluginMessage.Handshake( + pluginVersion = "0.10.0", + protocolMajor = ProtocolVersion.MAJOR, + protocolMinor = ProtocolVersion.MINOR, + protocolPatch = ProtocolVersion.PATCH, + ) + val data = PluginMessageCodec.encode(handshake) + val event = createPluginMessageEvent(connection, mockk(relaxed = true), channel, data) + + handler.onPluginMessage(event) + + verify { connection.sendPluginMessage(any<ChannelIdentifier>(), any<ByteArray>()) } + } + + @Test + fun `onPluginMessage should reject version mismatch handshake`() { + val (handler, _, _) = createHandler(pluginVersion = "0.10.0") + val connection = createServerConnection() + + val handshake = + PluginMessage.Handshake( + pluginVersion = "0.9.0", + protocolMajor = ProtocolVersion.MAJOR, + protocolMinor = ProtocolVersion.MINOR, + protocolPatch = ProtocolVersion.PATCH, + ) + val data = PluginMessageCodec.encode(handshake) + val event = createPluginMessageEvent(connection, mockk(relaxed = true), channel, data) + + handler.onPluginMessage(event) + + verify { connection.sendPluginMessage(any<ChannelIdentifier>(), any<ByteArray>()) } + } + + @Test + fun `onPluginMessage should reject protocol mismatch handshake`() { + val (handler, _, _) = createHandler(pluginVersion = "0.10.0") + val connection = createServerConnection() + + val handshake = + PluginMessage.Handshake( + pluginVersion = "0.10.0", + protocolMajor = ProtocolVersion.MAJOR + 1, + protocolMinor = ProtocolVersion.MINOR, + protocolPatch = ProtocolVersion.PATCH, + ) + val data = PluginMessageCodec.encode(handshake) + val event = createPluginMessageEvent(connection, mockk(relaxed = true), channel, data) + + handler.onPluginMessage(event) + + verify { connection.sendPluginMessage(any<ChannelIdentifier>(), any<ByteArray>()) } + } + + @Test + fun `onPluginMessage should handle status request`() { + val (handler, _, _) = createHandler() + val connection = createServerConnection() + + val data = PluginMessageCodec.encode(PluginMessage.StatusRequest) + val event = createPluginMessageEvent(connection, mockk(relaxed = true), channel, data) + + handler.onPluginMessage(event) + + verify { connection.sendPluginMessage(any<ChannelIdentifier>(), any<ByteArray>()) } + } + + @Test + fun `onPluginMessage should relay global chat message`() { + val (handler, _, relay) = createHandler() + val connection = createServerConnection() + + val chatMessage = + PluginMessage.GlobalChatMessage( + messageId = "msg-1", + serverName = "lobby", + playerId = "00000001-0000-0000-0000-000000000000", + playerName = "TestPlayer", + message = "Hello!", + timestamp = 1000L, + ) + val data = PluginMessageCodec.encode(chatMessage) + val event = createPluginMessageEvent(connection, mockk(relaxed = true), channel, data) + + handler.onPluginMessage(event) + + verify { relay.relayGlobalMessage(any<PluginMessage.GlobalChatMessage>(), any<RegisteredServer>()) } + } + + @Test + fun `onPluginMessage should ignore messages from wrong channel`() { + val (handler, _, relay) = createHandler() + val connection = createServerConnection() + + val wrongChannel = MinecraftChannelIdentifier.create("other", "channel") + val data = PluginMessageCodec.encode(PluginMessage.StatusRequest) + val event = createPluginMessageEvent(connection, mockk(relaxed = true), wrongChannel, data) + + handler.onPluginMessage(event) + + verify(exactly = 0) { relay.relayGlobalMessage(any<PluginMessage.GlobalChatMessage>(), any<RegisteredServer>()) } + } + + @Test + fun `onPluginMessage should ignore messages from non-server source`() { + val (handler, _, relay) = createHandler() + val source = mockk<ChannelMessageSource>(relaxed = true) + + val data = PluginMessageCodec.encode(PluginMessage.StatusRequest) + val event = createPluginMessageEvent(source, mockk(relaxed = true), channel, data) + + handler.onPluginMessage(event) + + verify(exactly = 0) { relay.relayGlobalMessage(any<PluginMessage.GlobalChatMessage>(), any<RegisteredServer>()) } + } + + @Test + fun `initialize should register channel and listener`() { + val (handler, server, _) = createHandler() + + handler.initialize() + + verify { server.channelRegistrar.register(any<ChannelIdentifier>()) } + verify { server.eventManager.register(any(), handler) } + } + + @Test + fun `shutdown should unregister listener`() { + val (handler, server, _) = createHandler() + + handler.shutdown() + + verify { server.eventManager.unregisterListener(any(), handler) } + } + + @Test + fun `handshake with matching patch difference should succeed`() { + val (handler, _, _) = createHandler(pluginVersion = "0.10.0") + val connection = createServerConnection() + + val handshake = + PluginMessage.Handshake( + pluginVersion = "0.10.0", + protocolMajor = ProtocolVersion.MAJOR, + protocolMinor = ProtocolVersion.MINOR, + protocolPatch = ProtocolVersion.PATCH + 5, + ) + val data = PluginMessageCodec.encode(handshake) + val event = createPluginMessageEvent(connection, mockk(relaxed = true), channel, data) + + handler.onPluginMessage(event) + + verify { connection.sendPluginMessage(any<ChannelIdentifier>(), any<ByteArray>()) } + } +} |