kageru/discord-kagebot
1
0
Fork 0
Code Issues 4 Pull Requests Releases Wiki Activity

Send a copy of each deleted message to the original author

This commit is contained in:
kageru 2019-06-10 14:15:03 +02:00
parent 41a1e62574
commit 1836844950
Signed by: kageru
GPG Key ID: 8282A2BEA4ADA3D2
5 changed files with 61 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/main/kotlin/moe/kageru/kagebot/Config.kt
View File

@ -40,4 +40,4 @@ class Config(
}
data class System(val serverId: String, val color: String)
data class Localization(val permissionDenied: String, val redirectedMessage: String)
data class Localization(val permissionDenied: String, val redirectedMessage: String, val messageDeleted: String)

7
src/main/kotlin/moe/kageru/kagebot/MessageActions.kt
View File

@ -9,6 +9,13 @@ class MessageActions(private val delete: Boolean, private val redirect: Redirect
fun run(message: MessageCreateEvent, command: Command) {
if (delete && message.message.canYouDelete()) {
message.deleteMessage()
message.messageAuthor.asUser().ifNotEmpty { user ->
user.sendMessage(
MessageUtil.getEmbedBuilder()
.addField("Blacklisted", config.localization.messageDeleted)
.addField("Original:", "“${message.readableMessageContent}”")
)
}
}
redirect?.execute(message, command)
}

1
src/main/resources/config.toml
View File

@ -6,6 +6,7 @@ color = "#1793d0"
permissionDenied = "You do not have permission to use this command."
# results in <name> says <message>
redirectedMessage = "says"
messageDeleted = "Your message was deleted because it contained a banned word or phrase."
[[command]]
trigger = "!ping"

64
src/test/kotlin/moe/kageru/kagebot/CommandTest.kt
View File

@ -7,8 +7,11 @@ import io.mockk.every
import io.mockk.mockk
import io.mockk.verify
import moe.kageru.kagebot.Config.Companion.config
import moe.kageru.kagebot.TestUtil.embedToString
import moe.kageru.kagebot.TestUtil.messageableAuthor
import moe.kageru.kagebot.TestUtil.mockMessage
import moe.kageru.kagebot.TestUtil.testMessageSuccess
import org.javacord.api.entity.message.embed.EmbedBuilder
import org.javacord.core.entity.message.embed.EmbedBuilderDelegateImpl
class CommandTest : StringSpec({
TestUtil.prepareServerConfig()
@ -26,37 +29,37 @@ class CommandTest : StringSpec({
}
"should not react to own message" {
val calls = mutableListOf<String>()
Kagebot.processMessage(TestUtil.mockMessage("!ping", capturedCalls = calls, isSelf = true))
calls.size shouldBe 0
Kagebot.processMessage(mockMessage("!ping", replies = calls, isSelf = true))
calls shouldBe mutableListOf()
}
"should delete messages" {
val mockMessage = TestUtil.mockMessage("delet this")
"should delete messages and send copy to author" {
val replies = mutableListOf<EmbedBuilder>()
val messageContent = "delet this"
val mockMessage = mockMessage(messageContent)
every { mockMessage.deleteMessage() } returns mockk()
every { mockMessage.messageAuthor.asUser() } returns messageableAuthor(replies)
Kagebot.processMessage(mockMessage)
verify(exactly = 1) { mockMessage.deleteMessage() }
replies.size shouldBe 1
embedToString(replies[0]) shouldContain messageContent
}
"should refuse command without permissions" {
val calls = mutableListOf<String>()
val mockMessage = TestUtil.mockMessage("!restricted", capturedCalls = calls)
every { mockMessage.messageAuthor.asUser() } returns mockk {
every { get().getRoles(any()) } returns emptyList()
every { isPresent } returns true
}
val replies = mutableListOf<String>()
val mockMessage = mockMessage("!restricted", replies = replies)
every { mockMessage.messageAuthor.asUser() } returns messageableAuthor()
Kagebot.processMessage(mockMessage)
calls.size shouldBe 1
calls[0] shouldBe config.localization.permissionDenied
replies shouldBe mutableListOf(config.localization.permissionDenied)
}
"should accept restricted command for owner" {
val calls = mutableListOf<String>()
val mockMessage = TestUtil.mockMessage("!restricted", capturedCalls = calls)
val mockMessage = mockMessage("!restricted", replies = calls)
every { mockMessage.messageAuthor.isBotOwner } returns true
Kagebot.processMessage(mockMessage)
calls.size shouldBe 1
calls[0] shouldBe "access granted"
calls shouldBe mutableListOf("access granted")
}
"should accept restricted command with permissions" {
val calls = mutableListOf<String>()
val mockMessage = TestUtil.mockMessage("!restricted", capturedCalls = calls)
val mockMessage = mockMessage("!restricted", replies = calls)
every { mockMessage.messageAuthor.asUser() } returns mockk {
every { isPresent } returns true
every { get().getRoles(any()) } returns listOf(
@ -64,12 +67,11 @@ class CommandTest : StringSpec({
)
}
Kagebot.processMessage(mockMessage)
calls.size shouldBe 1
calls[0] shouldBe "access granted"
calls shouldBe mutableListOf("access granted")
}
"should deny command to excluded roles" {
val calls = mutableListOf<String>()
val mockMessage = TestUtil.mockMessage("!almostUnrestricted", capturedCalls = calls)
val mockMessage = mockMessage("!almostUnrestricted", replies = calls)
// with the banned role
every { mockMessage.messageAuthor.asUser() } returns mockk {
every { isPresent } returns true
@ -85,9 +87,7 @@ class CommandTest : StringSpec({
every { get().getRoles(any()) } returns emptyList()
}
Kagebot.processMessage(mockMessage)
calls.size shouldBe 2
calls[0] shouldBe config.localization.permissionDenied
calls[1] shouldBe "access granted"
calls shouldBe mutableListOf(config.localization.permissionDenied, "access granted")
}
/*
* This implicitly tests that the message author is not included in anonymous complaints
@ -97,20 +97,8 @@ class CommandTest : StringSpec({
val calls = mutableListOf<EmbedBuilder>()
TestUtil.prepareServerConfig(calls)
val message = "this is a message"
Kagebot.processMessage(TestUtil.mockMessage("!anonRedirect $message"))
Kagebot.processMessage(mockMessage("!anonRedirect $message"))
calls.size shouldBe 1
val delegateImpl = calls[0].delegate as EmbedBuilderDelegateImpl
val embedContent = delegateImpl.toJsonNode().toString()
embedContent shouldContain "\"$message\""
embedToString(calls[0]) shouldContain "\"$message\""
}
}) {
companion object {
fun testMessageSuccess(content: String, result: String) {
val calls = mutableListOf<String>()
Kagebot.processMessage(TestUtil.mockMessage(content, capturedCalls = calls))
calls.size shouldBe 1
calls[0] shouldBe result
}
}
}
})

29
src/test/kotlin/moe/kageru/kagebot/TestUtil.kt
View File

@ -1,5 +1,6 @@
package moe.kageru.kagebot
import io.kotlintest.shouldBe
import io.mockk.Runs
import io.mockk.every
import io.mockk.just
@ -7,36 +8,58 @@ import io.mockk.mockk
import org.javacord.api.entity.channel.ServerTextChannel
import org.javacord.api.entity.message.embed.EmbedBuilder
import org.javacord.api.entity.server.Server
import org.javacord.api.entity.user.User
import org.javacord.api.event.message.MessageCreateEvent
import org.javacord.core.entity.message.embed.EmbedBuilderDelegateImpl
import java.util.*
object TestUtil {
fun mockMessage(
content: String,
author: Long = 1,
capturedCalls: MutableList<String> = mutableListOf(),
replies: MutableList<String> = mutableListOf(),
isSelf: Boolean = false
): MessageCreateEvent {
val message = mockk<MessageCreateEvent>()
every { message.messageContent } returns content
every { message.readableMessageContent } returns content
every { message.messageAuthor.id } returns author
every { message.channel.sendMessage(capture(capturedCalls)) } returns mockk()
every { message.channel.sendMessage(capture(replies)) } returns mockk()
every { message.messageAuthor.isYourself } returns isSelf
every { message.message.canYouDelete() } returns true
every { message.messageAuthor.isBotOwner } returns false
return message
}
fun messageableAuthor(messages: MutableList<EmbedBuilder> = mutableListOf()): Optional<User> {
return mockk {
every { isPresent } returns true
every { get() } returns mockk {
every { getRoles(any()) } returns emptyList()
every { sendMessage(capture(messages)) } returns mockk()
}
}
}
fun prepareServerConfig(sentMessages: MutableList<EmbedBuilder> = mutableListOf()) {
val channelMock = mockk<ServerTextChannel>()
every { channelMock.sendMessage(capture(sentMessages)) } returns mockk()
val resultMock = mockk<Optional<ServerTextChannel>>()
every { resultMock.isPresent } returns true
every {resultMock.get()} returns channelMock
every { resultMock.get() } returns channelMock
val server = mockk<Server>()
every { server.icon.ifPresent(any()) } just Runs
every { server.getTextChannelById(any<Long>()) } returns resultMock
Config.server = server
}
fun testMessageSuccess(content: String, result: String) {
val calls = mutableListOf<String>()
Kagebot.processMessage(mockMessage(content, replies = calls))
calls shouldBe mutableListOf(result)
}
fun embedToString(embed: EmbedBuilder): String {
return (embed.delegate as EmbedBuilderDelegateImpl).toJsonNode().toString()
}
}