tic_tac_toe_nhu 0.0.11 → 0.1.0

data/spec/tic_tac_toe/player_factory_spec.rb

@@ -2,58 +2,51 @@ 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
-
   before(:each) do
     @factory = TicTacToe::PlayerFactory.new
+    @value = TicTacToe::VALUES[0]
+  end
+
+  it "checks player types" do
+    [:human, :computer] == @factory.types
   end
 
-  context "console player" do
-    it "returns a console player with passed in values" do
-      name = "Billy"
-      value = "bill"
-      player = @factory.human(name, value)
-      player.name.should == name
-      player.value.should == value
+  context "human player" do
+    before(:each) do
+      @human = @factory.create(:human, @value)
     end
 
     it "strategy is console user" do
-      @factory.human.strategy.should be_kind_of(TicTacToe::Strategy::ConsoleUser)
+      @human.strategy.should be_kind_of(TicTacToe::Strategy::ConsoleUser)
     end
 
-    it "checks default name" do
-      @factory.human.name.should == "User"
+    it "checks name" do
+      @human.name.should == "User"
     end
 
-    it "checks default value" do
-      @factory.human.value.should == "X"
+    it "checks value" do
+      @human.value.should == @value
     end
   end
 
   context "computer player" do
     before(:each) do
-      @board = "fake board"
+      @computer = @factory.create(:computer, @value)
     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.value.should == computer_value
+    it "checks strategy" do
+      @computer.strategy.should be_kind_of(TicTacToe::Strategy::Minimax)
     end
 
-    it "checks default strategy" do
-      @factory.computer(@board).strategy.should be_kind_of(TicTacToe::Strategy::Minimax)
+    it "checks name" do
+      @computer.name.should == "Computer"
     end
 
-    it "checks default name" do
-      @factory.computer(@board).name.should == "Computer"
-    end
-
-    it "checks default value" do
-      @factory.computer(@board).value.should == "O"
+    it "checks value" do
+      @computer.value.should == @value
     end
   end
-
 end

data/spec/tic_tac_toe/player_spec.rb

@@ -1,32 +1,27 @@
 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
 end

data/spec/tic_tac_toe/runner_spec.rb

@@ -1,95 +1,88 @@
 require 'tic_tac_toe/spec_helper'
 require 'tic_tac_toe/runner'
-require 'tic_tac_toe/player'
-require 'tic_tac_toe/game'
-require 'tic_tac_toe/rules'
-require 'tic_tac_toe/board'
-require 'mocks/game'
+
 require 'mocks/game_factory'
+require 'mocks/game'
 require 'mocks/ui/console'
-require 'mocks/strategy/dynamic'
-require 'mocks/rules'
+require 'mocks/player'
 
 describe TicTacToe::Runner do
+  attr_reader :game, :ui, :game_state, :game_state_factory
+
   before(:each) do
+    @game_state = MockGame.factory
+    @game_state_factory = MockGameFactory.factory create: game_state
     @ui = MockConsole.factory
-    @todd = TicTacToe::Player.new("Todd", "X", MockDynamicStrategy.new([1,2,3]))
-    @game = MockGame.factory current_player: @todd, winner: @todd
-    @game_factory = MockGameFactory.factory create: @game
-    @controller = TicTacToe::Runner.new(@ui, @game_factory)
+    @game = TicTacToe::Runner.new(@ui, @game_state_factory)
   end
 
-  describe "starts game" do
-    it "displays welcome message" do
-      @controller.start
-      @ui.was told_to(:display_welcome_message)
-    end
+  it "displays a welcome message" do
+    game.start
+    ui.was told_to(:display_welcome_message)
+  end
 
-    it "asked ui to get game type" do
-      @controller.start
+  describe "create game state" do
+    it "asks user for a game type" do
+      game.start
       @ui.was asked_for(:game_type)
     end
 
-    it "creates a game based on user input" do
-      @controller.start
-      @game_factory.was told_to(:create)
+    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 "asks ui for game type again if the input is incorrect" do
-      @game_factory.will_create ArgumentError.new, @game
-      @controller.start
+      game_state_factory.will_create ArgumentError.new, game_state
+      game.start
+      ui.was asked_for(:game_type).times(2)
     end
   end
 
   describe "play game" do
-    before(:each) do
-      @game.will_over? false, true
-    end
+    attr_reader :player
 
-    it "display board" do
-      @controller.start
-      @ui.was told_to(:display_board)
-    end
-
-    it "displays whose turn it is" do
-      @controller.start
-      @ui.was told_to(:display_player_turn).with(@todd)
+    before(:each) do
+      @player = MockPlayer.new
+      game_state.will_game_over? false, true
+      game_state.will_have_current_player @player
     end
 
-    it "tells game to make a move" do
-      @game.will_over? false, true
-      @controller.start
-      @game.was told_to(:make_move)
+    it "displays the board" do
+      game.start
+      ui.was told_to(:display_board)
     end
 
-    it "asks for game move until game is over" do
-      @game.will_over? false, false, false, true
-      @controller.start
-      @game.was told_to(:make_move).times(3)
+    it "tells ui to display player turn" do
+      game.start
+      ui.was told_to(:display_player_turn).with(player)
     end
 
-    it "displays message when square is not available" do
-      @game.will_make_move TicTacToe::MoveNotAvailableError.new
-      @controller.start
-      @ui.was told_to(:display_square_not_available)
+    it "tells player to move again if there is an error" do
+      game_state.will_make_player_move TicTacToe::MoveNotAvailableError.new, nil
+      game.start
+      game_state.was told_to(:make_player_move).times(2)
     end
   end
 
   describe "end game" do
-    it "displays the board when the game is over" do
-      @controller.start
-      @ui.was told_to(:display_board)
+    it "display a board at the end of the game" do
+      game.start
+      ui.was told_to(:display_board)
     end
 
-    it "notifies user when player wins" do
-      @controller.start
-      @ui.was told_to(:display_winner).with(@todd)
+    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 "notifies user when it's a tied game" do
-      @game.will_have_winner nil
-      @controller.start
-      @ui.was told_to(:display_tied_game)
+    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/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)