How to use beforeTest method of io.kotest.core.spec.Spec class

Best Kotest code snippet using io.kotest.core.spec.Spec.beforeTest

SharedJdbcDatabaseContainerExtension.kt

Source:SharedJdbcDatabaseContainerExtension.kt

...30 *31 * @param container the specific database test container type32 * @param beforeSpec a beforeSpec callback33 * @param afterSpec an afterSpec callback34 * @param beforeTest a beforeTest callback35 * @param afterTest a afterTest callback36 * @param afterStart called one time, after the container is started37 * @param configure a callback to configure the [HikariConfig] instance that is used to create the [HikariDataSource].38 *39 * @since 1.3.040 */41class SharedJdbcDatabaseContainerExtension(42   private val container: JdbcDatabaseContainer<*>,43   private val beforeTest: suspend (HikariDataSource) -> Unit = {},44   private val afterTest: suspend (HikariDataSource) -> Unit = {},45   private val beforeSpec: suspend (HikariDataSource) -> Unit = {},46   private val afterSpec: suspend (HikariDataSource) -> Unit = {},47   private val afterStart: (HikariDataSource) -> Unit = {},48   private val configure: TestContainerHikariConfig.() -> Unit = {},49) : MountableExtension<TestContainerHikariConfig, HikariDataSource>,50   AfterProjectListener,51   BeforeTestListener,52   BeforeSpecListener,53   AfterTestListener,54   AfterSpecListener {55   private var ds: HikariDataSource? = null56   override fun mount(configure: TestContainerHikariConfig.() -> Unit): HikariDataSource {57      if (!container.isRunning) {58         container.start()59         ds = createDataSource().apply(afterStart)60      }61      return ds ?: error("DataSource was not initialized")62   }63   override suspend fun afterProject() {64      if (container.isRunning) container.stop()65   }66   override suspend fun beforeTest(testCase: TestCase) {67      beforeTest(ds ?: error("DataSource was not initialized"))68   }69   override suspend fun afterTest(testCase: TestCase, result: TestResult) {70      afterTest(ds ?: error("DataSource was not initialized"))71   }72   override suspend fun beforeSpec(spec: Spec) {73      beforeSpec(ds ?: error("DataSource was not initialized"))74   }75   override suspend fun afterSpec(spec: Spec) {76      afterSpec(ds ?: error("DataSource was not initialized"))77   }78   private fun runInitScripts(connection: Connection, dbInitScripts: List<String>) {79      if (dbInitScripts.isNotEmpty()) {80         val scriptRunner = ScriptRunner(connection)81         dbInitScripts.forEach { script ->...

SharedTestContainerExtension.kt

Source:SharedTestContainerExtension.kt

...24 *25 * @param container the specific database test container type26 * @param beforeSpec a beforeSpec callback, can be used to configure the container.27 * @param afterSpec an afterSpec callback, can be used to configure the container.28 * @param beforeTest a beforeTest callback, can be used to configure the container.29 * @param afterTest a afterTest callback, can be used to configure the container.30 * @param configure called one time after the container is started. Can configure the container without needing to31 * specify the configuration code at every use site.32 * @param mapper optional mapping function to adapt the materialized value.33 *34 * @since 1.3.035 */36class SharedTestContainerExtension<T : GenericContainer<*>, U>(37   private val container: T,38   private val beforeTest: suspend (T) -> Unit = {},39   private val afterTest: suspend (T) -> Unit = {},40   private val beforeSpec: suspend (T) -> Unit = {},41   private val afterSpec: suspend (T) -> Unit = {},42   private val configure: T.() -> Unit = {},43   private val mapper: T.() -> U,44) : MountableExtension<T, U>,45   AfterProjectListener,46   BeforeTestListener,47   BeforeSpecListener,48   AfterTestListener,49   AfterSpecListener {50   companion object {51      operator fun <T : GenericContainer<*>> invoke(52         container: T,53         beforeTest: (T) -> Unit = {},54         afterTest: (T) -> Unit = {},55         beforeSpec: (T) -> Unit = {},56         afterSpec: (T) -> Unit = {},57         configure: T.() -> Unit = {},58      ): SharedTestContainerExtension<T, T> {59         return SharedTestContainerExtension(60            container,61            beforeTest,62            afterTest,63            beforeSpec,64            afterSpec,65            configure66         ) { this }67      }68   }69   override fun mount(configure: T.() -> Unit): U {70      if (!container.isRunning) {71         container.start()72         configure(container)73         this@SharedTestContainerExtension.configure(container)74      }75      return this@SharedTestContainerExtension.mapper(container)76   }77   override suspend fun afterProject() {78      if (container.isRunning) container.stop()79   }80   override suspend fun beforeTest(testCase: TestCase) {81      beforeTest(container)82   }83   override suspend fun afterTest(testCase: TestCase, result: TestResult) {84      afterTest(container)85   }86   override suspend fun beforeSpec(spec: Spec) {87      beforeSpec(container)88   }89   override suspend fun afterSpec(spec: Spec) {90      afterSpec(container)91   }92}...

KotestStringSpecTest.kt

Source:KotestStringSpecTest.kt

...65    }66    override fun beforeSpec(spec: Spec) {67        logger.info("beforeSpec")68    }69    override fun beforeTest(testCase: TestCase) {70        logger.info("beforeTest")71    }72    override fun extensions(): List<Extension> {73        logger.info("extensions")74        return listOf(object : Extension {})75    }76    override fun listeners(): List<TestListener> {77        logger.info("listeners")78        return listOf(ExampleListener)79    }80}81object ExampleListener: TestListener {82    private val logger = logger<ExampleListener>()83    override suspend fun afterInvocation(testCase: TestCase, iteration: Int) {84        logger.info("afterInvocation ${testCase.displayName}")85    }86    override suspend fun afterSpec(spec: Spec) {87        val names = spec.rootTests().map { it.testCase.displayName }88        logger.info("afterSpec $names")89    }90    override suspend fun afterTest(testCase: TestCase, result: TestResult) {91        logger.info("afterTest ${testCase.displayName}, ${result.status} ${result.reason} ${result.error}")92    }93    override suspend fun beforeInvocation(testCase: TestCase, iteration: Int) {94        logger.info("beforeInvocation ${testCase.displayName}")95    }96    override suspend fun beforeSpec(spec: Spec) {97        val names = spec.rootTests().map { it.testCase.displayName }98        logger.info("beforeSpec $names")99    }100    override suspend fun beforeTest(testCase: TestCase) {101        logger.info("beforeTest ${testCase.displayName}")102    }103    override suspend fun finalizeSpec(kclass: KClass<out Spec>, results: Map<TestCase, TestResult>) {104        logger.info("finalizeSpec")105    }106    override suspend fun prepareSpec(kclass: KClass<out Spec>) {107        logger.info("prepareSpec")108    }109}...

TestListener.kt

Source:TestListener.kt

...16  }17  override suspend fun beforeSpec(spec: Spec) {18    println("BeforeSpec: ${spec.materializeRootTests().joinToString { it.testCase.displayName }}")19  }20  override suspend fun beforeTest(testCase: TestCase) {21    println("BeforeTest: ${testCase.displayName}")22  }23  override suspend fun afterTest(testCase: TestCase, result: TestResult) {24    println("AfterTest: ${testCase.displayName}")25  }26  override suspend fun afterSpec(spec: Spec) {27    println("AfterSpec: ${spec.materializeRootTests().joinToString { it.testCase.displayName }}")28  }29  override suspend fun finalizeSpec(kclass: KClass<out Spec>, results: Map<TestCase, TestResult>) {30    println("FinalizeSpec(in SpecLevelListener): ${kclass.qualifiedName}")31  }32}33class NumbersTestWithFixture1 : FunSpec() {34  init {...

StartablePerSpecListener.kt

Source:StartablePerSpecListener.kt

...9import org.testcontainers.lifecycle.TestLifecycleAware10/**11 * [StartablePerSpecListener] starts the given [startable] before execution of any test in the spec12 * and stops after execution of all tests. If the [startable] also inherit from [TestLifecycleAware]13 * then its [beforeTest] and [afterTest] method are also called by the listener.14 *15 * [startable] can any of [GenericContainer] [DockerComposeContainer] [LocalStackContainer] etc.16 *17 * This listener should be used when you want to use a single container for all tests in a single spec class.18 *19 * @see20 * [StartablePerTestListener]21 * */22class StartablePerSpecListener<T : Startable>(val startable: T) : TestListener {23   private val testLifecycleAwareListener = TestLifecycleAwareListener(startable)24   override suspend fun beforeSpec(spec: Spec) {25      withContext(Dispatchers.IO) {26         startable.start()27      }28   }29   override suspend fun beforeTest(testCase: TestCase) {30      withContext(Dispatchers.IO) {31         testLifecycleAwareListener.beforeTest(testCase)32      }33   }34   override suspend fun afterSpec(spec: Spec) {35      withContext(Dispatchers.IO) {36         startable.stop()37      }38   }39   override suspend fun afterTest(testCase: TestCase, result: TestResult) {40      withContext(Dispatchers.IO) {41         testLifecycleAwareListener.afterTest(testCase, result)42      }43   }44}...

LifecycleHooks.kt

Source:LifecycleHooks.kt

...6import io.kotest.core.spec.Spec7import io.kotest.core.spec.style.WordSpec8import io.kotest.core.test.TestCase9class LifecycleHooks : WordSpec({10    beforeTest {11        println("Starting a test $it")12    }13    afterTest { (test, result) ->14        println("Finished spec with result $result")15    }16    "this test" should {17        "be alive" {18            println("Johnny5 is alive!")19        }20    }21})22val startTest: BeforeTest = {23    println("Starting a test $it")24}25class LifecycleHooksExample1: WordSpec({26    beforeTest(startTest)27    "this test" should {28        "fail" {29//            fail("boom")30        }31    }32})33class LifecycleHooksExample2: WordSpec() {34    override fun beforeTest(testCase: TestCase) {35        println("Starting a test $testCase")36    }37    init {38        "this test" should {39            "be alive" {40                println("Johnny5 is alive!")41            }42        }43    }44}45// Listener is simple hook46class MyTestListener : BeforeSpecListener, AfterSpecListener {47    override suspend fun beforeSpec(spec: Spec) {48        println("power up kafka")...

RecipeFilterServiceTest.kt

Source:RecipeFilterServiceTest.kt

...8import io.kotest.matchers.shouldNotBe9class RecipeFilterServiceTest : StringSpec() {10    private lateinit var menu: Menu11    private lateinit var filterService: IFilterService12    override fun beforeTest(testCase: TestCase) {13        super.beforeTest(testCase)14        menu = getFakeMenu()15        filterService = FilterService(menu)16    }17    init {18        "check that getRecipesByTag returns filtered recipes list"{19            val recipesList = filterService.filterRecipeByTag("hot")20            recipesList.size shouldNotBe 021            recipesList.size shouldBeExactly 322        }23        "check that getRecipesByTag returns empty list if recipes not found by tag"{24            val recipesList = filterService.filterRecipeByTag("high-calories")25            recipesList.size shouldBe 026        }27    }...

BeforeSpecAndTestSample.kt

Source:BeforeSpecAndTestSample.kt

...9        super.beforeSpec(spec)10        println("beforeSpec")11    }12    //called every test13    override fun beforeTest(testCase: TestCase) {14        super.beforeTest(testCase)15        println("beforeTest")16    }17    init{18        test("first test"){19            val data = 1+120            data shouldBe 221        }22        test("second test"){23            val data = 2+224            data shouldBe 425        }26    }27}...

beforeTest

Using AI Code Generation

1override fun beforeTest(testCase: TestCase) {2}3override fun afterTest(testCase: TestCase, result: TestResult) {4}5override fun beforeSpec(spec: Spec) {6}7override fun afterSpec(spec: Spec) {8}9override fun afterContainer(testCase: TestCase, result: TestResult) {10}11override fun afterAny(testCase: TestCase, result: TestResult) {12}13override fun beforeContainer(testCase: TestCase) {14}15override fun beforeAny(testCase: TestCase) {16}17override fun afterProject() {18}19override fun beforeProject() {20}21override fun afterInvocation(testCase: TestCase, invocation: Int, result: TestResult) {22}23override fun beforeInvocation(testCase: TestCase, invocation: Int) {24}25override fun afterTest(testCase: TestCase, result: TestResult) {26}27override fun beforeTest(testCase: TestCase) {28}29override fun afterSpec(spec: Spec) {30}31override fun beforeSpec(spec: Spec) {32}33override fun afterAny(testCase: TestCase, result: TestResult) {

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.