tactical_tic_tac_toe 0.1.1

data/spec/board_spec.rb

@@ -0,0 +1,374 @@
+require "spec_helper"
+require "board"
+
+module TicTacToe
+  describe Board do
+    include_context "default_values"
+    include_context "helper_methods"
+
+    let(:board_error) { Board::BoardError }
+    let(:_) { Board.blank_mark }
+    let(:x) { @default_player_marks.first }
+    let(:o) { @default_player_marks.last }
+
+    describe ".blank_mark" do
+      it "returns the mark used by board to indicate a blank cell" do
+        board = blank_board(@default_board_size)
+
+        board.all_coordinates.each do |coordinates|
+          expect(board.read_cell(*coordinates)).to eq Board.blank_mark
+        end
+      end
+    end
+
+    describe "#initialize" do
+      it "raises error if given size is less than 3" do
+        error_info = [board_error, "Given size is too small, must be 3 or greater"]
+
+        expect { new_board(size: 2) }.to raise_error(*error_info)
+      end
+
+      context "given the configuration of a board with preexisting marks" do
+        let(:config) do
+          [ x, _, _,
+            _, o, _,
+            _, _, x ]
+        end
+
+        it "generates a board with the specified marks in each cell" do
+          board = new_board(size: Math.sqrt(config.size).to_i, config: config)
+
+          board.all_coordinates.zip(config).each do |coordinates, mark|
+            expect(board.read_cell(*coordinates)).to eq mark
+          end
+        end
+
+        it "raises error if given configuration does not reconcile with given size" do
+          error_info = [board_error, "Given size does not reconcile with given configuration"]
+          params = {
+            size: Math.sqrt(config.size).to_i + 1,
+            config: config
+          }
+
+          expect { new_board(params) }.to raise_error(*error_info)
+        end
+      end
+
+      context "when not given a configuration of a board with preexisting marks" do
+        it "generates a NxN board of the given size" do
+          (3..5).each do |size|
+            custom_board = new_board(size: size)
+
+            expect(custom_board.size).to eq size
+            expect(custom_board.all_coordinates.count).to eq size**2
+          end
+        end
+
+        it "leaves the generated board blank" do
+          expect(new_board(size: @default_board_size).all_blank?).to be true
+        end
+      end
+    end
+
+    describe "#read_cell" do
+      it "gets the contents of cell at given row and column" do
+        mark = @default_player_marks.sample
+        config = blank_board_configuration(@default_board_size)
+        config[0] = mark
+        board = build_board(config)
+
+        expect(board.read_cell(0, 0)).to eq mark
+      end
+
+      it "raises error if cell coordinates are out of bounds" do
+        error_info = [board_error, "Cell coordinates are out of bounds"]
+        board = blank_board(@default_board_size)
+        oob_coordinates = [board.size, board.size]
+
+        expect { board.read_cell(*oob_coordinates) }.to raise_error(*error_info)
+      end
+    end
+
+    describe "#mark_cell" do
+      let(:board) { blank_board(@default_board_size) }
+      let(:coordinates) { random_coordinates(board.size) }
+      let(:mark) { @default_player_marks.sample }
+
+      it "sets the contents of an empty cell at the given row and column" do
+        board.mark_cell(mark, *coordinates)
+
+        expect(board.read_cell(*coordinates)).to eq mark
+      end
+
+      it "records the coordinates of the last mark made" do
+        board.mark_cell(mark, *coordinates)
+
+        expect(board.last_move_made).to eq coordinates
+      end
+
+      it "raises error if cell coordinates are out of bounds" do
+        error_info = [board_error, "Cell coordinates are out of bounds"]
+        oob_coordinates = [board.size, board.size]
+
+        expect { board.mark_cell(mark, *oob_coordinates)}.to raise_error(*error_info)
+      end
+
+      it "raises error when attempting to change contents of non-empty cell" do
+        error_info = [board_error, "Cannot alter a marked cell"]
+        board.mark_cell(mark, *coordinates)
+
+        expect { board.mark_cell(mark, *coordinates) }.to raise_error(*error_info)
+      end
+    end
+
+    describe "#lines" do
+      let(:board) { blank_board(@default_board_size) }
+
+      it "returns the contents of every board-length line (rows, cols, and diagonals)" do
+        lines = board.lines
+
+        lines.each do |line|
+          expect(line.count).to eq board.size
+        end
+        expect(lines.count).to eq board.size * 2 + 2
+      end
+    end
+
+    describe "#all_coordinates" do
+      let(:board) { blank_board(@default_board_size) }
+
+      it "returns the coordinates of every cell in board" do
+        all_coordinates = (0...board.size).to_a.repeated_permutation(2).to_a
+
+        expect(board.all_coordinates).to match_array all_coordinates
+      end
+    end
+
+    describe "#blank_cell_coordinates" do
+      it "returns all cell coordinates when board is blank" do
+        board = blank_board(@default_board_size)
+
+        expect(board.blank_cell_coordinates).to match_array board.all_coordinates
+      end
+
+      it "returns the coordinates of all blank cells in board" do
+        config = [x, o, _, _, _, _, _, _, _].shuffle
+        board = build_board(config)
+        unmarked_coordinates = board.all_coordinates.reject { |coords| board.marked?(coords) }
+
+        expect(board.blank_cell_coordinates).to match_array unmarked_coordinates
+      end
+
+      it "returns no coordinates when no cells are blank" do
+        config = [x, o, x, o, x, o, x, o, x].shuffle
+        board = build_board(config)
+
+        expect(board.blank_cell_coordinates.count).to eq 0
+      end
+    end
+
+    describe "#last_mark_made" do
+      context "when board is blank" do
+        it "returns nil" do
+          expect(blank_board(@default_board_size).last_mark_made).to be nil
+        end
+      end
+
+      context "when board is not blank" do
+        it "returns the last mark made on the board" do
+          board = blank_board(@default_board_size)
+          mark = @default_player_marks.sample
+          board.mark_cell(mark, *random_coordinates(board.size))
+
+          expect(board.last_mark_made).to eq mark
+        end
+      end
+    end
+
+    describe "#deep_copy" do
+      it "returns a new board" do
+        board = blank_board(@default_board_size)
+        board_copy = board.deep_copy
+
+        expect(board).not_to eq board_copy
+      end
+
+      it "returns a board that has the same marks as called board" do
+        config = [x, o, x, o, x, o, _, _, _].shuffle
+        board = build_board(config)
+        board_copy = board.deep_copy
+
+        board.all_coordinates.each do |coordinates|
+          expect(board.read_cell(*coordinates)).to eq board_copy.read_cell(*coordinates)
+        end
+      end
+
+      it "returns a board which references cells that are not those of called board" do
+        board = blank_board(@default_board_size)
+        board_copy = board.deep_copy
+        coordinates = random_coordinates(board.size)
+        board.mark_cell(@default_player_marks.first, *coordinates)
+
+        expect(board.read_cell(*coordinates)).not_to eq board_copy.read_cell(*coordinates)
+      end
+    end
+
+    describe "#blank?" do
+      it "returns true if cell at given coordinates is blank" do
+        board = blank_board(@default_board_size)
+
+        expect(board.blank?(random_coordinates(board.size))).to be true
+      end
+
+      it "returns false if cell at given coordinates is not blank" do
+        board = blank_board(@default_board_size)
+        coordinates = random_coordinates(board.size)
+        board.mark_cell(@default_player_marks.sample, *coordinates)
+
+        expect(board.blank?(coordinates)).to be false
+      end
+    end
+
+    describe "#marked?" do
+      it "returns true if cell at given coordinates has any player's mark" do
+        board = blank_board(@default_board_size)
+        coordinates = random_coordinates(board.size)
+        board.mark_cell(@default_player_marks.sample, *coordinates)
+
+        expect(board.marked?(coordinates)).to be true
+      end
+
+      it "returns false if cell at given coordinates does not have a player's mark" do
+        blank_board = blank_board(@default_board_size)
+        coordinates = random_coordinates(blank_board.size)
+
+        expect(blank_board.marked?(coordinates)).to be false
+      end
+    end
+
+    describe "#out_of_bounds?" do
+      it "returns true if given coordinates are not within bounds of board" do
+        board = blank_board(@default_board_size)
+        coordinates = [0, board.size]
+
+        expect(board.out_of_bounds?(coordinates)).to be true
+      end
+
+      it "returns false if given coordinates are within bounds of board" do
+        board = blank_board(@default_board_size)
+
+        board.all_coordinates.each do |coordinates|
+          expect(board.out_of_bounds?(coordinates)).to be false
+        end
+      end
+    end
+
+    describe "#all_blank?" do
+      it "returns true if no cell in board is marked" do
+        board = blank_board(@default_board_size)
+
+        expect(board.all_blank?).to be true
+      end
+
+      it "returns false if any cell in board is marked" do
+        config = [x, _, _, _, _, _, _, _, _].shuffle
+        board = build_board(config)
+
+        expect(board.all_blank?).to be false
+      end
+    end
+
+    describe "#all_marked?" do
+      it "returns true if all cells in board are marked" do
+        config = [x, x, x, x, x, o, o, o, o].shuffle
+        board = build_board(config)
+
+        expect(board.all_marked?).to be true
+      end
+
+      it "returns false if any cell in board is blank" do
+        config = [x, x, x, x, _, o, o, o, o].shuffle
+        board = build_board(config)
+
+        expect(board.all_marked?).to be false
+      end
+    end
+
+    describe "#has_winning_line?" do
+      it "returns true if board has a horizontal winning line" do
+        winning_configs = [
+          [ x, x, x,
+            _, _, _,
+            _, _, _ ],
+          [ _, _, _,
+            x, x, x,
+            _, _, _ ],
+          [ _, _, _,
+            _, _, _,
+            x, x, x ]
+        ]
+
+        winning_configs.each do |config|
+          expect(build_board(config).has_winning_line?).to be true
+        end
+      end
+
+      it "returns true if board has a vertical winning line" do
+        winning_configs = [
+          [ x, _, _,
+            x, _, _,
+            x, _, _ ],
+          [ _, x, _,
+            _, x, _,
+            _, x, _ ],
+          [ _, _, x,
+            _, _, x,
+            _, _, x ]
+        ]
+
+        winning_configs.each do |config|
+          expect(build_board(config).has_winning_line?).to be true
+        end
+      end
+
+      it "returns true if board has a diagonal winning line" do
+        winning_configs = [
+          [ x, _, _,
+            _, x, _,
+            _, _, x ],
+          [ _, _, x,
+            _, x, _,
+            x, _, _ ]
+        ]
+
+        winning_configs.each do |config|
+          expect(build_board(config).has_winning_line?).to be true
+        end
+      end
+
+      it "returns false if board has no winning line" do
+        non_winning_configs = [
+          [ _, _, _,
+            _, _, _,
+            _, _, _ ],
+          [ _, _, _,
+            x, x, o,
+            _, _, _ ],
+          [ x, _, _,
+            x, _, _,
+            o, _, _ ],
+          [ x, _, _,
+            _, x, _,
+            _, _, o ],
+          [ x, o, x,
+            x, o, x,
+            o, x, o ]
+        ]
+
+        non_winning_configs.each do |config|
+          expect(build_board(config).has_winning_line?).to be false
+        end
+      end
+    end
+  end
+end

data/spec/command_line_interface_spec.rb

@@ -0,0 +1,167 @@
+require "spec_helper"
+require "command_line_interface"
+
+require "board"
+
+module TicTacToe
+  describe CommandLineInterface do
+    include_context "default_values"
+    include_context "helper_methods"
+
+    let(:input_stream) { StringIO.new }
+    let(:output_stream) { StringIO.new }
+    let(:interface) do
+      parameters = { input: input_stream, output: output_stream }
+      CommandLineInterface.new(parameters)
+    end
+
+    describe "#game_setup_interaction" do
+      before do
+        input_stream.string = %w(human computer).join("\n")
+      end
+
+      it "prints an introductory message to the command line" do
+        interface.game_setup_interaction(@default_player_marks)
+
+        expect(output_stream.string).not_to eq ""
+      end
+
+      it "returns the player type associated with each of the given player marks" do
+        player_types = interface.game_setup_interaction(@default_player_marks)
+
+        expect(player_types).to have(2).things
+        player_types.each do |type|
+          expect(@default_player_types).to include type
+        end
+      end
+    end
+
+    describe "#solicit_player_type" do
+      let(:valid_input) { "human" }
+
+      it "prints a prompt to the command line" do
+        input_stream.string = valid_input
+        interface.solicit_player_type(@default_first_player)
+
+        expect(output_stream.string).not_to eq ""
+      end
+
+      context "when given valid input" do
+        it "returns the player type input by user" do
+          input_stream.string = valid_input
+
+          expect(interface.solicit_player_type(@default_first_player)).to eq valid_input.to_sym
+        end
+      end
+
+      context "when given invalid input" do
+        let(:invalid_input) { "foo" }
+
+        it "prompts the user until given valid input" do
+          input_stream.string = invalid_input + "\n" + invalid_input + "\n" + valid_input
+          interface.solicit_player_type(@default_first_player)
+
+          expect(at_least_one_repeated_line?(output_stream.string)).to be true
+        end
+      end
+    end
+
+    describe "#show_game_board" do
+      it "prints a respresentation of the given board to the command line" do
+        board = board_with_draw(@default_board_size, @default_player_marks)
+        interface.show_game_board(board)
+
+        board_characters = output_stream.string.split("")
+        cell_count = board.size**2
+        expected_first_mark_count = cell_count.odd? ? cell_count / 2 + 1 : cell_count / 2
+        expected_second_mark_count = cell_count / 2
+
+        expect(board_characters.count(@default_first_player.to_s)).to eq expected_first_mark_count
+        expect(board_characters.count(@default_second_player.to_s)).to eq expected_second_mark_count
+      end
+    end
+
+    describe "solicit_move" do
+      let(:valid_input) { "0, 0" }
+
+      it "prints a prompt to the command line" do
+        input_stream.string = valid_input
+        interface.solicit_move(@default_first_player)
+
+        expect(output_stream.string).not_to eq ""
+      end
+
+      context "when given valid input" do
+        it "returns the move coordinates input by user" do
+          input_stream.string = valid_input
+          valid_coordinate = valid_input.split(",").map(&:to_i)
+
+          expect(interface.solicit_move(@default_first_player)).to eq valid_coordinate
+        end
+      end
+
+      context "when given invalid input" do
+        let(:invalid_input) { "foo" }
+
+        it "prompts the user until given valid input" do
+          input_stream.string = invalid_input + "\n" + invalid_input + "\n" + valid_input
+          interface.solicit_move(@default_first_player)
+
+          expect(at_least_one_repeated_line?(output_stream.string)).to be true
+        end
+      end
+    end
+
+    describe "#report_invalid_move" do
+      it "prints a notification that a move cannot be made at the given coordinates" do
+        interface.report_invalid_move([0, 0])
+
+        expect(output_stream.string.split("").count("0")).to eq 2
+      end
+    end
+
+    describe "#report_move" do
+      it "prints a notification of the move made by the given mark at the given coordinates" do
+        interface.report_move(@default_first_player, [0, 0])
+        interface_output = output_stream.string
+
+        expect(interface_output).to include @default_first_player.to_s
+        expect(interface_output.split("").count("0")).to eq 2
+      end
+    end
+
+    describe "#report_game_over" do
+      context "when given the mark of a winning player" do
+        it "prints a notification that the player has won" do
+          expect(interface).to receive(:report_win).with(@default_first_player)
+          interface.report_game_over(@default_first_player)
+        end
+      end
+
+      context "when winning player is ':none'" do
+        it "prints a notification that the game has ended in a draw" do
+          expect(interface).to receive(:report_draw)
+          interface.report_game_over(:none)
+        end
+      end
+    end
+
+    describe "#report_win" do
+      it "prints a notification that the player using the given mark has won" do
+        interface.report_win(@default_first_player)
+        interface_output = output_stream.string
+
+        expect(interface_output).to include @default_first_player.to_s
+        expect(interface_output).to include "wins"
+      end
+    end
+
+    describe "#report_draw" do
+      it "prints a notification that the game has ended in a draw" do
+        interface.report_draw
+
+        expect(output_stream.string).to include "draw"
+      end
+    end
+  end
+end