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

Copied to Clipboard!

How to use beforeEachTest method of org.spekframework.spek2.runtime.Collector class

Best Spek code snippet using org.spekframework.spek2.runtime.Collector.beforeEachTest

EnvironmentTelemetryCollectorSpec.kt

Source:EnvironmentTelemetryCollectorSpec.kt

...61                on { startTime } doReturn 1597138787193 // 2020-08-11T09:39:47.193Z62            }63        }64        val commandType = VersionInfoCommand::class65        beforeEachTest {66            systemProperties.setProperty("java.vendor", "JVMs R Us")67            systemProperties.setProperty("java.version", "2020.1")68            systemProperties.setProperty("java.vm.name", "64-Bit Server VM")69        }70        fun Suite.createEnvironmentCollector(hostEnvironmentVariables: HostEnvironmentVariables, commandLineOptions: CommandLineOptions = CommandLineOptions()) =71            createForEachTest { EnvironmentTelemetryCollector(telemetrySessionBuilder, hostEnvironmentVariables, gitClient, consoleInfo, commandLineOptions, ciEnvironmentDetector, systemInfo, runtimeMXBean, systemProperties) }72        given("the SHELL environment variable is set") {73            val shell = "/usr/local/bin/my-awesome-shell"74            given("the TERM environment variable is set") {75                val term = "xterm-9000color"76                given("the BATECT_WRAPPER_DID_DOWNLOAD environment variable is set to 'true'") {77                    val didDownload = "true"78                    val hostEnvironmentVariables = HostEnvironmentVariables("SHELL" to shell, "TERM" to term, "BATECT_WRAPPER_DID_DOWNLOAD" to didDownload)79                    given("the command line options have their default values") {80                        val commandLineOptions = CommandLineOptions()81                        val environmentCollector by createEnvironmentCollector(hostEnvironmentVariables, commandLineOptions)82                        given("the Git version is available") {83                            beforeEachTest {84                                whenever(gitClient.version).doReturn(GitVersionRetrievalResult.Succeeded("1.2.3"))85                            }86                            given("a CI system is not detected") {87                                beforeEachTest {88                                    environmentCollector.collect(commandType)89                                }90                                it("reports the user's shell, taking only the last segment of the path") {91                                    verify(telemetrySessionBuilder).addAttribute("shell", "my-awesome-shell")92                                }93                                it("reports the user's terminal") {94                                    verify(telemetrySessionBuilder).addAttribute("terminal", "xterm-9000color")95                                }96                                it("reports the Git version") {97                                    verify(telemetrySessionBuilder).addAttribute("gitVersion", "1.2.3")98                                }99                                it("reports details of the operating system") {100                                    verify(telemetrySessionBuilder).addAttribute("osName", "My Cool OS")101                                    verify(telemetrySessionBuilder).addAttribute("osVersion", "2020.08")102                                    verify(telemetrySessionBuilder).addAttribute("osArchitecture", "x86_64")103                                    verify(telemetrySessionBuilder).addAttribute("osDetails", "Ubuntu Linux 20.04")104                                }105                                it("reports details of the JVM") {106                                    verify(telemetrySessionBuilder).addAttribute("jvmVendor", "JVMs R Us")107                                    verify(telemetrySessionBuilder).addAttribute("jvmName", "64-Bit Server VM")108                                    verify(telemetrySessionBuilder).addAttribute("jvmVersion", "2020.1")109                                }110                                it("reports the type of command being run") {111                                    verify(telemetrySessionBuilder).addAttribute("commandType", "VersionInfoCommand")112                                }113                                it("reports that the wrapper downloaded the JAR for this invocation") {114                                    verify(telemetrySessionBuilder).addAttribute("wrapperDidDownload", true)115                                }116                                it("reports the time the JVM started, in UTC") {117                                    verify(telemetrySessionBuilder).addAttribute("jvmStartTime", "2020-08-11T09:39:47.193Z")118                                }119                                it("reports whether stdin is a TTY") {120                                    verify(telemetrySessionBuilder).addAttribute("stdinIsTTY", false)121                                }122                                it("reports whether stdout is a TTY") {123                                    verify(telemetrySessionBuilder).addAttribute("stdoutIsTTY", true)124                                }125                                it("reports whether interactivity is supported") {126                                    verify(telemetrySessionBuilder).addAttribute("consoleSupportsInteractivity", true)127                                }128                                it("reports that a custom configuration file name is not being used") {129                                    verify(telemetrySessionBuilder).addAttribute("usingNonDefaultConfigurationFileName", false)130                                }131                                it("reports that a config variables file is not being used") {132                                    verify(telemetrySessionBuilder).addAttribute("usingConfigVariablesFile", false)133                                }134                                it("reports the requested output style") {135                                    verify(telemetrySessionBuilder).addAttribute("requestedOutputStyle", null as String?)136                                }137                                it("reports that color output has not been disabled") {138                                    verify(telemetrySessionBuilder).addAttribute("colorOutputDisabled", false)139                                }140                                it("reports that update notifications have not been disabled") {141                                    verify(telemetrySessionBuilder).addAttribute("updateNotificationsDisabled", false)142                                }143                                it("reports that wrapper cache cleanup has not been disabled") {144                                    verify(telemetrySessionBuilder).addAttribute("wrapperCacheCleanupDisabled", false)145                                }146                                it("reports that cleanup after success has not been disabled") {147                                    verify(telemetrySessionBuilder).addAttribute("cleanupAfterSuccessDisabled", false)148                                }149                                it("reports that cleanup after failure has not been disabled") {150                                    verify(telemetrySessionBuilder).addAttribute("cleanupAfterFailureDisabled", false)151                                }152                                it("reports that proxy environment variable propagation has not been disabled") {153                                    verify(telemetrySessionBuilder).addAttribute("proxyEnvironmentVariablePropagationDisabled", false)154                                }155                                it("reports the number of additional task command arguments") {156                                    verify(telemetrySessionBuilder).addAttribute("additionalTaskCommandArgumentCount", 0)157                                }158                                it("reports the number of command line config variable overrides") {159                                    verify(telemetrySessionBuilder).addAttribute("commandLineConfigVariableOverrideCount", 0)160                                }161                                it("reports the number of command line image overrides") {162                                    verify(telemetrySessionBuilder).addAttribute("commandLineImageOverrideCount", 0)163                                }164                                it("reports that TLS is not being used for the connection to Docker") {165                                    verify(telemetrySessionBuilder).addAttribute("usingTLSForDockerConnection", false)166                                }167                                it("reports that TLS is not being verified for the connection to Docker") {168                                    verify(telemetrySessionBuilder).addAttribute("verifyingTLSForDockerConnection", false)169                                }170                                it("reports that an existing Docker network is not being used") {171                                    verify(telemetrySessionBuilder).addAttribute("usingExistingDockerNetwork", false)172                                }173                                it("reports that prerequisites are not being skipped") {174                                    verify(telemetrySessionBuilder).addAttribute("skippingPrerequisites", false)175                                }176                                it("reports that no maximum level of parallelism is set") {177                                    verify(telemetrySessionBuilder).addAttribute("maximumLevelOfParallelism", null as Int?)178                                }179                                it("reports that no CI system was detected") {180                                    verify(telemetrySessionBuilder).addAttribute("suspectRunningOnCI", false)181                                    verify(telemetrySessionBuilder).addAttribute("suspectedCISystem", null as String?)182                                }183                            }184                            given("a CI system is detected") {185                                beforeEachTest {186                                    whenever(ciEnvironmentDetector.detect()).doReturn(CIDetectionResult(true, "My CI System"))187                                    environmentCollector.collect(commandType)188                                }189                                it("reports that a CI system was detected") {190                                    verify(telemetrySessionBuilder).addAttribute("suspectRunningOnCI", true)191                                }192                                it("reports the CI system name") {193                                    verify(telemetrySessionBuilder).addAttribute("suspectedCISystem", "My CI System")194                                }195                            }196                        }197                        given("the Git version is not available") {198                            beforeEachTest {199                                whenever(gitClient.version).doReturn(GitVersionRetrievalResult.Failed("Something went wrong."))200                                environmentCollector.collect(commandType)201                            }202                            it("reports the Git version as unknown") {203                                verify(telemetrySessionBuilder).addNullAttribute("gitVersion")204                            }205                        }206                    }207                    given("the command line options do not have their default values") {208                        val commandLineOptions = CommandLineOptions(209                            configurationFileName = osIndependentPath("not-batect.yml"),210                            configVariablesSourceFile = osIndependentPath("some-variables.yml"),211                            requestedOutputStyle = OutputStyle.Fancy,212                            disableColorOutput = true,213                            disableUpdateNotification = true,214                            disableWrapperCacheCleanup = true,215                            disableCleanupAfterSuccess = true,216                            disableCleanupAfterFailure = true,217                            dontPropagateProxyEnvironmentVariables = true,218                            additionalTaskCommandArguments = listOf("some", "args"),219                            configVariableOverrides = mapOf("var" to "value", "other-var" to "other value"),220                            imageOverrides = mapOf("container-1" to "image-1"),221                            dockerUseTLS = true,222                            dockerVerifyTLS = true,223                            existingNetworkToUse = "some-network",224                            skipPrerequisites = true,225                            maximumLevelOfParallelism = 3226                        )227                        val environmentCollector by createEnvironmentCollector(hostEnvironmentVariables, commandLineOptions)228                        beforeEachTest { environmentCollector.collect(commandType) }229                        it("reports that a custom configuration file name is being used") {230                            verify(telemetrySessionBuilder).addAttribute("usingNonDefaultConfigurationFileName", true)231                        }232                        it("reports that a config variables file is being used") {233                            verify(telemetrySessionBuilder).addAttribute("usingConfigVariablesFile", true)234                        }235                        it("reports the requested output style") {236                            verify(telemetrySessionBuilder).addAttribute("requestedOutputStyle", "fancy")237                        }238                        it("reports that color output has been disabled") {239                            verify(telemetrySessionBuilder).addAttribute("colorOutputDisabled", true)240                        }241                        it("reports that update notifications have been disabled") {242                            verify(telemetrySessionBuilder).addAttribute("updateNotificationsDisabled", true)243                        }244                        it("reports that wrapper cache cleanup has been disabled") {245                            verify(telemetrySessionBuilder).addAttribute("wrapperCacheCleanupDisabled", true)246                        }247                        it("reports that cleanup after success has been disabled") {248                            verify(telemetrySessionBuilder).addAttribute("cleanupAfterSuccessDisabled", true)249                        }250                        it("reports that cleanup after failure has been disabled") {251                            verify(telemetrySessionBuilder).addAttribute("cleanupAfterFailureDisabled", true)252                        }253                        it("reports that proxy environment variable propagation has been disabled") {254                            verify(telemetrySessionBuilder).addAttribute("proxyEnvironmentVariablePropagationDisabled", true)255                        }256                        it("reports the number of additional task command arguments") {257                            verify(telemetrySessionBuilder).addAttribute("additionalTaskCommandArgumentCount", 2)258                        }259                        it("reports the number of command line config variable overrides") {260                            verify(telemetrySessionBuilder).addAttribute("commandLineConfigVariableOverrideCount", 2)261                        }262                        it("reports the number of command line image overrides") {263                            verify(telemetrySessionBuilder).addAttribute("commandLineImageOverrideCount", 1)264                        }265                        it("reports that TLS is being used for the connection to Docker") {266                            verify(telemetrySessionBuilder).addAttribute("usingTLSForDockerConnection", true)267                        }268                        it("reports that TLS is being verified for the connection to Docker") {269                            verify(telemetrySessionBuilder).addAttribute("verifyingTLSForDockerConnection", true)270                        }271                        it("reports that an existing Docker network is being used") {272                            verify(telemetrySessionBuilder).addAttribute("usingExistingDockerNetwork", true)273                        }274                        it("reports that prerequisites are being skipped") {275                            verify(telemetrySessionBuilder).addAttribute("skippingPrerequisites", true)276                        }277                        it("reports the configured maximum level of parallelism") {278                            verify(telemetrySessionBuilder).addAttribute("maximumLevelOfParallelism", 3)279                        }280                    }281                }282                given("the BATECT_WRAPPER_DID_DOWNLOAD environment variable is set to 'false'") {283                    val didDownload = "false"284                    val hostEnvironmentVariables = HostEnvironmentVariables("SHELL" to shell, "TERM" to term, "BATECT_WRAPPER_DID_DOWNLOAD" to didDownload)285                    val environmentCollector by createEnvironmentCollector(hostEnvironmentVariables)286                    beforeEachTest { environmentCollector.collect(commandType) }287                    it("reports that the wrapper did not download the JAR for this invocation") {288                        verify(telemetrySessionBuilder).addAttribute("wrapperDidDownload", false)289                    }290                }291                given("the BATECT_WRAPPER_DID_DOWNLOAD environment variable is not set to 'true' or 'false'") {292                    val didDownload = "blah"293                    val hostEnvironmentVariables = HostEnvironmentVariables("SHELL" to shell, "TERM" to term, "BATECT_WRAPPER_DID_DOWNLOAD" to didDownload)294                    val environmentCollector by createEnvironmentCollector(hostEnvironmentVariables)295                    beforeEachTest { environmentCollector.collect(commandType) }296                    it("reports the download status as unknown") {297                        verify(telemetrySessionBuilder).addNullAttribute("wrapperDidDownload")298                    }299                }300                given("the BATECT_WRAPPER_DID_DOWNLOAD environment variable is not set") {301                    val hostEnvironmentVariables = HostEnvironmentVariables("SHELL" to shell, "TERM" to term)302                    val environmentCollector by createEnvironmentCollector(hostEnvironmentVariables)303                    beforeEachTest { environmentCollector.collect(commandType) }304                    it("reports the download status as unknown") {305                        verify(telemetrySessionBuilder).addNullAttribute("wrapperDidDownload")306                    }307                }308            }309            given("the TERM environment variable is not set") {310                val hostEnvironmentVariables = HostEnvironmentVariables("SHELL" to shell)311                val environmentCollector by createEnvironmentCollector(hostEnvironmentVariables)312                beforeEachTest { environmentCollector.collect(commandType) }313                it("reports the user's terminal as unknown") {314                    verify(telemetrySessionBuilder).addAttribute("terminal", null as String?)315                }316            }317        }318        given("the SHELL environment variable is not set") {319            val hostEnvironmentVariables = HostEnvironmentVariables("TERM" to "something")320            val environmentCollector by createEnvironmentCollector(hostEnvironmentVariables)321            beforeEachTest { environmentCollector.collect(commandType) }322            it("reports the user's shell as unknown") {323                verify(telemetrySessionBuilder).addAttribute("shell", null as String?)324            }325        }326    }327})...

ApplicationSpec.kt

Source:ApplicationSpec.kt

...74        }75        val application by createForEachTest { Application(dependencies) }76        val args = listOf("some-command", "some-param")77        given("the application is running on a supported operating system") {78            beforeEachTest { whenever(systemInfo.isSupportedOperatingSystem).thenReturn(true) }79            given("parsing the command line arguments succeeds") {80                val applicationInfoLogger by createForEachTest { mock<ApplicationInfoLogger>() }81                val logSink by createForEachTest { InMemoryLogSink() }82                val loggerFactory by createForEachTest {83                    mock<LoggerFactory> {84                        on { createLoggerForClass(Application::class) } doReturn Logger("application", logSink)85                    }86                }87                val commandFactory by createForEachTest { mock<CommandFactory>() }88                val consoleManager by createForEachTest { mock<ConsoleManager>() }89                val errorConsole by createForEachTest { mock<Console>() }90                val wrapperCache by createForEachTest { mock<WrapperCache>() }91                val telemetryManager by createForEachTest { mock<TelemetryManager>() }92                val environmentTelemetryCollector by createForEachTest { mock<EnvironmentTelemetryCollector>() }93                val extendedDependencies by createForEachTest {94                    DI.direct {95                        bind<ApplicationInfoLogger>() with instance(applicationInfoLogger)96                        bind<LoggerFactory>() with instance(loggerFactory)97                        bind<CommandFactory>() with instance(commandFactory)98                        bind<Console>(StreamType.Error) with instance(errorConsole)99                        bind<ConsoleManager>() with instance(consoleManager)100                        bind<WrapperCache>() with instance(wrapperCache)101                        bind<TelemetryManager>() with instance(telemetryManager)102                        bind<EnvironmentTelemetryCollector>() with instance(environmentTelemetryCollector)103                    }104                }105                val options by createForEachTest {106                    mock<CommandLineOptions> {107                        on { extend(dependencies) } doReturn extendedDependencies108                    }109                }110                beforeEachTest {111                    whenever(commandLineOptionsParser.parse(args)).thenReturn(CommandLineOptionsParsingResult.Succeeded(options))112                }113                given("the command executes normally") {114                    val command by createForEachTest {115                        mock<Command> {116                            on { run() } doReturn 123117                        }118                    }119                    beforeEachTest {120                        whenever(commandFactory.createCommand(options, extendedDependencies)).thenReturn(command)121                    }122                    on("running the application") {123                        val exitCode by runForEachTest { application.run(args) }124                        it("does not print anything to the error stream") {125                            assertThat(errorStream.toString(), equalTo(""))126                        }127                        it("returns the exit code from the command") {128                            assertThat(exitCode, equalTo(123))129                        }130                        it("logs information about the application, enables console escape sequences, updates the last used time for the wrapper script and collects information about the environment before running the command") {131                            inOrder(consoleManager, applicationInfoLogger, wrapperCache, environmentTelemetryCollector, command) {132                                verify(applicationInfoLogger).logApplicationInfo(args)133                                verify(consoleManager).enableConsoleEscapeSequences()134                                verify(wrapperCache).setLastUsedForCurrentVersion()135                                verify(environmentTelemetryCollector).collect(command::class)136                                verify(command).run()137                            }138                        }139                        it("finishes the telemetry session after running the command") {140                            inOrder(command, telemetryManager) {141                                verify(command).run()142                                verify(telemetryManager).finishSession(telemetrySessionBuilder)143                            }144                        }145                        it("reports the exit code as part of the telemetry session") {146                            verify(telemetrySessionBuilder).addAttribute("exitCode", 123)147                        }148                    }149                }150                given("the command throws an exception") {151                    val exception = RuntimeException("Everything is broken")152                    val command by createForEachTest {153                        mock<Command> {154                            on { run() } doThrow exception155                        }156                    }157                    beforeEachTest {158                        whenever(commandFactory.createCommand(options, extendedDependencies)).thenReturn(command)159                    }160                    on("running the application") {161                        val exitCode by runForEachTest { application.run(args) }162                        it("prints the exception message to the error console in red") {163                            verify(errorConsole).println(Text.red("java.lang.RuntimeException: Everything is broken"))164                        }165                        it("logs the exception to the log") {166                            assertThat(logSink, hasMessage(withSeverity(Severity.Error) and withException(exception)))167                        }168                        it("returns a non-zero exit code") {169                            assertThat(exitCode, !equalTo(0))170                        }171                        it("reports the exit code as part of the telemetry session") {172                            verify(telemetrySessionBuilder).addAttribute("exitCode", exitCode)173                        }174                        it("reports the exception in telemetry") {175                            verify(telemetrySessionBuilder).addEvent(176                                CommonEvents.UnhandledException,177                                mapOf(178                                    CommonAttributes.Exception to AttributeValue(exception),179                                    CommonAttributes.ExceptionCaughtAt to AttributeValue("batect.Application.runCommand"),180                                    CommonAttributes.IsUserFacingException to AttributeValue(true)181                                )182                            )183                        }184                        it("finishes the telemetry session after printing the exception message") {185                            inOrder(errorConsole, telemetryManager) {186                                verify(errorConsole).println(any<Text>())187                                verify(telemetryManager).finishSession(telemetrySessionBuilder)188                            }189                        }190                    }191                }192            }193            given("parsing the command line arguments fails") {194                beforeEachTest {195                    whenever(commandLineOptionsParser.parse(args)).thenReturn(CommandLineOptionsParsingResult.Failed("Everything is broken"))196                }197                on("running the application") {198                    val exitCode by runForEachTest { application.run(args) }199                    it("prints the error message to the error stream") {200                        assertThat(errorStream.toString(), equalTo("Everything is broken\n".withPlatformSpecificLineSeparator()))201                    }202                    it("returns a non-zero exit code") {203                        assertThat(exitCode, !equalTo(0))204                    }205                }206            }207        }208        given("the application is running on an unsupported operating system") {209            beforeEachTest { whenever(systemInfo.isSupportedOperatingSystem).thenReturn(false) }210            on("running the application") {211                val exitCode by runForEachTest { application.run(args) }212                it("prints an error message to the error stream") {213                    assertThat(errorStream.toString(), equalTo("Batect only supports Linux, macOS and Windows.\n".withPlatformSpecificLineSeparator()))214                }215                it("returns a non-zero exit code") {216                    assertThat(exitCode, !equalTo(0))217                }218            }219        }220    }221})...

SpecificationStyleTest.kt

Source:SpecificationStyleTest.kt

...46	at org.spekframework.spek2.style.specification.SpecificationStyleKt.describe$default(specificationStyle.kt:76)47	at com.example.spek.SpecificationStyleTest$1.invoke(SpecificationStyleTest.kt:33)48	at com.example.spek.SpecificationStyleTest$1.invoke(SpecificationStyleTest.kt:9)49 */50        beforeEachTest {51            add("beforeEachTest-desc-1")52            logger.info("beforeEach in desc 1, memoized: {}, list: {}", items, list)53        }54        afterEachTest {55            add("afterEachTest-desc-1")56            logger.info("afterEachTest in desc 1, memoized: {}, list: {}", items, list)57        }58        it("is foo") {59            add("foo")60            logger.info("foo, memoized: {}, list: {}", items, list)61        }62        it("fails") {63            add("fail")64            logger.info("fail, memoized: {}, list: {}", items, list)65            fail { "fail: $items, $list" }66        }67        it("is bar") {68            add("bar")69            logger.info("bar, memoized: {}, list: {}", items, list)70        }71        describe("inner") {72            // cannot access items73//            add("inner")74//            logger.info("desc-1-inner, memoized: {}, list: {}", items, list)75/*76Caused by: java.lang.AssertionError: 'items' can not be accessed in this context.77	at org.spekframework.spek2.runtime.lifecycle.MemoizedValueAdapter.get(MemoizedValueAdapter.kt:33)78	at org.spekframework.spek2.runtime.lifecycle.MemoizedValueAdapter.getValue(MemoizedValueAdapter.kt:22)79	at com.example.spek.SpecificationStyleTest$1$1.invoke(SpecificationStyleTest.kt:16)80	at com.example.spek.SpecificationStyleTest$1$2$5.invoke(SpecificationStyleTest.kt:76)81	at com.example.spek.SpecificationStyleTest$1$2$5.invoke(SpecificationStyleTest.kt:9)82	at org.spekframework.spek2.style.specification.SpecificationStyleKt$createSuite$1.invoke(specificationStyle.kt:88)83	at org.spekframework.spek2.style.specification.SpecificationStyleKt$createSuite$1.invoke(specificationStyle.kt)84	at org.spekframework.spek2.runtime.Collector.group(Collectors.kt:91)85	at org.spekframework.spek2.dsl.GroupBody$DefaultImpls.group$default(dsl.kt:24)86	at org.spekframework.spek2.style.specification.SpecificationStyleKt.createSuite(specificationStyle.kt:87)87	at org.spekframework.spek2.style.specification.SpecificationStyleKt.access$createSuite(specificationStyle.kt:1)88	at org.spekframework.spek2.style.specification.Suite.describe(specificationStyle.kt:20)89	at org.spekframework.spek2.style.specification.Suite.describe$default(specificationStyle.kt:19)90	at com.example.spek.SpecificationStyleTest$1$2.invoke(SpecificationStyleTest.kt:75)91	at com.example.spek.SpecificationStyleTest$1$2.invoke(SpecificationStyleTest.kt:9)92 */93            beforeEachTest {94                add("beforeEachTest-inner")95                logger.info("beforeEachTest in inner, memoized: {}, list: {}", items, list)96            }97            it("inner") {98                add("inner-test")99                logger.info("inner-test, memoized: {}, list: {}", items, list)100            }101        }102    }103    xdescribe("desc skipped") {104        logger.info("desc skipped, memoized: {}, list: {}", items, list)105        it("will be skipped") {106            logger.info("it will be skipped, memoized: {}, list: {}", items, list)107            fail { "skip: $list" }108        }109    }...

Collectors.kt

Source:Collectors.kt

...75            lifecycleManager76        )77        root.addChild(test)78    }79    override fun beforeEachTest(callback: () -> Unit) {80        fixtures.registerBeforeEachTest(root, callback)81    }82    override fun afterEachTest(callback: () -> Unit) {83        fixtures.registerAfterEachTest(root, callback)84    }85    override fun beforeGroup(callback: () -> Unit) {86        fixtures.registerBeforeGroup(root, callback)87    }88    override fun afterGroup(callback: () -> Unit) {89        fixtures.registerAfterGroup(root, callback)90    }91    private fun idFor(description: String): ScopeId {92        val current = ids.getOrPut(description) { 0 } + 193        ids[description] = current...

beforeEachTest

Using AI Code Generation

1import org.spekframework.spek2.runtime.Collector2Collector.beforeEachTest {3}4Collector.afterEachTest {5}6import org.spekframework.spek2.Spek7import org.spekframework.spek2.style.gherkin.Feature8import org.junit.jupiter.api.Assertions.*9object CalculatorSpec : Spek({10Feature("Calculator") {11Scenario("should add two numbers") {12Given("a calculator") {13val calculator = Calculator()14}15When("adding two numbers") {16val result = calculator.add(1, 1)17}18Then("the result should be the sum of the two numbers") {19assertEquals(2, result)20}21}22}23})24import org.spekframework.spek2.junit.SpekJUnitPlatform25import org.spekframework.spek2.style.gherkin.Feature26import org.junit.jupiter.api.Assertions.*27object CalculatorSpec : SpekJUnitPlatform({28Feature("Calculator") {29Scenario("should add two numbers") {30Given("a calculator") {31val calculator = Calculator()32}33When("adding two numbers") {34val result = calculator.add(1, 1)35}36Then("the result should be the sum of the two numbers") {37assertEquals(2, result)38}39}40}41})42import org.spekframework.spek2.junit.SpekJUnitPlatform43import org.spekframework.spek2.style.gherkin.Feature44import org.junit.jupiter.api.Assertions.*45object CalculatorSpec : SpekJUnitPlatform({46Feature("Calculator") {47Scenario("should add two numbers") {48Given("a calculator") {49val calculator = Calculator()50}51When("adding two numbers") {52val result = calculator.add(1, 1)53}54Then("the result should be the sum of the two numbers") {55assertEquals(2, result)56}57}58}59})

beforeEachTest

Using AI Code Generation

1import org.spekframework.spek2.Spek2import org.spekframework.spek2.style.specification.describe3import kotlin.test.assertEquals4class CalculatorTest : Spek({5    val calculator: Calculator by memoized { Calculator() }6    beforeEachTest { calculator.clear() }7    describe("a calculator") {8        on("addition") {9            it("should return the sum of two numbers") {10                assertEquals(2, calculator.add(1, 1))11            }12            it("should return the sum of more than two numbers") {13                assertEquals(9, calculator.add(1, 2, 3, 3))

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.