tic_tac_toe_nhu 0.0.4 → 0.0.5

data/spec/mocks/player.rb

@@ -0,0 +1,16 @@
+require 'surrogate/rspec'
+
+class MockPlayer
+  Surrogate.endow(self)
+  define(:initialize) {|name = "Player", value = "X", strategy = "no"|}
+  define_reader :name
+  define_reader :value
+  define_reader :strategy
+  define(:move) {|board|}
+end
+
+describe TicTacToe::Player do
+  it "checks if mock is substitutable" do
+    MockPlayer.should be_substitutable_for(TicTacToe::Player)
+  end
+end

data/spec/mocks/player_factory.rb

@@ -1,10 +1,11 @@
 require 'surrogate/rspec'
+require 'tic_tac_toe/values'
 
 class MockPlayerFactory
   Surrogate.endow(self)
 
-  define(:human) {|name = "Sue", value = "X"|}
-  define(:computer) {|board, value = "X", opponent="O"|}
+  define(:human) {|name = "human", value = TicTacToe::VALUES[0]|}
+  define(:computer) {|value = TicTacToe::VALUES[1]|}
 end
 
 describe TicTacToe::PlayerFactory do

data/spec/mocks/strategy/dynamic.rb

@@ -9,7 +9,7 @@ class MockDynamicStrategy
     @moves << move
   end
 
-  def move
+  def move(*board)
     @moves.shift
   end
 

data/spec/tic_tac_toe/game_spec.rb

@@ -1,94 +1,99 @@
 require 'tic_tac_toe/spec_helper'
 require 'tic_tac_toe/game'
-require 'tic_tac_toe/board'
-require 'tic_tac_toe/player'
-require 'mocks/strategy/dynamic'
 
-describe TicTacToe::Game do
-  before(:each) do
-    @board = TicTacToe::Board.new
+require 'mocks/game_state_factory'
+require 'mocks/game_state'
+require 'mocks/ui/console'
+require 'mocks/player'
 
-    @player1_strategy = MockDynamicStrategy.new
-    @player1 = TicTacToe::Player.new("Todd", "X", @player1_strategy)
-
-    @player2_strategy = MockDynamicStrategy.new
-    @player2 = TicTacToe::Player.new("John", "O", @player2_strategy)
+describe TicTacToe::Game do
+  attr_reader :game, :ui, :game_state, :game_state_factory
 
-    @game = TicTacToe::Game.new(@board, @player1, @player2)
+  before(:each) do
+    @game_state = MockGameState.factory
+    @game_state_factory = MockGameStateFactory.factory create: game_state
+    @ui = MockConsole.factory
+    @game = TicTacToe::Game.new(@ui, @game_state_factory)
   end
 
-  context "marking board" do
-    it "mark the board with user input" do
-      @player1_strategy.add_move(1)
-      @game.make_move
-      @board.unique_marked_values.should include(@player1.value)
-    end
-
-    it "does not mark the board if user doesn't return an input" do
-      @player1_strategy.add_move(nil)
-      @game.make_move
-      @board.unique_marked_values.should_not include(@player1.value)
-    end
+  it "displays a welcome message" do
+    game.start
+    ui.was told_to(:display_welcome_message)
   end
 
-  describe "return winner player based on the value return from rules" do
-    it "is Todd when value is X" do
-      mark_board([0, 1, 2], @player1.value)
-      @game.winner.should == @player1
+  describe "create game state" do
+    it "asks user for a game type" do
+      game.start
+      @ui.was asked_for(:game_type)
     end
 
-    it "is John when it is O" do
-      mark_board([0, 1, 2], @player2.value)
-      @game.winner.should == @player2
+    it "asks game state factory to create a game with input game type" do
+      game_type = 4
+      ui.will_have_game_type 4
+      game.start
+      @game_state_factory.was told_to(:create).with(game_type)
     end
 
-    it "is nil when no one wins" do
-      @game.winner.should be_nil
+    it "asks ui for game type again if the input is incorrect" do
+      game_state_factory.will_create ArgumentError.new, game_state
+      game.start
+      ui.was asked_for(:game_type).times(2)
     end
   end
 
-  describe "changes player" do
-    it "doesn't change player if player 1 doesn't return a move" do
-      @game.current_player.should == @player1
-      @player1_strategy.add_move(nil)
+  describe "play game" do
+    attr_reader :player
 
-      @game.make_move
-      @game.current_player.should == @player1
+    before(:each) do
+      @player = MockPlayer.new
+      game_state.will_game_over? false, true
+      game_state.will_have_current_player @player
     end
 
-    it "changes to player 2 after player 1 moves" do
-      @game.current_player.should == @player1
-      @player1_strategy.add_move(1)
-
-      @game.make_move
-      @game.current_player.should == @player2
+    it "displays the board" do
+      game.start
+      ui.was told_to(:display_board)
     end
-  end
 
-  describe "game over" do
-    it "is over when there is a winner" do
-      mark_board([0, 1, 2], @player2.value)
-      @game.should be_over
+    it "tells ui to display player turn" do
+      game.start
+      ui.was told_to(:display_player_turn).with(player)
     end
 
-    it "is over when there is a tied" do
-      mark_board((0...9).to_a, "i")
-      @game.should be_over
+    it "told player to move" do
+      game.start
+      player.was told_to(:move)
     end
 
-    it "is not over when there is no mark on the board" do
-      @game.should_not be_over
+    it "tells player to move again if there is an error" do
+      player.will_move TicTacToe::MoveNotAvailableError.new, nil
+      game.start
+      player.was told_to(:move).times(2)
     end
 
-    it "is not over when there is no winner or a tied" do
-      mark_board([1, 2], @player1.value)
-      @game.should_not be_over
+    it "changes the player after a player move" do
+      game.start
+      game_state.was told_to(:change_player)
     end
+
   end
 
-  def mark_board(moves, value)
-    moves.each do |m|
-      @board.mark(m, value)
+  describe "end game" do
+    it "display a board at the end of the game" do
+      game.start
+      ui.was told_to(:display_board)
+    end
+
+    it "asks ui to display a winner if there is a winner" do
+      winner = "Winner"
+      game_state.will_have_winner winner
+      game.start
+      ui.was told_to(:display_winner).with(winner)
+    end
+
+    it "asks ui to display a draw" do
+      game.start
+      ui.was told_to(:display_tied_game)
     end
   end
 end

data/spec/tic_tac_toe/game_state_factory_spec.rb

@@ -0,0 +1,63 @@
+require 'tic_tac_toe/spec_helper'
+require 'tic_tac_toe/game_state_factory'
+require 'tic_tac_toe/player_factory'
+require 'mocks/player_factory'
+require 'tic_tac_toe/player'
+
+describe TicTacToe::GameStateFactory do
+  before(:each) do
+    @player_factory = MockPlayerFactory.new
+    @game_factory = TicTacToe::GameStateFactory.new(@player_factory)
+  end
+
+  it "returns 4 types of games" do
+    @game_factory.types.size.should == 4
+  end
+
+  context "creates game state" do
+    before(:each) do
+      @human = TicTacToe::Player.new("Human", TicTacToe::VALUES[0], nil)
+      @computer = TicTacToe::Player.new("Computer", opponent_value(@human.value), nil)
+
+      @player_factory.will_have_human @human
+      @player_factory.will_have_computer @computer
+    end
+
+    def test_game_state_creation(game_type, players)
+      game = @game_factory.create(game_type)
+      game.current_player.should == players[0]
+      game.change_player
+      game.current_player.should == players[1]
+    end
+
+    it "returns human vs computer game state" do
+      test_game_state_creation(1, [@human, @computer])
+    end
+
+    it "returns computer vs human game" do
+      test_game_state_creation(2, [@computer, @human])
+    end
+
+    it "returns user vs user game" do
+      @human2 = TicTacToe::Player.new("Human 2", opponent_value(@human.value), nil)
+      @player_factory.will_have_human @human, @human2
+
+      test_game_state_creation(3, [@human, @human2])
+    end
+
+    it "returns computer vs computer game" do
+      @computer2 = TicTacToe::Player.new("Computer 2", opponent_value(@computer.value), nil)
+      @player_factory.will_have_computer @computer, @computer2
+
+      test_game_state_creation(4, [@computer, @computer2])
+    end
+  end
+
+  it "raises an error when the game type doesn't exist" do
+    lambda{@game_factory.create(10)}.should raise_error(ArgumentError)
+  end
+
+  def opponent_value(value)
+    TicTacToe::Values.opponent(value)
+  end
+end

data/spec/tic_tac_toe/game_state_spec.rb

@@ -0,0 +1,73 @@
+require 'tic_tac_toe/spec_helper'
+require 'tic_tac_toe/board'
+require 'tic_tac_toe/game_state'
+require 'tic_tac_toe/player'
+require 'tic_tac_toe/values'
+
+describe TicTacToe::GameState do
+  attr_reader :game_state, :player1, :player2, :board
+
+  before(:each) do
+    @board = TicTacToe::Board.new
+    @player1 = TicTacToe::Player.new("player1", TicTacToe::VALUES[0], nil)
+    @player2 = TicTacToe::Player.new("player1", TicTacToe::VALUES[1], nil)
+    @game_state = TicTacToe::GameState.new([@player1, @player2], @board)
+  end
+
+
+  it "can read board" do
+    game_state.board.should == board
+  end
+
+  describe "current player" do
+    it "starts with player 1 as the current player" do
+      game_state.current_player.should == player1
+    end
+
+    it "changes current player to player 2" do
+      game_state.current_player.should == player1
+      game_state.change_player
+      game_state.current_player.should == player2
+    end
+
+    it "changes current player to player 1 after two calls on change player" do
+      game_state.current_player.should == player1
+      game_state.change_player
+      game_state.change_player
+      game_state.current_player.should == player1
+    end
+  end
+
+  describe "game over" do
+    it "is false when there is no mark" do
+      game_state.should_not be_game_over
+    end
+
+    it "should be over when there is a winner" do
+      mark_winning_board(player1.value)
+      game_state.should be_game_over
+    end
+  end
+
+  describe "winner" do
+    it "has no winner when there is no mark" do
+      game_state.winner.should be_nil
+    end
+
+    it "is player 1" do
+      mark_winning_board(player1.value)
+      game_state.winner.should == player1
+    end
+
+    it "is player 2" do
+      mark_winning_board(player2.value)
+      game_state.winner.should == player2
+    end
+  end
+
+  def mark_winning_board(value)
+    [0, 4, 8].each do |move|
+      game_state.board.mark(move, value)
+    end
+  end
+end

data/spec/tic_tac_toe/player_factory_spec.rb

@@ -2,6 +2,7 @@ require 'tic_tac_toe/spec_helper'
 require 'tic_tac_toe/player_factory'
 require 'tic_tac_toe/strategy/minimax'
 require 'tic_tac_toe/strategy/console_user'
+require 'tic_tac_toe/values'
 
 describe TicTacToe::PlayerFactory do
 
@@ -32,27 +33,22 @@ describe TicTacToe::PlayerFactory do
   end
 
   context "computer player" do
-    before(:each) do
-      @board = "fake board"
-    end
-
     it "returns a computer player with given value" do
       computer_value = "Danny"
-      opponent_value = "Bill"
-      player = @factory.computer(@board, computer_value, opponent_value)
+      player = @factory.computer(computer_value)
       player.value.should == computer_value
     end
 
     it "checks default strategy" do
-      @factory.computer(@board).strategy.should be_kind_of(TicTacToe::Strategy::Minimax)
+      @factory.computer.strategy.should be_kind_of(TicTacToe::Strategy::Minimax)
     end
 
     it "checks default name" do
-      @factory.computer(@board).name.should == "Computer"
+      @factory.computer.name.should == "Computer"
     end
 
     it "checks default value" do
-      @factory.computer(@board).value.should == "O"
+      @factory.computer.value.should == "O"
     end
   end
 

data/spec/tic_tac_toe/player_spec.rb

@@ -1,32 +1,33 @@
 require 'tic_tac_toe/spec_helper'
 require 'tic_tac_toe/player'
+require 'tic_tac_toe/board'
+require 'tic_tac_toe/values'
 require 'mocks/strategy/dynamic'
 
 describe TicTacToe::Player do
+  before(:each) do
+    @move = 4
+    @value = TicTacToe::VALUES[0]
+    @name = "blu"
+    @strategy = MockDynamicStrategy.new([@move])
+    @player = TicTacToe::Player.new(@name, @value, @strategy)
+  end
 
   it "gets name" do
-    name = "bruce"
-    player = TicTacToe::Player.new(name, nil, nil)
-    player.name.should == name
+    @player.name.should == @name
   end
 
   it "gets player value" do
-    value = "X"
-    player = TicTacToe::Player.new(nil, value, nil)
-    player.value.should == value
-  end
-
-  it "gets player's move" do
-    move = 4
-    strategy = MockDynamicStrategy.new([4])
-    player = TicTacToe::Player.new(nil, nil, strategy)
-    player.move.should == move
+    @player.value.should == @value
   end
 
   it "gets strategy" do
-    strategy = MockDynamicStrategy.new([4])
-    player = TicTacToe::Player.new(nil, nil, strategy)
-    player.strategy.should == strategy
+    @player.strategy.should == @strategy
+  end
 
+  it "makes move" do
+    board = TicTacToe::Board.new
+    @player.move(board)
+    board.available_moves.should_not include(@move)
   end
 end

data/spec/tic_tac_toe/strategy/console_user_spec.rb

@@ -13,7 +13,7 @@ describe TicTacToe::Strategy::ConsoleUser do
     it "prompts the user for a move" do
       @output.should_receive(:puts).with("Please enter a square number that is not marked: ")
       @input.should_receive(:gets).and_return("3")
-      @strategy.move
+      @strategy.move(@board)
     end
 
     it "returns a number when user enters a number" do

data/spec/tic_tac_toe/strategy/minimax_spec.rb

@@ -1,156 +1,157 @@
 require 'tic_tac_toe/spec_helper'
 require 'tic_tac_toe/board'
 require 'tic_tac_toe/strategy/minimax'
+require 'tic_tac_toe/values'
 
 describe TicTacToe::Strategy::Minimax, :slow_test => true do
 
   before(:each) do
     @board = TicTacToe::Board.new(3)
-    @opponent = "X"
-    @computer = "O"
-    @strategy = TicTacToe::Strategy::Minimax.new(@board, @computer, @opponent)
+    @computer_value = TicTacToe::VALUES[1]
+    @opponent_value = TicTacToe::Values.opponent(@computer_value)
+    @strategy = TicTacToe::Strategy::Minimax.new(@computer_value)
   end
 
   context "move" do
     context "when there is only one position left" do
       it "returns move when it's a winning move" do
-        mark((1...@board.size**2), @computer)
-        @strategy.move.should == 0
+        mark((1...@board.size**2), @computer_value)
+        @strategy.move(@board).should == 0
       end
 
       it "returns the move when it's a tied" do
-        mark([0, 2, 5, 6], @computer)
-        mark([1, 3, 4, 8], @opponent)
-        @strategy.move.should == 7
+        mark([0, 2, 5, 6], @computer_value)
+        mark([1, 3, 4, 8], @opponent_value)
+        @strategy.move(@board).should == 7
       end
 
       it "returns the move when opponent wins" do
-        mark((0...@board.size**2 - 1).to_a, @opponent)
-        @strategy.move.should == 8
+        mark((0...@board.size**2 - 1).to_a, @opponent_value)
+        @strategy.move(@board).should == 8
       end
     end
 
     context "when there are two positions left" do
       it "returns losing scores when the two moves are losing moves" do
-        mark((2...@board.size**2).to_a, @opponent)
-        @strategy.move.should == 0
+        mark((2...@board.size**2).to_a, @opponent_value)
+        @strategy.move(@board).should == 0
       end
 
       it "returns the first win move when the two moves are winning moves" do
-        mark((2...@board.size**2).to_a, @computer)
-        @strategy.move.should == 0
+        mark((2...@board.size**2).to_a, @computer_value)
+        @strategy.move(@board).should == 0
       end
 
       it "returns the first tie move when the two moves are tie moves" do
-        mark([0, 2, 7], @computer)
-        mark([1, 4, 6, 8], @opponent)
-        @strategy.move.should == 3
+        mark([0, 2, 7], @computer_value)
+        mark([1, 4, 6, 8], @opponent_value)
+        @strategy.move(@board).should == 3
       end
 
       it "returns win move when there are winning and losing moves" do
-        mark([0, 1, 3, 7], @computer)
-        mark([2, 4, 5], @opponent)
-        @strategy.move.should == 6
+        mark([0, 1, 3, 7], @computer_value)
+        mark([2, 4, 5], @opponent_value)
+        @strategy.move(@board).should == 6
       end
 
       it "returns winning move when there are winning and tie moves" do
-        mark([0, 2, 3, 4], @computer)
-        mark([1, 5, 8], @opponent)
-        @strategy.move.should == 6
+        mark([0, 2, 3, 4], @computer_value)
+        mark([1, 5, 8], @opponent_value)
+        @strategy.move(@board).should == 6
       end
 
       it "returns tied move when there are losing and tie moves" do
-        mark([2, 3, 4], @computer)
-        mark([0, 5, 6, 7], @opponent)
-        @strategy.move.should == 8
+        mark([2, 3, 4], @computer_value)
+        mark([0, 5, 6, 7], @opponent_value)
+        @strategy.move(@board).should == 8
       end
 
       context "winning move appear later in the board" do
         it "returns win move when winning move is later than losing move" do
-          mark([1, 2, 5, 7], @computer)
-          mark([0, 3, 4], @opponent)
-          @strategy.move.should == 8
+          mark([1, 2, 5, 7], @computer_value)
+          mark([0, 3, 4], @opponent_value)
+          @strategy.move(@board).should == 8
         end
 
         it "returns winning move when winning move is later than tie move" do
-          mark([0, 2, 4, 5], @computer)
-          mark([1, 3, 6], @opponent)
-          @strategy.move.should == 8
+          mark([0, 2, 4, 5], @computer_value)
+          mark([1, 3, 6], @opponent_value)
+          @strategy.move(@board).should == 8
         end
 
         it "returns tied move when there are losing and tie moves" do
-          mark([2, 3, 4], @computer)
-          mark([0, 5, 6, 7], @opponent)
-          @strategy.move.should == 8
+          mark([2, 3, 4], @computer_value)
+          mark([0, 5, 6, 7], @opponent_value)
+          @strategy.move(@board).should == 8
         end
       end
     end
 
     context "when there are three moves left" do
       it "chooses the winning move when there is one available" do
-        mark([1, 4], @computer)
-        mark([0, 3, 2, 5], @opponent)
-        @strategy.move.should == 7
+        mark([1, 4], @computer_value)
+        mark([0, 3, 2, 5], @opponent_value)
+        @strategy.move(@board).should == 7
       end
 
       it "chooses a tie move when there are only losing and tie moves" do
-        mark([1, 4], @computer)
-        mark([0, 2, 5, 7], @opponent)
-        @strategy.move.should == 8
+        mark([1, 4], @computer_value)
+        mark([0, 2, 5, 7], @opponent_value)
+        @strategy.move(@board).should == 8
       end
     end
 
     context "when there are 4 moves left" do
       it "chooses a winning move when one is available" do
-        mark([0, 4], @computer)
-        mark([1, 2, 6], @opponent)
-        @strategy.move.should == 8
+        mark([0, 4], @computer_value)
+        mark([1, 2, 6], @opponent_value)
+        @strategy.move(@board).should == 8
       end
 
       it "chooses a move that would create 2 winning moves" do
-        mark([0, 6], @computer)
-        mark([1, 3, 5], @opponent)
-        @strategy.move.should == 4
+        mark([0, 6], @computer_value)
+        mark([1, 3, 5], @opponent_value)
+        @strategy.move(@board).should == 4
       end
     end
   end
 
   it "chooses the winning move when available" do
-    mark([1, 4], @computer)
-    mark([0], @opponent)
-    @strategy.move.should == 7
+    mark([1, 4], @computer_value)
+    mark([0], @opponent_value)
+    @strategy.move(@board).should == 7
   end
 
   it "chooses the winning move when available" do
-    mark([0, 4], @computer)
-    mark([1, 2], @opponent)
-    @strategy.move.should == 8
+    mark([0, 4], @computer_value)
+    mark([1, 2], @opponent_value)
+    @strategy.move(@board).should == 8
   end
 
   it "chooses a blocking move when there is no winning move" do
-    mark([2], @computer)
-    mark([0, 4], @opponent)
-    @strategy.move.should == 8
+    mark([2], @computer_value)
+    mark([0, 4], @opponent_value)
+    @strategy.move(@board).should == 8
   end
 
   it "chooses a blocking move when there is no winning move" do
-    mark([2], @computer)
-    mark([1, 4], @opponent)
-    @strategy.move.should == 7
+    mark([2], @computer_value)
+    mark([1, 4], @opponent_value)
+    @strategy.move(@board).should == 7
   end
 
   it "chooses the middle square when computer is the second player" do
-    mark([0], @opponent)
-    @strategy.move.should == 4
+    mark([0], @opponent_value)
+    @strategy.move(@board).should == 4
   end
 
   it "chooses the first corner of the board when the middle square is taken as a second player" do
-    mark([4], @opponent)
-    @strategy.move.should == 0
+    mark([4], @opponent_value)
+    @strategy.move(@board).should == 0
   end
 
   it "chooses the middle square on the first move" do
-    @strategy.move.should == 4
+    @strategy.move(@board).should == 4
   end
 
   def move_node(move, score)

data/spec/tic_tac_toe/ui/console_spec.rb

@@ -79,7 +79,7 @@ describe TicTacToe::Console do
   it "displays winner" do
     player = TicTacToe::Player.new("Todd", "X", nil)
     @console.display_winner(player)
-    @output.string.should == "Todd(X) win!\n"
+    @output.string.should == "Todd(X) wins!\n"
   end
 
   it "display tied game" do