erics_tic_tac_toe 0.1.0 → 0.5.0

data/test/game_presentor_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class GamePresentorTest < MiniTest::Unit::TestCase
+  def setup
+    @game = TicTacToe::Game.new
+    @presentor = TicTacToe::GamePresentor.new(@game)
+  end
+
+  def test_grid
+    assert_equal [%w(1 2 3), %w(4 5 6), %w(7 8 9)], @presentor.grid
+  end
+
+  def test_grid_with_moves
+    @game = TicTacToe::Game.new([['x', nil, nil], [nil, nil, nil], [nil, nil, nil]])
+    @presentor = TicTacToe::GamePresentor.new(@game)
+
+    assert_equal [%w(x 2 3), %w(4 5 6), %w(7 8 9)], @presentor.grid
+  end
+end

data/test/game_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+
+class GameTest < MiniTest::Unit::TestCase
+
+  class PlayerMock
+    def initialize(move)
+      @move = move
+    end
+
+    def get_move(_board)
+      move = @move
+      @move = nil
+      move
+    end
+
+    def has_next_move?
+      !!@move
+    end
+
+    def letter
+      'x'
+    end
+  end
+
+  def test_grid
+    game = TicTacToe::Game.new
+
+    assert_equal game.grid, empty_grid
+  end
+
+  def test_an_empty_game_is_not_solved
+    game = TicTacToe::Game.new
+
+    refute game.solved?
+  end
+
+  def test_a_full_grid_is_cats
+    # x o x
+    # x o x
+    # o x o
+    game = TicTacToe::Game.new([%w(x o x), %w(x o x), %w(o x o)])
+
+    assert game.cats?
+  end
+
+  def test_winner
+    game = TicTacToe::Game.new([%w(x x x), [nil,nil,nil], [nil, nil, nil]], 
+                               PlayerMock.new(nil), PlayerMock.new(nil))
+
+    assert_equal 'x', game.winner
+  end
+
+  def test_setting_a_players_move
+    game = TicTacToe::Game.new(empty_grid, PlayerMock.new('1'), PlayerMock.new(nil))
+    game.start
+
+    assert_equal 'x', game.board.get_cell(0, 0)
+  end
+
+  def test_set_move_via_computer
+    game = TicTacToe::Game.new(empty_grid, PlayerMock.new([0,0]), PlayerMock.new([2,2]))
+    game.start
+
+    assert_equal 7, game.board.empty_positions.size
+  end
+
+  def test_skip_a_players_turn
+    game = TicTacToe::Game.new(empty_grid, PlayerMock.new([0,0]), PlayerMock.new(nil))
+    game.start
+
+    assert game.board.only_one?
+  end
+  
+
+  def empty_grid(size=3)
+    Array.new(size) { Array.new(size) { nil } }
+  end
+end

data/test/player_presenter_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+
+class PlayerPresenterTest < MiniTest::Unit::TestCase
+  def setup
+    @player_mock = OpenStruct.new(letter: 'x', type: 'mock')
+  end
+
+  def test_move_json
+    assert_equal({letter: 'x', type: 'mock', move: '1'}.to_json,
+                 TicTacToe::PlayerPresenter.new(@player_mock).move_json('1'))
+  end
+end

data/test/player_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class BoardMock; end
+
+class PlayerTest < MiniTest::Unit::TestCase
+
+  def test_build_human_player
+    assert_equal TicTacToe::HumanPlayer,
+                 TicTacToe::Player.build('type' => 'human').class
+  end
+
+  def test_build_computer_player
+    assert_equal TicTacToe::ComputerPlayer,
+                 TicTacToe::Player.build('type' => 'computer').class
+  end
+end
+
+module SharedPlayerTests
+  def test_gets_move
+    assert_equal [0, 0], @player.get_move(BoardMock.new)
+  end
+
+  def test_letter
+    assert_equal 'x', @player.letter
+  end
+
+  def test_has_next_move
+    assert @player.has_next_move?
+  end
+
+  def test_has_type
+    refute @player.type.nil?
+  end
+
+end
+
+class HumanPlayerTest < MiniTest::Unit::TestCase
+  def setup
+    @player = TicTacToe::HumanPlayer.new('letter' => "x", 'move' => [0,0])
+  end
+
+  include SharedPlayerTests
+end
+
+
+class ComputerPlayerTest < MiniTest::Unit::TestCase
+  class SolverMock
+    def solve
+      [0, 0]
+    end
+  end
+  def setup
+    @player = TicTacToe::ComputerPlayer.new({'letter' => "x"}, SolverMock)
+  end
+
+  include SharedPlayerTests
+end

data/test/potential_state_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+class PotentialStateTest < MiniTest::Unit::TestCase
+  def test_solved
+    set_grid([ ['x', 'x', 'x'], [nil, nil, nil], [nil, nil, nil] ])
+    assert @state.solved?
+  end
+
+  def test_fork_exists
+    set_grid([ ['x', nil, 'x'], [nil, 'x', nil], [nil, nil, nil] ])
+    assert @state.fork_exists?
+
+    set_grid([ ['x', nil, 'x'], [nil, 'o', nil], ['x', nil, nil] ])
+    assert @state.fork_exists?
+
+    set_grid([ ['o', nil, 'o'], [nil, 'x', nil], ['o', nil, nil] ])
+    refute @state.fork_exists?
+    
+  end
+
+  def test_forking_positions
+    # o | 2 | x | 
+    # 4 | o | 6 | 
+    # x | 8 | 9 | 
+    set_grid([ ['o', nil, 'x'], [nil, 'o', nil], ['x', nil, nil] ])
+    assert @state.forking_positions.size == 1
+  end
+
+  def test_can_win_next_turn
+    set_grid([[ 'x', nil, 'x'], [nil, nil, nil], [nil, nil, nil] ])
+    assert @state.can_win_next_turn?
+
+    # 1 | 2 | x
+    # 4 | o | 6
+    # 7 | x | x
+    set_grid([[ nil, nil, 'x'], [nil, 'o', nil], [nil, 'x', 'x'] ])
+    assert @state.can_win_next_turn?
+
+    # o | 2 | x | 
+    # 4 | o | 6 | 
+    # x | 8 | 9 | 
+    set_grid([ ['o', nil, 'x'], [nil, 'o', nil], ['x', nil, nil] ])
+    refute @state.can_win_next_turn?
+  end
+
+private
+
+  def set_grid(grid)
+    board = TicTacToe::Board.new
+    board.grid = grid
+    @state = TicTacToe::ThreeByThree::PotentialState.new(board, 'x')
+  end
+end

data/test/solver_test.rb

@@ -1,131 +1,140 @@
 require 'test_helper'
 
-class SolverTest < MiniTest::Unit::TestCase
-  def setup
-    TicTacToe::Solver.instance_eval { attr_accessor :strategy } # For testing
-    @solver = TicTacToe::Solver.new(TicTacToe::Board.new, 'x')
-    @solver.strategy.class.instance_eval { attr_accessor :implementation } # For testing
-    @solver.strategy.implementation.class.instance_eval { attr_accessor :board } # For testing
+module SharedSolverTests
+  def test_win_horizontally
+    refute @board.solved?
+
+    # Will win, when there is a winning move
+    set_grid([[ 'x', 'x', nil], 
+              [ 'o', 'o', nil], 
+              [ 'x', 'o', nil] ])
+    refute @board.solved? # Is not solved yet
+    solve!
+    assert !!@board.solved?, "Could not solve the board" # Solved it
+    assert_equal 'x', @board.get_cell(2, 0) # Placed the right letter
   end
 
-  def test_win_next_move
-    refute board.solved?
+  def test_wins_across
 
-    # Will win, when there is a winning move
-    set_grid([[ 'x', 'x', nil], [nil, nil, nil], [nil, nil, nil] ])
-    refute board.solved? # Is not solved yet
-    @solver.next_move!
-    assert board.solved? # Solved it
-    assert_equal 'x', board.get_cell(2, 0) # Placed the right letter
-
-    set_grid([[ 'x', nil, nil], [nil, 'x', nil], [nil, nil, nil] ])
-    refute board.solved?
-    @solver.next_move!
-    assert board.solved?
-    assert_equal 'x', board.get_cell(2, 2)
+    set_grid([[ 'x', 'o', nil], 
+              [ nil, 'x', nil], 
+              [ 'o', nil, nil] ])
+    refute @board.solved?
+    solve!
+    assert !!@board.solved?
+    assert_equal 'x', @board.get_cell(2, 2)
+  end
+
+  def test_wins_vertically
     
-    set_grid([[ 'x', nil, nil], [nil, nil, nil], ['x', nil, nil] ])
-    refute board.solved?
-    @solver.next_move!
-    assert board.solved?
-    assert_equal 'x', board.get_cell(0, 1)
+    set_grid([[ 'x', nil, 'o'], 
+              [nil,  'o', 'o'], 
+              [ 'x', nil, nil] ])
+    refute @board.solved?
+    solve!
+    assert !!@board.solved?
+    assert_equal 'x', @board.get_cell(0, 1)
+  end
+
+  def test_does_not_win_unsolvable_board
 
     # Can not win when there is no winning move
     set_grid([[ 'o', nil, nil], [nil, nil, nil], ['o', nil, nil] ])
-    refute board.solved?
-    @solver.next_move!
-    refute board.solved?
+    refute @board.solved?
+    solve!
+    refute @board.solved?
   end
 
-  def test_block_next_move
-    refute board.solved?
+  def test_blocks_horizontally
+    refute @board.solved?
 
     # Will block when the opponent is about to win
-    set_grid([ ['o', 'o', nil], [nil, nil,nil], [nil,nil,nil]])
-    refute board.solved?
-    @solver.next_move!
-    refute board.solved?
+    set_grid([ ['o', 'o', nil], 
+               [nil, 'x', nil], 
+               [nil, 'x', nil]])
+    refute @board.solved?
+    solve!
+    refute @board.solved?
     # Placed the right letter at the right place
-    assert_equal 'x', board.get_cell(2, 0) 
+    assert_equal 'x', @board.get_cell(2, 0) 
   end
 
+  def test_blocks_vertically
+
+    set_grid([ ['x', 'o', nil],
+               [nil, nil, nil],
+               [nil, 'o', nil]])
+    solve!
+    assert_equal 'x', @board.get_cell(1, 1)
+  end
 
-  def test_fork_next_move
-    refute board.solved?
+
+  def test_forks_in_middle
+    refute @board.solved?
 
     # Place letter in place where next turn is an automatic win
-    set_grid([ ['x', nil, nil], [nil, 'o',nil], [nil,nil,'x']])
-    refute board.solved?
-    @solver.next_move!
-    refute board.solved?
-    assert_equal 'x', board.get_cell(2, 0)
+    set_grid([ ['x', 'o', 'x'], 
+               [nil, nil, 'o'], 
+               [nil, nil, nil]])
+    refute @board.solved?
+    solve!
+    refute @board.solved?
+    correct_cells =  @board.get_cell(1, 1) || @board.get_cell(0, 2)
+    assert !!correct_cells
+  end
+
+  def test_forks_in_corner
 
     # 1 | 2 | x
     # 4 | o | 6
     # 7 | x | 9 <--
-    set_grid([ [nil, nil, 'x'], [nil, 'o',nil], [nil,'x',nil]])
-    refute board.solved?
-    @solver.next_move!
-    refute board.solved?
-    assert_equal 'x', board.get_cell(2, 2)
+    set_grid([ [nil, 'o', 'x'], 
+               [nil, 'o', nil], 
+               [nil, 'x', nil]])
+    refute @board.solved?
+    solve!
+    refute @board.solved?
+    assert_equal 'x', @board.get_cell(2, 2)
   end
 
-  def test_block_fork_next_move
-    # Will block an opponent if they will have a change to fork next turn
-
-    # 1 | 2 | o
-    # 4 | x | 6
-    # 7 | o | 9 <--
-    set_grid([ [nil, nil, 'o'], [nil, 'x',nil], [nil,'o',nil]])
-    refute board.solved?
-    @solver.next_move!
-    refute board.solved?
-    assert_equal 'x', board.get_cell(2, 2)
-
+  def test_does_not_create_fork
     # 1 | 2 | o
     # 4 | x | 6
     # o | 8 | 9
-    set_grid([[nil,nil,'o'],[nil,'x',nil],['o',nil,nil]])
-    @solver.next_move!
-    assert_nil board.get_cell(2,2)
-    assert_nil board.get_cell(0,0)
+    set_grid([[nil,nil,'o'],
+              [nil,'x',nil],
+              ['o',nil,nil]])
+    solve!
+    assert_nil @board.get_cell(2,2)
+    assert_nil @board.get_cell(0,0)
+  end
+
+  def test_does_not_create_fork_in_the_future
 
     # x | 2 | 3
     # 4 | o | 6
     # 7 | 8 | o
     set_grid([ ['x',nil,nil], [nil,'o',nil], [nil,nil,'o'] ])
-    @solver.next_move!
-    assert_nil board.get_cell(1, 0)
-    assert_nil board.get_cell(0, 1)
-    assert_nil board.get_cell(2, 1)
-    assert_nil board.get_cell(1, 2)
+    solve!
+    assert_nil @board.get_cell(1, 0)
+    assert_nil @board.get_cell(0, 1)
+    assert_nil @board.get_cell(2, 1)
+    assert_nil @board.get_cell(1, 2)
   end
 
-  def test_center
-    # Will play in the center if its an empty board
-    assert board.empty?
-    @solver.next_move!
-    assert_equal 'x', board.center_cell
-    assert board.only_one?
+  def test_does_not_create_fork_in_the_far_future
+    set_grid([['o', nil, nil], [nil, nil, nil], [nil, nil, nil]])
+    solve!
+    assert_nil @board.get_cell(0, 2)
   end
-  
-  def test_oposite_corner
-    # 1 | 2 | o
-    # 4 | x | 6
-    # 7 | 8 | 9
-    set_grid([[nil,nil,'o'],[nil,'x',nil],[nil,nil,nil]])
-    @solver.next_move!
-    assert_equal 'x', board.get_cell(0, 2)
 
-    set_grid([['o',nil,nil],[nil,'x',nil],[nil,nil,nil]])
-    @solver.next_move!
-    assert_equal 'x', board.get_cell(2, 2)
-  end
 
   def test_empty_corner
     set_grid([[nil,nil,nil],[nil,'o',nil],[nil,nil,nil]])
-    @solver.next_move!
-    assert_equal 'x', board.get_cell(0,0)
+    solve!
+    played_corner = @board.get_cell(0,0) || @board.get_cell(0,2) || 
+                    @board.get_cell(2,0) || @board.get_cell(2,2)
+    assert played_corner
   end
   
   def test_any_empty_position
@@ -133,17 +142,84 @@ class SolverTest < MiniTest::Unit::TestCase
     # o | x | 6
     # x | o | x
     set_grid([['o', 'x', 'o'],['o','x',nil],['x','o','x']])
-    @solver.next_move!
-    assert_equal 'x', board.get_cell(2, 1)
+    solve!
+    assert_equal 'x', @board.get_cell(2, 1)
+  end
+
+  def test_raises_exception_on_full_board
+    set_grid([%w(x o x), %w(o o x), %w(o x o)])
+    assert_raises(RuntimeError) { solve! }
   end
 
   private
 
   def set_grid(grid)
-    board.instance_variable_set("@grid", grid)
+    @board.grid = grid
   end
 
-  def board
-    @solver.strategy.implementation.board
+  def solve!
+    @board.play_at(*@solver.solve, 'x')
+  end
+end
+
+class MinimaxSolverTest < MiniTest::Unit::TestCase
+  def setup
+    @board = TicTacToe::Board.new
+    @solver = TicTacToe::MinimaxStrategy.new(@board, 'x')
+  end
+  
+  include SharedSolverTests
+end
+
+class ThreeByThreeSolverTest < MiniTest::Unit::TestCase
+  def setup
+    @board = TicTacToe::Board.new
+    @solver = TicTacToe::ThreeByThreeStrategy.new(@board, 'x')
+  end
+  
+  include SharedSolverTests
+
+  def test_block_fork
+    set_grid([['o', nil, nil], ['x', 'o', nil], [nil, nil, 'x']])
+    solve!
+    assert_equal 'x', @board.get_cell(1, 0)
+  end
+  
+  def test_center
+    # Will play in the center if its an empty @board
+    assert @board.empty?
+    solve!
+    assert_equal 'x', @board.get_cell(@board.size/2, @board.size/2)
+    assert @board.only_one?
+  end
+  
+  def test_opposite_corner
+    # 1 | 2 | o
+    # 4 | x | 6
+    # 7 | 8 | 9
+    set_grid([[nil,nil,'o'],[nil,'x',nil],[nil,nil,nil]])
+    solve!
+    assert_equal 'x', @board.get_cell(0, 2)
+
+    set_grid([['o',nil,nil],[nil,'x',nil],[nil,nil,nil]])
+    solve!
+    assert_equal 'x', @board.get_cell(2, 2)
+  end
+
+  def test_corners
+    set_grid([['x', nil, nil], [nil, 'o', nil], [nil, nil, nil]])
+    solve!
+    assert_equal 'x', @board.get_cell(2,0)
+
+    set_grid([['x', 'o', 'x'], [nil, 'o', nil], ['o', 'x', nil]])
+    solve!
+    assert_equal 'x', @board.get_cell(2, 2)
+
+    # x | o | x
+    # o | o | x
+    #   | x | o
+    set_grid([['x', 'o', 'x'], ['o', 'o', 'x'], [nil, 'x', 'o']])
+    solve!
+    assert_equal 'x', @board.get_cell(0, 2)
   end
 end