2019-06-08 21:52:30 +02:00
package moe.kageru.kagebot
2019-11-12 22:02:32 +01:00
import arrow.core.ListK
import arrow.core.Option
2019-07-11 20:14:22 +02:00
import io.kotlintest.matchers.string.shouldContain
import io.kotlintest.matchers.string.shouldNotContain
2019-06-10 14:15:03 +02:00
import io.kotlintest.shouldBe
2019-06-09 18:41:51 +02:00
import io.mockk.Runs
2019-06-08 21:52:47 +02:00
import io.mockk.every
2019-06-09 18:41:51 +02:00
import io.mockk.just
2019-06-08 21:52:47 +02:00
import io.mockk.mockk
2019-07-17 23:22:18 +02:00
import moe.kageru.kagebot.Kagebot.process
2019-07-13 15:39:50 +02:00
import moe.kageru.kagebot.config.Config
2019-07-13 15:32:23 +02:00
import moe.kageru.kagebot.config.ConfigParser
2019-11-12 22:02:32 +01:00
import moe.kageru.kagebot.extensions.*
2019-06-09 18:41:51 +02:00
import org.javacord.api.entity.channel.ServerTextChannel
import org.javacord.api.entity.message.embed.EmbedBuilder
2019-07-25 21:04:13 +02:00
import org.javacord.api.entity.permission.Role
2019-06-10 14:15:03 +02:00
import org.javacord.api.entity.user.User
2019-06-08 21:52:47 +02:00
import org.javacord.api.event.message.MessageCreateEvent
2019-06-10 14:15:03 +02:00
import org.javacord.core.entity.message.embed.EmbedBuilderDelegateImpl
2019-07-14 17:14:23 +02:00
import java.io.File
2019-07-13 15:32:23 +02:00
import java.util.*
2019-06-08 21:52:47 +02:00
object TestUtil {
2019-11-14 15:10:30 +01:00
private val TIMEOUT _ROLE = mockk < Role > {
every { id } returns 123
}
val TEST _ROLE = mockk < Role > {
every { id } returns 1
every { isManaged } returns false
}
2019-07-25 21:04:13 +02:00
2019-11-14 15:10:30 +01:00
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 ( relaxed = true ) {
every { isCompletedExceptionally } returns false
}
every { channel . sendMessage ( capture ( replyEmbeds ) ) } returns mockk ( relaxed = true ) {
every { isCompletedExceptionally } returns false
}
every { channel . sendMessage ( capture ( files ) ) } returns mockk ( relaxed = true ) {
every { isCompletedExceptionally } returns false
}
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 ( replyEmbeds ) )
every { messageAuthor . name } returns " kageru "
2019-06-08 21:52:47 +02:00
}
2019-11-14 15:10:30 +01:00
}
2019-06-09 18:41:51 +02:00
2019-11-14 15:10:30 +01:00
fun messageableAuthor ( messages : MutableList < EmbedBuilder > = mutableListOf ( ) ) : User {
return mockk {
every { roles ( ) } returns ListK . empty ( )
every { sendMessage ( capture ( messages ) ) } returns mockk ( relaxed = true )
2019-06-14 23:16:31 +02:00
}
2019-11-14 15:10:30 +01:00
}
2019-06-14 23:16:31 +02:00
2019-11-14 15:10:30 +01:00
fun prepareTestEnvironment (
sentEmbeds : MutableList < EmbedBuilder > = mutableListOf ( ) ,
sentMessages : MutableList < String > = mutableListOf ( ) ,
dmEmbeds : MutableList < EmbedBuilder > = mutableListOf ( )
) {
val channel = mockk < ServerTextChannel > ( relaxed = true ) {
every { sendMessage ( capture ( sentEmbeds ) ) } returns mockk ( relaxed = true ) {
every { join ( ) } returns mockk {
every { isCompletedExceptionally } returns false
2019-11-12 22:02:32 +01:00
}
2019-11-14 15:10:30 +01:00
every { isCompletedExceptionally } returns false
}
every { sendMessage ( capture ( sentMessages ) ) } returns mockk ( relaxed = true )
}
2019-11-24 14:03:45 +01:00
// mockk tries to access Config.server in the mocking block below, so we need to provide some kind of value
Config . server = mockk ( )
Config . server = mockk ( relaxed = true ) {
every { icon . ifPresent ( any ( ) ) } just Runs
every { channelById ( any ( ) ) } returns Option . just ( channel )
every { channelsByName ( any ( ) ) } returns ListK . just ( channel )
every { rolesByName ( " testrole " ) } returns ListK . just ( TEST _ROLE )
every { rolesByName ( " timeout " ) } returns ListK . just ( TIMEOUT _ROLE )
every { categoriesByName ( any ( ) ) } returns ListK . just ( mockk ( ) )
every { createVoiceChannelBuilder ( ) . create ( ) } returns mockk {
every { isCompletedExceptionally } returns false
every { join ( ) . idAsString } returns " 12345 "
}
every { getMembersByName ( any ( ) ) } returns ListK . just ( mockk ( relaxed = true ) {
every { id } returns 123
every { roles ( ) } returns ListK . just ( TEST _ROLE )
every { getRoles ( any ( ) ) } returns ListK . just ( TEST _ROLE )
every { sendMessage ( capture ( dmEmbeds ) ) } returns mockk ( relaxed = true ) {
2019-11-14 15:10:30 +01:00
every { isCompletedExceptionally } returns false
2019-06-14 21:23:17 +02:00
}
2019-11-14 15:10:30 +01:00
} )
2019-06-09 18:41:51 +02:00
}
2019-11-24 14:03:45 +01:00
Globals . api = mockk ( relaxed = true ) {
every { getServerById ( any < String > ( ) ) } returns Optional . of ( Config . server )
}
2019-11-14 15:10:30 +01:00
ConfigParser . initialLoad ( " testconfig.toml " )
}
2019-06-10 14:15:03 +02:00
2019-11-14 15:10:30 +01:00
fun testMessageSuccess ( content : String , result : String ) {
val calls = mutableListOf < String > ( )
mockMessage ( content , replies = calls ) . process ( )
calls shouldBe mutableListOf ( result )
}
2019-06-10 14:15:03 +02:00
2019-11-14 15:10:30 +01:00
fun embedToString ( embed : EmbedBuilder ) : String {
return ( embed . delegate as EmbedBuilderDelegateImpl ) . toJsonNode ( ) . toString ( )
}
2019-06-14 23:16:31 +02:00
2019-11-14 15:10:30 +01:00
fun withCommands ( config : String , test : ( ( ) -> Unit ) ) {
val oldCmds = Config . commandConfig
Config . commandConfig = Config . commandSpec . string ( config )
test ( )
Config . commandConfig = oldCmds
}
2019-06-15 11:47:11 +02:00
2019-11-14 15:10:30 +01:00
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
2019-07-11 20:14:22 +02:00
}
2019-11-14 15:10:30 +01:00
}
2019-07-13 14:52:05 +02:00
}