Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use withClasses method of io.kotest.engine.TestEngineLauncher class

Best Kotest code snippet using io.kotest.engine.TestEngineLauncher.withClasses

ExtensionErrorsTest.kt

Source:ExtensionErrorsTest.kt

...14   init {15      test("beforeSpec function overrides should be wrapped") {16         val collector = CollectingTestEngineListener()17         TestEngineLauncher(collector)18            .withClasses(BeforeSpecFunctionOverrideError::class)19            .launch()20         val error = collector.specs.values.first().errorOrNull21         error.shouldBeInstanceOf<ExtensionException.BeforeSpecException>()22      }23      test("beforeSpec DSL errors should be wrapped") {24         val collector = CollectingTestEngineListener()25         TestEngineLauncher(collector)26            .withClasses(BeforeSpecDSLError::class)27            .launch()28         val error = collector.specs.values.first().errorOrNull29         error.shouldBeInstanceOf<ExtensionException.BeforeSpecException>()30      }31      test("multiple beforeSpec should be collected") {32         val collector = CollectingTestEngineListener()33         TestEngineLauncher(collector)34            .withClasses(MultipleBeforeSpecErrors::class)35            .launch()36         val error = collector.specs.values.first().errorOrNull37         error.shouldBeInstanceOf<MultipleExceptions>()38         error.causes.shouldHaveSize(3)39         error.causes.forAll { it.shouldBeInstanceOf<ExtensionException.BeforeSpecException>() }40      }41      test("afterSpec function overrides should be wrapped") {42         val collector = CollectingTestEngineListener()43         TestEngineLauncher(collector)44            .withClasses(AfterSpecFunctionOverrideError::class)45            .launch()46         val error = collector.specs.values.first().errorOrNull47         error.shouldBeInstanceOf<ExtensionException.AfterSpecException>()48      }49      test("afterSpec DSL errors should be wrapped") {50         val collector = CollectingTestEngineListener()51         TestEngineLauncher(collector)52            .withClasses(AfterSpecDSLError::class)53            .launch()54         val error = collector.specs.values.first().errorOrNull55         error.shouldBeInstanceOf<ExtensionException.AfterSpecException>()56      }57      test("multiple afterSpec should be collected") {58         val collector = CollectingTestEngineListener()59         TestEngineLauncher(collector)60            .withClasses(MultipleAfterSpecErrors::class)61            .launch()62         val error = collector.specs.values.first().errorOrNull63         error.shouldBeInstanceOf<MultipleExceptions>()64         error.causes.shouldHaveSize(3)65         error.causes.forAll { it.shouldBeInstanceOf<ExtensionException.AfterSpecException>() }66      }67      test("beforeTest function overrides should be wrapped") {68         val collector = CollectingTestEngineListener()69         TestEngineLauncher(collector)70            .withClasses(BeforeTestFunctionOverrideError::class)71            .launch()72         val error = collector.tests.values.first().errorOrNull73         error.shouldBeInstanceOf<ExtensionException.BeforeTestException>()74      }75      test("beforeTest DSL errors should be wrapped") {76         val collector = CollectingTestEngineListener()77         TestEngineLauncher(collector)78            .withClasses(BeforeTestDSLError::class)79            .launch()80         val error = collector.tests.values.first().errorOrNull81         error.shouldBeInstanceOf<ExtensionException.BeforeTestException>()82      }83      test("multiple beforeTest errors should be collected") {84         val collector = CollectingTestEngineListener()85         TestEngineLauncher(collector)86            .withClasses(MultipleBeforeTestErrors::class)87            .launch()88         val error = collector.tests.values.first().errorOrNull89         error.shouldBeInstanceOf<MultipleExceptions>()90         error.causes.shouldHaveSize(3)91         error.causes.forAll { it.shouldBeInstanceOf<ExtensionException.BeforeTestException>() }92      }93      test("afterTest function overrides should be wrapped") {94         val collector = CollectingTestEngineListener()95         TestEngineLauncher(collector)96            .withClasses(AfterTestFunctionOverrideError::class)97            .launch()98         val error = collector.tests.values.first().errorOrNull99         error.shouldBeInstanceOf<ExtensionException.AfterTestException>()100      }101      test("afterTest DSL errors should be wrapped") {102         val collector = CollectingTestEngineListener()103         TestEngineLauncher(collector)104            .withClasses(AfterTestDSLError::class)105            .launch()106         val error = collector.tests.values.first().errorOrNull107         error.shouldBeInstanceOf<ExtensionException.AfterTestException>()108      }109      test("multiple afterTest errors should be collected") {110         val collector = CollectingTestEngineListener()111         TestEngineLauncher(collector)112            .withClasses(MultipleAfterTestErrors::class)113            .launch()114         val error = collector.tests.values.first().errorOrNull115         error.shouldBeInstanceOf<MultipleExceptions>()116         error.causes.shouldHaveSize(3)117         error.causes.forAll { it.shouldBeInstanceOf<ExtensionException.AfterTestException>() }118      }119   }120}121private class BeforeSpecFunctionOverrideError : FunSpec() {122   override suspend fun beforeSpec(spec: Spec) {123      error("foo")124   }125   init {126      test("a") { }...

SystemPropertyFiltersTests.kt

Source:SystemPropertyFiltersTests.kt

...46         mapOf(47            KotestEngineProperties.filterSpecs to "",48            KotestEngineProperties.filterTests to ""49         )50      ) { TestEngineLauncher().withClasses(testSuite).withConfiguration(ProjectConfiguration()).launch() }51      numberOfTestsRunShouldBe(13)52   }53   test("filters a specific class") {54      withSystemProperties(55         mapOf(56            KotestEngineProperties.filterSpecs to "*DistantFutureSciFiTests",57            KotestEngineProperties.filterTests to ""58         )59      ) { TestEngineLauncher().withClasses(testSuite).withConfiguration(ProjectConfiguration()).launch() }60      numberOfTestsRunShouldBe(7)61   }62   test("filters a class prefix") {63      withSystemProperties(64         mapOf(65            KotestEngineProperties.filterSpecs to "*FutureSciFiTests",66            KotestEngineProperties.filterTests to ""67         )68      ) { TestEngineLauncher().withClasses(testSuite).withConfiguration(ProjectConfiguration()).launch() }69      numberOfTestsRunShouldBe(9)70   }71   test("filters a specific class and test") {72      withSystemProperties(73         mapOf(74            KotestEngineProperties.filterSpecs to "*NearFutureSciFiTests",75            KotestEngineProperties.filterTests to "Daedalus*"76         )77      ) { TestEngineLauncher().withClasses(testSuite).withConfiguration(ProjectConfiguration()).launch() }78      numberOfTestsRunShouldBe(1)79   }80   test("filters a test name with spaces") {81      withSystemProperties(82         mapOf(83            KotestEngineProperties.filterSpecs to "",84            KotestEngineProperties.filterTests to "trek tests*"85         )86      ) { TestEngineLauncher().withClasses(testSuite).withConfiguration(ProjectConfiguration()).launch() }87      numberOfTestsRunShouldBe(3)88   }89   test("filters all classes in a package") {90      withSystemProperties(91         mapOf(92            KotestEngineProperties.filterSpecs to "com.sksamuel.kotest.engine.interceptors.filters1.*",93            KotestEngineProperties.filterTests to ""94         )95      ) { TestEngineLauncher().withClasses(testSuite).withConfiguration(ProjectConfiguration()).launch() }96      numberOfTestsRunShouldBe(2)97   }98   test("filters nested tests in a context") {99      withSystemProperties(100         mapOf(101            KotestEngineProperties.filterSpecs to "",102            KotestEngineProperties.filterTests to "expanse tests*"103         )104      ) { TestEngineLauncher().withClasses(testSuite).withConfiguration(ProjectConfiguration()).launch() }105      numberOfTestsRunShouldBe(4)106   }107   test("filter tests using prefix and suffix wildcard") {108      withSystemProperties(109         mapOf(110            KotestEngineProperties.filterSpecs to "",111            KotestEngineProperties.filterTests to "*anse tes*"112         )113      ) { TestEngineLauncher().withClasses(testSuite).withConfiguration(ProjectConfiguration()).launch() }114      numberOfTestsRunShouldBe(4)115   }116   test("filter tests with prefix wildcard") {117      withSystemProperties(118         mapOf(119            KotestEngineProperties.filterSpecs to "",120            KotestEngineProperties.filterTests to "*BC-304"121         )122      ) { TestEngineLauncher().withClasses(testSuite).withConfiguration(ProjectConfiguration()).launch() }123      numberOfTestsRunShouldBe(2)124      testsRunShouldBe("Daedalus BC-304", "Odyssey BC-304")125   }126})127private class DistantFutureSciFiTests : FunSpec({128   context("trek tests") {129      test("Enterprise NCC-1701") { testAndIncrementCounter() }130      test("Excelsior NCC-2000") { testAndIncrementCounter() }131      test("Defiant NX-74205") { testAndIncrementCounter() }132   }133   context("expanse tests") {134      test("MCRN Donnager") { testAndIncrementCounter() }135      test("Rocinante") { testAndIncrementCounter() }136      test("UNN Arboghast") { testAndIncrementCounter() }...

IgnoredTestReasonTest.kt

Source:IgnoredTestReasonTest.kt

...13   init {14      test("enabledOrReasonIf should report the reason for skipping") {15         val collector = CollectingTestEngineListener()16         TestEngineLauncher(collector)17            .withClasses(EnabledOrReasonIfSpec::class)18            .launch()19         collector.tests.toList().first().second.reasonOrNull shouldBe "wobble"20      }21      test("EnabledExtension should report the reason for skipping") {22         val ext = object : EnabledExtension {23            override suspend fun isEnabled(descriptor: Descriptor): Enabled = Enabled.disabled("wibble")24         }25         val c = ProjectConfiguration().apply { registry.add(ext) }26         val collector = CollectingTestEngineListener()27         TestEngineLauncher(collector)28            .withClasses(MyFunSpec::class)29            .withConfiguration(c)30            .launch()31         collector.tests.toList().first().second.reasonOrNull shouldBe "wibble"32      }33      test("xdisabled in fun spec should report the reason for skipping") {34         val collector = CollectingTestEngineListener()35         TestEngineLauncher(collector)36            .withClasses(XReasonFunSpec::class)37            .launch()38         collector.tests.toList().first().second.reasonOrNull shouldBe "Disabled by xmethod"39      }40      test("xdisabled in describe spec should report the reason for skipping") {41         val collector = CollectingTestEngineListener()42         TestEngineLauncher(collector)43            .withClasses(XReasonDescribeSpec::class)44            .launch()45         collector.tests.toList().first().second.reasonOrNull shouldBe "Disabled by xmethod"46      }47      test("xdisabled in should spec should report the reason for skipping") {48         val collector = CollectingTestEngineListener()49         TestEngineLauncher(collector)50            .withClasses(XReasonShouldSpec::class)51            .launch()52         collector.tests.toList().first().second.reasonOrNull shouldBe "Disabled by xmethod"53      }54      test("enabled should report some reason for skipping") {55         val collector = CollectingTestEngineListener()56         TestEngineLauncher(collector)57            .withClasses(EnabledSpec::class)58            .launch()59         collector.tests.toList().first().second.reasonOrNull shouldBe "Disabled by enabled flag in config"60      }61      test("enabledIf should report some reason for skipping") {62         val collector = CollectingTestEngineListener()63         TestEngineLauncher(collector)64            .withClasses(EnabledIfSpec::class)65            .launch()66         collector.tests.toList().first().second.reasonOrNull shouldBe "Disabled by enabledIf flag in config"67      }68      test("bang should report some reason for skipping") {69         val collector = CollectingTestEngineListener()70         TestEngineLauncher(collector)71            .withClasses(BangSpec::class)72            .launch()73         collector.tests.toList().first().second.reasonOrNull shouldBe "Disabled by bang"74      }75   }76}77private class BangSpec : FunSpec() {78   init {79      test("!a") {80         throw RuntimeException()81      }82   }83}84private class EnabledSpec : FunSpec() {85   init {...

launcher.kt

Source:launcher.kt

...28   if (error != null) throw error29   TestEngineLauncher(listener)30      .withExtensions(listOfNotNull(filter))31      .withTagExpression(args.tagExpression?.let { TagExpression(it) })32      .withClasses(specs)33}34/**35 * Returns the spec classes to execute by using an FQN class name, a package scan,36 * or a full scan.37 */38private fun specs(specClass: KClass<out Spec>?, packageName: String?): DiscoveryResult {39   // if the spec class was null, then we perform discovery to locate all the classes40   // otherwise that specific spec class is used41   return when (specClass) {42      null -> scan(packageName)43      else -> DiscoveryResult(listOf(specClass), emptyList(), null)44   }45}46private fun scan(packageName: String?): DiscoveryResult {...

LateRootTestDefinitionTest.kt

Source:LateRootTestDefinitionTest.kt

...16   init {17      test("expect spec") {18         val listener = CollectingTestEngineListener()19         TestEngineLauncher(listener)20            .withClasses(ExpectSpecWithExtraRootTests::class)21            .launch()22         listener.result("foo")!!.errorOrNull!!.shouldBeInstanceOf<InvalidDslException>()23      }24      test("feature spec") {25         val listener = CollectingTestEngineListener()26         TestEngineLauncher(listener)27            .withClasses(FeatureSpecWithExtraRootTests::class)28            .launch()29         listener.result("foo")!!.errorOrNull!!.shouldBeInstanceOf<InvalidDslException>()30      }31      test("free spec") {32         val listener = CollectingTestEngineListener()33         TestEngineLauncher(listener)34            .withClasses(FreeSpecWithExtraRootTests::class)35            .launch()36         listener.result("foo")!!.errorOrNull!!.shouldBeInstanceOf<InvalidDslException>()37      }38      test("fun spec") {39         val listener = CollectingTestEngineListener()40         TestEngineLauncher(listener)41            .withClasses(FunSpecWithExtraRootTests::class)42            .launch()43         listener.result("foo")!!.errorOrNull!!.shouldBeInstanceOf<InvalidDslException>()44      }45      test("should spec") {46         val listener = CollectingTestEngineListener()47         TestEngineLauncher(listener)48            .withClasses(ShouldSpecWithExtraRootTests::class)49            .launch()50         listener.result("foo")!!.errorOrNull!!.shouldBeInstanceOf<InvalidDslException>()51      }52   }53}54private class FreeSpecWithExtraRootTests : FreeSpec() {55   init {56      "foo" {57         this@FreeSpecWithExtraRootTests.addTest(TestName("bar"), false, null) { }58      }59   }60}61private class FunSpecWithExtraRootTests : FunSpec() {62   init {...

AnnotationSpecTest.kt

Source:AnnotationSpecTest.kt

...9class AnnotationSpecTest : DescribeSpec({10   describe("An AnnotationSpec") {11      it("should detect public and private methods annotated with @Test") {12         val listener = CollectingTestEngineListener()13         TestEngineLauncher(listener).withClasses(AnnotationSpecClass::class).launch()14         listener.tests.shouldHaveSize(2)15      }16//      it("should detect nested classes") {17//         val listener = CollectingTestEngineListener()18//         TestEngineLauncher(listener).withClasses(AnnotationSpecWithNested::class).launch()19//         listener.tests.shouldHaveSize(2)20//      }21      it("should support throwing exceptions with @Test(expected=foo)") {22         val listener = CollectingTestEngineListener()23         TestEngineLauncher(listener).withClasses(AnnotationSpecWithExceptions::class).launch()24         val ds = listener.tests.mapKeys { it.key.descriptor.id }25         ds[DescriptorId("test1")]?.isSuccess shouldBe true26      }27      it("should fail on unexpected exception") {28         val listener = CollectingTestEngineListener()29         TestEngineLauncher(listener).withClasses(AnnotationSpecWithExceptions::class).launch()30         val ds = listener.tests.mapKeys { it.key.descriptor.id }31         ds[DescriptorId("test2")]?.isFailure shouldBe true32      }33      it("should fail on expected exception that wasn't thrown") {34         val listener = CollectingTestEngineListener()35         TestEngineLauncher(listener).withClasses(AnnotationSpecWithExceptions::class).launch()36         val ds = listener.tests.mapKeys { it.key.descriptor.id }37         ds[DescriptorId("test3")]?.isFailure shouldBe true38      }39   }40})41private class AnnotationSpecClass : AnnotationSpec() {42   @Test43   fun myTest() {44   }45   @Test46   private fun test2() {47   }48}49private class AnnotationSpecWithExceptions : AnnotationSpec() {...

UnfinishedTestDefinitionTest.kt

Source:UnfinishedTestDefinitionTest.kt

...15         TestDslState.reset()16      }17      test("fun spec") {18         val result = TestEngineLauncher(NoopTestEngineListener)19            .withClasses(FunSpecUnfinishedTestDefinitionTest::class)20            .launch()21         result.errors.forAtLeastOne { it.message!!.shouldContain("unfinished test") }22      }23      test("describe spec") {24         val result = TestEngineLauncher(NoopTestEngineListener)25            .withClasses(DescribeSpecUnfinishedTestDefinitionTest::class)26            .launch()27         result.errors.forAtLeastOne { it.message!!.shouldContain("unfinished it") }28      }29      test("should spec") {30         val result = TestEngineLauncher(NoopTestEngineListener)31            .withClasses(ShouldSpecUnfinishedTestDefinitionTest::class)32            .launch()33         result.errors.forAtLeastOne { it.message!!.shouldContain("unfinished should") }34      }35      test("feature spec") {36         val result = TestEngineLauncher(NoopTestEngineListener)37            .withClasses(FeatureSpecUnfinishedTestDefinitionTest::class)38            .launch()39         result.errors.forAtLeastOne { it.message!!.shouldContain("unfinished scenario") }40      }41      test("expect spec") {42         val result = TestEngineLauncher(NoopTestEngineListener)43            .withClasses(ExpectSpecUnfinishedTestDefinitionTest::class)44            .launch()45         result.errors.forAtLeastOne { it.message!!.shouldContain("unfinished expect") }46      }47   }48}49private class FunSpecUnfinishedTestDefinitionTest : FunSpec({50   context("context") {51      test("unfinished test")52   }53})54private class FeatureSpecUnfinishedTestDefinitionTest : FeatureSpec({55   feature("feature") {56      scenario("unfinished scenario")57   }...

KotestUnit.kt

Source:KotestUnit.kt

...31         }32      }33      TestEngineLauncher()34         .withListener(listener)35         .withClasses(klass)36         .launch()37   }38}...

withClasses

Using AI Code Generation

1import io.kotest.core.config.configuration2import io.kotest.core.spec.Spec3import io.kotest.core.spec.style.FunSpec4import io.kotest.engine.TestEngineLauncher5import io.kotest.matchers.shouldBe6class MySpec : FunSpec({7    test("hello") {8    }9})10fun main() {11    TestEngineLauncher()12        .withClasses(MySpec::class)13        .launch()14}15import io.kotest.core.config.configuration16import io.kotest.core.spec.Spec17import io.kotest.core.spec.style.FunSpec18import io.kotest.engine.TestEngineLauncher19import io.kotest.matchers.shouldBe20class MySpec : FunSpec({21    test("hello") {22    }23})24fun main() {25    TestEngineLauncher()26        .withSpecs(MySpec::class)27        .launch()28}29import io.kotest.core.config.configuration30import io.kotest.core.spec.Spec31import io.kotest.core.spec.style.FunSpec32import io.kotest.engine.TestEngineLauncher33import io.kotest.matchers.shouldBe34class MySpec : FunSpec({35    test("hello") {36    }37})38fun main() {39    TestEngineLauncher()40        .withSpec(MySpec())41        .launch()42}43import io.kotest.core.config.configuration44import io.kotest.core.spec.Spec45import io.kotest.core.spec.style.FunSpec46import io.kotest.engine.TestEngineLauncher47import io.kotest.matchers.shouldBe48class MySpec : FunSpec({49    test("hello") {50    }51})52fun main() {53    TestEngineLauncher()54        .withSpecs(MySpec())55        .launch()56}57import io.kotest.core.config.configuration58import io.kotest.core.spec.Spec59import io.kotest.core.spec.style.FunSpec60import io.kotest.engine.Test

withClasses

Using AI Code Generation

1val launcher = TestEngineLauncher()2launcher.withClasses(MyTest::class)3launcher.execute()4val launcher = TestEngineLauncher()5launcher.withClasses(MyTest::class)6launcher.execute()7val launcher = TestEngineLauncher()8launcher.withClasses(MyTest::class)9launcher.execute()10val launcher = TestEngineLauncher()11launcher.withClasses(MyTest::class)12launcher.execute()13val launcher = TestEngineLauncher()14launcher.withClasses(MyTest::class)15launcher.execute()16val launcher = TestEngineLauncher()17launcher.withClasses(MyTest::class)18launcher.execute()19val launcher = TestEngineLauncher()20launcher.withClasses(MyTest::class)21launcher.execute()22val launcher = TestEngineLauncher()23launcher.withClasses(MyTest::class)24launcher.execute()25val launcher = TestEngineLauncher()26launcher.withClasses(MyTest::class)27launcher.execute()28val launcher = TestEngineLauncher()29launcher.withClasses(MyTest::class)30launcher.execute()31val launcher = TestEngineLauncher()32launcher.withClasses(MyTest::class)33launcher.execute()34val launcher = TestEngineLauncher()35launcher.withClasses(MyTest::class)36launcher.execute()37val launcher = TestEngineLauncher()38launcher.withClasses(MyTest::class)39launcher.execute()40val launcher = TestEngineLauncher()41launcher.withClasses(MyTest::class)42launcher.execute()

withClasses

Using AI Code Generation

1val classes = listOf ( "org.example.MyTest1" , "org.example.MyTest2" )2val launcher = TestEngineLauncher . withClasses ( classes )3val launcher = TestEngineLauncher . withSpecs ( MyTest1 :: class , MyTest2 :: class )4val launcher = TestEngineLauncher . withSpecClasses ( MyTest1 :: class , MyTest2 :: class )5val launcher = TestEngineLauncher . withSpecs ( MyTest1 :: class , MyTest2 :: class )6val launcher = TestEngineLauncher . withSpecClasses ( MyTest1 :: class , MyTest2 :: class )7val launcher = TestEngineLauncher . withSpecs ( MyTest1 :: class , MyTest2 :: class )8val launcher = TestEngineLauncher . withSpecClasses ( MyTest1 :: class , MyTest2 :: class )9val launcher = TestEngineLauncher . withSpecs ( MyTest1 :: class , MyTest2 :: class )10val launcher = TestEngineLauncher . withSpecClasses ( MyTest1 :: class , MyTest2 :: class )11val launcher = TestEngineLauncher . withSpecs ( MyTest1 :: class , MyTest2 :: class )12val launcher = TestEngineLauncher . withSpecClasses ( MyTest1 :: class , MyTest2 :: class )13val launcher = TestEngineLauncher . withSpecs ( MyTest1 :: class , MyTest2 :: class )

withClasses

Using AI Code Generation

1val launcher = TestEngineLauncher.newInstance()2launcher.registerTestEngine(Engine::class)3launcher.withClasses(MySpec::class)4launcher.withListener(listener)5launcher.execute()6val launcher = TestEngineLauncher.newInstance()7launcher.registerTestEngine(Engine::class)8launcher.withSpecs(MySpec::class)9launcher.withListener(listener)10launcher.execute()11val launcher = TestEngineLauncher.newInstance()12launcher.registerTestEngine(Engine::class)13launcher.withSpecs(MySpec::class)14launcher.withListener(listener)15launcher.execute()16val launcher = TestEngineLauncher.newInstance()17launcher.registerTestEngine(Engine::class)18launcher.withSpecs(MySpec::class)19launcher.withListener(listener)20launcher.execute()21val launcher = TestEngineLauncher.newInstance()22launcher.registerTestEngine(Engine::class)23launcher.withSpecs(MySpec::class)24launcher.withListener(listener)25launcher.execute()26val launcher = TestEngineLauncher.newInstance()27launcher.registerTestEngine(Engine::class)28launcher.withSpecs(MySpec::class)29launcher.withListener(listener)30launcher.execute()31val launcher = TestEngineLauncher.newInstance()32launcher.registerTestEngine(Engine::class)33launcher.withSpecs(MySpec::class)34launcher.withListener(listener)35launcher.execute()36val launcher = TestEngineLauncher.newInstance()37launcher.registerTestEngine(Engine::class)38launcher.withSpecs(MySpec::class)39launcher.withListener(listener)40launcher.execute()41val launcher = TestEngineLauncher.newInstance()42launcher.registerTestEngine(Engine::class)43launcher.withSpecs(MySpec::class)44launcher.withListener(listener)45launcher.execute()46val launcher = TestEngineLauncher.newInstance()47launcher.registerTestEngine(Engine::class)48launcher.withSpecs(My

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.