functional-programming-snake/scala/test/M09App.test.scala

package snake

import M09Helpers.{classicMain, drawn}

class M09AppSuite extends munit.FunSuite:
  private def time(t: Long): Event = Event.Time(t)
  private def down(key: String): Event = Event.KeyDown(key)

  test("the game ticks every 150 ms") { assertEquals(App.TICK_MS, 150L) }

  test("classicActions turns the clock into Tick actions and keys into Turn actions") {
    assertEquals(
      App.classicActions.run(List(time(150), down("ArrowUp"), down("x"), time(300))),
      List(Action.Tick, Action.Turn(Direction.Up), Action.Tick)
    )
  }

  test("states starts with the new game, then yields one state per action") {
    val out = App.states(42, App.classicActions).run(List(time(150), down("ArrowUp"), time(300)))
    assertEquals(out.length, 4)
    assertEquals(out.head, Spawn.newGame(42))
    assertEquals(out.map(_.snake.head), List(Point(10, 10), Point(11, 10), Point(11, 10), Point(11, 9)))
    assertEquals(out.map(_.nextDir), List(Direction.Right, Direction.Right, Direction.Up, Direction.Up))
    assertEquals(out.map(_.dir), List(Direction.Right, Direction.Right, Direction.Right, Direction.Up))
  }

  test("render draws the whole view of the state") {
    assertEquals(IO.trace(App.render(Spawn.newGame(42)), 0).ops, View.view(Spawn.newGame(42)).map(Op.Draw(_)))
  }

  // Module 10 (Exercise 10.7) makes `main` also load the stored best and draw one more shape after the game's view,
  // so this test accepts both versions; m10 pins the final one exactly.
  test("main asks for a random seed, then builds the stream from it") {
    val traced = IO.trace(App.main, 42)
    assert(
      traced.ops == List(Op.RandomSeed) || traced.ops == List(Op.RandomSeed, Op.LoadBest),
      s"main may only ask for the seed (and, from m10 on, the stored best); it asked for ${traced.ops}"
    )
    val (outs, _) = traced.result.step(time(0))
    assertEquals(outs.length, 1)
    val expected = View.view(Spawn.newGame(42))
    assertEquals(drawn(outs.head).take(expected.length), expected)
  }

  // `main` itself switches to speedActions in m10, so the 150 ms behaviour is checked on the same program built from classicActions.
  test("the program built from classicActions draws the new game first, then the ticked game after 150 ms") {
    val stream = IO.trace(classicMain, 42).result
    val (first, next) = stream.step(time(0))
    val (second, _) = next.step(time(150))
    assertEquals(drawn(first.head), View.view(Spawn.newGame(42)))
    assertEquals(second.length, 1)
    assertNotEquals(drawn(second.head), drawn(first.head))
  }

  // Holds before and after m10: whatever `main` ticks with, the clock must be wired in, so time passing produces more drawings.
  test("main draws again once time has passed") {
    val stream = IO.trace(App.main, 42).result
    val (first, next) = stream.step(time(0))
    val (later, _) = next.step(time(150))
    assertEquals(first.length, 1)
    assert(later.nonEmpty)
  }

  // ---- play: the whole program in one equality (Exercise 9.5)

  private def drawOps(state: GameState): List[Op] = View.view(state).map(Op.Draw(_))

  test("play on the classic program equals the scenes of the expected states") {
    val events = List(time(150), down("ArrowUp"), down("x"), time(300), time(310))
    val expectedStates = Game.history(Spawn.newGame(42), List(Action.Tick, Action.Turn(Direction.Up), Action.Tick))
    assertEquals(App.play(classicMain, 42, events), expectedStates.map(drawOps))
  }

  test("play with no events gives no drawings") {
    assertEquals(App.play(classicMain, 42, Nil), Nil)
  }

  test("play uses the seed for the program's RandomSeed") {
    assertEquals(App.play(classicMain, 7, List(time(0))), List(drawOps(Spawn.newGame(7))))
  }