bashrw_ttt 0.1.0

data/spec/ttt/ai_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+module TTT
+  describe AI do
+
+    let(:ai)      { AI.new(side: "x") }
+    let(:board)   { ThreeByThree.new }
+
+    describe "#move" do
+      it "responds to message(:move)" do
+        ai.should respond_to(:move)
+      end
+    end
+
+    describe "#available_moves" do
+      it "returns an array of available moves" do
+        ai.board = board
+        ai.available_moves.should == [0,1,2,3,4,5,6,7,8]
+      end
+
+      it "returns [] when no available moves are found" do
+        board[] = ["o", "x", "o", "x", "o", "x", "o", "x", "o"]
+        ai.board = board
+        ai.available_moves.should == []
+      end
+    end
+
+    describe "#undo_move" do
+      it "should revert the original game board back to its previous state" do
+        index = 3
+        ai.board = board
+        ai.board[][3] = "x"
+        ai.undo_move(index)
+        ai.board[][3].should == " "
+      end
+    end
+
+    describe "#no_gui?" do
+      it "returns true" do
+        ai.no_gui?.should == true
+      end
+    end
+
+    describe "#prompt" do
+      it "returns 'Computer thinking'" do
+        ai.prompt.should == "Computer thinking."
+      end
+    end
+  end
+end

data/spec/ttt/board_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+module TTT
+  describe Board do
+    let(:board)     { ThreeByThree.new }
+
+    describe "#initialize" do
+      it "board has length 9" do
+        board[].length.should == 9
+      end
+    end
+
+    describe "#update" do
+      it "updates the game board after move is received" do
+        board.update(1, "x")
+        board[].should == [" ", "x", " ", " ", " ", " ", " ", " ", " "]
+      end
+    end
+
+    describe "#empty?" do
+      it "returns true when board is empty" do
+        board.empty?.should == true
+      end
+
+      it "returns false when board is not empty" do
+        board.update(1, "x")
+        board.empty?.should == false
+      end
+    end
+
+    describe "#full?" do
+      it "returns true when board is full" do
+        9.times do |n|
+          board.update(n, "o")
+        end
+        board.full?.should == true
+      end
+
+      it "returns false when board isn't full" do
+        board.update(1, "x")
+        board.full?.should == false
+      end
+    end
+
+    describe "#free?" do
+      it "returns false when board is occupied at a given cell" do
+        board.update(1, "x")
+        board.free?(1).should == false
+      end
+
+      it "returns true when board is not occupied at a given cell" do
+        board.free?(0).should == true
+      end
+    end
+
+    describe "#draw_game?" do
+      it "returns false when board is not full" do
+        board.draw_game?.should == false
+      end
+
+      it "returns true when board is full" do
+        board[] = ["x", "o", "x", "x", "o", "o", "o", "x", "o"]
+        board.draw_game?.should == true
+      end
+    end
+
+    describe "#winner?" do
+      it "returns false when the board has no winner" do
+        board.winner?.should == false
+      end
+
+      it "returns true when the board has a winner" do
+        board[] = ["x", "x", "x", "o", " ", "o", " ", " ", " "]
+        board.winner?.should == true
+      end
+    end
+
+    describe "#finished?" do
+      it "returns false when board is not full, no win, or no draw" do
+        board.finished?.should == false
+      end
+
+      it "returns true when board has a win" do
+        board.update(0, 'x')
+        board.update(1, 'x')
+        board.update(2, 'x')
+        board.finished?.should == true
+      end
+
+      it "returns true when board has a draw" do
+        board[] = ["x", "o", "x", "x", "o", "o", "o", "x", "o"]
+        board.finished?.should == true
+      end
+    end
+  end
+end

data/spec/ttt/config_helper_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'ttt/config_options'
+
+module TTT
+  describe ConfigHelper do
+    describe "#self.player_types" do
+      it { described_class.player_types.should == ConfigOptions::HUMAN_READABLE_PLAYERS }
+    end
+
+    describe "#self.board_types" do
+      it { described_class.board_types.should == ConfigOptions::HUMAN_READABLE_BOARDS }
+    end
+
+    describe "#self.bucket" do
+      it { described_class.bucket.should == ConfigOptions::BUCKET }
+    end
+
+    describe "#self.port" do
+      it { described_class.port.should == ConfigOptions::PORT }
+    end
+
+    describe "#self.http_backend" do
+      it { described_class.http_backend.should == ConfigOptions::HTTP_BACKEND }
+    end
+
+    describe "#self.get_player_const" do
+      it { described_class.get_player_const("Human").should == Human }
+    end
+
+    describe "#self.get_board_const" do
+      it { described_class.get_board_const("3x3").should == ThreeByThree }
+    end
+
+    describe "#self.get_player_index" do
+      it { described_class.get_player_index("Human").should == ConfigOptions::HUMAN_READABLE_PLAYERS.index("Human") }
+    end
+
+    describe "#self.get_board_index" do
+      it { described_class.get_board_index("3x3").should == ConfigOptions::HUMAN_READABLE_BOARDS.index("3x3") }
+    end
+
+    describe "#self.get_db_const" do
+      it { described_class.get_db_const.should == ConfigOptions::DB }
+    end
+
+    describe "#self.get_history_const" do
+      it { described_class.get_history_const.should == ConfigOptions::HISTORY }
+    end
+
+    describe "#self.get_game_interactor_const" do
+      it { described_class.get_game_interactor_const.should == ConfigOptions::INTERACTOR }
+    end
+  end
+end

data/spec/ttt/context_spec.rb

@@ -0,0 +1,398 @@
+require 'spec_helper'
+require 'ttt/config_options'
+
+module TTT
+  describe Context do
+    let(:context)          { Context.instance }
+    let(:setup)            { Setup.new }
+    let(:players)          { setup.players }
+    let(:boards)           { setup.boards }
+    let(:game)             { setup.new_game(player1: players.first, player2: players.first, board: boards.first) }
+
+    before(:each) do
+      context.setup=(Setup)
+    end
+
+    describe "players" do
+      it "returns the list of player types supported by the library" do
+        context.players.should == ConfigOptions::HUMAN_READABLE_PLAYERS
+      end
+    end
+
+    describe "boards" do
+      it "returns the list of board types supported by the library" do
+        context.boards.should == ConfigOptions::HUMAN_READABLE_BOARDS
+      end
+    end
+
+    describe "setup" do
+      it "returns a reference to a TTT::Setup object" do
+        context.setup.class.should == TTT::Setup
+      end
+    end
+
+    describe "add_game" do
+      it "adds a game to the db and returns the id" do
+        id = context.add_game(game)
+        id.should_not == nil
+      end
+    end
+
+    describe "create_game" do
+      it "create a new game and adds it to the db, returning the id" do
+        id = context.create_game(players.first, players.first, boards.first)
+        context.get_game(id).should_not == nil
+      end
+    end
+
+    describe "get_game" do
+      it "gets a game from the db and returns the game" do
+        game.player1.side = "get_game_test"
+        id = context.add_game(game)
+        retrieved_game = context.get_game(id)
+        retrieved_game.player1.side.should == game.player1.side
+      end
+    end
+
+    describe "#delete_game" do
+      it "removes a game from the db" do
+        id = context.add_game(game)
+        context.delete_game(id)
+        context.get_game(id).should == nil
+      end
+    end
+
+    describe "#save_game" do
+      it "saves a game to the db" do
+        id = context.add_game(game)
+        added_game = context.get_game(id)
+        added_game.board[] = %w(a b c d e f g h i)
+        context.save_game(id, added_game)
+        saved_game = context.get_game(id)
+        added_game.board[].should == saved_game.board[]
+      end
+    end
+
+    describe "#update_game" do
+      before(:each) do
+        id = context.add_game(game)
+        context.update_game(id, 0, 'x')
+        @updated_game = context.get_game(id)
+      end
+
+      it "updates a game in the db" do
+       @updated_game.board[][0].should == "x"
+      end
+
+      it "records move history" do
+        @updated_game.history.history.length.should == 1
+      end
+
+      it "switches the player" do
+        @updated_game.current_player.eql? @updated_game.player2
+      end
+
+      it "returns nil if no game is associated with the id" do
+        context.update_game(10000000000, 0, 'x').should == nil
+      end
+    end
+
+    describe "#game_list" do
+      it "returns an array of game ids (Strings)" do
+        context.game_list.should_not == []
+      end
+
+      it "gets a list of all game id's from the db" do
+        id = context.add_game(game)
+        context.game_list.include? id
+      end
+    end
+
+    describe "#ai_move?" do
+      it "returns true if the next move is from an AI player" do
+        game.player1 = TTT::AIEasy.new(:side => "x")
+        game.current_player = game.player1
+        id = context.add_game(game)
+        context.ai_move?(id).should == true
+      end
+
+      it "returns false if the next move is not from an AI player" do
+        id = context.add_game(game)
+        context.ai_move?(id).should == false
+      end
+
+      it "returns nil if the game cannot be found" do
+        context.ai_move?(100000000000000).should == nil
+      end
+    end
+
+    describe "#ai_move" do
+      before(:each) do
+        game.player1 = AIEasy.new(:side => 'x')
+        game.current_player = game.player1
+        id = context.add_game(game)
+        context.ai_move(id)
+        @updated_game = context.get_game(id)
+      end
+
+      it "gets an updated game with the board containing the ai move" do
+        @updated_game.board.empty?.should_not == true
+      end
+
+      it "advances current player to the next player" do
+        @updated_game.current_player.eql? game.player2
+      end
+
+      it "records the game history for the ai move" do
+        @updated_game.history.history.length.should == 1
+      end
+    end
+
+    describe "#finished?" do
+      it "returns true if the game is over" do
+        game.board[] = %w(a b c d e f g h i)
+        id = context.add_game(game)
+        context.finished?(id).should == true
+      end
+
+      it "returns false if the game is not over" do
+        game.board[] = Array.new(9, " ")
+        id = context.add_game(game)
+        context.finished?(id).should == false
+      end
+
+      it "returns nil if the game is not found" do
+        context.finished?(100000000).should == nil
+      end
+    end
+
+    describe "#winner?" do
+      it "returns true if a winner is found" do
+        game.board[] = %w(x x x x x x x x x)
+        id = context.add_game(game)
+        context.winner?(id).should == true
+      end
+
+      it "returns false if a winner is not found" do
+        game.board[] = Array.new(9, " ")
+        id = context.add_game(game)
+        context.winner?(id).should == false
+      end
+
+      it "returns nil if no game exists for the provided id" do
+        context.winner?(100000000).should == nil
+      end
+    end
+
+    describe "#winner" do
+      it "returns the winner as a string: 'Player 1' or 'Player 2'" do
+        game.board[] = %w(x x x x x x x x x)
+        game.switch_player
+        id = context.add_game(game)
+        context.winner(id).should == "Player 1"
+      end
+
+      it "returns nil if no game exists for the provided id" do
+        context.winner?(10000000000000).should == nil
+      end
+    end
+
+    describe "#draw?" do
+      it "returns true if the game is a draw" do
+        game.board[] = %w(a b c d e f g h i)
+        id = context.add_game(game)
+        context.draw?(id).should == true
+      end
+
+      it "returns false if the game is not a draw" do
+        game.board[] = Array.new(9, " ")
+        id = context.add_game(game)
+        context.draw?(id).should == false
+      end
+
+      it "returns false if the game has a winner" do
+        game.board[] = %w(x x x x x x x x x)
+        id = context.add_game(game)
+        context.draw?(id).should == false
+      end
+
+      it "returns nil if there is no game for that id" do
+        context.draw?(1000000000).should == nil
+      end
+    end
+
+    describe "#which_board" do
+      it "returns `three_by_three` when the board type is 3x3" do
+        id = context.add_game(game)
+        context.which_board(id).should == "three_by_three"
+      end
+
+      it "returns `four_by_four` when the board type is 4x4" do
+        game.board = FourByFour.new
+        id = context.add_game(game)
+        context.which_board(id).should == "four_by_four"
+      end
+
+      it "returns `three_by_three_by_three` when the board type is 3x3x3" do
+        game.board = ThreeByThreeByThree.new
+        id = context.add_game(game)
+        context.which_board(id).should == "three_by_three_by_three"
+      end
+
+      it "returns nil if there is no game associated with the id" do
+        context.which_board(10000000000).should == nil
+      end
+    end
+
+    describe "#valid_move?" do
+      it "returns true if the move input by the user is a valid move for the current game board" do
+        id   = context.add_game(game)
+        move = 0
+        context.valid_move?(id, move).should == true
+      end
+
+      it "returns false if the move input by the user is not a valid move for the current game board" do
+        game.board[] = %w(x x x x x x x x x)
+        id   = context.add_game(game)
+        move = 0
+        context.valid_move?(id, move).should == false
+      end
+
+      it "returns nil if there is no game associated with the id" do
+        context.valid_move?(100000000000000, 0).should == nil
+      end
+    end
+
+    describe "#show_history" do
+      it "returns an array of move_history objects for the current game" do
+        id = context.add_game(game)
+        context.update_game(id, 0, 'x')
+        context.update_game(id, 1, 'o')
+        context.get_history(id).length.should == 2
+      end
+
+      it "returns an empty array when no move has occurred" do
+        id = context.add_game(game)
+        context.get_history(id).should == []
+      end
+
+      it "returns nil if the game associated with the id doesn't exist" do
+        context.get_history(100000000000).should == nil
+      end
+    end
+
+    describe "#which_current_player?" do
+      it "returns a string of the current player" do
+        id = context.add_game(game)
+        context.which_current_player?(id).should == "Player 1"
+      end
+
+      it "returns nil if the game associated with the id doesn't exist" do
+        context.which_current_player?(100000000000000).should == nil
+      end
+    end
+
+    describe "#board_arr" do
+      it "returns the board array" do
+        id = context.add_game(game)
+        context.board(id).should == Array.new(9, " ")
+      end
+
+      it "returns nil if the game associated with an id doesn't exist" do
+        context.board(10000000000).should == nil
+      end
+    end
+
+    describe "#adjust_move_index" do
+      before(:each) do
+        game.record_move(1, 'x')
+        game.record_move(2, 'o')
+        game.record_move(3, 'x')
+        game.record_move(4, 'o')
+        @id = context.add_game(game)
+      end
+
+      it "adjusts a game's move traverser move index by -1 when it receives -1" do
+        cur_move_index = game.history.move_traverser.move_index
+        cur_move_index.should == 4
+        context.adjust_move_index(@id, -1)
+        updated_game = context.get_game(@id)
+        updated_game.history.move_traverser.move_index.should == 3
+      end
+
+      it "cannot move to a move index less than 0" do
+        context.adjust_move_index(@id, -4)
+        updated_game = context.get_game(@id)
+        updated_game.history.move_traverser.move_index.should == 0
+        context.adjust_move_index(@id, -3)
+        updated_game = context.get_game(@id)
+        updated_game.history.move_traverser.move_index.should == 0
+      end
+
+      it "cannot move to a move index greater than the max length of a game's move history" do
+        context.adjust_move_index(@id, 100)
+        updated_game = context.get_game(@id)
+        updated_game.history.move_traverser.move_index.should == 4
+      end
+
+      it "adjusts a game's move traverser move index by 1 when it receives 1" do
+        context.adjust_move_index(@id, -2)
+        updated_game = context.get_game(@id)
+        updated_game.history.move_traverser.move_index.should == 2
+        context.adjust_move_index(@id, 1)
+        updated_game = context.get_game(@id)
+        updated_game.history.move_traverser.move_index.should == 3
+      end
+    end
+
+    describe "#get_history_board" do
+      it "returns the game's board as an array" do
+        id = context.add_game(game)
+        context.get_history_board(id).should == Array.new(9, " ")
+      end
+    end
+
+    describe "#initialize_history" do
+      before(:each) do
+        game.record_move(0, 'o')
+        game.record_move(1, 'x')
+        game.record_move(2, 'x')
+        game.record_move(3, 'x')
+        game.record_move(4, 'o')
+        game.record_move(5, 'o')
+        game.record_move(6, 'x')
+        game.record_move(7, 'o')
+        game.record_move(8, 'x')
+        @id = context.add_game(game)
+      end
+
+      it "returns the game's move history index to it the length of the number of moves made in the game" do
+        stored_game = context.get_game(@id)
+        stored_game.history.move_traverser.move_index.should == 9
+        context.adjust_move_index(@id, -9)
+        stored_game = context.get_game(@id)
+        stored_game.history.move_traverser.move_index.should == 0
+        context.initialize_history(@id)
+        stored_game = context.get_game(@id)
+        stored_game.history.move_traverser.move_index.should == 9
+      end
+    end
+
+    describe "#get_move_index" do
+      before(:each) do
+      end
+
+      it "returns the current move index" do
+        id = context.add_game(game)
+        cur_game = context.get_game(id)
+        cur_game.record_move(1, 'x')
+        context.save_game(id, cur_game)
+        context.get_move_index(id).should == 1
+        cur_game = context.get_game(id)
+        cur_game.record_move(2, 'o')
+        context.save_game(id, cur_game)
+        context.get_move_index(id).should == 2
+      end
+    end
+  end
+end