127 lines
4.9 KiB
Kotlin
127 lines
4.9 KiB
Kotlin
package moe.kageru.kagebot
|
|
|
|
import io.kotlintest.matchers.string.shouldContain
|
|
import io.kotlintest.matchers.string.shouldNotContain
|
|
import io.kotlintest.shouldBe
|
|
import io.mockk.Runs
|
|
import io.mockk.every
|
|
import io.mockk.just
|
|
import io.mockk.mockk
|
|
import moe.kageru.kagebot.config.Config
|
|
import moe.kageru.kagebot.config.ConfigParser
|
|
import moe.kageru.kagebot.config.RawConfig
|
|
import org.javacord.api.DiscordApi
|
|
import org.javacord.api.entity.channel.ServerTextChannel
|
|
import org.javacord.api.entity.message.embed.EmbedBuilder
|
|
import org.javacord.api.entity.user.User
|
|
import org.javacord.api.event.message.MessageCreateEvent
|
|
import org.javacord.core.entity.message.embed.EmbedBuilderDelegateImpl
|
|
import java.io.File
|
|
import java.util.*
|
|
|
|
object TestUtil {
|
|
fun mockMessage(
|
|
content: String,
|
|
replies: MutableList<String> = mutableListOf(),
|
|
replyEmbeds: MutableList<EmbedBuilder> = mutableListOf(),
|
|
files: MutableList<File> = mutableListOf(),
|
|
isBot: Boolean = false
|
|
): MessageCreateEvent {
|
|
return mockk {
|
|
every { messageContent } returns content
|
|
every { readableMessageContent } returns content
|
|
every { channel.sendMessage(capture(replies)) } returns mockk()
|
|
every { channel.sendMessage(capture(replyEmbeds)) } returns mockk()
|
|
every { channel.sendMessage(capture(files)) } returns mockk()
|
|
every { message.canYouDelete() } returns true
|
|
every { isPrivateMessage } returns false
|
|
// We can’t use a nested mock here because other fields of messageAuthor might
|
|
// get overwritten by other tests, which would delete a nested mock.
|
|
every { messageAuthor.id } returns 1
|
|
every { messageAuthor.discriminatedName } returns "testuser#1234"
|
|
every { messageAuthor.isBotUser } returns isBot
|
|
every { messageAuthor.isYourself } returns isBot
|
|
every { messageAuthor.isBotOwner } returns false
|
|
every { messageAuthor.asUser() } returns Optional.of(messageableAuthor())
|
|
}
|
|
}
|
|
|
|
fun messageableAuthor(messages: MutableList<EmbedBuilder> = mutableListOf()): User {
|
|
return mockk {
|
|
every { getRoles(any()) } returns emptyList()
|
|
every { sendMessage(capture(messages)) } returns mockk()
|
|
}
|
|
}
|
|
|
|
fun prepareTestEnvironment(
|
|
sentEmbeds: MutableList<EmbedBuilder> = mutableListOf(),
|
|
sentMessages: MutableList<String> = mutableListOf()
|
|
) {
|
|
val channel = mockk<Optional<ServerTextChannel>> {
|
|
every { isPresent } returns true
|
|
every { get() } returns mockk {
|
|
every { sendMessage(capture(sentEmbeds)) } returns mockk {
|
|
every { join() } returns mockk()
|
|
every { isCompletedExceptionally } returns false
|
|
}
|
|
every { sendMessage(capture(sentMessages)) } returns mockk()
|
|
}
|
|
}
|
|
val api = mockk<DiscordApi> {
|
|
every { getServerById(any<String>()) } returns Optional.of(mockk {
|
|
every { icon.ifPresent(any()) } just Runs
|
|
every { getTextChannelById(any<String>()) } returns channel
|
|
every { getTextChannelsByName(any()) } returns listOf(channel.get())
|
|
every { getRolesByNameIgnoreCase("testrole") } returns listOf(mockk {
|
|
every { id } returns 1
|
|
})
|
|
})
|
|
}
|
|
Globals.api = api
|
|
ConfigParser.initialLoad(RawConfig.read("testconfig.toml"))
|
|
}
|
|
|
|
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()
|
|
}
|
|
|
|
fun <R> withCommands(config: String, test: (() -> R)) {
|
|
val oldCmds = Config.commands
|
|
val rawConfig = RawConfig.readFromString(config)
|
|
ConfigParser.reloadCommands(rawConfig)
|
|
test()
|
|
Config.commands = oldCmds
|
|
}
|
|
|
|
fun <R> withLocalization(config: String, test: (() -> R)) {
|
|
val oldLoc = Config.localization
|
|
val rawConfig = RawConfig.readFromString(config)
|
|
ConfigParser.reloadLocalization(rawConfig)
|
|
test()
|
|
Config.localization = oldLoc
|
|
}
|
|
|
|
fun withReplyContents(
|
|
expected: List<String> = emptyList(),
|
|
unexpected: List<String> = emptyList(),
|
|
op: (MutableList<EmbedBuilder>) -> Unit
|
|
) {
|
|
val replies = mutableListOf<EmbedBuilder>()
|
|
op(replies)
|
|
replies.size shouldBe 1
|
|
val replyString = embedToString(replies[0])
|
|
for (string in expected) {
|
|
replyString shouldContain string
|
|
}
|
|
for (string in unexpected) {
|
|
replyString shouldNotContain string
|
|
}
|
|
}
|
|
}
|