bashrw_ttt 0.1.0

data/spec/ttt/human_spec.rb

@@ -0,0 +1,18 @@
+module TTT
+  describe Human do
+    let(:human) { Human.new(side: "x") }
+    let(:game)  { Game.new(view: view, board: board) }
+
+    describe "#no_gui?" do
+      it "returns false" do
+        human.no_gui?.should == false
+      end
+    end
+
+    describe "#prompt" do
+      it "returns 'Player thinking'" do
+        human.prompt.should == "Enter move:"
+      end
+    end
+  end
+end

data/spec/ttt/move_history_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+module TTT
+  describe MoveHistory do
+    describe "#new" do
+      it "returns a new TTT::MoveHistory object with side and move attributes" do
+        move_history = described_class.new(side: "x", move: 0)
+        move_history.side.should == "x"
+        move_history.move.should == 0
+      end
+    end
+  end
+end

data/spec/ttt/move_traverser_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module TTT
+  describe MoveTraverser do
+    let(:board)        { ThreeByThree.new }
+    let(:game_history) { GameHistory.new }
+    let(:traverser)    { game_history.move_traverser }
+
+    context do
+      before(:each) do
+        game_history.record_move(0, 'x')
+        game_history.record_move(1, 'o')
+        game_history.record_move(2, 'x')
+        game_history.record_move(3, 'o')
+        game_history.record_move(4, 'x')
+      end
+
+      describe "#adjust_move_index" do
+
+        it "moves backward in the move history by 1 when its invoked with -1" do
+          traverser.adjust_move_index(-1)
+          traverser.move_index.should == 4
+        end
+
+        it "moves forward in the move history by 1 when its invoked with 1" do
+          traverser.move_index = 4
+          traverser.adjust_move_index(1)
+          traverser.move_index.should == 5
+        end
+
+        it "moves backward in the move history by 2 when its invoked with -2" do
+          traverser.adjust_move_index(-2)
+          traverser.move_index.should == 3
+        end
+
+        it "moves forward in the move history by 2 when its invoked with 2" do
+          traverser.move_index = 2
+          traverser.adjust_move_index(2)
+          traverser.move_index.should == 4
+        end
+
+        it "cannot move backwards beyond move index 0" do
+          traverser.move_index = 0
+          traverser.adjust_move_index(-1)
+          traverser.move_index.should == 0
+        end
+
+        it "cannot move beyond the max length" do
+          traverser.move_index = traverser.max_length
+          traverser.adjust_move_index(100)
+          traverser.move_index.should == traverser.max_length
+        end
+      end
+
+      describe "#history_board_builder" do
+        it "returns a board array representing the moves made up to move_number in history" do
+          traverser.history_board_builder(board, 3).should == ['x', 'o', 'x', ' ', ' ', ' ', ' ', ' ', ' ']
+          board.board = Array.new(9, ' ')
+          traverser.history_board_builder(board, 5).should == ['x', 'o', 'x', 'o', 'x', ' ', ' ', ' ', ' ']
+          board.board = Array.new(9, ' ')
+          traverser.history_board_builder(board, 0).should == Array.new(9, ' ')
+        end
+
+        it "does not alter the original board" do
+          traverser.history_board_builder(board, 3).should_not == board.board
+        end
+
+        it "does not alter the original game history" do
+          original_history = traverser.game_history.history
+          traverser.game_history.history.should == original_history
+        end
+      end
+    end
+  end
+end

data/spec/ttt/player_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+module TTT
+  describe Player do
+
+     describe "#initialize" do
+       it "should initialize a blank new player" do
+         player = Player.new(side: "x")
+         player.side.should == "x"
+       end
+     end
+  end
+end

data/spec/ttt/riak_db_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+module TTT
+  describe RiakDB do
+    Riak.disable_list_keys_warnings = true
+    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) }
+    let(:riak)    { setup.new_db }
+    let(:bucket)  { riak.bucket }
+
+    describe "#new" do
+      it "establishes a connection with the Riak cluster" do
+      riak.client.should_not be_nil
+      end
+    end
+
+    describe "#add_game" do
+      it "adds a game to the game_list bucket" do
+        @id = riak.add_game(game)
+        riak.client[bucket].get(@id).data[:game].should_not == nil
+      end
+    end
+
+    describe "#game_list" do
+      it "returns a list of games available in the specified game bucket" do
+        num_keys_in_db = riak.client[bucket].keys.length
+        riak.game_list.length.should == num_keys_in_db
+      end
+    end
+
+    describe "#get_game" do
+      it "returns a game object from the Riak datastore" do
+        cur_id = riak.cur_id
+        riak.get_game(cur_id).class.should == Game
+      end
+
+      it "returns nil if there is no game at the specified id" do
+        riak.get_game(10000000000000000000).should == nil
+      end
+    end
+
+    describe "#save_game" do
+      it "saves an existing game to the Riak datastore" do
+        cur_id = riak.cur_id
+        new_game = riak.get_game(cur_id)
+        new_game.player1.side = "test"
+        riak.save_game(cur_id, new_game)
+        after_save = riak.get_game(cur_id)
+        new_game.player1.side.should == after_save.player1.side
+      end
+    end
+
+    describe "#delete_game" do
+      it "deletes an existing game from the Riak datastore" do
+        id = riak.add_game(game)
+        riak.get_game(id).class.should == Game
+        riak.delete_game(id)
+        riak.client[bucket].get_or_new(id).data.should == nil
+      end
+    end
+  end
+end

data/spec/ttt/setup_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'ttt/config_options'
+
+module TTT
+  describe Setup do
+    let(:setup) { Setup.new }
+
+    describe "#new_game" do
+      it "returns a new game object after instantiating the players, board, db and game history" do
+        game = setup.new_game(player1: "Human", player2: "AI Easy", board: "3x3")
+        game.player1.class.should == Human
+        game.player2.class.should == AIEasy
+        game.player1.side.should  == "x"
+        game.player2.side.should  == "o"
+        game.board.class.should   == ThreeByThree
+        game.history.should_not be_nil
+      end
+    end
+
+    describe "#new_db" do
+      it "returns a new db object" do
+        db = setup.new_db
+        db.should respond_to(:client)
+        db.should respond_to(:bucket)
+        db.should respond_to(:cur_id)
+        db.should respond_to(:save_game)
+        db.should respond_to(:get_game)
+        db.should respond_to(:add_game)
+        db.should respond_to(:game_list)
+      end
+    end
+
+    describe "#players" do
+      it "returns a list of player types supported by the library" do
+        setup.players.should == ConfigOptions::HUMAN_READABLE_PLAYERS
+      end
+    end
+
+    describe "#boards" do
+      it "returns a list of board types supported by the library" do
+        setup.boards.should == ConfigOptions::HUMAN_READABLE_BOARDS
+      end
+    end
+
+    describe "#db" do
+      it "returns the db const specified in the config options file" do
+        setup.db.should == ConfigOptions::DB
+      end
+    end
+
+    describe "#interactor" do
+      it "returns the interactor const specified in the config options file" do
+        setup.interactor.should == ConfigOptions::INTERACTOR
+      end
+    end
+
+    describe "#new_interactor" do
+      it "returns an instance of a game interactor" do
+        setup.new_interactor.class.should == GameInteractor
+      end
+    end
+  end
+end

data/spec/ttt/three_by_three_by_three_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+module TTT
+  describe ThreeByThreeByThree do
+    let(:board) { ThreeByThreeByThree.new }
+
+    describe "#initialize" do
+      it "board has length 27" do
+        board[].length.should == 27
+      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
+        27.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[] = ["a", "b", "c", "d", "e", "f", "g", "h", "i",
+                   "j", "k", "l", "m", "n", "o", "p", "q", "r",
+                   "s", "t", "u", "v", "w", "x", "y", "z", "a"]
+        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 same-ply winner" do
+        board[] = ["x", "x", "x", "o", " ", "o", " ", " ", " ",
+                   " ", " ", " ", " ", " ", " ", " ", " ", " ",
+                   " ", " ", " ", " ", " ", " ", " ", " ", " "]
+        board.winner?.should == true
+      end
+
+      it "returns true when the board has a multi-ply regular winner" do
+        board[] = ["x", " ", " ", " ", " ", " ", " ", " ", " ",
+                   "x", " ", " ", " ", " ", " ", " ", " ", " ",
+                   "x", " ", " ", " ", " ", " ", " ", " ", " "]
+        board.winner?.should == true
+      end
+
+      it "returns true when the board has a multi-ply diagonal winner" do
+        board[] = ["x", " ", " ", " ", " ", " ", " ", " ", " ",
+                   " ", " ", " ", " ", "x", " ", " ", " ", " ",
+                   " ", " ", " ", " ", " ", " ", " ", " ", "x"]
+        board.winner?.should == true
+      end
+
+      it "returns true when the board has a multi-ply horizontal stacked winner" do
+        board[] = ["x", " ", " ", " ", " ", " ", " ", " ", " ",
+                   " ", "x", " ", " ", " ", " ", " ", " ", " ",
+                   " ", " ", "x", " ", " ", " ", " ", " ", " "]
+        board.winner?.should == true
+      end
+
+      it "returns true when the board has a multi-ply horizontal stacked winner" do
+         board[] = [" ", " ", " ", " ", " ", " ", "x", " ", " ",
+                   " ", " ", " ", "x", " ", " ", " ", " ", " ",
+                   "x", " ", " ", " ", " ", " ", " ", " ", " "]
+         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/three_by_three_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+module TTT
+  describe ThreeByThree 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
+
+      it "returns true when the board has a block winner" do
+        board[] = ["x", "x", "o", "x", "x", "o", " ", " ", " "]
+        board.winner?.should == true
+      end
+    end
+
+    describe "#block_winner?" do
+      it "returns true when the board has a block winner" do
+        board[] = ["x", "x", "o", "x", "x", "o", " ", " ", " "]
+      end
+
+      it "returns false when the board has no block winner" do
+        board[] = ["x", "o", " ", " ", " ", " ", " ", " ", " "]
+      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