I have some ktor server tests and ktor's server te...

# kotest

[bbaldino]

I have some ktor server tests and ktor's server test harness involves executing the requests inside of a scope, which means my verification of the responses happens there. Looks something like this:

context("when the server") {
    withTestApplication({
        myServerModule()
    }) {
        context("receives a request for url/to/something") {
            with(handleRequest(<http://HttpMethod.Post|HttpMethod.Post>, "url/to/som ething") {
                should("return the correct response") {
                    response.status() shouldBe HttpStatusCode.OK
                }
            }
        }
    }
}

This doesn't work though, as where should is there isn't a coroutine scope and it complains. Is there a better way to do tests like this? Or would it be possible to have a non-suspend version of should?

[bbaldino]

I can wrap it runBlocking in the meantime, but that feels a bit hacky

[sam]

are you on 4.1.1 ?

[sam]

In 4.1.x we made all scopes be suspendable

[bbaldino]

4.1.1, yeah

[sam]

seems like maybe one was missed

[sam]

does it work if you change should to test, and ShouldSpec to FunSpec ?

[bbaldino]

Well, I think the scope is suspendable...at some layer...but I'm wrapped inside this ktor test harness scope

[sam]

Actually I see

[sam]

The with is changing the receiver probably, so you can't call should

[sam]

try to reference the context lambda in a var. It might be ugly though

[sam]

context("when the server") {
    withTestApplication({
        myServerModule()
    }) {
        context("receives a request for url/to/something") { context ->
            with(handleRequest(<http://HttpMethod.Post|HttpMethod.Post>, "url/to/som ething") {
                context.should("return the correct response") {
                    response.status() shouldBe HttpStatusCode.OK
                }
            }
        }
    }
}

[LeoColman]

An alternative (which you probably thought of, but just in case) is to invert with and should

[LeoColman]

And having ktor context as the last inner context

[bbaldino]

Thanks @sam that's not too bad

[bbaldino]

@LeoColman I've got multiple should blocks for the request, so can't flip unfortunately 😕

[LeoColman]

Yeah, that's what I thought

[LeoColman]

I believe KTor also has a way to execute that code without using with

[LeoColman]

You can probably put ktor's receiver in a variable and operate with that inside your next scopes

[bbaldino]

Actually that's a good idea @LeoColman! That might be best.

[bbaldino]

Even just saving the return of handleRequest rather than using with

[bbaldino]

Ah, shit...it's not that part which is screwing it up

[bbaldino]

(Or, at least, not only that part)

[bbaldino]

It's the top level server part

[bbaldino]

the withTestApplication lambda is a receiver

[sam]

Do the same trick and move the context -> up to the top scope

[bbaldino]

Oh, wait, there is a non-suspending should ?

[bbaldino]

Oh, but it doesn't take a TestContext block

[sam]

don't mix up should scope with the should assertion

[bbaldino]

Yeah I'm looking at ShouldSpecContextScope.kt

[bbaldino]

there are 4 shoulds there, but yeah I guess the non-suspend ones are for something else

[bbaldino]

I'm also considering writing a non-suspend should function there which just calls the suspend one inside of runBlocking

[bbaldino]

Ok, I think I'm gonna do that ☝️ @sam is it PR-worthy to add that?

[sam]

The framework shouldn't be calling runBlocking at all

[bbaldino]

ok

[sam]

fun should(name: String) =
      TestWithConfigBuilder(TestName("should ", name), testContext, defaultConfig, xdisabled = false)

   fun xshould(name: String) =
      TestWithConfigBuilder(TestName("should ", name), testContext, defaultConfig, xdisabled = true)

[bbaldino]

maybe coroutineScope would do it

[sam]

Those two are non suspend because the test is passed into the second call on those

[sam]

there are for should("name").config() { }

[bbaldino]

"into the second call"

what do you mean?

[bbaldino]

ah

[bbaldino]

does ContainerScope#addTest need to be suspend?

[bbaldino]

Nevermind, the real question is if registerTestCase needs to be suspend

[sam]

Yes, because it ends up calling into the spec runners

[bbaldino]

Ok

[sam]

and that's getting in the heart of the execution of the tests, which are all coroutine based

[bbaldino]

Hm, naming the context receiver doesn't actually work since it's a receiver, not an argument.

[bbaldino]

And naming it via context("some test") test@ { and then doing [e-mail] doesn't work either

[sam]

inside the context, then do val context = this

[bbaldino]

That still doesn't work, because it isn't within a coroutine body where I'm trying to call it

[bbaldino]

Hmph 😕

[sam]

context("when the server") {
    val c1 = this
    withTestApplication({
        myServerModule()
    }) {
        c1.context("receives a request for url/to/something") {
            with(handleRequest(<http://HttpMethod.Post|HttpMethod.Post>, "url/to/som ething") {
                should("return the correct response") {
                    response.status() shouldBe HttpStatusCode.OK
                }
            }
        }
    }
}

[bbaldino]

Ayyyyy. 🎉 Good idea

[bbaldino]

Oh, shit.

[bbaldino]

Same problem, context has to be called within a coroutine 😕

[sam]

wrap it in a runblocking then

[sam]

that's ok for your test case

[bbaldino]

Yeah