A specification framework for Kotlin

Hello,

Please consider the following test (using MockK):

class MockkSpec : Spek({
  val mock = mockk<Greeter>()

  beforeEachTest {
    every { mock.greet(any()) } answers { "Hello ${args[0]}" }
  }

  afterEachTest {
    clearMocks(mock)
  }

  describe("greet(\"mock\")") {
    val result by memoized { mock.greet("mock") }

    it("should return \"Hello mock\"") {
      assertEquals("Hello mock", result)
    }
  }
})

It runs fine from gradle (graldew test). But running the test from IntelliJ fails with:

Exception in thread "main" java.lang.NoClassDefFoundError: io/mockk/proxy/jvm/dispatcher/JvmMockKDispatcher
	at java.base/java.lang.ClassLoader.defineClass1(Native Method)
	at java.base/java.lang.ClassLoader.defineClass(ClassLoader.java:1016)
	at java.base/java.security.SecureClassLoader.defineClass(SecureClassLoader.java:174)
	at java.base/jdk.internal.loader.BuiltinClassLoader.defineClass(BuiltinClassLoader.java:801)
	at java.base/jdk.internal.loader.BuiltinClassLoader.findClassOnClassPathOrNull(BuiltinClassLoader.java:699)
	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClassOrNull(BuiltinClassLoader.java:622)
	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:580)
	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:178)
	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:521)
	at java.base/java.lang.ClassLoader.defineClass1(Native Method)
	at java.base/java.lang.ClassLoader.defineClass(ClassLoader.java:1016)
	at java.base/java.security.SecureClassLoader.defineClass(SecureClassLoader.java:174)
	at java.base/jdk.internal.loader.BuiltinClassLoader.defineClass(BuiltinClassLoader.java:801)
	at java.base/jdk.internal.loader.BuiltinClassLoader.findClassOnClassPathOrNull(BuiltinClassLoader.java:699)
	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClassOrNull(BuiltinClassLoader.java:622)
	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:580)
	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:178)
	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:521)
	at io.mockk.proxy.jvm.transformation.SubclassInstrumentation$AdviceBuilder.build(SubclassInstrumentation.kt:28)
	at io.mockk.proxy.jvm.transformation.SubclassInstrumentation.<init>(SubclassInstrumentation.kt:33)
	at io.mockk.proxy.jvm.JvmMockKAgentFactory$init$Initializer.init(JvmMockKAgentFactory.kt:92)
	at io.mockk.proxy.jvm.JvmMockKAgentFactory.init(JvmMockKAgentFactory.kt:123)
	at io.mockk.impl.JvmMockKGateway.<init>(JvmMockKGateway.kt:46)
	at io.mockk.impl.JvmMockKGateway.<clinit>(JvmMockKGateway.kt:169)
	at playground.MockkSpec$1.invoke(MockkSpec.kt:37)
	at playground.MockkSpec$1.invoke(MockkSpec.kt:11)
	at org.spekframework.spek2.runtime.AbstractRuntime.resolveSpec(SpekRuntime.kt:27)
	at org.spekframework.spek2.runtime.SpekRuntime.discover(SpekJvmRuntime.kt:35)
	at org.spekframework.ide.Spek2ConsoleLauncher.run(console.kt:21)
	at org.spekframework.ide.ConsoleKt$main$1.invoke(console.kt:34)
	at org.spekframework.ide.ConsoleKt$main$1.invoke(console.kt)
	at shadow.com.xenomachina.argparser.SystemExitExceptionKt.mainBody(SystemExitException.kt:74)
	at shadow.com.xenomachina.argparser.SystemExitExceptionKt.mainBody$default(SystemExitException.kt:72)
	at org.spekframework.ide.ConsoleKt.main(console.kt:32)
Caused by: java.lang.ClassNotFoundException: io.mockk.proxy.jvm.dispatcher.JvmMockKDispatcher
	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:582)
	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:178)
	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:521)
	... 34 more

Please also note that it doesn't concern only Mockk. Using Mockito also fail:

Exception in thread "main" java.lang.IllegalStateException: Could not initialize plugin: interface org.mockito.plugins.MockMaker (alternate: null)
	at org.mockito.internal.configuration.plugins.PluginLoader$1.invoke(PluginLoader.java:74)
	at com.sun.proxy.$Proxy2.isTypeMockable(Unknown Source)
	at org.mockito.internal.util.MockUtil.typeMockabilityOf(MockUtil.java:29)
	at org.mockito.internal.util.MockCreationValidator.validateType(MockCreationValidator.java:22)
	at org.mockito.internal.creation.MockSettingsImpl.validatedSettings(MockSettingsImpl.java:238)
	at org.mockito.internal.creation.MockSettingsImpl.build(MockSettingsImpl.java:226)
	at org.mockito.internal.MockitoCore.mock(MockitoCore.java:68)
	at org.mockito.Mockito.mock(Mockito.java:1896)
	at org.mockito.Mockito.mock(Mockito.java:1805)
	at playground.MockitoSpec$1.invoke(MockitoSpec.kt:11)
	at playground.MockitoSpec$1.invoke(MockitoSpec.kt:10)
	at org.spekframework.spek2.runtime.AbstractRuntime.resolveSpec(SpekRuntime.kt:27)
	at org.spekframework.spek2.runtime.SpekRuntime.discover(SpekJvmRuntime.kt:35)
	at org.spekframework.ide.Spek2ConsoleLauncher.run(console.kt:21)
	at org.spekframework.ide.ConsoleKt$main$1.invoke(console.kt:34)
	at org.spekframework.ide.ConsoleKt$main$1.invoke(console.kt)
	at shadow.com.xenomachina.argparser.SystemExitExceptionKt.mainBody(SystemExitException.kt:74)
	at shadow.com.xenomachina.argparser.SystemExitExceptionKt.mainBody$default(SystemExitException.kt:72)
	at org.spekframework.ide.ConsoleKt.main(console.kt:32)
Caused by: java.lang.IllegalStateException: Failed to load interface org.mockito.plugins.MockMaker implementation declared in java.lang.CompoundEnumeration@21129f1f
	at org.mockito.internal.configuration.plugins.PluginInitializer.loadImpl(PluginInitializer.java:54)
	at org.mockito.internal.configuration.plugins.PluginLoader.loadPlugin(PluginLoader.java:57)
	at org.mockito.internal.configuration.plugins.PluginLoader.loadPlugin(PluginLoader.java:44)
	at org.mockito.internal.configuration.plugins.PluginRegistry.<init>(PluginRegistry.java:21)
	at org.mockito.internal.configuration.plugins.Plugins.<clinit>(Plugins.java:18)
	at org.mockito.internal.util.MockUtil.<clinit>(MockUtil.java:24)
	... 16 more
Caused by: org.mockito.exceptions.base.MockitoInitializationException: 
Could not initialize inline Byte Buddy mock maker. (This mock maker is not supported on Android.)

And finally also note that running the Junit5 equivalents works just fine, even when triggered from IntellIJ.

Spek is unable to find any of the tests when run with the newly released Kotlin 1.1.4 but works with 1.1.3-2. Spek version is 1.1.2, Gradle version is 4.1

When run with 1.1.3-2

Test run finished after 5478 ms
[        31 containers found      ]
[         0 containers skipped    ]
[        31 containers started    ]
[         0 containers aborted    ]
[        31 containers successful ]
[         0 containers failed     ]
[        20 tests found           ]
[         0 tests skipped         ]
[        20 tests started         ]
[         0 tests aborted         ]
[        20 tests successful      ]
[         0 tests failed          ]

When run with 1.1.4

Test run finished after 5049 ms
[         1 containers found      ]
[         0 containers skipped    ]
[         1 containers started    ]
[         0 containers aborted    ]
[         1 containers successful ]
[         0 containers failed     ]
[         0 tests found           ]
[         0 tests skipped         ]
[         0 tests started         ]
[         0 tests aborted         ]
[         0 tests successful      ]
[         0 tests failed          ]

Fixes - https://github.com/spekframework/spek/issues/65 I still need to add documentation, unit tests, and code styling but sending an early PR for feedback. I have never written kotlin so it can be rusty.

There are multiple limitations since unlike JUnit, Spek doesn't create a new instance of the unit test. Method level configs and multiple SDK support for tests are not available. I will add the limitations in the doc.

Also, there are lifecycle callbacks which can't be used since it expects a java.lang.reflect.Method. Need to think about it carefully and remove those (they won't be invoked).

Is there an equivalent for the following JUnit?

@RunWith(SpringJUnit4ClassRunner::class)
@ContextConfiguration(classes = arrayOf(Application::class), loader = SpringApplicationContextLoader::class)
@WebIntegrationTest

I have both Spock and JUnit tests in folders parallel to the Spek tests, but these are just ignored by both the IDE and Gradle CLI. Is there something else I need to configure for the JUnitPlatform?

Relevant parts of build.gradle:

buildscript { ext.kotlin_version = '1.1.3-2'

repositories {
    mavenLocal()
    jcenter()
    mavenCentral()
}

dependencies {
    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    classpath 'org.junit.platform:junit-platform-gradle-plugin:1.0.0-M4'
}

}

apply plugin: 'kotlin' apply plugin: 'org.junit.platform.gradle.plugin'

junitPlatform { filters { engines { include 'spek' } } }

repositories { mavenLocal() jcenter() mavenCentral() }

version ='0.0.0.1'

dependencies { compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"

testCompile ('org.jetbrains.spek:spek-api:1.1.2') {
    exclude group: 'org.jetbrains.kotlin'
}
testRuntime ('org.jetbrains.spek:spek-junit-platform-engine:1.1.2') {
    exclude group: 'org.junit.platform'
    exclude group: 'org.jetbrains.kotlin'
}

testRuntime "org.junit.platform:junit-platform-launcher:1.0.0-M4" }

I was surprised to learn that I can put context blocks inside describe and other group blocks but not inside on (action) blocks. I would like to be able to group it blocks within an on. e.g.:

describe("/persons") {
    val personsWebTarget = rootWebTarget.path("persons")
    on("GET") {
        val response by lazy { personsWebTarget.request().get() }
        it("should have response status 200 (OK) status code") {
            assertThat(response.status).isEqualTo(200)
        }
        context("Response Headers") {
            it("should have Transfer-Encoding: chunk") {
                assertThat(response.getHeaderString("Transfer-Encoding")).isEqualTo("chunked")
            }
            it("should have Date that satisfies RFC 7231 and is recent") {
                assertThat(Duration.between(response.date.toInstant(), Instant.now()))
                        .isLessThan(Duration.ofSeconds(3))
            }
            it("should have Content-Type: application/json;charset=UTF-8") {
                assertThat(response.mediaType)
                        .isEqualTo(MediaType.APPLICATION_JSON_TYPE.withCharset("UTF-8"))
            }
        }
        ...
    }
    ...
}

Hiya,

I'm a bit confused how the setup of Spek for Android projects should be. Previously in Android Studio 2.3.3 everything seemed to be working just fine with the Spek plugin installed.

Following the documentation I retried from scratch in a clean new project since I can't share my particular project. The problem seems to exist there as well.

Upon running I get:

WARNING: TestEngine with ID 'spek' failed to discover tests org.junit.platform.commons.util.PreconditionViolationException: Could not load class with name: vrt.be.rijckaert.tim.spekproblem.CalculatorSpec

I also tried to add a compileDebugUnitTestSources Gradle task before running the unit tests.

You can find the full example here How can I get Spek to run with Android Studio 3.0.0 ? To my understanding something goes wrong with the new bundled JUnit 5 runner?

Thanks in advance

Tim

I've been trying to get Spek to run from Maven for over a day now. I've followed all guides and examples I could find on the internet, but with no luck. I can run them in my IDE (IntelliJ), manually, but cannot get them to automatically run in bulk.

The documentation on how to run Spek from Maven on the official website, is very incomplete in my opinion (http://spekframework.org/docs/latest/#_maven). The pom has to be removed to allow compilation even.

Can anyone lend me a hand on this please? I've attached my entire pom.xml file (but have removed some private values). My tests/specifications have classnames of the form "...Spec.kt". pom.xml.zip

Thanks in advance!

• Ruud

Issue

At this point there are two ways to do the same thing — using action and group.

group("service") {
    
    beforeEachTest { 
        service.start()
    }
    
    test("it calls backend") {
        verify(backend).call()
    }
}

action("service") {

    service.start()
    
    test("it calls backend") {
        verify(backend).call()
    }
}

The difference is obvious — it is possible to omit beforeEachTest when using action. At the same time action cannot be nested. Before 2.0 this could lead to nasty bugs related to putting nested groups into action which were essentially ignored. Fortunately enough @DslMarker magic solved this for us. It leaves a couple of open issues though.

Alien Concept

Judging from experience — not a lot of people recognize what the difference is and when to use group and when to use action. And it is actually understandable. People coming from JUnit have to live with two completely new concepts (action and group) because the previous experience introduced them only to test. People coming from other languages do not get it as well — as far as I know RSpec from Ruby, Mamba from Python and Quick from Swift do not have action concept at all. The concept of action becomes kind of alien to them.

BTW — at current projects I work on we just ban action altogether to avoid bugs (2.0 is not released yet). And even 2.0 would not solve things like #388.

Scale

At the same time action does not scale well. I’ve encountered a lot of situations when product changes extend the behaviour. I. e. click shows content becomes click shows content and another click shows screen. Fortunately we have nesting but action in such case needs to be migrated to group anyway since action does not support nesting.

Syntax

Since we are leaning to have two styles in 2.0 it becomes not quite obvious what is action and what is group.

• Specification — describe (group) + context (group) + it (test).
• Gherkin — given (group) + when (group) + then (test) + and (test).

There is basically no room for action at this point.

Tech

Internally having both group and action brings some complexity. I would not say it makes things drastically worse but it is something to have to live with.

CC @raniejade @hhariri @artem-zinnatullin

Would it be possible to add cdescribe, ccontext, cBeforeEachTest and cit, etc.. (for example), that would have a runBlocking (or the new TestCoroutine system...) inside... that would avoid extra nesting (like mockk.io did...).

@RunWith(JUnitPlatform::class)
class ExampleUnitTest : Spek({
    given("a test") {
        val test = Test()
        on("thisIsTrue is false"){
            test.thisIsTrue = false
            it("should be false"){
                assertEquals(false, test.thisIsTrue)
            }
        }
    }
})

Resluts in "0 of 1 test" "Process finished with exit code 0"

If I don't have an IT block the test will run fine.

@RunWith(JUnitPlatform::class)
class ExampleUnitTest : Spek({
    given("a test") {
        val test = Test()
        on("thisIsTrue is false"){
            test.thisIsTrue = false
            assertEquals(false, test.thisIsTrue)
        }
    }
})

Requires one-of SHA-1: /org/spekframework/spek2/spek-runtime-native-macos/2.0.19/spek-runtime-native-macos-2.0.19.klib.sha1, MD5: /org/spekframework/spek2/spek-runtime-native-macos/2.0.19/spek-runtime-native-macos-2.0.19.klib.md5, SHA-256: /org/spekframework/spek2/spek-runtime-native-macos/2.0.19/spek-runtime-native-macos-2.0.19.klib.sha256, SHA-512: /org/spekframework/spek2/spek-runtime-native-macos/2.0.19/spek-runtime-native-macos-2.0.19.klib.sha512

Hi @raniejade I get the message Incompatible: requires IDE build 213.* or earlier on the Android Studio Electric Eel | 2022.2.1 Canary 5 #AI-221.4165.146.2211.8713749, built on June 17, 2022.

Yet, I have to stay on Android Studio Electric Eel | 2022.1.1 Canary 3 #AI-213.7172.25.2211.8624637, built on May 21, 2022.

When will you have a chance to support the new version? Thanks!

I am working on a Kotlin multiplatform project (iOS and Android only for now) and would love to give Spek a try, however all threads that refer to it seem to indicate that only JVM is supported.

Since those are all pretty old, could we get clarity on what the roadmap is (+ maybe timeline?) and what's currently supported?

Hi guys,

First thank you for this framwork.

I think we miss some kind of Group between Feature and Scenario on Gherkin implementation. In fact there is actually such definition on Gherkin specification: https://cucumber.io/docs/gherkin/reference/#rule

I would like to add it in the framework if it don't bother you?

I think it is just a matter of extension, BUT when I try to do it in my codebase, green arrow button on Android Studio has been replaced by "Do Nothing" text.

Can you help me on this issue?

Edit: Seems to be a duplicate of https://github.com/spekframework/spek/issues/873

@Synonym(SynonymType.GROUP, prefix = "Rule: ")
@Descriptions(Description(DescriptionLocation.VALUE_PARAMETER, 0))
fun FeatureBody.Rule(description: String, body: RuleBody.() -> Unit) =
    delegate.group("Rule: $description",
        defaultCachingMode = CachingMode.EACH_GROUP,
        preserveExecutionOrder = true,
        failFast = true) {
        body(RuleBody(this))
    }

@SpekDsl
class RuleBody(val delegate: GroupBody) : LifecycleAware by delegate {
    var defaultTimeout: Long
        get() = delegate.defaultTimeout
        set(value) {
            delegate.defaultTimeout = value
        }

    @Synonym(SynonymType.GROUP, prefix = "Scenario: ")
    @Descriptions(Description(DescriptionLocation.VALUE_PARAMETER, 0))
    fun Scenario(description: String, body: ScenarioBody.() -> Unit) {
        delegate.group("Scenario: $description",
            defaultCachingMode = CachingMode.SCOPE,
            preserveExecutionOrder = true,
            failFast = true) {
            body(ScenarioBody(this))
        }
    }

    @Synonym(SynonymType.GROUP, prefix = "Rule: ")
    @Descriptions(Description(DescriptionLocation.VALUE_PARAMETER, 0))
    fun Rule(description: String, body: RuleBody.() -> Unit) =
        delegate.group("Rule: $description",
            defaultCachingMode = CachingMode.EACH_GROUP,
            preserveExecutionOrder = true,
            failFast = true) {
            body(RuleBody(this))
        }

    fun beforeEachScenario(fixture: Fixture) = delegate.beforeEachGroup(fixture)
    fun afterEachScenario(fixture: Fixture) = delegate.afterEachGroup(fixture)
    fun beforeFeature(fixture: Fixture) = delegate.beforeGroup(fixture)
    fun afterFeature(fixture: Fixture) = delegate.afterGroup(fixture)

    @Deprecated("Use beforeEachScenario instead", ReplaceWith("beforeEachScenario(fixture)"))
    override fun beforeEachGroup(fixture: Fixture) = beforeEachScenario(fixture)

    @Deprecated("Use afterEachScenario instead", ReplaceWith("afterEachScenario(fixture)"))
    override fun afterEachGroup(fixture: Fixture) = afterEachScenario(fixture)

    @Deprecated("Use beforeFeature instead", ReplaceWith("beforeFeature(fixture)"))
    override fun beforeGroup(fixture: Fixture) = beforeFeature(fixture)

    @Deprecated("Use afterFeature instead", ReplaceWith("afterFeature(fixture)"))
    override fun afterGroup(fixture: Fixture) = afterFeature(fixture)
}

Launching IntelliJ IDEA 2021.3 with the latest Spek version results in the following error when launching the IDE:

Plugin 'Spek Framework' (version '2.0.17-IJ2021.2') is not compatible with the current version of the IDE, because it requires build 212.* or older but the current build is IU-213.5744.223

As a result, none of the plugin's features are available. The plugin should be updated to support the latest IDE version.

Additionally, because this is not the first time that the plugin is incompatible with the latest version (cf. #829, #834, #889, #939, #954, #980), I think it might be worthwhile to stop restricting the until version supported by the plugin, so that the plugin is considered compatible with all future versions by default. I admit I'm not intimately familiar with Spek's architecture, but it's not clear to me why a different release is created for each IDE version.