问题描述
情景
在我目前正在编写的应用程序中，我在中使用了 -effect 的 。
如果从命令行参数“debug”开始，我会将我的程序流委派到一个调试循环中，该循环等待用户输入并执行各种与调试相关的方法。
一旦开发人员在没有任何输入的情况下按下enter ，应用程序将退出调试循环并退出 main 方法，从而关闭应用程序。
此应用程序的主要方法大致如下所示：
import scala.concurrent.{ExecutionContext, ExecutionContextExecutor}
import cats.effect.{ExitCode, IO, IOApp}
import cats.implicits._
object Main extends IOApp {
val BlockingFileIO: ExecutionContextExecutor = ExecutionContext.fromExecutor(blockingIOCachedThreadPool)
def run(args: List[String]): IO[ExitCode] = for {
_ <- IO { println ("Running with args: " + args.mkString(","))}
debug = args.contains("debug")
// do all kinds of other stuff like initializing a webserver, file IO etc.
// ...
_ <- if(debug) debugLoop else IO.unit
} yield ExitCode.Success
def debugLoop: IO[Unit] = for {
_ <- IO(println("Debug mode: exit application be pressing ENTER."))
_ <- IO.shift(BlockingFileIO) // readLine might block for a long time so we shift to another thread
input <- IO(StdIn.readLine()) // let it run until user presses return
_ <- IO.shift(ExecutionContext.global) // shift back to main thread
_ <- if(input == "b") {
// do some debug relevant stuff
IO(Unit) >> debugLoop
} else {
shutDown()
}
} yield Unit
// shuts down everything
def shutDown(): IO[Unit] = ???
}
现在，我想测试例如我的run方法在我的ScalaTest s 中是否表现得像预期的那样：
import org.scalatest.FlatSpec
class MainSpec extends FlatSpec{
"Main" should "enter the debug loop if args contain 'debug'" in {
val program: IO[ExitCode] = Main.run("debug" :: Nil)
// is there some way I can 'search through the IO monad' and determine if my program contains the statements from the debug loop?
}
}
我的问题
我能否以某种方式“搜索/迭代 IO monad”并确定我的程序是否包含来自调试循环的语句？
我是否必须调用program.unsafeRunSync()来检查它？
1楼
您可以在自己的方法中实现run的逻辑，并进行测试，在返回类型中不受限制并向前run到您自己的实现。
由于run强制您执行IO[ExitCode] ，因此您无法从返回值中表达太多内容。
一般来说，没有办法“搜索”一个IO值，因为它只是一个描述具有副作用的计算的值。
如果你想检查它的潜在价值，你可以通过在世界尽头（你的main方法）运行它来实现，或者对于你的测试，你unsafeRunSync它。
例如：
sealed trait RunResult extends Product with Serializable
case object Run extends RunResult
case object Debug extends RunResult
def run(args: List[String]): IO[ExitCode] = {
run0(args) >> IO.pure(ExitCode.Success)
}
def run0(args: List[String]): IO[RunResult] = {
for {
_ <- IO { println("Running with args: " + args.mkString(",")) }
debug = args.contains("debug")
runResult <- if (debug) debugLoop else IO.pure(Run)
} yield runResult
}
def debugLoop: IO[Debug.type] =
for {
_ <- IO(println("Debug mode: exit application be pressing ENTER."))
_ <- IO.shift(BlockingFileIO) // readLine might block for a long time so we shift to another thread
input <- IO(StdIn.readLine()) // let it run until user presses return
_ <- IO.shift(ExecutionContext.global) // shift back to main thread
_ <- if (input == "b") {
// do some debug relevant stuff
IO(Unit) >> debugLoop
} else {
shutDown()
}
} yield Debug
// shuts down everything
def shutDown(): IO[Unit] = ???
}
然后在你的测试中：
import org.scalatest.FlatSpec
class MainSpec extends FlatSpec {
"Main" should "enter the debug loop if args contain 'debug'" in {
val program: IO[RunResult] = Main.run0("debug" :: Nil)
program.unsafeRunSync() match {
case Debug => // do stuff
case Run => // other stuff
}
}
}
2楼
要搜索某个 monad 表达式，它必须是值，而不是语句，也就是具体化。
这就是（臭名昭著的）Free monad 背后的核心思想。
如果您要经历在某些“代数”中表达您的代码的麻烦，因为他们称之为（想想 DSL）并通过Free将其提升到 monad 表达式嵌套中，那么是的，您将能够搜索它。
有很多资源可以比我更好地解释 Free monads 谷歌是你的朋友。
我的一般建议是，良好测试的一般原则适用于任何地方。 隔离副作用部分并将其注入到主要逻辑部分，以便您可以在测试中注入假实现以允许各种断言。