ManualTicTacToe: Split out ConsoleIO layer; added tests of ColoredConsoleTextIO.

Author: Daniel Barclay

src/main/scala/com/us/dsb/explore/algs/ttt/manual/ManualTicTacToe.scala

@@ -1,10 +1,10 @@
 package com.us.dsb.explore.algs.ttt.manual
 
-import com.us.dsb.explore.algs.ttt.manual.ui.{ColoredConsoleTextIO, GameUI}
+import com.us.dsb.explore.algs.ttt.manual.ui.{LiveColoredConsoleTextIO, GameUI}
 
 object ManualTicTacToe extends App {
 
-  val gameResult = GameUI.runGame(ColoredConsoleTextIO)
+  val gameResult = GameUI.runGame(LiveColoredConsoleTextIO)
   println("Game result: " + gameResult.text)
 
 }

src/main/scala/com/us/dsb/explore/algs/ttt/manual/ui/TextIO.scala

@@ -2,7 +2,19 @@ package com.us.dsb.explore.algs.ttt.manual.ui
 
 import com.us.dsb.explore.algs.ttt.manual.ui.GameUI.GameUIResult
 
-// ?? revisit names
+// Doing ConsoleIO as separate layer to have more simple layers for exploring
+// testing, ZIO, etc.
+private[ui] trait ConsoleIO {
+  def println(lineOrLines: String): Unit
+  def readLine(prompt: String): String
+}
+object LiveConsoleIO extends ConsoleIO {
+  override def println(lineOrLines: String): Unit = Predef.println(lineOrLines)
+  override def readLine(prompt: String): String = scala.io.StdIn.readLine(prompt)
+}
+// (Expect to have test-double version in tests.)
+
+// ?? revisit names:
 
 private[ui] trait SegregatedTextIO {
   private[ui] def printStateText(lineOrLines: String): Unit
@@ -13,18 +25,18 @@ private[ui] trait SegregatedTextIO {
   private[ui] def printResult(result: GameUIResult): Unit = printResult(result.text)
 }
 
-private[ui] class BaseConsoleTextIO extends SegregatedTextIO {
-  import scala.io.StdIn.readLine
-
-  private[ui] override def printStateText(lineOrLines: String): Unit = println(lineOrLines)
-  private[ui] override def readPromptedLine(prompt: String): String  = readLine(prompt)
-  private[ui] override def printError(fullLine: String): Unit = println(fullLine)
-  private[ui] override def printResult(lineOrLines: String): Unit = println(lineOrLines)
+private[ui] class BaseConsoleTextIO(cio: ConsoleIO) extends SegregatedTextIO {
+  private[ui] override def printStateText(lineOrLines: String): Unit = cio.println(lineOrLines)
+  private[ui] override def readPromptedLine(prompt: String): String  = cio.readLine(prompt)
+  private[ui] override def printError(fullLine: String): Unit = cio.println(fullLine)
+  private[ui] override def printResult(lineOrLines: String): Unit = cio.println(lineOrLines)
 }
 
-object PlainConsoleTextIO extends BaseConsoleTextIO
+class PlainConsoleTextIO(x: ConsoleIO) extends BaseConsoleTextIO(x)
+object LivePlainConsoleTextIO extends PlainConsoleTextIO(LiveConsoleIO)
+// (Expect to have test version in tests.)
 
-object ColoredConsoleTextIO extends BaseConsoleTextIO {
+class ColoredConsoleTextIO(x: ConsoleIO) extends BaseConsoleTextIO(x) {
   import scala.io.AnsiColor._
   private[ui] override def readPromptedLine(prompt: String): String =
     super.readPromptedLine(BLUE + prompt + RESET)
@@ -33,3 +45,5 @@ object ColoredConsoleTextIO extends BaseConsoleTextIO {
   private[ui] override def printResult(lineOrLines: String): Unit =
     super.printResult(BOLD + lineOrLines + RESET)
 }
+object LiveColoredConsoleTextIO extends ColoredConsoleTextIO(LiveConsoleIO)
+// (Expect to have test-double version in tests.)

src/test/scala/com/us/dsb/explore/algs/ttt/manual/ui/TextIOTest.scala

@@ -0,0 +1,137 @@
+package com.us.dsb.explore.algs.ttt.manual.ui
+
+import org.scalatest.LoneElement
+import org.scalatest.funspec.AnyFunSpec
+import org.scalatest.matchers.should.Matchers._
+
+class TextIOTest extends AnyFunSpec {
+
+  it/*describe*/("TextIO?:") {
+    cancel()
+    it("println ...") {
+    }
+    it("readLine ...") {
+    }
+  }
+
+  // Crude, manual stub and spy ConsoleIO.
+  class TextConsoleIO(inputLines: String*) extends ConsoleIO {
+    private var stringsToRead = inputLines
+    private var printedStrings: List[String] = Nil;
+    def getPrintedStrings: List[String] = printedStrings
+
+    override def println(lineOrLines: String): Unit = {
+      printedStrings ::= lineOrLines
+    }
+
+    override def readLine(prompt: String): String = {
+      printedStrings ::= prompt
+
+      val lineRead = stringsToRead.head  // .get - unsafe - but crude anyway
+      stringsToRead = stringsToRead.drop(1)
+      lineRead
+    }
+  }
+
+  describe("ColoredConsoleTextIO") {
+    import org.scalatest.LoneElement._
+
+    def getUUT(consoleIODouble: ConsoleIO): SegregatedTextIO = {
+      // Demo:  Try injecting "bad" UUT and see how failing conditions show up:
+      new ColoredConsoleTextIO(consoleIODouble)
+      //new PlainConsoleTextIO(consoleIODouble)
+    }
+
+    // Demo:  Checking subconditions in multiple leaf-level tests:
+    describe("printStateText should print given text plainly; output should:") {
+      // Note:  "lazy" avoids executing during ScalaTest's registration phase.
+      lazy val printedStrings = {
+        val consoleIODouble = new TextConsoleIO
+        val uut = getUUT(consoleIODouble)
+
+        uut.printStateText("text")
+
+        consoleIODouble.getPrintedStrings
+      }
+      it("include given text") {
+        printedStrings.loneElement should include ("text")
+      }
+      it("not include color/decoration escape sequences") {
+        printedStrings.loneElement should not include (scala.io.AnsiColor.RED.take(1))
+      }
+      it("include only given text") {
+        printedStrings.loneElement should be ("text")
+      }
+    }
+
+    describe("printError should print given text in red; output should:") {
+      lazy val printedStrings = {
+        val consoleIODouble = new TextConsoleIO
+        val uut = getUUT(consoleIODouble)
+
+        uut.printError("given text")
+
+        consoleIODouble.getPrintedStrings
+      }
+      it("include given text") {
+        printedStrings.loneElement should include ("given text")
+      }
+      it("include red escape sequence") {
+        printedStrings.loneElement should include (scala.io.AnsiColor.RED) // ?? in order too
+      }
+      it("include reset escape sequence") {
+        printedStrings.loneElement should include (scala.io.AnsiColor.RESET)  // ?? in order too
+      }
+      it("not include only given text") {
+        printedStrings.loneElement should not be ("given text")
+      }
+    }
+
+    // Demo:  checking subconditions with "should ... and ..." (in one test):
+    it("printResult should print given text in bold (should ... and ...)") {
+      val consoleIODouble = new TextConsoleIO
+      val uut = getUUT(consoleIODouble)
+
+      uut.printResult("given text")
+      val printedStrings = consoleIODouble.getPrintedStrings
+
+      // Note:  "should ... and ..." reports only _first_condition that failed
+      // (though error message does seem to include actual value).
+      printedStrings.loneElement should (
+          include ("given text") and
+              include (scala.io.AnsiColor.BOLD) and
+              include (scala.io.AnsiColor.RESET) and
+              not be ("given text"))
+    }
+
+    describe("readPromptedLine should print given prompt value and get input") {
+      lazy val (printedStrings, lineRead) = {
+        val consoleIODouble = new TextConsoleIO("given input")
+        val uut = getUUT(consoleIODouble)
+
+        val lineRead = uut.readPromptedLine("given text")
+
+        (consoleIODouble.getPrintedStrings, lineRead)
+      }
+      describe("should print given prompted text in blue; output should:") {
+        it("include given text") {
+          printedStrings.loneElement should include("given text")
+        }
+        it("include blue escape sequence") {
+          printedStrings.loneElement should include(scala.io.AnsiColor.BLUE) // ?? in order too
+        }
+        it("include reset escape sequence") {
+          printedStrings.loneElement should include(scala.io.AnsiColor.RESET) // ?? in order too
+        }
+        it("not include only given text") {
+          printedStrings.loneElement should not be ("given text")
+        }
+      }
+      it("should read input line text") {
+        lineRead should be ("given input")
+      }
+    }
+
+  }
+
+}