bashrw_ttt 0.1.0

data/lib/ttt/interfaces/cli/lib/cli/cli_presenter.rb

@@ -0,0 +1,216 @@
+module CLI
+  class CLIPresenter
+    attr_accessor :io
+    def initialize(input, output)
+      self.io = CLIO.new(input, output)
+    end
+
+    def output(args)
+      io.output args
+    end
+
+    def padding
+      output "\n"
+    end
+
+    def input
+      io.input
+    end
+
+    def welcome_prompt
+      output "Welcome to TTT!"
+    end
+
+    def command_list
+      output "\nPlease select an option from the following list:"
+      padding
+      output "1. Play TTT!\n\n"
+      output "2. Load game\n\n"
+      output "3. Quit\n\n"
+      padding
+    end
+
+    def menu
+      welcome_prompt
+      command_list
+      selection = input.chomp
+      if valid_menu?(selection)
+        selection
+      else
+        error
+        menu
+      end
+    end
+
+    def valid_menu?(selection)
+      selection.to_i >= 1 && selection.to_i <= 3
+    end
+
+    def process_game_list(list)
+      clear
+      puts "Please choose one of the following games:\n\n"
+      list.each do |key|
+        output key
+      end
+      output "\n"
+      input.chomp
+    end
+
+    def sort_list(list)
+      list.map(&:to_i).sort.map(&:to_s)
+    end
+
+    def no_games
+      output "No games were found."
+    end
+
+    def player_type_prompt(num, players)
+      output "\nPlease select an option for Player #{num}:\n\n"
+      display_options_with_index(players)
+      input
+    end
+
+    def select_game_prompt
+      output "\nPlease choose one of the following games:\n\n"
+    end
+
+    def player_prompt(board, history, player)
+      output_help(board)
+      output_move_history(history)
+      output_board(board)
+      output "\n#{player.prompt}"
+    end
+
+    def output_move_history(moves)
+      output "\n"
+      output "Move History:".rjust(10)
+      move_num = "#"
+      move_side = "side"
+      move_square = "square"
+      output "#{move_num} #{move_side.rjust(7)} #{move_square.rjust(7)}"
+      moves.each_with_index do |move, n|
+        output "#{n}. #{(move.side).to_s.rjust(5)}  #{(move.move).to_s.rjust(5)}"
+      end
+    end
+
+    def process_winner(board, history, player)
+      clear
+      output_move_history(history)
+      output_board(board)
+      winner_prompt(player)
+    end
+
+    def process_draw(board, history)
+      clear
+      output_move_history(history)
+      output_board(board)
+      draw_prompt
+    end
+
+    def board_selection_prompt(boards)
+      clear
+      output "\nPlease select which board you'd like to play:\n"
+      display_options_with_index(boards)
+    end
+
+    def display_options_with_index(options)
+      options.each_with_index do |option, index|
+        output "#{index + 1}: #{option}\n\n"
+      end
+    end
+
+    def clear
+      system('clear')
+      #output "\e[2J"
+      #output "\e[0;0H"
+    end
+
+    def ai_difficulty_prompt(ai_options)
+      clear
+      output "\nChoose a difficulty level for the computer:"
+      ai_options.inject(1) do |index, difficulty|
+        output "#{index}. #{difficulty.to_s.gsub(/TTT::AI/, '')}"
+        index += 1
+      end
+    end
+
+    def post_game_msg
+      output "\nWould you like to review the game history (y or n)?"
+    end
+
+    def play_again_msg
+      output "\nPlay again (y or n)?"
+    end
+
+    def walk_msg
+      output "\nEnter -1 to go back, 0 for main menu, or 1 to go forward"
+    end
+
+    def output_board(board)
+      output "\n"
+      case board.length
+      when 9
+        output_three_by_three(board)
+      when 16
+        output_four_by_four(board)
+      when 27
+        output_3d(board)
+      end
+    end
+
+    def output_help(board)
+      clear
+      output "\nMove options:"
+      case board.length
+      when 9
+       regular_move_prompt
+      when 16
+       four_by_four_move_prompt
+      when 27
+        three_d_prompt
+      end
+      output "\n"
+    end
+
+    def error
+      output "\nI'm sorry, I didn't understand. Please try again."
+    end
+
+    def winner_prompt(winner)
+      output "\n#{winner} is the winner!"
+    end
+
+    def draw_prompt
+      output "\nIt's a draw!"
+    end
+
+    def output_three_by_three(board)
+      output("\n  #{board[0]}  |  #{board[1]}  |  #{board[2]}  \n-----------------\n  #{board[3]}  |  #{board[4]}  |  #{board[5]}  \n-----------------\n  #{board[6]}  |  #{board[7]}  |  #{board[8]}  ")
+    end
+
+    def output_four_by_four(board)
+      output("\n  #{board[0]}  |  #{board[1]}  |  #{board[2]}  |  #{board[3]}  \n-----------------------\n  #{board[4]}  |  #{board[5]}  |  #{board[6]}  |  #{board[7]}  \n-----------------------\n  #{board[8]}  |  #{board[9]}  |  #{board[10]}  |  #{board[11]}  \n-----------------------\n  #{board[12]}  |  #{board[13]}  |  #{board[14]}  |  #{board[15]}   ")
+    end
+
+    def output_3d(board)
+      output("\n  #{board[0]}  |  #{board[1]}  |  #{board[2]}       #{board[9]}  |  #{board[10]}  |  #{board[11]}       #{board[18]}  |  #{board[19]}  |  #{board[20]}   \n-----------------   -----------------   -----------------\n  #{board[3]}  |  #{board[4]}  |  #{board[5]}       #{board[12]}  |  #{board[13]}  |  #{board[14]}       #{board[21]}  |  #{board[22]}  |  #{board[23]}   \n-----------------   -----------------   -----------------\n  #{board[6]}  |  #{board[7]}  |  #{board[8]}       #{board[15]}  |  #{board[16]}  |  #{board[17]}       #{board[24]}  |  #{board[25]}  |  #{board[26]}  ")
+    end
+
+    def three_d_prompt
+      output("\n  0  |  1  |  2       9  |  10 |  11      18 |  19 |  20  \n-----------------   -----------------   -----------------\n  3  |  4  |  5       12 |  13 |  14      21 |  22 |  23 \n-----------------   -----------------   -----------------\n  6  |  7  |  8       15 |  16 |  17      24 |  25 |  26 ")
+    end
+
+    def regular_move_prompt
+      output("\n  0  |  1  |  2  \n-----------------\n  3  |  4  |  5  \n-----------------\n  6  |  7  |  8  ")
+    end
+
+    def four_by_four_move_prompt
+      output("\n  0  |  1  |  2  |  3  \n-----------------------\n  4  |  5  |  6  |  7  \n-----------------------\n  8  |  9  | 10  | 11  \n-----------------------\n 12  | 13  | 14  | 15   ")
+    end
+
+    def welcome_prompt
+      clear
+      output("Welcome to TTT!")
+    end
+  end
+end

data/lib/ttt/interfaces/cli/lib/cli/clio.rb

@@ -0,0 +1,17 @@
+module CLI
+  class CLIO
+    attr_accessor :outstream, :instream
+    def initialize(input, output)
+      self.outstream    = output
+      self.instream     = input
+    end
+
+    def output(message)
+      outstream.puts message
+    end
+
+    def input
+      instream.gets
+    end
+  end
+end

data/lib/ttt/interfaces/cli/lib/cli/play_again.rb

@@ -0,0 +1,38 @@
+module CLI
+  class PlayAgain
+
+    def initialize(presenter)
+      self.presenter = presenter
+    end
+
+    def play_again?
+      play_again_msg
+      process_reply input
+    end
+
+    def process_reply reply
+      if valid_reply?(reply)
+        return false if reply.chomp == "n"
+        true
+      else
+        presenter.error
+        play_again?
+      end
+    end
+
+    def input
+      presenter.input
+    end
+
+    def valid_reply?(response)
+      response =~ (/(y|n)/i)
+    end
+
+    def play_again_msg
+      presenter.play_again_msg
+    end
+
+    private
+    attr_accessor :presenter
+  end
+end

data/lib/ttt/interfaces/cli/lib/cli/player_selection.rb

@@ -0,0 +1,43 @@
+require 'cli/selection'
+
+module CLI
+  class PlayerSelection < Selection
+    attr_accessor :presenter, :players, :player1, :player2
+    def initialize(players, presenter)
+      self.presenter = presenter
+      self.players   = players
+    end
+
+    def process
+      process_player_type_input(1, presenter.player_type_prompt(1, players))
+      process_player_type_input(2, presenter.player_type_prompt(2, players))
+      self
+    end
+
+    def process_player_type_input(num, selection)
+      if player_selection_valid? selection.chomp.to_i
+        set_player_string(num, selection.chomp.to_i)
+      else
+        presenter.error
+        process_player_type_input(num, presenter.player_type_prompt(num, players))
+      end
+    end
+
+    def set_player_string(num, selection)
+      case num
+      when 1
+        self.player1 = _player(selection)
+      when 2
+        self.player2 = _player(selection)
+      end
+    end
+
+    def _player(selection)
+      players[selection - 1]
+    end
+
+    def player_selection_valid?(selection)
+      0 < selection.to_i && selection <= players.length
+    end
+  end
+end

data/lib/ttt/interfaces/cli/lib/cli/selection.rb

@@ -0,0 +1,8 @@
+module CLI
+  class Selection
+    attr_accessor :players, :boards, :presenter
+    def input
+      presenter.input
+    end
+  end
+end

data/lib/ttt/interfaces/cli/lib/cli/walk_history.rb

@@ -0,0 +1,48 @@
+module CLI
+  class WalkHistory
+    attr_accessor :presenter, :game, :move_traverser, :board
+    def initialize(presenter, game)
+      self.presenter      = presenter
+      self.move_traverser = game.history.move_traverser
+      self.game           = game
+    end
+
+    def post_game_msg
+      presenter.post_game_msg
+      process(presenter.input.chomp)
+    end
+
+    def process(selection)
+      if selection =~ (/y|n/i)
+        walk_msg if selection =~ (/y/i)
+      else
+        presenter.error
+        post_game_msg
+      end
+    end
+
+    def walk_msg
+      presenter.clear
+      presenter.output_board(build_board)
+      presenter.walk_msg
+      diff_index = presenter.input.chomp
+      case diff_index
+      when "-1" then walk_history(-1)
+      when "0"  then return
+      when "1"  then walk_history(1)
+      else
+        presenter.error
+        walk_msg
+      end
+    end
+
+    def walk_history(diff_index)
+      move_traverser.adjust_move_index(diff_index)
+      walk_msg
+    end
+
+    def build_board(board = game.board, move_index = move_traverser.move_index)
+      move_traverser.history_board_builder(board, move_index)
+    end
+  end
+end

data/lib/ttt/interfaces/cli/spec/cli/board_selection_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module CLI
+  describe BoardSelection do
+    let(:view)       { CLIO.new(StringIO.new, StringIO.new) }
+    let(:boards)     { TTT::Setup.new.players }
+    let(:presenter)  { CLIPresenter.new(StringIO.new, StringIO.new) }
+    let(:boardio)    { BoardSelection.new(boards, presenter) }
+
+    describe "#board_selection_input_valid?" do
+      it "returns true when input is within valid range of options" do
+        boardio.board_selection_input_valid?(1).should == true
+        boardio.board_selection_input_valid?(2).should == true
+      end
+
+      it "returns false when input is not within valid range of options" do
+        boardio.board_selection_input_valid?(6).should == false
+        boardio.board_selection_input_valid?(1.5).should == false
+      end
+    end
+
+    describe "#process" do
+      it "displays a generic error message if the user inputs invalid input" do
+        presenter.io.instream = StringIO.new("9\n1\n")
+        boardio.process
+      end
+    end
+  end
+end

data/lib/ttt/interfaces/cli/spec/cli/cli_game_spec.rb

@@ -0,0 +1,376 @@
+require 'spec_helper'
+require 'stringio'
+require 'ttt/context'
+
+module CLI
+  describe CLIGame do
+    let(:setup)       { TTT::Setup.new }
+    let(:context)     { TTT::Context.instance }
+    let(:players)     { setup.players }
+    let(:boards)      { setup.boards }
+    let(:db)          { setup.new_db }
+    let(:presenter)   { CLIPresenter.new(input, output) }
+    let(:output)      { StringIO.new }
+    let(:input1)      { StringIO.new("1\n1\n1\n0\n3\n1\n4\n2\nn\n") }
+    let(:input)       { StringIO.new }
+    let(:game)        { setup.new_game(player1: players.first, player2: players.first, board: boards.first) }
+    let(:ai_game)     { setup.new_game(player1: players.last,  player2: players.last,  board: boards.first) }
+
+    before(:each) do
+      context.setup = TTT::Setup
+      @cli_game = described_class.new(context, input, output)
+    end
+
+    describe "#play" do
+      it "displays the main game menu to the user" do
+        @cli_game.stub(:process_command).and_return(nil)
+        @cli_game.presenter.should_receive(:menu)
+        @cli_game.play
+      end
+
+      it "chooses the game made" do
+        @cli_game.presenter.stub(:menu).and_return(1)
+        @cli_game.should_receive(:process_command).with(1)
+        @cli_game.play
+      end
+    end
+
+    describe "#process_command" do
+      context "matches user game mode selection with the proper game play option" do
+        it "starts a new game when the user selects option 1" do
+          @cli_game.should_receive(:init_game)
+          @cli_game.process_command("1\n")
+        end
+
+        it "prompts the user to load a previously played game when the user selects option 2" do
+          @cli_game.should_receive(:game_list)
+          @cli_game.process_command("2\n")
+        end
+
+        it "exits the game when the user selects option 3" do
+          @cli_game.should_receive(:exit)
+          @cli_game.process_command("3\n")
+        end
+
+        it "reprompts the user with the main menu if invalid input is received" do
+          @cli_game.should_receive(:play)
+          @cli_game.process_command("aoivoijv\n")
+        end
+      end
+    end
+
+    describe "#init_game" do
+      before(:each) do
+        @cli_game.presenter.io.instream = StringIO.new("1\n1\n1\n")
+      end
+
+      it "presents a welcome prompt to the user" do
+        @cli_game.presenter.should_receive(:welcome_prompt)
+        @cli_game.stub(:get_player_selection => nil)
+        @cli_game.stub(:get_board_selection => nil)
+        @cli_game.stub(:build_game => nil)
+        @cli_game.context.stub(:add_game => nil)
+        @cli_game.stub(:play_game => nil)
+        @cli_game.init_game
+      end
+
+      it "asks the user to select player types for player 1 and player 2" do
+        @cli_game.should_receive(:get_player_selection)
+        @cli_game.stub(:get_board_selection => nil)
+        @cli_game.stub(:build_game => nil)
+        @cli_game.context.stub(:add_game => nil)
+        @cli_game.stub(:play_game => nil)
+        @cli_game.init_game
+      end
+
+      it "asks the user to select the board type for the new game" do
+        @cli_game.stub(:get_player_selection => nil)
+        @cli_game.should_receive(:get_board_selection)
+        @cli_game.stub(:build_game => nil)
+        @cli_game.context.stub(:add_game => nil)
+        @cli_game.stub(:play_game => nil)
+        @cli_game.init_game
+      end
+
+      it "builds a new game based on the player type and board type selections of the user" do
+        @cli_game.should_receive(:build_game)
+        @cli_game.context.stub(:add_game => nil)
+        @cli_game.stub(:play_game => nil)
+        @cli_game.init_game
+      end
+
+      it "a new game is added to the datastore" do
+        @cli_game.context.should_receive(:add_game)
+        @cli_game.stub(:play_game => nil)
+        @cli_game.init_game
+      end
+
+      it "begins to play the game after a new game has been successfully created" do
+        @cli_game.should_receive(:play_game)
+        @cli_game.init_game
+        @cli_game.id.should_not be_nil
+      end
+    end
+
+    describe "#get_player_selection" do
+      it "selects the player type for player1 and player2 based on the context.players list" do
+        context.players.length.times do |n|
+          @cli_game.presenter.io.instream = StringIO.new("#{n + 1}\n#{n + 1}\n")
+          players_selection = @cli_game.get_player_selection
+          players_selection.player1.should == context.players[n]
+          players_selection.player2.should == context.players[n]
+        end
+      end
+    end
+
+    describe "#get_board_selection" do
+      it "selects the board type based on the context.boards list" do
+        context.boards.length.times do |n|
+          @cli_game.presenter.io.instream = StringIO.new("#{n + 1}\n#{n + 1}\n")
+          board_selection = @cli_game.get_board_selection
+          board_selection.board.should == context.boards[n]
+        end
+      end
+    end
+
+    describe "#build_game" do
+      it "constructs a new game based on the player types and board type selected by the user" do
+        p1 = [*1..context.players.length].sample
+        p2 = [*1..context.players.length].sample
+        b  = [*1..context.boards.length].sample
+        @cli_game.presenter.io.instream = StringIO.new("#{p1}\n#{p2}\n#{b}\n")
+        player_selection = @cli_game.get_player_selection
+        board_selection = @cli_game.get_board_selection
+        game = @cli_game.build_game(player_selection, board_selection)
+        game.player1.should_not be_nil
+        game.player2.should_not be_nil
+        game.board.should_not be_nil
+      end
+    end
+
+    describe "#play_game" do
+      before(:each) do
+        @cli_game.presenter.io.instream = StringIO.new("1\n1\n1\n0\n1\n4\n5\n8\n")
+      end
+
+      it "plays a game until the game is finished" do
+        @cli_game.should_receive(:game_over)
+        @cli_game.init_game
+        @cli_game.game.board.board.should == ['x', 'o', ' ', ' ', 'x', 'o', ' ', ' ', 'x']
+     end
+    end
+
+    describe "#game_over" do
+      it "prompts the user to walk the previously played game's history" do
+        @cli_game.should_receive(:walk_history)
+        @cli_game.stub(:play_again)
+        @cli_game.game_over
+      end
+
+      it "prompts the user to play again" do
+        @cli_game.should_receive(:play_again)
+        @cli_game.stub(:walk_history)
+        @cli_game.game_over
+      end
+    end
+
+    describe "#play_again" do
+      it "exits the program if the user doesn't want to play again" do
+        PlayAgain.stub_chain(:new, :play_again?).and_return(nil)
+        @cli_game.should_receive(:exit)
+        @cli_game.stub(:play => nil)
+        @cli_game.play_again
+      end
+    end
+
+    describe "#game" do
+      it "returns the current game from the datastore" do
+        @cli_game.presenter.io.instream = StringIO.new("1\n1\n1\n")
+        @cli_game.stub(:play_game => nil)
+        @cli_game.game.should == context.get_game(@cli_game.id)
+      end
+    end
+
+    describe "#move_cycle" do
+      it "prompts the current player to move" do
+        @cli_game.id = context.add_game(game)
+        @cli_game.stub(:process_next_move => nil)
+        @cli_game.presenter.should_receive(:player_prompt).with(game.board.board, game.show_history, game.current_player)
+        @cli_game.move_cycle
+      end
+
+      it "receives the next move from the current_player" do
+        @cli_game.id = context.add_game(ai_game)
+        @cli_game.stub(:game => context.get_game(@cli_game.id))
+        @cli_game.presenter.stub(:player_prompt => nil)
+        @cli_game.should_receive(:process_next_move)
+        @cli_game.move_cycle
+      end
+    end
+
+    describe "#player_prompt" do
+      it "calls player_prompt on @presenter" do
+        @cli_game.id = context.add_game(game)
+        @cli_game.presenter.should_receive(:player_prompt)
+        @cli_game.player_prompt(context.get_game(@cli_game.id))
+      end
+    end
+
+    describe "#process_next_move" do
+      context "When an AI player move is processed" do
+        it "returns the AI player's move if the current player is an AI player" do
+          @cli_game.id = context.add_game(ai_game)
+          original_board = @cli_game.game.board.board
+          @cli_game.process_next_move
+          original_board.should_not == @cli_game.game.board.board
+        end
+      end
+
+      context "When a Human player move is processed" do
+        before(:each) do
+          @cli_game.id = context.add_game(game)
+          @cli_game.presenter.io.instream = StringIO.new("1\n")
+        end
+
+        it "gets the human player's move" do
+          @cli_game.process_next_move
+          @cli_game.game.board.board.should == [' ', 'x', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
+        end
+
+        it "validates the human player's move" do
+          @cli_game.should_receive(:validate_move).with("1\n").and_return(true)
+          @cli_game.process_next_move
+        end
+
+        it "updates the game with the human player's move" do
+          @cli_game.game.board.board.should == [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
+          @cli_game.process_next_move
+          @cli_game.game.board.board.should == [' ', 'x', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
+        end
+      end
+
+      it "evaluates the game after the move has been processed" do
+        @cli_game.id = context.add_game(game)
+        game = @cli_game.game
+        game.board.board = ['x', 'o', ' ', ' ', 'x', 'o', ' ', ' ', ' ']
+        context.save_game(@cli_game.id, game)
+        @cli_game.presenter.io.instream = StringIO.new("8\n") # win for 'x'
+        @cli_game.presenter.should_receive(:process_winner)
+        @cli_game.process_next_move
+        @cli_game.game.winner?.should == true
+      end
+    end
+
+    describe "#get_next_move" do
+      it "prompts the human player for input on the command line if the current player is human" do
+        @cli_game.id = context.add_game(game)
+        @cli_game.presenter.io.instream = StringIO.new("1\n")
+        @cli_game.presenter.should_receive(:input).and_return("1\n")
+        @cli_game.process_next_move
+      end
+
+      it "gets the AI player's move when the current player is an AI player" do
+        @cli_game.id = context.add_game(ai_game)
+        original_board = @cli_game.game.board.board
+        @cli_game.get_next_move
+        original_board.should_not == @cli_game.game.board.board
+      end
+    end
+
+    describe "#get_games" do
+      it "asks the context object for alist of games saved to the datastore" do
+        games = context.game_list
+        @cli_game.get_games
+        @cli_game.games.length.should == games.length
+      end
+
+      it "sets @games equal to nil if there are no games in the datastore" do
+        @cli_game.context.stub(:game_list => [])
+        @cli_game.get_games
+        @cli_game.games.should == nil
+      end
+    end
+
+    describe "#load_game" do
+      before(:each) do
+        @cli_game.stub(:game_list => nil)
+      end
+      it "prompts the user to select a game id from the game list" do
+        @cli_game.presenter.should_receive(:process_game_list).with(@cli_game.games).and_return("1\n")
+        @cli_game.context.stub(:get_game => nil)
+        @cli_game.load_game
+      end
+
+      it "loads a game with a given id" do
+        @cli_game.id = context.add_game(game)
+        @cli_game.presenter.stub(:process_game_list => @cli_game.id)
+        @cli_game.context.stub(:get_game => @cli_game.game)
+        @cli_game.should_receive(:resume_game)
+        @cli_game.load_game
+      end
+    end
+
+    describe "#no_games" do
+      it "prompts the users that no games exist in the datastore and returns to the main menu" do
+        @cli_game.presenter.should_receive(:no_games)
+        @cli_game.should_receive(:play)
+        @cli_game.no_games
+      end
+
+      it "sleeps for one second" do
+        @cli_game.should_receive(:sleep).with(1)
+        @cli_game.stub(:play => nil)
+        @cli_game.no_games
+      end
+    end
+
+    describe "#resume_game" do
+      it "prompts the player to resume playing an unfinished game loaded from the datastore" do
+        @cli_game.id = context.add_game(game)
+        @cli_game.presenter.should_receive(:player_prompt).with(@cli_game.game.board.board, @cli_game.game.show_history, @cli_game.game.current_player)
+        @cli_game.stub(:play_game => nil)
+        @cli_game.resume_game
+      end
+
+      it "displasy a loaded game's final state when a finished game is loaded from the db" do
+        @cli_game.id = context.add_game(game)
+        game = context.get_game(@cli_game.id)
+        game.board.board = %w(a b c d e f g h i)
+        @cli_game.context.save_game(@cli_game.id, game)
+        @cli_game.stub(:play_game => nil)
+        @cli_game.presenter.io.outstream.include? "It's a draw"
+      end
+    end
+
+    describe "#game_list" do
+      it "gets a list of games" do
+        @cli_game.should_receive(:get_games)
+        @cli_game.stub(:load_game)
+        @cli_game.stub(:no_games)
+        @cli_game.game_list
+      end
+
+      it "calls #load_game if there are games stored in the datastore" do
+        @cli_game.should_receive(:load_game)
+        @cli_game.game_list
+      end
+
+      it "calls #no_games if there are no games stored in the datastore" do
+        @cli_game.stub(:get_games => nil)
+        @cli_game.games = nil
+        @cli_game.should_receive(:no_games)
+        @cli_game.game_list
+      end
+    end
+
+    describe "#walk_history" do
+      it "makes a new WalkHistory object" do
+        @cli_game.id = context.add_game(game)
+        @cli_game.presenter.stub(:input => "n")
+        @cli_game.stub(:play_again => nil)
+        @cli_game.presenter.should_receive(:post_game_msg)
+        @cli_game.walk_history
+      end
+    end
+  end
+end