tic_tac_toes 0.0.2 → 0.0.3

data/spec/command_line/menu_spec.rb

@@ -1,73 +1,69 @@
-require 'tic_tac_toes/io_interface'
 require 'command_line/menu'
-require 'tic_tac_toes/medium_ai'
-require 'tic_tac_toes/spec_helper'
+require 'tic_tac_toes/board_factory'
+require 'tic_tac_toes/player_factory'
+require 'tic_tac_toes/io'
+require 'tic_tac_toes/move_strategies/human'
+require 'tic_tac_toes/move_strategies/medium_ai'
 
 describe CommandLine::Menu do
-  let(:io) { double("io") }
-  let(:io_interface) { TicTacToes::IOInterface.new(io) }
-  let(:menu) { CommandLine::Menu.new(io_interface) }
-
+  let(:io) { double }
+  let(:board_factory) { TicTacToes::BoardFactory.new }
+  let(:player_factory) { TicTacToes::PlayerFactory.new(io) }
+  let(:menu) { CommandLine::Menu.new(io, board_factory, player_factory) }
 
   describe '#get_board' do
     let(:invalid_row_size) { 11 }
     let(:valid_row_size) { 7 }
 
-    it "displays an invalid row size error when given an invalid (outside 2-10) row size" do
-      allow(io_interface).to receive(:get_row_size).and_return(invalid_row_size, valid_row_size)
+    it 'displays an invalid row size error when given a row size outside 2-10' do
+      allow(io).to receive(:get_row_size).and_return(invalid_row_size, valid_row_size)
 
-      expect(io_interface).to receive(:invalid_row_size_error)
+      expect(io).to receive(:invalid_row_size_error)
       menu.get_board
     end
 
-    it "only returns a row size once it receives a valid (2-10) row size" do
-      allow(io_interface).to receive(:invalid_row_size_error)
-      allow(io_interface).to receive(:get_row_size).and_return(invalid_row_size, valid_row_size)
+    it 'only returns a row size once it receives a valid (2-10) row size' do
+      allow(io).to receive(:invalid_row_size_error)
+      allow(io).to receive(:get_row_size).and_return(invalid_row_size, valid_row_size)
 
       board = menu.get_board
       expect(board.row_size).to eq(valid_row_size)
     end
   end
 
-
   describe '#get_players' do
-    before(:each) do
-      allow(io).to receive(:blue) { |argument| argument }
-      allow(io).to receive(:red) { |argument| argument }
-    end
-
-    it "returns an array with a human (IO decider) player and a computer (AI decider) player" do
-      first_token, second_token = "X", "O"
+    it 'returns an array with a human player and a computer player' do
+      first_token, second_token = 'X', 'O'
       difficulty = :medium
 
-      allow(io_interface).to receive(:get_token).and_return(first_token, second_token)
-      allow(io_interface).to receive(:get_difficulty).and_return(difficulty)
+      allow(io).to receive(:get_token).and_return(first_token, second_token)
+      allow(io).to receive(:get_difficulty).and_return(difficulty)
 
       human_player, computer_player = menu.get_players
-      expect(human_player.decider).to be_a TicTacToes::IOInterface
-      expect(computer_player.decider).to eq(TicTacToes::MediumAI)
+      expect(human_player.move_strategy).to be_a TicTacToes::MoveStrategies::Human
+      expect(computer_player.move_strategy).to eq(TicTacToes::MoveStrategies::MediumAI)
     end
 
     context 'when given an invalid (non-single-character) token' do
-      let(:invalid_token) { "invalid" }
-      let(:first_token) { "X" }
-      let(:second_token) { "O" }
+      let(:invalid_token) { 'invalid' }
+      let(:first_token) { 'X' }
+      let(:second_token) { 'O' }
 
       before(:each) do
         valid_difficulty = :medium
-        allow(io_interface).to receive(:get_difficulty) { valid_difficulty }
+        allow(io).to receive(:get_difficulty) { valid_difficulty }
       end
 
-      it "displays an invalid token error" do
-        allow(io_interface).to receive(:get_token).and_return(invalid_token, first_token, second_token)
+      it 'displays an invalid token error' do
+        allow(io).to receive(:get_token).and_return(invalid_token, first_token, second_token)
 
-        expect(io_interface).to receive(:invalid_token_error)
+        expect(io).to receive(:invalid_token_error)
         menu.get_players
       end
 
-      it "only returns an array of players (with correct tokens) once it receives a valid token" do
-        allow(io_interface).to receive(:invalid_token_error)
-        allow(io_interface).to receive(:get_token).and_return(invalid_token, first_token, second_token)
+      it 'only returns an array of players (with correct tokens) once it receives a valid token' do
+        allow(io).to receive(:invalid_token_error)
+        allow(io).to receive(:get_token).and_return(invalid_token, first_token, second_token)
 
         first_player, second_player = menu.get_players
         expect(first_player.token).to eq(first_token)
@@ -80,23 +76,23 @@ describe CommandLine::Menu do
       let(:valid_difficulty) { :medium }
 
       before(:each) do
-        first_token, second_token = "X", "O"
-        allow(io_interface).to receive(:get_token).and_return(first_token, second_token)
+        first_token, second_token = 'X', 'O'
+        allow(io).to receive(:get_token).and_return(first_token, second_token)
       end
 
-      it "displays an invalid difficulty error" do
-        allow(io_interface).to receive(:get_difficulty).and_return(invalid_difficulty, valid_difficulty)
+      it 'displays an invalid difficulty error' do
+        allow(io).to receive(:get_difficulty).and_return(invalid_difficulty, valid_difficulty)
 
-        expect(io_interface).to receive(:invalid_difficulty_error)
+        expect(io).to receive(:invalid_difficulty_error)
         menu.get_players
       end
 
-      it "only returns an array of players (with correct difficulty) once it receives a valid difficulty" do
-        allow(io_interface).to receive(:invalid_difficulty_error)
-        allow(io_interface).to receive(:get_difficulty).and_return(invalid_difficulty, valid_difficulty)
+      it 'only returns an array of players (with correct difficulty) once it receives a valid difficulty' do
+        allow(io).to receive(:invalid_difficulty_error)
+        allow(io).to receive(:get_difficulty).and_return(invalid_difficulty, valid_difficulty)
 
         computer_player = menu.get_players.last
-        expect(computer_player.decider).to eq(TicTacToes::MediumAI)
+        expect(computer_player.move_strategy).to eq(TicTacToes::MoveStrategies::MediumAI)
       end
     end
   end

data/spec/command_line/runner_spec.rb

@@ -1,119 +1,41 @@
 require 'command_line/runner'
-require 'tic_tac_toes/board'
-require 'tic_tac_toes/history'
-require 'tic_tac_toes/spec_helper'
 
 describe CommandLine::Runner do
-  let(:io_interface)        { double("io interface",
-                              :draw_board => true,
-                              :thinking_notification => true,
-                              :game_over_notification => true) }
-  let(:board)               { TicTacToes::Board.new(row_size: 3) }
-  let(:menu)                { double("menu",
-                              :get_board => board,
-                              :get_players => true) }
-  let(:rules)               { double("rules",
-                              :game_over? => true,
-                              :determine_winner => "X") }
-  let(:database_interface)  { double("database interface", :record_game_history => true) }
-  let(:history)             { TicTacToes::History.new(database_interface) }
-
-  let(:runner)              { CommandLine::Runner.new(io_interface, menu, rules, history) }
-
-
   describe '#run' do
-    it "gets a board and players" do
-      expect(menu).to receive(:get_board)
-      expect(menu).to receive(:get_players)
+    let(:game_state) { double(board: 'board', players: 'players', game_over: true) }
+
+    let(:io)                  { double(draw_board: true,
+                                       thinking_notification: true,
+                                       game_over_notification: true) }
+    let(:menu)                { double(get_board: true,
+                                       get_players: true) }
+    let(:game_state)          { double(board: 'board',
+                                       players: 'players',
+                                       game_over: true) }
+    let(:game_state_factory)  { double(generate_game_state: game_state) }
+    let(:rules)               { double(game_over?: true,
+                                       determine_winner: true) }
+
+    let(:runner)              { CommandLine::Runner.new(io,
+                                                        menu,
+                                                        game_state_factory,
+                                                        rules) }
+
+    it 'gets an initial game state' do
+      expect(game_state_factory).to receive(:generate_game_state)
       runner.run
     end
 
-    it "has its history object record the board size" do
-      runner.run
-      expect(history.board_size).to eq(board.size)
-    end
-
-    it "takes turns until the game is over" do
+    it 'takes turns until the game is over' do
       allow(rules).to receive(:game_over?).and_return(false, true)
 
       expect(runner).to receive(:take_turn).once
       runner.run
     end
 
-    it "ends the game when the game is over" do
+    it 'ends the game when the game is over' do
       expect(runner).to receive(:end_game)
       runner.run
     end
   end
-
-
-  describe '#take_turn' do
-    move = ["X", 0]
-    let(:board) { double("board") }
-    let(:first_player) { double("first player", make_move: move, needs_to_think: true) }
-    let(:second_player) { double("second player", make_move: move, needs_to_think: false) }
-    let(:players) { [first_player, second_player] }
-
-    it "draws the board" do
-      expect(io_interface).to receive(:draw_board)
-      runner.take_turn(board, players)
-    end
-
-    it "displays a thinking notification if the current player needs to think" do
-      expect(io_interface).to receive(:thinking_notification)
-      runner.take_turn(board, players)
-
-      expect(io_interface).not_to receive(:thinking_notification)
-      runner.take_turn(board, players)
-    end
-
-    it "asks the first player to make a move" do
-      expect(first_player).to receive(:make_move)
-      runner.take_turn(board, players)
-    end
-
-    it "has its history object record the move" do
-      runner.take_turn(board, players)
-      expect(history.moves.first).to eql(move)
-    end
-
-    it "keeps track of the current player by rotating the players" do
-      runner.take_turn(board, players)
-      expect(second_player).to receive(:make_move)
-      runner.take_turn(board, players)
-    end
-  end
-
-
-  describe '#end_game' do
-    let(:board) { double("board") }
-    let(:players) { double("players") }
-
-    it "draws the board" do
-      expect(io_interface).to receive(:draw_board)
-      runner.end_game(board, players)
-    end
-
-    it "determines the winner" do
-      expect(rules).to receive(:determine_winner)
-      runner.end_game(board, players)
-    end
-
-    it "displays the winner" do
-      allow(rules).to receive(:determine_winner) { :winner }
-
-      expect(io_interface).to receive(:game_over_notification).with(:winner)
-      runner.end_game(board, players)
-    end
-
-    it "has its history object record the winner" do
-      runner.end_game(board, players)
-      expect(history.winner).to eq("X")
-    end
-
-    it "has its history object persist the game history" do
-      expect(history).to receive(:persist)
-      runner.end_game(board, players)
-    end
-  end
 end

data/spec/database/pg_wrapper_spec.rb

@@ -1,6 +1,5 @@
 require 'database/pg_wrapper'
 require 'pg'
-require 'tic_tac_toes/spec_helper'
 
 describe Database::PGWrapper do
   database = "tic_tac_toes_test"

data/spec/test_board_generator.rb

@@ -0,0 +1,15 @@
+require 'tic_tac_toes/board'
+
+module TestBoardGenerator
+  def self.generate(structure)
+    board_size = structure.count
+    row_size = Math.sqrt(board_size)
+    board = TicTacToes::Board.new(row_size: row_size)
+
+    structure.each_with_index do |player, index|
+      board.place(player, index)
+    end
+
+    board
+  end
+end

data/spec/tic_tac_toes/board_factory_spec.rb

@@ -0,0 +1,13 @@
+require 'tic_tac_toes/board_factory'
+
+describe TicTacToes::BoardFactory do
+  describe '#generate_board' do
+    it 'returns a board object generated from a row size' do
+      board_factory = TicTacToes::BoardFactory.new
+      row_size = 5
+
+      board = board_factory.generate_board(row_size)
+      expect(board.row_size).to eq(row_size)
+    end
+  end
+end

data/spec/tic_tac_toes/board_spec.rb

@@ -1,4 +1,4 @@
-require 'tic_tac_toes/spec_helper'
+require 'test_board_generator'
 require 'tic_tac_toes/board'
 
 describe TicTacToes::Board do
@@ -28,10 +28,9 @@ describe TicTacToes::Board do
 
   describe '#open_spaces' do
     it "returns an array of the board's nil spaces" do
-      structure = [:X, :O, nil,
-                   :O, :O,  :X,
-                   :X, :X, nil]
-      board = generate_board(structure)
+      board = TestBoardGenerator.generate([:X, :O, nil,
+                                           :O, :O,  :X,
+                                           :X, :X, nil])
       open_spaces = [2, 8]
 
       expect(board.open_spaces).to eql(open_spaces)
@@ -41,11 +40,10 @@ describe TicTacToes::Board do
 
   describe '#rows' do
     it "returns an array of row arrays based on the board's spaces" do
-      structure = [ :X,  :X,  :X,  :X,
-                   nil, nil, nil, nil,
-                   nil, nil, nil, nil,
-                   nil, nil, nil, nil]
-      board = generate_board(structure)
+      board = TestBoardGenerator.generate([ :X,  :X,  :X,  :X,
+                                           nil, nil, nil, nil,
+                                           nil, nil, nil, nil,
+                                           nil, nil, nil, nil])
       first_row = [:X, :X, :X, :X]
 
       expect(board.rows.size).to eq(4)
@@ -56,11 +54,10 @@ describe TicTacToes::Board do
 
   describe '#columns' do
     it "returns an array of column arrays based on the board's spaces" do
-      structure = [:X, nil, nil, nil,
-                   :X, nil, nil, nil,
-                   :X, nil, nil, nil,
-                   :X, nil, nil, nil]
-      board = generate_board(structure)
+      board = TestBoardGenerator.generate([:X, nil, nil, nil,
+                                           :X, nil, nil, nil,
+                                           :X, nil, nil, nil,
+                                           :X, nil, nil, nil])
       first_column = [:X, :X, :X, :X]
 
       expect(board.columns.size).to eq(4)
@@ -71,12 +68,11 @@ describe TicTacToes::Board do
 
   describe '#diagonals' do
     it "returns an array of diagonal arrays based on the board's spaces" do
-      structure = [ :X, nil, nil,  :O,
-                   nil,  :X,  :O, nil,
-                   nil,  :O,  :X, nil,
-                    :O, nil, nil,  :X]
-      board = generate_board(structure)
-      back_diagonal = [:X, :X, :X, :X]
+      board = TestBoardGenerator.generate([ :X, nil, nil,  :O,
+                                           nil,  :X,  :O, nil,
+                                           nil,  :O,  :X, nil,
+                                            :O, nil, nil,  :X])
+      back_diagonal  = [:X, :X, :X, :X]
       front_diagonal = [:O, :O, :O, :O]
 
       expect(board.diagonals.size).to eq(2)
@@ -93,10 +89,9 @@ describe TicTacToes::Board do
     end
 
     it "returns true if all spaces are non-nil" do
-      structure = [:X, :O, :X,
-                   :O, :X, :O,
-                   :X, :O, :X]
-      board = generate_board(structure)
+      board = TestBoardGenerator.generate([:X, :O, :X,
+                                           :O, :X, :O,
+                                           :X, :O, :X])
 
       expect(board.full?).to be true
     end

data/spec/tic_tac_toes/game_state_factory_spec.rb

@@ -0,0 +1,15 @@
+require 'tic_tac_toes/game_state_factory'
+
+describe TicTacToes::GameStateFactory do
+  describe '#generate_game_state' do
+    it 'returns a game state object generated from a board object and player array' do
+      history = double(record_board_size: true)
+      game_state_factory = TicTacToes::GameStateFactory.new(history)
+      board, players = double(size: 3), double
+
+      game_state = game_state_factory.generate_game_state(board, players)
+      expect(game_state.board).to eq(board)
+      expect(game_state.players).to eq(players)
+    end
+  end
+end

data/spec/tic_tac_toes/game_state_spec.rb

@@ -0,0 +1,66 @@
+require 'tic_tac_toes/game_state'
+
+describe TicTacToes::GameState do
+  describe '@initialize' do
+    it "records its board's size" do
+      size = 5
+      board = double(size: size)
+      history = double
+
+      expect(history).to receive(:record_board_size).with(size)
+      TicTacToes::GameState.new(board, 'players', history)
+    end
+  end
+
+  describe '#current_player' do
+    it 'returns the first item of its players array' do
+      history = double(record_board_size: true)
+      players = ['first_player', 'second_player']
+      game_state = TicTacToes::GameState.new('board', players, history)
+
+      current_player = game_state.current_player
+      expect(current_player).to eq('first_player')
+    end
+  end
+
+  describe '#turn_over' do
+    it 'records the last move' do
+      move = double
+      players = double(rotate!: true)
+      history = double(record_board_size: true)
+      game_state = TicTacToes::GameState.new('board', players, history)
+
+      expect(history).to receive(:record_move).with(move)
+      game_state.turn_over(move)
+    end
+
+    it 'rotates its player array' do
+      players = ['first_player', 'second_player']
+      history = double(record_board_size: true, record_move: true)
+      game_state = TicTacToes::GameState.new('board', players, history)
+
+      game_state.turn_over('move')
+      expect(game_state.current_player).to eq('second_player')
+    end
+  end
+
+  describe '#game_over' do
+    it 'records the winner' do
+      winner = double
+      history = double(record_board_size: true, persist: true)
+      game_state = TicTacToes::GameState.new('board', 'players', history)
+
+      expect(history).to receive(:record_winner).with(winner)
+      game_state.game_over(winner)
+    end
+
+    it 'persists its history' do
+      winner = double
+      history = double(record_board_size: true, record_winner: true)
+      game_state = TicTacToes::GameState.new('board', 'players', history)
+
+      expect(history).to receive(:persist)
+      game_state.game_over(winner)
+    end
+  end
+end

data/spec/tic_tac_toes/history_spec.rb

@@ -1,9 +1,8 @@
-require 'tic_tac_toes/spec_helper'
 require 'tic_tac_toes/history'
 
 describe TicTacToes::History do
-  let(:database_interface) { double("database interface", :record_game_history => true) }
-  let(:history) { TicTacToes::History.new(database_interface) }
+  let(:database_wrapper)  { double("database wrapper", :record_game_history => true) }
+  let(:history)           { TicTacToes::History.new(database_wrapper) }
 
   describe '#record_board_size' do
     it "records the passed board size" do
@@ -34,7 +33,7 @@ describe TicTacToes::History do
 
   describe '#persist' do
     it "sends the history instance to its database interface for storage" do
-      expect(database_interface).to receive(:record_game_history).with history
+      expect(database_wrapper).to receive(:record_game_history).with history
       history.persist
     end
   end

data/spec/tic_tac_toes/io_spec.rb

@@ -0,0 +1,163 @@
+require 'tic_tac_toes/board'
+require 'tic_tac_toes/io'
+require 'tic_tac_toes/strings'
+
+describe TicTacToes::IO do
+  let(:strings)  { TicTacToes::Strings }
+  let(:prompt)   { double("prompt", solicit_input: 0, display: true, display_red: true) }
+  let(:io)       { TicTacToes::IO.new(prompt) }
+
+  describe '#get_row_size' do
+    it "displays a row size solicitation" do
+      expect(io).to receive(:row_size_solicitation)
+      io.get_row_size
+    end
+
+    context 'when given not-integer-like input' do
+      let(:not_integer_like)  { "string" }
+      let(:integer_like)      { "100" }
+
+      it "displays a not an integer error" do
+        allow(prompt).to receive(:solicit_input).and_return(not_integer_like, integer_like)
+
+        expect(io).to receive(:not_an_integer_error).once
+        io.get_row_size
+      end
+
+      it "only returns a row size (converted to integer) once it gets integer-like input" do
+        allow(prompt).to receive(:solicit_input).and_return(not_integer_like, integer_like)
+
+        expect(io.get_row_size).to eq(100)
+      end
+    end
+  end
+
+
+  describe '#get_token' do
+    let(:player) { double("player") }
+
+    it "displays a token solicitation with the name of the player whose token is to be set" do
+      expect(io).to receive(:token_solicitation).with(player)
+      io.get_token(player)
+    end
+
+    it "returns the user input" do
+      token = "X"
+      allow(prompt).to receive(:solicit_input) { token }
+
+      expect(io.get_token(player)).to equal(token)
+    end
+  end
+
+
+  describe '#get_difficulty' do
+    let(:difficulty) { "HARD" }
+
+    it "displays a difficulty solicitation" do
+      allow(prompt).to receive(:solicit_input) { difficulty }
+
+      expect(io).to receive(:difficulty_solicitation)
+      io.get_difficulty
+    end
+
+    it "returns the user input (downcased and converted into a symbol)" do
+      allow(prompt).to receive(:solicit_input) { difficulty }
+
+      expect(io.get_difficulty).to equal(:hard)
+    end
+  end
+
+
+  describe '#draw_board' do
+    it "displays a board string" do
+      board = TicTacToes::Board.new
+      board_string = strings.board(board)
+
+      expect(prompt).to receive(:display).with(board_string)
+      io.draw_board(board)
+    end
+  end
+
+
+  describe '#invalid_row_size_error' do
+    it "displays a red invalid row size message" do
+      expect(prompt).to receive(:display_red).with(strings::INVALID_ROW_SIZE)
+      io.invalid_row_size_error
+    end
+  end
+
+
+  describe '#invalid_token_error' do
+    it "displays a red invalid token message" do
+      expect(prompt).to receive(:display_red).with(strings::INVALID_TOKEN)
+      io.invalid_token_error
+    end
+  end
+
+
+  describe '#invalid_difficulty_error' do
+    it "displays a red invalid difficulty message" do
+      expect(prompt).to receive(:display_red).with(strings::INVALID_DIFFICULTY)
+      io.invalid_difficulty_error
+    end
+  end
+
+
+  describe '#invalid_move_error' do
+    it "displays a red invalid move message" do
+      expect(prompt).to receive(:display_red).with(strings::INVALID_MOVE)
+      io.invalid_move_error
+    end
+  end
+
+
+  describe '#thinking_notification' do
+    it "displays a red thinking message" do
+      expect(prompt).to receive(:display_red).with(strings::THINKING)
+      io.thinking_notification
+    end
+  end
+
+
+  describe '#game_over_notification' do
+    it "displays a game over message with the name of the winner" do
+      winner = :X
+      game_over_message = strings.game_over_notification(winner)
+
+      expect(prompt).to receive(:display).with(game_over_message)
+      io.game_over_notification(winner)
+    end
+  end
+
+
+  describe '#move_solicitation' do
+    it "displays a move solicitation message" do
+      expect(prompt).to receive(:display).with(strings::MOVE_SOLICITATION)
+      io.move_solicitation
+    end
+  end
+
+
+  describe '#not_an_integer_error' do
+    it "displays a red not an integer message" do
+      expect(prompt).to receive(:display_red).with(strings::NOT_AN_INTEGER)
+      io.not_an_integer_error
+    end
+  end
+
+
+  describe '#red' do
+    it "calls its IO's red method with the passed message" do
+      expect(io).to receive(:red).with("message")
+      io.red("message")
+    end
+  end
+
+
+  describe '#blue' do
+    it "calls its IO's blue method with the passed message" do
+      expect(io).to receive(:blue).with("message")
+      io.blue("message")
+    end
+  end
+end