How to use internal class of io.kotest.engine.spec package

Best Kotest code snippet using io.kotest.engine.spec.internal

Dependencies.kt

Source:Dependencies.kt

...3import org.gradle.kotlin.dsl.ScriptHandlerScope4import org.gradle.kotlin.dsl.exclude5import org.gradle.plugin.use.PluginDependenciesSpec6object Versions {7    // Branch targets for internal deps8    const val Master = "master-+"9    const val Develop = "develop-+"10    const val ProvenanceCore = Master11    const val StreamData = Master12    const val Kotlin = "1.6.21"13    const val KotlinCoroutines = "1.6.1"14    const val Protobuf = "3.18.1"15    const val SpringBoot = "2.5.6"16    const val KotlinLogging = "2.0.11"17    const val Reactor = "3.4.9"18    const val Jackson = "2.12.5"19    const val Redisson = "3.16.0"20    const val Ktlint = "0.45.2"21    const val Detekt = "1.18.1"...

ServerTest.kt

Source:ServerTest.kt

...57        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.id...

ReviewBotSpec.kt

Source:ReviewBotSpec.kt

1package reviewbot2import io.kotest.assertions.json.shouldContainJsonKeyValue3import io.kotest.assertions.json.shouldNotContainJsonKey4import io.kotest.assertions.ktor.shouldHaveStatus5import io.kotest.core.spec.style.FreeSpec6import io.kotest.extensions.mockserver.MockServerListener7import io.kotest.matchers.shouldBe8import io.ktor.application.*9import io.ktor.http.*10import io.ktor.server.testing.*11import module12import org.litote.kmongo.EMPTY_BSON13import org.litote.kmongo.coroutine.CoroutineCollection14import org.mockserver.client.MockServerClient15import org.mockserver.matchers.Times16import org.mockserver.model.HttpRequest.request17import org.mockserver.model.HttpResponse.response18import org.mockserver.model.MediaType19import reviewbot.db.DbClient20import reviewbot.db.PagesDao21import reviewbot.db.ReviewDao22import reviewbot.infra.Settings23import java.time.Instant24suspend fun CoroutineCollection<*>.deleteAll() = deleteMany(EMPTY_BSON)25class ReviewBotSpec : FreeSpec({26    listener(MockServerListener(80))27    beforeSpec {28        val s = Settings()29        val dbClient = DbClient(s.MongoConfig)30        ReviewDao(dbClient.db).collection.deleteAll()31        PagesDao(dbClient.db).collection.deleteAll()32    }33    "# trigger-webhook flow" - {34        fun TestApplicationEngine.triggerCall(): TestApplicationCall = handleRequest(HttpMethod.Post, "/trigger") {35            val payload = """36                {37                    "to": "5315069535230088",38                    "for": "106964551485187",39                    "trigger": {40                        "type": "reviewbot.events.Trigger.SaySomething",41                        "something": "test-me"42    43                    }44                }45            """.trimIndent()46            addHeader(HttpHeaders.ContentType, ContentType.Application.Json.toString())47            setBody(payload)48        }49        fun TestApplicationEngine.lastReview(): TestApplicationCall = handleRequest(HttpMethod.Get, "/reviews?psid=5315069535230088&pageId=106964551485187&limit=1")50        "when page is not configured" - {51            "returns an error" {52                withTestApplication(Application::module) {53                    with(triggerCall()) {54                        requestHandled shouldBe true55                        response shouldHaveStatus HttpStatusCode.InternalServerError56                    }57                }58            }59        }60        "when page is configured" - {61            fun TestApplicationEngine.setupPage(): TestApplicationCall = handleRequest(HttpMethod.Post, "/page") {62                addHeader(HttpHeaders.ContentType, ContentType.Application.Json.toString())63                setBody("""{ "name": "test-me", "id": "106964551485187", "accessToken": "fake" }""")64            }65            beforeEach {66                MockServerClient("localhost", 80)67                    .`when`(request().withMethod("POST").withContentType(MediaType.APPLICATION_JSON), Times.once())68                    .respond(69                        response()70                            .withStatusCode(200)71                            .withContentType(MediaType.APPLICATION_JSON)72                            .withBody("""{"recipient_id": "5315069535230088", "message_id": "1"}""")73                    )74            }75            "saves the sent response" {76                withTestApplication(Application::module) {77                    setupPage()78                    with(triggerCall()) {79                        response shouldHaveStatus HttpStatusCode.OK80                        val content = response.content81                        content.shouldContainJsonKeyValue("$.messageId", "1")82                        content.shouldNotContainJsonKey("$.responses")83                    }84                }85            }86            "and user replies" - {87                fun TestApplicationEngine.webhook(replyTs: Instant): TestApplicationCall = handleRequest(HttpMethod.Post, "/webhook") {88                    val reply =89                        """{"object":"page","entry":[{"id":"106964551485187","time":1616958576924,"messaging":[{"sender":{"id":"5315069535230088"},"recipient":{"id":"106964551485187"},"timestamp":${replyTs.toEpochMilli()},"message":{"mid":"mid1","text":"bla bla"}}]}]}"""90                    addHeader(HttpHeaders.ContentType, ContentType.Application.Json.toString())91                    setBody(reply)92                }93                "adds the reply to the original message" {94                    withTestApplication(Application::module) {95                        val ts = Instant.now()96                        with(webhook(ts)) {97                            response shouldHaveStatus HttpStatusCode.OK98                        }99                        with(lastReview()) {100                            response shouldHaveStatus HttpStatusCode.OK101                            val content = response.content102                            content.shouldContainJsonKeyValue("$[0].messageId", "1")103                            content.shouldContainJsonKeyValue("$[0].responses[0].mid", "mid1")104                            content.shouldContainJsonKeyValue("$[0].responses[0].text", "bla bla")105                        }106                    }107                }108            }109        }110    }111})...

FaultHandlingRouteTest.kt

Source:FaultHandlingRouteTest.kt

...24            testWithFaultRoute("/InternalFault") {25                val response = handleGet("/test/fault/InternalFault")26                response.status() shouldBe HttpStatusCode.InternalServerError27                response.contentAs<ApiErrorRto>() shouldBe ApiErrorRto(28                    message = TestableFaultHandlingRoute.Faults.internalFault.displayMessage29                )30            }31            testWithFaultRoute("/NotFoundFault") {32                val response = handleGet("/test/fault/NotFoundFault")33                response.status() shouldBe HttpStatusCode.NotFound34                response.contentAs<ApiErrorRto>() shouldBe ApiErrorRto(35                    message = TestableFaultHandlingRoute.Faults.notFoundFault.displayMessage36                )37            }38            testWithFaultRoute("/ValidationFault") {39                val response = handleGet("/test/fault/ValidationFault")40                response.status() shouldBe HttpStatusCode.InternalServerError41                response.contentAs<ApiErrorRto>() shouldBe ApiErrorRto(42                    message = TestableFaultHandlingRoute.Faults.validationFault.displayMessage43                )44            }45        }46    }47    private suspend fun DescribeSpecContainerContext.testWithFaultRoute(48        testName: String,49        testCode: TestApplicationEngine.() -> Unit50    ) {51        test(52            name = testName,53            additionalModules = testModule {54                single { TestableFaultHandlingRoute() } bind Route::class55            },56            testCode = testCode57        )58    }59}60class TestableFaultHandlingRoute : Route {61    object Faults {62        val internalFault = InternalFault.any()63        val notFoundFault = NotFoundFault.any()64        val validationFault = ValidationFault.any()65    }66    override fun Routing.install() {67        route("/test/fault") {68            get("/InternalFault") {69                call.respondFault(Faults.internalFault)70            }71            get("/NotFoundFault") {72                call.respondFault(Faults.notFoundFault)73            }74            get("/ValidationFault") {75                call.respondFault(Faults.validationFault)76            }77        }78    }79}...

launcher.kt

Source:launcher.kt

...15import kotlin.reflect.KClass16/**17 * Creates a [TestEngineLauncher] to be used to launch the test engine.18 */19internal fun setupLauncher(20   args: LauncherArgs,21   listener: TestEngineListener,22): Result<TestEngineLauncher> = runCatching {23   val specClass = args.spec?.let { (Class.forName(it) as Class<Spec>).kotlin }24   val (specs, _, error) = specs(specClass, args.packageName)25   val filter = if (args.testpath == null || specClass == null) null else {26      TestPathTestCaseFilter(args.testpath, specClass)27   }28   if (error != null) throw error29   TestEngineLauncher(listener)30      .withExtensions(listOfNotNull(filter))31      .withTagExpression(args.tagExpression?.let { TagExpression(it) })32      .withClasses(specs)33}...

InternalHttpApiTest.kt

Source:InternalHttpApiTest.kt

...13 * See the License for the specific language governing permissions and14 * limitations under the License.15 *16 */17package org.jitsi.jibri.api.http.internal18import io.kotest.core.spec.IsolationMode19import io.kotest.core.spec.style.FunSpec20import io.kotest.matchers.shouldBe21import io.ktor.http.HttpMethod22import io.ktor.http.HttpStatusCode23import io.ktor.server.testing.TestApplicationEngine24import io.ktor.server.testing.handleRequest25import io.ktor.server.testing.withTestApplication26class InternalHttpApiTest : FunSpec() {27    private var gracefulShutdownHandlerCalls = 028    private var shutdownHandlerCalls = 029    private var configChangedHandlerCalls = 030    private val internalApi = InternalHttpApi(31        { configChangedHandlerCalls++ },32        { gracefulShutdownHandlerCalls++ },33        { shutdownHandlerCalls++ }34    )35    init {36        isolationMode = IsolationMode.InstancePerLeaf37        test("gracefulShutdown should return a 200 and invoke the graceful shutdown handler") {38            apiTest {39                with(handleRequest(HttpMethod.Post, "/jibri/api/internal/v1.0/gracefulShutdown")) {40                    response.status() shouldBe HttpStatusCode.OK41                    gracefulShutdownHandlerCalls shouldBe 142                    configChangedHandlerCalls shouldBe 043                    shutdownHandlerCalls shouldBe 044                }45            }46        }47        test("notifyConfigChanged should return a 200 and invoke the config changed handler") {48            apiTest {49                with(handleRequest(HttpMethod.Post, "/jibri/api/internal/v1.0/notifyConfigChanged")) {50                    response.status() shouldBe HttpStatusCode.OK51                    gracefulShutdownHandlerCalls shouldBe 052                    configChangedHandlerCalls shouldBe 153                    shutdownHandlerCalls shouldBe 054                }55            }56        }57        test("shutdown should return a 200 and invoke the shutdown handler") {58            apiTest {59                with(handleRequest(HttpMethod.Post, "/jibri/api/internal/v1.0/shutdown")) {60                    response.status() shouldBe HttpStatusCode.OK61                    gracefulShutdownHandlerCalls shouldBe 062                    configChangedHandlerCalls shouldBe 063                    shutdownHandlerCalls shouldBe 164                }65            }66        }67    }68    private fun <R> apiTest(block: TestApplicationEngine.() -> R) {69        with(internalApi) {70            withTestApplication({71                internalApiModule()72            }) {73                block()74            }75        }76    }77}...

TestReadme.kt

Source:TestReadme.kt

...19 * limitations under the License.20 */21@OptIn(ExperimentalKotest::class)22@Suppress("unused")23internal object TestReadme: BehaviorSpec({24  val testRegex =25    Regex("<test(Groovy|Kotlin)([^>]*)>(.*?)</test(Groovy|Kotlin)>", option = RegexOption.DOT_MATCHES_ALL)26  val argRegex = Regex("""arg="([^"]*)"""")27  val idRegex = Regex("""id="([^"]*)"""")28  data class Test(val source: String, val args: String, val useKotlin: Boolean, val id: String)29  fun tests(): Sequence<Test> {30    val pluginVersion = ProjectFixture.getVersion()31    return testRegex.findAll(File("README.md.src").readText()).map { matchResult ->32      val useKotlin = matchResult.groupValues[1] == "Kotlin"33      val src = matchResult.groupValues[3]34        .replace(Regex("</?exclude>", RegexOption.DOT_MATCHES_ALL), "")35        .replace("<currentVersion>", pluginVersion)36      val args = argRegex.find(matchResult.groupValues[2])?.groupValues?.get(1) ?: throw AssertionError()37      val id = idRegex.find(matchResult.groupValues[2])?.groupValues?.get(1) ?: "<unknown>"...

ProcessorPendingSpec.kt

Source:ProcessorPendingSpec.kt

1/*2 * Copyright 2022 https://github.com/openapi-processor/openapi-processor-spring3 * PDX-License-Identifier: Apache-2.04 */5package io.openapiprocessor.spring6import io.kotest.core.spec.style.StringSpec7import io.kotest.engine.spec.tempdir8import io.kotest.matchers.booleans.shouldBeTrue9import io.openapiprocessor.core.parser.ParserType.INTERNAL10import io.openapiprocessor.test.FileSupport11import io.openapiprocessor.test.TestSet12import io.openapiprocessor.test.TestSetRunner13/**14 * helper to run selected integration tests.15 */16class ProcessorPendingSpec: StringSpec({17    for (testSet in sources()) {18        "native - $testSet".config(enabled = false) {19            val folder = tempdir()20            val support = FileSupport(21                ProcessorPendingSpec::class.java,22                testSet.inputs, testSet.generated)23            TestSetRunner(testSet, support)24            .runOnNativeFileSystem(folder)25            .shouldBeTrue()26        }27    }28})29private fun sources(): Collection<TestSet> {30    setTestHeader()31    return listOf(32        testSet("params-request-body-multipart-mapping", INTERNAL, API_30),33        testSet("params-request-body-multipart-mapping", INTERNAL, API_31)34    )35}...

internal

Using AI Code Generation

1internal class TestEngineListener : TestEngineListener {2    override fun engineStarted(classes: List<KClass<out Spec>>) {3        println("engineStarted")4    }5    override fun engineFinished(t: List<Throwable>) {6        println("engineFinished")7    }8    override fun specStarted(kclass: KClass<out Spec>) {9        println("specStarted")10    }11    override fun specFinished(kclass: KClass<out Spec>, t: Throwable?) {12        println("specFinished")13    }14    override fun specInstantiated(kclass: KClass<out Spec>) {15        println("specInstantiated")16    }17    override fun specInstantiationError(kclass: KClass<out Spec>, t: Throwable) {18        println("specInstantiationError")19    }20    override fun testStarted(testCase: TestCase) {21        println("testStarted")22    }23    override fun testFinished(testCase: TestCase, result: TestResult) {24        println("testFinished")25    }26    override fun testIgnored(testCase: TestCase, reason: String?) {27        println("testIgnored")28    }29    override fun testError(testCase: TestCase, t: Throwable) {30        println("testError")31    }32}33internal class TestEngineListener2 : TestEngineListener {34    override fun engineStarted(classes: List<KClass<out Spec>>) {35        println("engineStarted2")36    }37    override fun engineFinished(t: List<Throwable>) {38        println("engineFinished2")39    }40    override fun specStarted(kclass: KClass<out Spec>) {41        println("specStarted2")42    }43    override fun specFinished(kclass: KClass<out Spec>, t: Throwable?) {44        println("specFinished2")45    }46    override fun specInstantiated(kclass: KClass<out Spec>) {47        println("specInstantiated2")48    }49    override fun specInstantiationError(kclass: KClass<out Spec>, t: Throwable) {50        println("specInstantiationError2")51    }52    override fun testStarted(testCase: TestCase) {53        println("testStarted2")54    }55    override fun testFinished(testCase: TestCase, result: TestResult) {56        println("testFinished2")57    }58    override fun testIgnored(testCase: TestCase, reason: String?) {59        println("testIgn

internal

Using AI Code Generation

1+internal class KotestEngineSpec : StringSpec() {2+   init {3+      "should be able to use internal classes" {4+      }5+   }6+}7+internal class KotestEngineSpec2 : FunSpec() {8+   init {9+      test("should be able to use internal classes") {10+      }11+   }12+}13+internal class KotestEngineSpec3 : BehaviorSpec() {14+   init {15+      Given("should be able to use internal classes") {16+      }17+   }18+}19+internal class KotestEngineSpec4 : DescribeSpec() {20+   init {21+      describe("should be able to use internal classes") {22+      }23+   }24+}25+internal class KotestEngineSpec5 : WordSpec() {26+   init {27+      "should be able to use internal classes" should {28+      }29+   }30+}31+internal class KotestEngineSpec6 : ExpectSpec() {32+   init {33+      context("should be able to use internal classes") {34+      }35+   }36+}37+internal class KotestEngineSpec7 : FeatureSpec() {38+   init {39+      feature("should be able to use internal classes") {40+      }41+   }42+}

internal

Using AI Code Generation

1    private val testContext: TestContext = TestContext(this)2    override fun invoke(testCase: TestCase, execute: (TestCase) -> TestResult): TestResult {3        testContext.registerTestCase(testCase)4        return execute(testCase)5    }6}7    class MySpec : StringSpec() {8        override fun interceptTestCase(testCase: TestCase, execute: (TestCase) -> TestResult): TestResult {9            MyInterceptor().interceptTestCase(testCase, execute)10        }11        init {12            "test1" {13            }14            "test2" {15            }16        }17    }

internal

Using AI Code Generation

1+    return spec::class.nestedClasses.first { it.simpleName == "TestCaseExecutor" }.objectInstance as TestCaseExecutor2+  }3+}4+class TestCaseExecutor {5+  fun execute(testCase: TestCase, test: suspend () -> Unit) {6+    println("Executing test case: ${testCase.description.name}")7+  }8+}9+class MySpec : FunSpec() {10+  init {11+    test("some test") {12+    }13+  }14+}15+fun main() {16+  MySpec().executeTestCase()17+}

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.