Files
chess-endgame-trainer/test/chesstrainer_web/live/endgame_live/play_test.exs
T
owenrees 248504cc58 Play the opponent's optimal defence after a passing move
#8: after a passing move, fetch the post-move position's tablebase and
reply with moves[0] (the defender's optimal defence). The client applies
and animates the reply, reports the resulting FEN, and the server fetches
that position's tablebase before resuming the user's turn.

Losing moves and terminal positions do not trigger a reply; a failed
post-reply fetch blocks the attempt. The board stays locked during the
reply round-trip so play cannot get out of sync.
2026-11-01 21:45:32 +01:00

246 lines
7.6 KiB
Elixir

defmodule ChesstrainerWeb.EndgameLive.PlayTest do
use ChesstrainerWeb.ConnCase
import Phoenix.LiveViewTest
import Chesstrainer.EndgamesFixtures
alias Chesstrainer.Endgames.Tablebase
alias Chesstrainer.Endgames.Tablebase.Cache, as: TablebaseCache
alias Chesstrainer.Ratelimiters
defp assert_init_board(view, expected_fen, expected_orientation, expected_player_color) do
%{proxy: {ref, _topic, _}} = view
assert_receive {^ref, {:push_event, "init_board", payload}}, 100
assert payload.fen == expected_fen
assert payload.orientation == expected_orientation
assert payload.player_color == expected_player_color
end
# Seed the tablebase cache so mount never touches the network in tests.
defp seed_tablebase(fen, opts \\ []) do
tablebase = %Tablebase{
category: Keyword.get(opts, :category, :win),
moves: Keyword.get(opts, :moves, [])
}
TablebaseCache.put(fen, tablebase)
on_exit(fn -> TablebaseCache.delete(fen) end)
end
defp grading_moves do
[
%Tablebase.Move{uci: "d1d7", san: "Qd7+", category: :loss, dtz: -1},
%Tablebase.Move{uci: "d1d5", san: "Qd5", category: :loss, dtz: -9},
%Tablebase.Move{uci: "d1d4", san: "Qd4", category: :draw, dtz: 0}
]
end
defp play_move(view, endgame, from, to, san) do
render_hook(view, "endgame_move_played", %{
"from" => from,
"to" => to,
"san" => san,
"prev_fen" => endgame.fen,
"fen" => endgame.fen,
"endgame_id" => endgame.id
})
end
describe "mount" do
test "renders the chessboard hook div and pushes init_board", %{conn: conn} do
endgame = endgame_fixture(color: :white)
seed_tablebase(endgame.fen)
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
assert has_element?(view, "#endgame-board")
assert_init_board(view, endgame.fen, "white", "white")
end
test "pushes black orientation when the endgame color is black", %{conn: conn} do
endgame = endgame_fixture(color: :black)
seed_tablebase(endgame.fen)
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
assert_init_board(view, endgame.fen, "black", "black")
end
test "shows endgame metadata in the header", %{conn: conn} do
endgame = endgame_fixture(key: "KQ v K", color: :white, result: :win, rating: 1800)
seed_tablebase(endgame.fen)
{:ok, _view, html} = live(conn, ~p"/endgames/#{endgame}/play")
assert html =~ "KQ v K"
assert html =~ "White to move"
assert html =~ "1800"
end
test "raises when the endgame does not exist", %{conn: conn} do
assert_raise Ecto.NoResultsError, fn ->
live(conn, ~p"/endgames/00000000-0000-0000-0000-000000000000/play")
end
end
end
describe "tablebase availability" do
test "blocks the attempt when the tablebase is cooling down", %{conn: conn} do
endgame = endgame_fixture()
TablebaseCache.delete(endgame.fen)
Ratelimiters.lichess_add_cooldown()
on_exit(fn -> Ratelimiters.lichess_reset_cooldown() end)
{:ok, view, html} = live(conn, ~p"/endgames/#{endgame}/play")
assert html =~ "Tablebase unavailable"
play_move(view, endgame, "d1", "d7", "Qd7+")
assert render(view) =~ "cannot be graded"
end
end
describe "chess_fen_invalid" do
test "shows a flash when the chessground hook reports an unparseable FEN", %{conn: conn} do
endgame = endgame_fixture()
seed_tablebase(endgame.fen)
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
view
|> render_hook("chess_fen_invalid", %{
"fen" => endgame.fen,
"message" => "Invalid FEN: move number must be a positive integer"
})
html = render(view)
assert html =~ "Endgame FEN is invalid"
assert html =~ "move number must be a positive integer"
end
end
describe "endgame_move_played" do
test "grades the optimal move", %{conn: conn} do
endgame = endgame_fixture()
seed_tablebase(endgame.fen, moves: grading_moves())
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
play_move(view, endgame, "d1", "d7", "Qd7+")
html = render(view)
assert html =~ "Optimal move"
assert html =~ "Qd7+"
end
test "grades a winning but slower move as winning", %{conn: conn} do
endgame = endgame_fixture()
seed_tablebase(endgame.fen, moves: grading_moves())
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
play_move(view, endgame, "d1", "d5", "Qd5")
assert render(view) =~ "Winning — but not the sharpest"
end
test "grades a move that throws the win away as losing", %{conn: conn} do
endgame = endgame_fixture()
seed_tablebase(endgame.fen, moves: grading_moves())
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
play_move(view, endgame, "d1", "d4", "Qd4")
assert render(view) =~ "Losing move"
end
test "rejects a move that is out of sequence", %{conn: conn} do
endgame = endgame_fixture()
seed_tablebase(endgame.fen, moves: grading_moves())
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
render_hook(view, "endgame_move_played", %{
"from" => "d1",
"to" => "d7",
"san" => "Qd7+",
"prev_fen" => "8/8/8/8/8/8/8/8 w - - 0 1",
"fen" => endgame.fen,
"endgame_id" => endgame.id
})
assert render(view) =~ "out of sequence"
end
end
describe "opponent reply" do
test "plays the opponent's optimal defence and resumes the user's turn", %{conn: conn} do
endgame = endgame_fixture()
fen_after = "8/8/8/8/8/8/8/8 b - - 0 1"
fen_after_reply = "8/8/8/8/8/8/8/8 w - - 0 1"
reply = %Tablebase.Move{uci: "e8e7", san: "Ke7", category: :loss, dtz: -3}
seed_tablebase(endgame.fen, moves: grading_moves())
seed_tablebase(fen_after, category: :loss, moves: [reply])
seed_tablebase(fen_after_reply, category: :win, moves: grading_moves())
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
render_hook(view, "endgame_move_played", %{
"from" => "d1",
"to" => "d7",
"san" => "Qd7+",
"prev_fen" => endgame.fen,
"fen" => fen_after,
"endgame_id" => endgame.id
})
%{proxy: {ref, _topic, _}} = view
assert_receive {^ref, {:push_event, "opponent_move", payload}}, 100
assert payload == %{from: "e8", to: "e7", promotion: nil, san: "Ke7"}
render_hook(view, "opponent_reply_applied", %{"fen" => fen_after_reply})
assert_receive {^ref, {:push_event, "resume_board", _payload}}, 100
end
test "does not reply when the move throws the win away", %{conn: conn} do
endgame = endgame_fixture()
seed_tablebase(endgame.fen, moves: grading_moves())
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
play_move(view, endgame, "d1", "d4", "Qd4")
%{proxy: {ref, _topic, _}} = view
refute_receive {^ref, {:push_event, "opponent_move", _payload}}, 100
assert render(view) =~ "Losing move"
end
end
describe "reset" do
test "clears the move list and grade, and re-pushes init_board", %{conn: conn} do
endgame = endgame_fixture()
seed_tablebase(endgame.fen, moves: grading_moves())
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
play_move(view, endgame, "d1", "d7", "Qd7+")
assert render(view) =~ "Qd7+"
view |> element("button", "Reset") |> render_click()
html = render(view)
assert html =~ "No Moves"
refute html =~ "Optimal move"
assert_init_board(view, endgame.fen, "white", "white")
end
end
end