ScalaTest: assert blocking statement - scala

Question

I'm using some code with blocking statement:
blocking {
Thread.sleep(10*1000)
}
Is there a way to assert that this blocking statement is given? Or in other words: Can I write a test that fails if somebody removes the blocking statement?
Update: How to assert blocking when used in Futures?

Answer 1

Try playing with BlockContext.
You should get something like this:
var blocked = false // flag to detect blocking
val oldContext = BlockContext.current
val myContext = new BlockContext {
override def blockOn[T](thunk: =>T)(implicit permission: CanAwait): T = {
blocked = true
oldContext.blockOn(thunk)
}
}
BlockContext.withBlockContext(myContext) {
blocking {} // block (or not) here
}
assert(blocked) // verify that blocking happened
Update on making it work if you want to test code wrapped in Future (comment follow-up)
When you construct the Future it's factory method takes block of code (function) to execute explicitly and execution context implicitly (commonly scala.concurrent.ExecutionContext.Implicits.global).
The block of code later will be scheduled to execution context and will be runned in one of it's threads.
Now, if you simply wrap blocking piece of code into Future inside code block passed to BlockContext.withBlockContext, like you suggest in comment:
BlockContext.withBlockContext(myContext) {
Future {
blocking { Thread.sleep(100) }
}
}
... this will not work since your current thread will only do Future construction and actual code passed to Future will be executed in thread from relevant execution context (BlockContext.withBlockContext detects blockings in current thread).
Having that said, I can suggest you to do one of 3 things:
Do not wrap code you want to test into Future. If you want to test whether piece of code uses blocking or not - just do that.
Write a function and test it, you can pass it to Future in production.
Lets assume that for some reason you can't avoid creating Future in your test. In this case you'll have to tamper with execution context that is used when constucting future.
This code sample demonstrates how one could do that (reuse blocked and myContext from my original example):
// execution context that submits everything that is passed to it to global execution context
// it also wraps any work submited to it into block context that records blocks
implicit val ec = new ExecutionContext {
override def execute(runnable: Runnable): Unit = {
ExecutionContext.Implicits.global execute new Runnable {
override def run(): Unit = {
BlockContext.withBlockContext(myContext) {
runnable.run()
}
}
}
}
override def reportFailure(t: Throwable): Unit = {
ExecutionContext.Implicits.global.reportFailure(t)
}
}
// this future will use execution context defined above
val f = Future {
blocking {} // block (or not) here
}
Await.ready(f, scala.concurrent.duration.Duration.Inf)
assert(blocked)
If your Future gets created indirectly, for example, as a result calling some other function that you run in your test, then you'll have to somehow (possibly using dependency injection) drag your mocked execution context into wherever Future gets created and use it there to consruct it.
As you can see, the first option is the simpliest one and I suggest sticking to it if you can.