Strange "Behavior Spec" behavior

Hello. I tried the last 2.0-SNAPSHOT of kotlinspec (built from this commit). I have next code:

class Test : BehaviorSpec() {
    init {

        Given("test") {

            When("when 1") {
                println("when 1")

                Then("test 1") {
                    println("test 1")
                }
                Then("test 2") {
                    println("test 2")
                }
            }

            When("when 2") {
                println("when 2")

                Then("test 3") {
                    println("test 3")
                }
                Then("test 4") {
                    println("test 4")
                }
            }
        }

    }
}

And there are outputs:

oneInstancePerTest = true     |     oneInstancePerTest = false
when 1                        |     when 1
when 2                        |     when 2
when 1                        |     test 1
when 2                        |     test 2
test 1                        |     test 3
when 1                        |     test 4
when 2 
test 2 
when 1
when 2
test 3
when 1
when 2
test 4

May I am wrong, but I think when block must be running separately just for inner then block:

when 1 -> test 1 -> test 2
when 2 -> test 3 -> test 4

so I can write something like that:

Given(a user try to login)

    When(login was failed)  // mock request, configured via Mockito, returns error, valid for this `when` block
        Then(show error for user)

    When(login is success) // the same mock request returns success, valid for this `when` block
        Then(store auth token)
        Then(redirects user to main)

[newcat]

The problem might be related to this: When I used interceptors to do setup work before the tests were run, I noticed that code in the Given and When blocks is executed before the spec interceptor is called.

Test setup:

class Test : BehaviorSpec() {
    override fun interceptSpec(context: Spec, spec: () -> Unit) {
        System.out.println("Before Spec")
        spec()
        System.out.println("After Spec")
    }

    init {
        Given("Given") {
            System.out.println("Running Given")
            When("When") {
                System.out.println("Running When")
                Then("Then 1") { System.out.println("Running Then 1") }
                Then("Then 2") { System.out.println("Running Then 2") }
            }
        }
    }
}

Result:

oneInstancePerTest = false
Running Given
Running When
Before Spec
Running Then 1
Running Then 2
After Spec

oneInstancePerTest = true
Running Given
Running When
Before Spec
Running Given
Running When
Running Then 1
Running Given
Running When
Running Then 2
After Spec

IMO the spec interceptor should be called before any code in a given, when or then block is executed.

[sksamuel]

I think oneInstancePerTest affects things, but isn’t the root cause. I’m looking into it.