tic_tac_toe_nhu 0.0.2

data/spec/tic_tac_toe/board_spec.rb

@@ -0,0 +1,186 @@
+require 'tic_tac_toe/spec_helper'
+require 'tic_tac_toe/board'
+
+describe TicTacToe::Board do
+  before(:each) do
+    @player = "X"
+    @size = 3
+    @board = TicTacToe::Board.new(@size)
+  end
+
+  it "clears all the markings for the board" do
+    @board.mark(0, @player)
+    @board.reset
+    @board.squares.should_not include @player
+  end
+
+  context "marking the board" do
+    it "marks the board" do
+      @board.mark(0, @player)
+      @board.available_moves.should_not include 0
+    end
+
+    context "raises an exception" do
+      it "when move is less than the first square" do
+        lambda {@board.mark(-1, @player)}.should raise_error TicTacToe::MoveNotAvailableError
+      end
+
+      it "when move is higher than the last square" do
+        lambda {@board.mark(9, @player)}.should raise_error TicTacToe::MoveNotAvailableError
+      end
+
+      it "when move is already mark" do
+        @board.mark(0, @player)
+        lambda {@board.mark(0, @player)}.should raise_error TicTacToe::MoveNotAvailableError
+      end
+
+    end
+  end
+
+  context "number of moves made" do
+    it "is 0 when there is no move" do
+      @board.number_of_moves.should == 0
+    end
+
+    it "is 1 after user makes a move" do
+      @board.mark(0, @player)
+      @board.number_of_moves.should == 1
+    end
+
+    it "is 9 when user marks all the squares" do
+      mark_all_squares
+      @board.number_of_moves.should == @size**2
+    end
+  end
+
+  it "clears the value" do
+    @board.mark(0, @player)
+    @board.clear(0)
+    @board.available_moves.should include 0
+  end
+
+  context "filled?" do
+    it "is true when all the squares are marked" do
+      mark_all_squares
+      @board.should be_filled
+    end
+
+    it "is false when the board is empty" do
+      @board.should_not be_filled
+    end
+
+    it "is false when all but one squares are marked" do
+      mark_all_squares
+      @board.clear(0)
+      @board.should_not be_filled
+    end
+  end
+
+  context "empty?" do
+
+
+  end
+
+	it "board @size is the @size set" do
+		@board.size.should == @size
+	end
+
+  describe "rows" do
+    it "number of board rows is the same as the board @size" do
+      rows = @board.rows
+      rows.size.should == @size
+    end
+
+    it "the first element in the rows is the first row" do
+      @board.mark(0, @player)
+      rows = @board.rows
+      rows[0].should == [@player, nil, nil]
+    end
+
+    it "returns the rows with the middle element as the middle rows" do
+      @board.mark(3, @player)
+      rows = @board.rows
+      rows[@size/2].should == [@player, nil, nil]
+    end
+
+    it "returns the rows with the last elements as the last rows" do
+      @board.mark(6, @player)
+      rows = @board.rows
+      rows[@size - 1].should == [@player, nil, nil]
+    end
+
+    it "returns an empty row when the squares in the row is not mark" do
+      rows = @board.rows
+      rows[0].should == default_square_sets[0]
+    end
+  end
+
+  describe "columns" do
+    it "returns the columns of the boards" do
+      cols = default_square_sets(3)
+      @board.columns.should == cols
+    end
+
+    it "number of columns is the @size of the board" do
+      @board.columns.size.should == @size
+    end
+  end
+
+  describe "diagonals" do
+    it "returns the diagonal squares" do
+      squares = default_square_sets(2)
+      @board.diagonals.should == squares
+    end
+
+    it "returns the diagonal squares with the marked value" do
+      @board.mark(4, @player)
+      squares = [[nil, @player, nil], [nil, @player, nil]]
+      @board.diagonals.should == squares
+    end
+  end
+
+  describe "available squares" do
+    it "returns all squares when none is marked" do
+      @board.available_moves.should == (0...@size**2).to_a
+    end
+
+    it "doesn't return the marked square" do
+      move = 2
+      @board.mark(move, @player)
+      @board.available_moves.should_not include move
+    end
+
+    it "is empty when all the squares are marked" do
+      mark_all_squares
+      @board.available_moves.should == []
+    end
+  end
+
+  describe "unique marks" do
+    it "returns user marks when user marks the board" do
+      @board.mark(4, @player)
+      @board.unique_marked_values.should == [@player]
+    end
+
+    it "returns two marks when two user marks the board" do
+      @board.mark(4, "X")
+      @board.mark(0, "O")
+      @board.unique_marked_values.should == ["X", "O"]
+    end
+
+    it "returns one mark even though user marks the board twice" do
+      @board.mark(4, @player)
+      @board.mark(0, @player)
+      @board.unique_marked_values.should == [@player]
+    end
+
+  end
+
+  def mark_all_squares
+    (0...@size**2).each {|position| @board.mark(position, @player)}
+  end
+
+  def default_square_sets(size = 1)
+    Array.new(size, Array.new(3))
+  end
+end

data/spec/tic_tac_toe/game_factory_spec.rb

@@ -0,0 +1,78 @@
+require 'tic_tac_toe/spec_helper'
+require 'tic_tac_toe/game_factory'
+require 'tic_tac_toe/player_factory'
+require 'mocks/player_factory'
+
+describe TicTacToe::GameFactory do
+
+  before(:each) do
+    @board = "board"
+    @player_factory = MockPlayerFactory.new
+    @game_factory = TicTacToe::GameFactory.new(@player_factory)
+  end
+
+  it "ensures MockPlayerFactory has the same interface as PlayerFactory" do
+    MockPlayerFactory.should be_substitutable_for(TicTacToe::PlayerFactory)
+  end
+
+  it "returns 4 types of games" do
+    @game_factory.types.size.should == 4
+  end
+
+  it "sets the board in the game" do
+    game = @game_factory.create(1, @board)
+    game.board.should == @board
+  end
+
+  it "returns human vs computer game" do
+    human = "human"
+    computer = "computer"
+    @player_factory.will_have_human human
+    @player_factory.will_have_computer computer
+
+    game = @game_factory.create(1, @board)
+    game.current_player.should == human
+
+    @player_factory.was asked_for :computer
+    @player_factory.was asked_for :human
+  end
+
+  it "returns computer vs human game" do
+    human = "human"
+    computer = "computer"
+    @player_factory.will_have_human human
+    @player_factory.will_have_computer computer
+
+    game = @game_factory.create(2, @board)
+    game.current_player.should == computer
+
+    @player_factory.was asked_for :computer
+    @player_factory.was asked_for :human
+  end
+
+  it "returns user vs user game" do
+    human1 = "mary"
+    human2 = "alice"
+    @player_factory.will_have_human human1, human2
+
+    game = @game_factory.create(3, @board)
+    game.current_player.should == human1
+
+    @player_factory.was asked_for(:human).times(2)
+  end
+
+  it "returns computer vs computer game" do
+    computer1 = "computer1"
+    computer2 = "computer2"
+    @player_factory.will_have_computer computer2, computer1
+
+    game = @game_factory.create(4, @board)
+    game.current_player.should == computer2
+
+    @player_factory.was asked_for(:computer).times(2)
+  end
+
+  it "raises an error when the game type doesn't exist" do
+    lambda{@game_factory.create(5, @board)}.should raise_error(ArgumentError)
+  end
+end

data/spec/tic_tac_toe/game_spec.rb

@@ -0,0 +1,94 @@
+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
+
+    @todd_strategy = MockDynamicStrategy.new
+    @todd = TicTacToe::Player.new("Todd", "X", @todd_strategy)
+
+    @john_strategy = MockDynamicStrategy.new
+    @john = TicTacToe::Player.new("John", "O", @john_strategy)
+
+    @game = TicTacToe::Game.new(@board, @todd, @john)
+  end
+
+  context "marking board" do
+    it "mark the board with user input" do
+      @todd_strategy.add_move(1)
+      @game.make_move
+      @board.unique_marked_values.should include(@todd.value)
+    end
+
+    it "does not mark the board if user doesn't return an input" do
+      @todd_strategy.add_move(nil)
+      @game.make_move
+      @board.unique_marked_values.should_not include(@todd.value)
+    end
+  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], @todd.value)
+      @game.winner.should == @todd
+    end
+
+    it "is John when it is O" do
+      mark_board([0, 1, 2], @john.value)
+      @game.winner.should == @john
+    end
+
+    it "is nil when no one wins" do
+      @game.winner.should be_nil
+    end
+  end
+
+  describe "changes player" do
+    it "doesn't change player if player 1 doesn't return a move" do
+      @game.current_player.should == @todd
+      @todd_strategy.add_move(nil)
+
+      @game.make_move
+      @game.current_player.should == @todd
+    end
+
+    it "changes to player 2 after player 1 moves" do
+      @game.current_player.should == @todd
+      @todd_strategy.add_move(1)
+
+      @game.make_move
+      @game.current_player.should == @john
+    end
+  end
+
+  describe "game over" do
+    it "is over when there is a winner" do
+      mark_board([0, 1, 2], @john.value)
+      @game.should be_over
+    end
+
+    it "is over when there is a tied" do
+      mark_board((0...9).to_a, "i")
+      @game.should be_over
+    end
+
+    it "is not over when there is no mark on the board" do
+      @game.should_not be_over
+    end
+
+    it "is not over when there is no winner or a tied" do
+      mark_board([1, 2], @todd.value)
+      @game.should_not be_over
+    end
+  end
+
+  def mark_board(moves, value)
+    moves.each do |m|
+      @board.mark(m, value)
+    end
+  end
+end

data/spec/tic_tac_toe/main_spec.rb

@@ -0,0 +1,104 @@
+require 'tic_tac_toe/spec_helper'
+require 'tic_tac_toe/main'
+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/ui/console'
+require 'mocks/strategy/dynamic'
+require 'mocks/rules'
+
+describe TicTacToe::Main do
+  before(:each) do
+    @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::Main.new(@ui, @game_factory)
+  end
+
+  context "ensure mock class has the same interface" do
+    it "checks MockGame" do
+      MockGame.should be_substitutable_for(TicTacToe::Game)
+    end
+
+    it "checks console" do
+      MockConsole.should be_substitutable_for(TicTacToe::Console)
+    end
+
+    it "checks game factory" do
+      MockGameFactory.should be_substitutable_for(TicTacToe::GameFactory)
+    end
+  end
+
+  describe "starts game" do
+    it "displays welcome message" do
+      @controller.start
+      @ui.was told_to(:display_welcome_message)
+    end
+
+    it "asked ui to get game type" do
+      @controller.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)
+    end
+  end
+
+  describe "play game" do
+    before(:each) do
+      @game.will_over? false, true
+    end
+
+    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)
+    end
+
+    it "tells game to make a move" do
+      @game.will_over? false, true
+      @controller.start
+      @game.was told_to(:make_move)
+    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)
+    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)
+    end
+  end
+
+  describe "end game" do
+    it "displays the board when the game is over" do
+      @controller.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)
+    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)
+    end
+  end
+end

data/spec/tic_tac_toe/player_factory_mock.rb

@@ -0,0 +1,10 @@
+class PlayerFactoryMock
+
+  def human(name = "User", value = "X")
+    "Human"
+  end
+
+  def computer(board, value = "O", opponent_value = "X")
+    "Computer"
+  end
+end

data/spec/tic_tac_toe/player_factory_spec.rb

@@ -0,0 +1,59 @@
+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'
+
+describe TicTacToe::PlayerFactory do
+
+  before(:each) do
+    @factory = TicTacToe::PlayerFactory.new
+  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
+    end
+
+    it "strategy is console user" do
+      @factory.human.strategy.should be_kind_of(TicTacToe::Strategy::ConsoleUser)
+    end
+
+    it "checks default name" do
+      @factory.human.name.should == "User"
+    end
+
+    it "checks default value" do
+      @factory.human.value.should == "X"
+    end
+  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.value.should == computer_value
+    end
+
+    it "checks default strategy" do
+      @factory.computer(@board).strategy.should be_kind_of(TicTacToe::Strategy::Minimax)
+    end
+
+    it "checks default name" do
+      @factory.computer(@board).name.should == "Computer"
+    end
+
+    it "checks default value" do
+      @factory.computer(@board).value.should == "O"
+    end
+  end
+
+end

data/spec/tic_tac_toe/player_spec.rb

@@ -0,0 +1,32 @@
+require 'tic_tac_toe/spec_helper'
+require 'tic_tac_toe/player'
+require 'tic_tac_toe/strategy/mock'
+
+describe TicTacToe::Player do
+
+  it "gets name" do
+    name = "bruce"
+    player = TicTacToe::Player.new(name, nil, nil)
+    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 = MockStrategy.new([4])
+    player = TicTacToe::Player.new(nil, nil, strategy)
+    player.move.should == move
+  end
+
+  it "gets strategy" do
+    strategy = MockStrategy.new([4])
+    player = TicTacToe::Player.new(nil, nil, strategy)
+    player.strategy.should == strategy
+
+  end
+end