From 232ce55f187d7ec0cea2037d8d285d60465e51ff Mon Sep 17 00:00:00 2001 From: Sho Sakuma Date: Sun, 2 Aug 2026 19:24:41 +0900 Subject: refactor: describe a setting once, on its SettingKey The three setting handlers were the same 53-line class three times over, differing in one copy() field, one read, and two message keys. Adding persistence, auditing or a permission check to settings meant writing it three times, and a fourth setting meant a fourth copy. A setting is its key, the messages that report it, and how it is read from and written to PlayerChatSettings - so SettingKey now carries all of that, and SettingHandler is the single mechanism that applies it. The registry keeps its role as the seam where features decide which settings exist, which is why registration is still conditional in LunaticChat. SettingHandlerTest now asserts over every SettingKey rather than repeating five near-identical tests per handler, so a new setting is covered the moment it is declared. It also pins down the property that made the old duplication dangerous: writing one setting must not disturb the others. Co-Authored-By: Claude --- .../dev/m1sk9/lunaticChat/paper/LunaticChat.kt | 38 ++-- .../paper/command/setting/SettingHandler.kt | 43 +++-- .../paper/command/setting/SettingKey.kt | 47 ++++- .../handler/ChannelMessageNoticeSettingHandler.kt | 53 ------ .../handler/DirectMessageNoticeSettingHandler.kt | 53 ------ .../handler/JapaneseConversionSettingHandler.kt | 53 ------ .../command/setting/SettingHandlerRegistryTest.kt | 16 +- .../paper/command/setting/SettingHandlerTest.kt | 106 ++++++++++++ .../command/setting/handler/SettingHandlerTest.kt | 191 --------------------- 9 files changed, 196 insertions(+), 404 deletions(-) delete mode 100644 platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/ChannelMessageNoticeSettingHandler.kt delete mode 100644 platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/DirectMessageNoticeSettingHandler.kt delete mode 100644 platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/JapaneseConversionSettingHandler.kt create mode 100644 platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingHandlerTest.kt delete mode 100644 platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/SettingHandlerTest.kt (limited to 'platform-paper') diff --git a/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/LunaticChat.kt b/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/LunaticChat.kt index e006299..f0bbc2c 100644 --- a/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/LunaticChat.kt +++ b/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/LunaticChat.kt @@ -10,10 +10,9 @@ import dev.m1sk9.lunaticChat.paper.command.impl.ReplyCommand import dev.m1sk9.lunaticChat.paper.command.impl.TellCommand import dev.m1sk9.lunaticChat.paper.command.impl.lc.LunaticChatCommand import dev.m1sk9.lunaticChat.paper.command.impl.lcv.VelocityStatusCommand +import dev.m1sk9.lunaticChat.paper.command.setting.SettingHandler import dev.m1sk9.lunaticChat.paper.command.setting.SettingHandlerRegistry -import dev.m1sk9.lunaticChat.paper.command.setting.handler.ChannelMessageNoticeSettingHandler -import dev.m1sk9.lunaticChat.paper.command.setting.handler.DirectMessageNoticeSettingHandler -import dev.m1sk9.lunaticChat.paper.command.setting.handler.JapaneseConversionSettingHandler +import dev.m1sk9.lunaticChat.paper.command.setting.SettingKey import dev.m1sk9.lunaticChat.paper.common.UpdateCheckResult import dev.m1sk9.lunaticChat.paper.common.UpdateChecker import dev.m1sk9.lunaticChat.paper.config.ConfigManager @@ -109,31 +108,16 @@ class LunaticChat : val commandRegistry = CommandRegistry(this) val settingHandlerRegistry = SettingHandlerRegistry() - // Always register DM notification setting - settingHandlerRegistry.register( - DirectMessageNoticeSettingHandler( - services.playerSettingsManager, - services.languageManager, - ), - ) - - // Always register channel message notification setting if channel is enabled - if (services.channelManager != null) { - settingHandlerRegistry.register( - ChannelMessageNoticeSettingHandler( - services.playerSettingsManager, - services.languageManager, - ), - ) - } - - // Conditionally register Japanese conversion setting - if (services.romajiConverter != null) { + // DM notification is always available; the other two follow their feature + val enabledSettings = + buildList { + add(SettingKey.Notice) + if (services.channelManager != null) add(SettingKey.ChNotice) + if (services.romajiConverter != null) add(SettingKey.Japanese) + } + enabledSettings.forEach { key -> settingHandlerRegistry.register( - JapaneseConversionSettingHandler( - services.playerSettingsManager, - services.languageManager, - ), + SettingHandler(key, services.playerSettingsManager, services.languageManager), ) } diff --git a/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingHandler.kt b/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingHandler.kt index c36257c..7b1fcdd 100644 --- a/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingHandler.kt +++ b/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingHandler.kt @@ -2,18 +2,21 @@ package dev.m1sk9.lunaticChat.paper.command.setting import dev.m1sk9.lunaticChat.engine.command.CommandResult import dev.m1sk9.lunaticChat.paper.command.core.CommandContext +import dev.m1sk9.lunaticChat.paper.i18n.LanguageManager +import dev.m1sk9.lunaticChat.paper.i18n.MessageFormatter +import dev.m1sk9.lunaticChat.paper.settings.PlayerSettingsManager /** - * Interface for handling individual setting operations. - * Each setting (japanese, notice, etc.) implements this interface to provide - * its own logic for getting, setting, and displaying status. + * Reads and writes one player setting, identified by [key]. + * + * Everything that differs between settings lives on the [SettingKey]; this class is the shared + * mechanism that applies it. */ -interface SettingHandler { - /** - * The setting key this handler manages. - */ - val key: SettingKey - +class SettingHandler( + val key: SettingKey, + private val settingsManager: PlayerSettingsManager, + private val languageManager: LanguageManager, +) { /** * Enables or disables the setting for a player. * @@ -24,7 +27,14 @@ interface SettingHandler { fun execute( ctx: CommandContext, enable: Boolean, - ): CommandResult + ): CommandResult { + val player = ctx.requirePlayer() + val settings = settingsManager.getSettings(player.uniqueId) + settingsManager.updateSettings(key.write(settings, enable)) + + player.sendMessage(MessageFormatter.formatSuccess(message(key.toggleMessageKey, enable))) + return CommandResult.Success + } /** * Shows the current status of the setting for a player. @@ -32,5 +42,16 @@ interface SettingHandler { * @param ctx The command context containing player information * @return Command result indicating success or failure */ - fun showStatus(ctx: CommandContext): CommandResult + fun showStatus(ctx: CommandContext): CommandResult { + val player = ctx.requirePlayer() + val settings = settingsManager.getSettings(player.uniqueId) + + player.sendMessage(MessageFormatter.format(message(key.statusMessageKey, key.read(settings)))) + return CommandResult.Success + } + + private fun message( + messageKey: String, + enabled: Boolean, + ): String = languageManager.getMessage(messageKey, mapOf("toggle" to languageManager.getToggleText(enabled))) } diff --git a/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingKey.kt b/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingKey.kt index 076a7aa..2106cc5 100644 --- a/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingKey.kt +++ b/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingKey.kt @@ -1,29 +1,68 @@ package dev.m1sk9.lunaticChat.paper.command.setting +import dev.m1sk9.lunaticChat.engine.settings.PlayerChatSettings + /** * Sealed class representing all available setting keys. - * Each setting key has a unique identifier used in command arguments. + * + * A setting is fully described here: the literal it is typed as, the messages that report it, and + * how it is read from and written to [PlayerChatSettings]. [SettingHandler] is the one mechanism + * that drives all of them. + * + * @property key Unique identifier used in command arguments + * @property toggleMessageKey Language key for the message confirming a change + * @property statusMessageKey Language key for the message reporting the current value */ sealed class SettingKey( val key: String, + val toggleMessageKey: String, + val statusMessageKey: String, ) { + abstract fun read(settings: PlayerChatSettings): Boolean + + abstract fun write( + settings: PlayerChatSettings, + enabled: Boolean, + ): PlayerChatSettings + /** * Japanese romaji conversion setting * Command: /lc setting japanese */ - data object Japanese : SettingKey("japanese") + data object Japanese : SettingKey("japanese", "romajiConversion.toggle", "romajiConversion.status") { + override fun read(settings: PlayerChatSettings) = settings.japaneseConversionEnabled + + override fun write( + settings: PlayerChatSettings, + enabled: Boolean, + ) = settings.copy(japaneseConversionEnabled = enabled) + } /** * Direct message notification setting * Command: /lc setting notice */ - data object Notice : SettingKey("notice") + data object Notice : SettingKey("notice", "directMessage.noticeToggle", "directMessage.noticeStatus") { + override fun read(settings: PlayerChatSettings) = settings.directMessageNotificationEnabled + + override fun write( + settings: PlayerChatSettings, + enabled: Boolean, + ) = settings.copy(directMessageNotificationEnabled = enabled) + } /** * Channel message notification setting * Command: /lc setting chNotice */ - data object ChNotice : SettingKey("chNotice") + data object ChNotice : SettingKey("chNotice", "channelMessage.noticeToggle", "channelMessage.noticeStatus") { + override fun read(settings: PlayerChatSettings) = settings.channelMessageNotificationEnabled + + override fun write( + settings: PlayerChatSettings, + enabled: Boolean, + ) = settings.copy(channelMessageNotificationEnabled = enabled) + } companion object { /** diff --git a/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/ChannelMessageNoticeSettingHandler.kt b/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/ChannelMessageNoticeSettingHandler.kt deleted file mode 100644 index 8867e7c..0000000 --- a/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/ChannelMessageNoticeSettingHandler.kt +++ /dev/null @@ -1,53 +0,0 @@ -package dev.m1sk9.lunaticChat.paper.command.setting.handler - -import dev.m1sk9.lunaticChat.engine.command.CommandResult -import dev.m1sk9.lunaticChat.paper.command.core.CommandContext -import dev.m1sk9.lunaticChat.paper.command.setting.SettingHandler -import dev.m1sk9.lunaticChat.paper.command.setting.SettingKey -import dev.m1sk9.lunaticChat.paper.i18n.LanguageManager -import dev.m1sk9.lunaticChat.paper.i18n.MessageFormatter -import dev.m1sk9.lunaticChat.paper.settings.PlayerSettingsManager - -/** - * Handles the channel message notification setting. - * Manages enabling/disabling channel message notifications for players. - */ -class ChannelMessageNoticeSettingHandler( - private val settingsManager: PlayerSettingsManager, - private val languageManager: LanguageManager, -) : SettingHandler { - override val key: SettingKey = SettingKey.ChNotice - - override fun execute( - ctx: CommandContext, - enable: Boolean, - ): CommandResult { - val player = ctx.requirePlayer() - val currentSettings = settingsManager.getSettings(player.uniqueId) - val updatedSettings = currentSettings.copy(channelMessageNotificationEnabled = enable) - settingsManager.updateSettings(updatedSettings) - - val toggleText = languageManager.getToggleText(enable) - val message = - MessageFormatter.formatSuccess( - languageManager.getMessage("channelMessage.noticeToggle", mapOf("toggle" to toggleText)), - ) - - player.sendMessage(message) - return CommandResult.Success - } - - override fun showStatus(ctx: CommandContext): CommandResult { - val player = ctx.requirePlayer() - val settings = settingsManager.getSettings(player.uniqueId) - - val toggleText = languageManager.getToggleText(settings.channelMessageNotificationEnabled) - val message = - MessageFormatter.format( - languageManager.getMessage("channelMessage.noticeStatus", mapOf("toggle" to toggleText)), - ) - - player.sendMessage(message) - return CommandResult.Success - } -} diff --git a/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/DirectMessageNoticeSettingHandler.kt b/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/DirectMessageNoticeSettingHandler.kt deleted file mode 100644 index 1564615..0000000 --- a/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/DirectMessageNoticeSettingHandler.kt +++ /dev/null @@ -1,53 +0,0 @@ -package dev.m1sk9.lunaticChat.paper.command.setting.handler - -import dev.m1sk9.lunaticChat.engine.command.CommandResult -import dev.m1sk9.lunaticChat.paper.command.core.CommandContext -import dev.m1sk9.lunaticChat.paper.command.setting.SettingHandler -import dev.m1sk9.lunaticChat.paper.command.setting.SettingKey -import dev.m1sk9.lunaticChat.paper.i18n.LanguageManager -import dev.m1sk9.lunaticChat.paper.i18n.MessageFormatter -import dev.m1sk9.lunaticChat.paper.settings.PlayerSettingsManager - -/** - * Handles the direct message notification setting. - * Manages enabling/disabling DM notifications for players. - */ -class DirectMessageNoticeSettingHandler( - private val settingsManager: PlayerSettingsManager, - private val languageManager: LanguageManager, -) : SettingHandler { - override val key: SettingKey = SettingKey.Notice - - override fun execute( - ctx: CommandContext, - enable: Boolean, - ): CommandResult { - val player = ctx.requirePlayer() - val currentSettings = settingsManager.getSettings(player.uniqueId) - val updatedSettings = currentSettings.copy(directMessageNotificationEnabled = enable) - settingsManager.updateSettings(updatedSettings) - - val toggleText = languageManager.getToggleText(enable) - val message = - MessageFormatter.formatSuccess( - languageManager.getMessage("directMessage.noticeToggle", mapOf("toggle" to toggleText)), - ) - - player.sendMessage(message) - return CommandResult.Success - } - - override fun showStatus(ctx: CommandContext): CommandResult { - val player = ctx.requirePlayer() - val settings = settingsManager.getSettings(player.uniqueId) - - val toggleText = languageManager.getToggleText(settings.directMessageNotificationEnabled) - val message = - MessageFormatter.format( - languageManager.getMessage("directMessage.noticeStatus", mapOf("toggle" to toggleText)), - ) - - player.sendMessage(message) - return CommandResult.Success - } -} diff --git a/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/JapaneseConversionSettingHandler.kt b/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/JapaneseConversionSettingHandler.kt deleted file mode 100644 index 2c682ba..0000000 --- a/platform-paper/src/main/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/JapaneseConversionSettingHandler.kt +++ /dev/null @@ -1,53 +0,0 @@ -package dev.m1sk9.lunaticChat.paper.command.setting.handler - -import dev.m1sk9.lunaticChat.engine.command.CommandResult -import dev.m1sk9.lunaticChat.paper.command.core.CommandContext -import dev.m1sk9.lunaticChat.paper.command.setting.SettingHandler -import dev.m1sk9.lunaticChat.paper.command.setting.SettingKey -import dev.m1sk9.lunaticChat.paper.i18n.LanguageManager -import dev.m1sk9.lunaticChat.paper.i18n.MessageFormatter -import dev.m1sk9.lunaticChat.paper.settings.PlayerSettingsManager - -/** - * Handles the Japanese romaji conversion setting. - * Manages enabling/disabling Japanese conversion for players. - */ -class JapaneseConversionSettingHandler( - private val settingsManager: PlayerSettingsManager, - private val languageManager: LanguageManager, -) : SettingHandler { - override val key: SettingKey = SettingKey.Japanese - - override fun execute( - ctx: CommandContext, - enable: Boolean, - ): CommandResult { - val player = ctx.requirePlayer() - val currentSettings = settingsManager.getSettings(player.uniqueId) - val updatedSettings = currentSettings.copy(japaneseConversionEnabled = enable) - settingsManager.updateSettings(updatedSettings) - - val toggleText = languageManager.getToggleText(enable) - val message = - MessageFormatter.formatSuccess( - languageManager.getMessage("romajiConversion.toggle", mapOf("toggle" to toggleText)), - ) - - player.sendMessage(message) - return CommandResult.Success - } - - override fun showStatus(ctx: CommandContext): CommandResult { - val player = ctx.requirePlayer() - val settings = settingsManager.getSettings(player.uniqueId) - - val toggleText = languageManager.getToggleText(settings.japaneseConversionEnabled) - val message = - MessageFormatter.format( - languageManager.getMessage("romajiConversion.status", mapOf("toggle" to toggleText)), - ) - - player.sendMessage(message) - return CommandResult.Success - } -} diff --git a/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingHandlerRegistryTest.kt b/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingHandlerRegistryTest.kt index 52927a8..e05426e 100644 --- a/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingHandlerRegistryTest.kt +++ b/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingHandlerRegistryTest.kt @@ -1,7 +1,8 @@ package dev.m1sk9.lunaticChat.paper.command.setting -import dev.m1sk9.lunaticChat.engine.command.CommandResult -import dev.m1sk9.lunaticChat.paper.command.core.CommandContext +import dev.m1sk9.lunaticChat.paper.i18n.LanguageManager +import dev.m1sk9.lunaticChat.paper.settings.PlayerSettingsManager +import io.mockk.mockk import kotlin.test.Test import kotlin.test.assertEquals import kotlin.test.assertNull @@ -9,16 +10,7 @@ import kotlin.test.assertTrue class SettingHandlerRegistryTest { private fun createMockHandler(settingKey: SettingKey): SettingHandler = - object : SettingHandler { - override val key: SettingKey = settingKey - - override fun execute( - ctx: CommandContext, - enable: Boolean, - ): CommandResult = CommandResult.Success - - override fun showStatus(ctx: CommandContext): CommandResult = CommandResult.Success - } + SettingHandler(settingKey, mockk(relaxed = true), mockk(relaxed = true)) @Test fun `register should make handler retrievable`() { diff --git a/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingHandlerTest.kt b/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingHandlerTest.kt new file mode 100644 index 0000000..3e80ba0 --- /dev/null +++ b/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/SettingHandlerTest.kt @@ -0,0 +1,106 @@ +package dev.m1sk9.lunaticChat.paper.command.setting + +import dev.m1sk9.lunaticChat.engine.command.CommandResult +import dev.m1sk9.lunaticChat.paper.TestUtils +import dev.m1sk9.lunaticChat.paper.command.core.CommandContext +import dev.m1sk9.lunaticChat.paper.i18n.LanguageManager +import dev.m1sk9.lunaticChat.paper.settings.PlayerSettingsManager +import io.mockk.every +import io.mockk.mockk +import io.mockk.verify +import net.kyori.adventure.text.Component +import java.util.UUID +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertIs +import kotlin.test.assertTrue + +class SettingHandlerTest { + private val testUUID = UUID.fromString("00000001-0000-0000-0000-000000000000") + + private class Fixture( + key: SettingKey, + uuid: UUID, + ) { + val ctx = mockk(relaxed = true) + val settingsManager = mockk(relaxed = true) + val languageManager = mockk(relaxed = true) + val handler: SettingHandler + + init { + every { ctx.requirePlayer() } returns TestUtils.createMockPlayer(uuid = uuid, name = "TestPlayer") + every { settingsManager.getSettings(uuid) } returns TestUtils.createTestPlayerSettings(uuid = uuid) + every { languageManager.getMessage(any(), any()) } returns "test message" + every { languageManager.getToggleText(any()) } returns "ON" + handler = SettingHandler(key, settingsManager, languageManager) + } + } + + private fun eachKey(assertion: (SettingKey, Fixture) -> Unit) = + SettingKey.values().forEach { key -> assertion(key, Fixture(key, testUUID)) } + + @Test + fun `execute enable writes the setting as enabled`() = + eachKey { key, f -> + assertIs(f.handler.execute(f.ctx, true)) + verify { f.settingsManager.updateSettings(match { key.read(it) }) } + } + + @Test + fun `execute disable writes the setting as disabled`() = + eachKey { key, f -> + assertIs(f.handler.execute(f.ctx, false)) + verify { f.settingsManager.updateSettings(match { !key.read(it) }) } + } + + @Test + fun `execute reports the change with the toggle message`() = + eachKey { key, f -> + f.handler.execute(f.ctx, true) + + val player = f.ctx.requirePlayer() + verify { f.languageManager.getMessage(key.toggleMessageKey, mapOf("toggle" to "ON")) } + verify { player.sendMessage(any()) } + } + + @Test + fun `showStatus reports the current value with the status message`() = + eachKey { key, f -> + assertIs(f.handler.showStatus(f.ctx)) + + val player = f.ctx.requirePlayer() + verify { f.languageManager.getMessage(key.statusMessageKey, mapOf("toggle" to "ON")) } + verify { player.sendMessage(any()) } + } + + @Test + fun `handler exposes the key it was built for`() = eachKey { key, f -> assertEquals(key, f.handler.key) } + + @Test + fun `each key round-trips through write and read`() { + val settings = TestUtils.createTestPlayerSettings(uuid = testUUID) + + SettingKey.values().forEach { key -> + assertTrue(key.read(key.write(settings, true)), key.key) + assertFalse(key.read(key.write(settings, false)), key.key) + } + } + + @Test + fun `writing one key leaves the other settings untouched`() { + val original = TestUtils.createTestPlayerSettings(uuid = testUUID) + + SettingKey.values().forEach { key -> + val flipped = key.write(original, !key.read(original)) + + SettingKey.values().filterNot { it == key }.forEach { other -> + assertEquals( + other.read(original), + other.read(flipped), + "${other.key} changed while writing ${key.key}", + ) + } + } + } +} diff --git a/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/SettingHandlerTest.kt b/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/SettingHandlerTest.kt deleted file mode 100644 index 1967e1c..0000000 --- a/platform-paper/src/test/kotlin/dev/m1sk9/lunaticChat/paper/command/setting/handler/SettingHandlerTest.kt +++ /dev/null @@ -1,191 +0,0 @@ -package dev.m1sk9.lunaticChat.paper.command.setting.handler - -import dev.m1sk9.lunaticChat.engine.command.CommandResult -import dev.m1sk9.lunaticChat.paper.TestUtils -import dev.m1sk9.lunaticChat.paper.command.core.CommandContext -import dev.m1sk9.lunaticChat.paper.command.setting.SettingKey -import dev.m1sk9.lunaticChat.paper.i18n.LanguageManager -import dev.m1sk9.lunaticChat.paper.settings.PlayerSettingsManager -import io.mockk.every -import io.mockk.mockk -import io.mockk.verify -import net.kyori.adventure.text.Component -import java.util.UUID -import kotlin.test.Test -import kotlin.test.assertIs - -class SettingHandlerTest { - private val testUUID = UUID.fromString("00000001-0000-0000-0000-000000000000") - - private fun createDependencies(): Triple { - val player = TestUtils.createMockPlayer(uuid = testUUID, name = "TestPlayer") - val ctx = mockk(relaxed = true) - every { ctx.requirePlayer() } returns player - - val settingsManager = mockk(relaxed = true) - every { settingsManager.getSettings(testUUID) } returns - TestUtils.createTestPlayerSettings(uuid = testUUID) - - val languageManager = mockk(relaxed = true) - every { languageManager.getMessage(any(), any()) } returns "test message" - every { languageManager.getToggleText(any()) } returns "ON" - - return Triple(ctx, settingsManager, languageManager) - } - - // --- JapaneseConversionSettingHandler --- - - @Test - fun `JapaneseConversionSettingHandler key should be Japanese`() { - val (_, settingsManager, languageManager) = createDependencies() - val handler = JapaneseConversionSettingHandler(settingsManager, languageManager) - assertIs(handler.key) - } - - @Test - fun `JapaneseConversionSettingHandler execute enable should return Success`() { - val (ctx, settingsManager, languageManager) = createDependencies() - val handler = JapaneseConversionSettingHandler(settingsManager, languageManager) - - val result = handler.execute(ctx, true) - - assertIs(result) - verify { settingsManager.updateSettings(match { it.japaneseConversionEnabled }) } - } - - @Test - fun `JapaneseConversionSettingHandler execute disable should return Success`() { - val (ctx, settingsManager, languageManager) = createDependencies() - val handler = JapaneseConversionSettingHandler(settingsManager, languageManager) - - val result = handler.execute(ctx, false) - - assertIs(result) - verify { settingsManager.updateSettings(match { !it.japaneseConversionEnabled }) } - } - - @Test - fun `JapaneseConversionSettingHandler showStatus should return Success`() { - val (ctx, settingsManager, languageManager) = createDependencies() - val handler = JapaneseConversionSettingHandler(settingsManager, languageManager) - - val result = handler.showStatus(ctx) - - assertIs(result) - } - - @Test - fun `JapaneseConversionSettingHandler execute should send message to player`() { - val (ctx, settingsManager, languageManager) = createDependencies() - val handler = JapaneseConversionSettingHandler(settingsManager, languageManager) - - handler.execute(ctx, true) - - val player = ctx.requirePlayer() - verify { player.sendMessage(any()) } - } - - // --- DirectMessageNoticeSettingHandler --- - - @Test - fun `DirectMessageNoticeSettingHandler key should be Notice`() { - val (_, settingsManager, languageManager) = createDependencies() - val handler = DirectMessageNoticeSettingHandler(settingsManager, languageManager) - assertIs(handler.key) - } - - @Test - fun `DirectMessageNoticeSettingHandler execute enable should return Success`() { - val (ctx, settingsManager, languageManager) = createDependencies() - val handler = DirectMessageNoticeSettingHandler(settingsManager, languageManager) - - val result = handler.execute(ctx, true) - - assertIs(result) - verify { settingsManager.updateSettings(match { it.directMessageNotificationEnabled }) } - } - - @Test - fun `DirectMessageNoticeSettingHandler execute disable should return Success`() { - val (ctx, settingsManager, languageManager) = createDependencies() - val handler = DirectMessageNoticeSettingHandler(settingsManager, languageManager) - - val result = handler.execute(ctx, false) - - assertIs(result) - verify { settingsManager.updateSettings(match { !it.directMessageNotificationEnabled }) } - } - - @Test - fun `DirectMessageNoticeSettingHandler showStatus should return Success`() { - val (ctx, settingsManager, languageManager) = createDependencies() - val handler = DirectMessageNoticeSettingHandler(settingsManager, languageManager) - - val result = handler.showStatus(ctx) - - assertIs(result) - } - - @Test - fun `DirectMessageNoticeSettingHandler execute should send message to player`() { - val (ctx, settingsManager, languageManager) = createDependencies() - val handler = DirectMessageNoticeSettingHandler(settingsManager, languageManager) - - handler.execute(ctx, true) - - val player = ctx.requirePlayer() - verify { player.sendMessage(any()) } - } - - // --- ChannelMessageNoticeSettingHandler --- - - @Test - fun `ChannelMessageNoticeSettingHandler key should be ChNotice`() { - val (_, settingsManager, languageManager) = createDependencies() - val handler = ChannelMessageNoticeSettingHandler(settingsManager, languageManager) - assertIs(handler.key) - } - - @Test - fun `ChannelMessageNoticeSettingHandler execute enable should return Success`() { - val (ctx, settingsManager, languageManager) = createDependencies() - val handler = ChannelMessageNoticeSettingHandler(settingsManager, languageManager) - - val result = handler.execute(ctx, true) - - assertIs(result) - verify { settingsManager.updateSettings(match { it.channelMessageNotificationEnabled }) } - } - - @Test - fun `ChannelMessageNoticeSettingHandler execute disable should return Success`() { - val (ctx, settingsManager, languageManager) = createDependencies() - val handler = ChannelMessageNoticeSettingHandler(settingsManager, languageManager) - - val result = handler.execute(ctx, false) - - assertIs(result) - verify { settingsManager.updateSettings(match { !it.channelMessageNotificationEnabled }) } - } - - @Test - fun `ChannelMessageNoticeSettingHandler showStatus should return Success`() { - val (ctx, settingsManager, languageManager) = createDependencies() - val handler = ChannelMessageNoticeSettingHandler(settingsManager, languageManager) - - val result = handler.showStatus(ctx) - - assertIs(result) - } - - @Test - fun `ChannelMessageNoticeSettingHandler execute should send message to player`() { - val (ctx, settingsManager, languageManager) = createDependencies() - val handler = ChannelMessageNoticeSettingHandler(settingsManager, languageManager) - - handler.execute(ctx, true) - - val player = ctx.requirePlayer() - verify { player.sendMessage(any()) } - } -} -- cgit v1.2.1