How to use test method of io.kotest.matchers.internal class

Best Kotest code snippet using io.kotest.matchers.internal.test

ServerTest.kt

Source:ServerTest.kt

...21 * SOFTWARE.22 *23 */24package ttgamelib.net25import io.kotest.core.spec.style.FunSpec26import io.kotest.data.forAll27import io.kotest.data.row28import io.kotest.inspectors.forAll29import io.kotest.matchers.booleans.shouldBeFalse30import io.kotest.matchers.booleans.shouldBeTrue31import io.kotest.matchers.collections.shouldBeEmpty32import io.kotest.matchers.collections.shouldContain33import io.kotest.matchers.collections.shouldHaveSize34import io.kotest.matchers.maps.shouldContainValue35import io.kotest.matchers.shouldBe36import io.kotest.matchers.shouldNotBe37import io.kotest.matchers.types.shouldBeInstanceOf38import io.kotest.matchers.types.shouldBeTypeOf39import io.ktor.http.cio.websocket.*40import io.mockk.*41import kotlinx.serialization.json.Json42import ttgamelib.GameEngine43private inline fun<reified T: Packet> List<Frame>.decode(): List<T> {44    return map {45        Json.decodeFromString(Packet.serializer(), (it as Frame.Text).readText()) as T46    }47}48private fun createConnection(userName: String, clientId: Int): Pair<ClientConnection, MutableList<Frame>> {49    val sentPackets = mutableListOf<Frame>()50    val session = mockk<DefaultWebSocketSession>().also {51        coEvery {52            it.send(capture(sentPackets))53        } just Runs54    }55    val connection = ClientConnection(session).apply {56        name = userName57        id = clientId58    }59    return connection to sentPackets60}61internal class ServerTest : FunSpec({62    val engine = mockk<GameEngine>(relaxed = true)63    val (connection, sentPackets) = createConnection("player1", 1)64    lateinit var server: Server65    beforeEach {66        sentPackets.clear()67    }68    context("SendNamePacket") {69        val userName = "New User"70        server = Server("localhost", 1000, engine)71        test("should create new user if name is not in use") {72            server.handlePacket(SendNamePacket(userName), connection)73            val sent = sentPackets.decode<Packet>()74            sent[0].shouldBeInstanceOf<InitClientPacket>()75            (sent[0] as InitClientPacket).clientId shouldBe connection.id76            sent[1].shouldBeInstanceOf<ChatMessagePacket>()77            coVerify {78                engine.playerConnected(connection.id, userName)79            }80        }81        test("should request another name if in use") {82            val (connection2, sentPackets2) = createConnection("player2", 2)83            server.handlePacket(SendNamePacket(userName), connection2)84            val sent = sentPackets2.decode<SuggestNamePacket>()85            with (sent[0]) {86                name shouldNotBe userName87                taken.shouldContain(userName)88                disconnected.shouldBeFalse()89            }90        }91        test("should check for reconnection if disconnected") {92            server.connections.remove(connection.id)93            server.handlePacket(SendNamePacket(userName), connection)94            val sent = sentPackets.decode<SuggestNamePacket>()95            with (sent[0]) {96                name shouldNotBe userName97                taken.shouldContain(userName)98                disconnected.shouldBeTrue()99            }100        }101        test("should replace player on reconnection") {102            server.handlePacket(SendNamePacket(userName, true), connection)103            val sent = sentPackets.decode<Packet>()104            sent[0].shouldBeInstanceOf<InitClientPacket>()105            (sent[0] as InitClientPacket).clientId shouldBe connection.id106            sent[1].shouldBeInstanceOf<ChatMessagePacket>()107            coVerify {108                engine.playerReconnected(connection.id)109            }110        }111        test("should not replace player that is connected") {112            server.handlePacket(SendNamePacket(userName, true), connection)113            val sent = sentPackets.decode<SuggestNamePacket>()114            with (sent[0]) {115                name shouldNotBe userName116                disconnected.shouldBeFalse()117            }118        }119    }120    test("GameCommandPacket should be sent to game engine") {121        val packet = MessagePacket(object : GameMessage{})122        server.handlePacket(packet, connection)123        sentPackets.shouldBeEmpty()124        coVerify {125            engine.handle(connection.id, packet)126        }127    }128    context("chat command") {129        server = Server("localhost", 1000, engine)130        val connections = mutableListOf<ClientConnection>()131        val outgoing = mutableListOf<MutableList<Frame>>()132        for (i in 1..3) {133            with (createConnection("player$i", i)) {134                connections += first135                outgoing += second136                server.handlePacket(SendNamePacket(first.name), first)137            }138        }139        beforeEach {140            outgoing.forEach { it.clear() }141        }142        test("there should be three connected players") {143            connections.forAll {144                server.connections.shouldContainValue(it)145            }146        }147        test("emote should send message to all users") {148            forAll(149                row("/em is here"),150                row("/me is here")151            ) { msg ->152                server.handlePacket(ChatCommandPacket(connection.id, msg), connection)153            }154            outgoing.forEach {155                with (it.decode<ChatMessagePacket>()) {156                    shouldHaveSize(2)157                    forAll { it.message.shouldBeTypeOf<EmoteMessage>() }158                }159            }160        }161        test("whisper should send message to one user") {162            server.handlePacket(ChatCommandPacket(connections[0].id, "/w player2 a secret"), connections[0])163            outgoing[0].shouldHaveSize(1)164            outgoing[1].shouldHaveSize(1)165            outgoing[2].shouldBeEmpty()166        }167        test("whisper to unknown user should send info message to sender") {168            server.handlePacket(ChatCommandPacket(connections[1].id, "/w nobody a secret"), connections[1])169            outgoing[0].shouldHaveSize(0)170            outgoing[2].shouldHaveSize(0)171            outgoing[1].shouldHaveSize(1)172            outgoing[1].decode<ChatMessagePacket>().forAll {173                it.message.shouldBeTypeOf<InfoMessage>()174            }175        }176        test("unknown command should send info message to sender") {177            server.handlePacket(ChatCommandPacket(connections[1].id, "/foo bar baz"), connections[1])178            outgoing[0].shouldHaveSize(0)179            outgoing[2].shouldHaveSize(0)180            outgoing[1].shouldHaveSize(1)181            outgoing[1].decode<ChatMessagePacket>().forAll {182                it.message.shouldBeTypeOf<InfoMessage>()183            }184        }185    }186})...

BagRegulationCheckerTest.kt

Source:BagRegulationCheckerTest.kt

1package me.advent.of.code.problems.day72import io.kotest.matchers.collections.shouldBeEmpty3import io.kotest.matchers.collections.shouldContainExactly4import io.kotest.matchers.collections.shouldHaveSize5import io.kotest.matchers.nulls.shouldNotBeNull6import io.kotest.matchers.shouldBe7import me.advent.of.code.reader.readFile8import org.junit.jupiter.api.Test9internal class BagRegulationCheckerTest {10    private val initialInput = readFile("src/test/resources/inputs/day7/input_AoC.txt")11    private var sut = BagRegulationChecker(initialInput)12    @Test13    internal fun `Should split string correctly`() {14        val regulation = "light red bags contain 1 bright white bag, 2 muted yellow bags."15        val extractedRegulation: BagRegulation = sut.extractRegulationFromText(regulation)16        extractedRegulation.bag.colorCode shouldBe "light red"17        val acceptedContent = extractedRegulation.contentRegulation18        acceptedContent shouldHaveSize 219        acceptedContent[0].quantity shouldBe 120        acceptedContent[0].bag shouldBe Bag("bright white", 0)21        acceptedContent[1].quantity shouldBe 222        acceptedContent[1].bag shouldBe Bag("muted yellow", 0)23    }24    @Test...

InfiniteLoopFixerTest.kt

Source:InfiniteLoopFixerTest.kt

1package me.advent.of.code.problems.day82import io.kotest.matchers.collections.shouldContainAll3import io.kotest.matchers.collections.shouldHaveSize4import io.kotest.matchers.equality.shouldBeEqualToUsingFields5import io.kotest.matchers.shouldBe6import io.kotest.matchers.types.shouldBeInstanceOf7import me.advent.of.code.problems.day8.operations.Accumulation8import me.advent.of.code.problems.day8.operations.Jump9import me.advent.of.code.problems.day8.operations.NoOperation10import me.advent.of.code.problems.day8.operations.Operation11import me.advent.of.code.reader.readFile12import org.junit.jupiter.api.Test13import org.junit.jupiter.params.ParameterizedTest14import org.junit.jupiter.params.provider.Arguments15import org.junit.jupiter.params.provider.MethodSource16internal class InfiniteLoopFixerTest{17    companion object {18        @JvmStatic19        fun instructions() = listOf(20            Arguments.of("nop +0", NoOperation()),21            Arguments.of("acc +1", Accumulation(1)),22            Arguments.of("jmp -4", Jump(-4))23        )24    }25    private val initialInput = readFile("src/test/resources/inputs/day8/input_AoC.txt")26    private var sut = InfiniteLoopFixer(initialInput)27    @ParameterizedTest(name = "Operation {0} should be instance of {1}")28    @MethodSource(value = ["instructions"])29    internal fun `Should create different instances for each instruction type`(instruction : String, expectedOperation: Operation) {30        val operation = sut.extractOperationFromInstruction(instruction)31        operation::class shouldBe expectedOperation::class32        operation.shouldBeEqualToUsingFields(expectedOperation, Operation::argument)33    }34    @Test35    internal fun `Should create list of operations from input`() {36        val operations : List<Operation> = sut.extractOperations()37        38        operations shouldHaveSize 939        ...

ShardExtKtTest.kt

Source:ShardExtKtTest.kt

1package ch.sourcemotion.vertx.kinesis.consumer.orchestra.impl.ext2import ch.sourcemotion.vertx.kinesis.consumer.orchestra.testing.ShardIdGenerator3import ch.sourcemotion.vertx.kinesis.consumer.orchestra.testing.shardOf4import io.kotest.matchers.booleans.shouldBeFalse5import io.kotest.matchers.booleans.shouldBeTrue6import io.kotest.matchers.collections.shouldBeEmpty7import io.kotest.matchers.collections.shouldContainExactly8import io.kotest.matchers.nulls.shouldBeNull9import io.kotest.matchers.shouldBe10import org.junit.jupiter.api.Test11internal class ShardExtKtTest {12    @Test13    internal fun parentShardIds_not_a_child_shard() {14        val splitChild = shardOf(ShardIdGenerator.generateShardId(0))15        splitChild.parentShardIds().shouldBeEmpty()16        splitChild.isSplitChild().shouldBeFalse()17        splitChild.isMergedChild().shouldBeFalse()18        splitChild.shardIdTyped().shouldBe(splitChild.shardIdTyped())19        splitChild.parentShardIdTyped().shouldBeNull()20        splitChild.adjacentParentShardIdTyped().shouldBeNull()21    }22    @Test23    internal fun parentShardIds_split_shard() {...

DefaultJobSchedulerSpec.kt

Source:DefaultJobSchedulerSpec.kt

1package it.justwrote.kjob.internal2import io.kotest.assertions.throwables.shouldThrowMessage3import io.kotest.core.spec.style.ShouldSpec4import io.kotest.matchers.maps.shouldContainExactly5import io.kotest.matchers.nulls.shouldNotBeNull6import io.kotest.matchers.shouldBe7import io.mockk.coEvery8import io.mockk.mockk9import io.mockk.slot10import it.justwrote.kjob.Job11import it.justwrote.kjob.internal.scheduler.sj12import it.justwrote.kjob.job.JobSettings13import it.justwrote.kjob.repository.JobRepository14class DefaultJobSchedulerSpec : ShouldSpec() {15    init {16        val jobRepositoryMock = mockk<JobRepository>()17        should("return a ScheduledJob if scheduling was successfully") {18            val slot = slot<JobSettings>()19            coEvery { jobRepositoryMock.exist(any()) } returns false20            coEvery { jobRepositoryMock.save(capture(slot), null) } answers { sj(settings = slot.captured) }21            val testee = DefaultJobScheduler(jobRepositoryMock)22            val result = testee.schedule(JobSettings("id-123", "test-job", mapOf("int-test" to 3, "string-test2" to "test")))23            result.shouldNotBeNull()24            result.settings.id shouldBe "id-123"25            result.settings.properties shouldContainExactly mapOf("int-test" to 3, "string-test2" to "test")26            result.settings.name shouldBe "test-job"27        }28        should("throw an exception if a job with the same id already exist") {29            coEvery { jobRepositoryMock.exist(any()) } returns true30            val testee = DefaultJobScheduler(jobRepositoryMock)31            shouldThrowMessage("Job 'test-job' with id 'test' has already been scheduled.") {32                testee.schedule(JobSettings("test", "test-job", mapOf()))33            }34        }35    }36}...

QuestionTest.kt

Source:QuestionTest.kt

1package com.bryanspitz.architecturedemo.ui.shared2import com.bryanspitz.architecturedemo.testutil.launchAndTest3import io.kotest.assertions.throwables.shouldThrow4import io.kotest.core.spec.style.BehaviorSpec5import io.kotest.matchers.booleans.shouldBeTrue6import io.kotest.matchers.nulls.shouldBeNull7import io.kotest.matchers.shouldBe8private const val QUESTION = "a question"9internal class QuestionTest : BehaviorSpec({10	val question = Question<String, Boolean>()11	12	Given("no question is asked") {13		Then("the state is null") {14			question.state.value.shouldBeNull()15		}16	}17	Given("a question is asked") {18		var result: Boolean? = null19		launchAndTest({ result = question.ask(QUESTION) }) {20			21			Then("the state is equal to the question parameter") {...

CreateTrialUserImplTest.kt

Source:CreateTrialUserImplTest.kt

1package com.falcon.falcon.core.usecase.trial2import com.falcon.falcon.core.entity.User3import com.falcon.falcon.core.enumeration.UserType4import com.falcon.falcon.core.usecase.user.CreateUserUseCase5import io.kotest.matchers.date.shouldBeBetween6import io.kotest.matchers.shouldBe7import io.kotest.matchers.string.shouldBeUUID8import io.kotest.matchers.types.shouldBeTypeOf9import io.mockk.clearAllMocks10import io.mockk.every11import io.mockk.mockk12import org.junit.jupiter.api.BeforeEach13import org.junit.jupiter.api.Test14import org.junit.jupiter.api.TestInstance15import java.time.Instant16import java.time.temporal.ChronoUnit17@TestInstance(TestInstance.Lifecycle.PER_CLASS)18internal class CreateTrialUserImplTest {19    private val createUserUseCase: CreateUserUseCase = mockk()20    private val trialDuration = 1L21    private val underTest: CreateTrialUserImpl = CreateTrialUserImpl(createUserUseCase, trialDuration)22    @BeforeEach...

RecordedRequestMatchers.kt

Source:RecordedRequestMatchers.kt

1package com.nrojiani.bartender.data.test.utils2import io.kotest.matchers.collections.shouldBeIn3import io.kotest.matchers.collections.shouldContain4import io.kotest.matchers.collections.shouldHaveSize5import io.kotest.matchers.nulls.shouldNotBeNull6import io.kotest.matchers.shouldBe7import okhttp3.mockwebserver.RecordedRequest8internal fun RecordedRequest.shouldHaveQueryParam(key: String, expectedValue: String) {9    requestUrl?.queryParameterValues(key)10        .shouldNotBeNull()11        .shouldHaveSize(1)12        .shouldContain(expectedValue)13}14internal fun RecordedRequest.shouldContainHeaders(headers: Map<String, String>) {15    headers.forEach { (name, expectedValue) ->16        this.getHeader(name).shouldBe(expectedValue)17    }18}19enum class HttpRequestMethod {20    GET, HEAD, PUT, POST, PATCH, DELETE, CONNECT, OPTIONS, TRACE...

test

Using AI Code Generation

1class StringSpecTest : StringSpec() {2init {3"test" {4}5}6}7fun test() {8}9class StringSpecTest : StringSpec() {10init {11"test" {12}13}14}15fun test() {16}17class StringSpecTest : StringSpec() {18init {19"test" {20}21}22}23fun test() {24}25class StringSpecTest : StringSpec() {26init {27"test" {28}29}30}31fun test() {32}33class StringSpecTest : StringSpec() {34init {35"test" {36}37}38}39fun test() {40}41class StringSpecTest : StringSpec() {42init {43"test" {44}45}46}47fun test() {48}49class StringSpecTest : StringSpec() {50init {51"test" {52}53}54}55fun test() {56}57class StringSpecTest : StringSpec() {58init {59"test" {60}61}62}63fun test() {64}65class StringSpecTest : StringSpec() {66init {67"test" {68}69}70}71fun test() {72}73class StringSpecTest : StringSpec() {74init {75"test" {76}77}78}79fun test() {80}81class StringSpecTest : StringSpec() {82init {83"test" {84}85}86}87fun test() {88}89class StringSpecTest : StringSpec() {90init {91"test" {92}93}94}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.