xo 0.0.1 → 1.0.0

data/spec/xo/engine_spec.rb

@@ -6,49 +6,325 @@ module XO
 
     let (:engine) { Engine.new }
 
-    describe 'initial state' do
+    describe "its initial state" do
 
-      it 'has an empty grid' do
-        engine.grid.empty?.must_equal true
+      it "is in the :init state" do
+        engine.state.must_equal :init
       end
 
       it "is nobody's turn" do
         engine.turn.must_equal :nobody
       end
 
-      it 'is in the idle state' do
-        engine.state.must_equal :idle
+      it "has an empty grid" do
+        engine.grid.empty?.must_equal true
+      end
+
+      it "has last event set to :new" do
+        event = engine.last_event
+
+        event[:name].must_equal :new
+      end
+
+      describe "#next_turn" do
+
+        it "returns :nobody" do
+          engine.next_turn.must_equal :nobody
+        end
       end
     end
 
-    describe '#grid' do
+    describe "#grid" do
 
-      it 'returns a copy' do
+      it "returns a copy of the underlying grid" do
         grid = engine.grid
-        grid[1, 1] = X
 
-        # FIXME: How else can I test this requirement? I don't like that the test
-        # depends on knowing the name of the internal private instance variable.
-        engine.instance_variable_get(:@grid).empty?.must_equal true
+        grid[1, 1] = Grid::X
+
+        engine.grid.open?(1, 1).must_equal true
       end
     end
 
-    describe 'a single round of play' do
+    describe "how the state machine works" do
+
+      describe "state :init" do
+
+        it "is in state :init" do
+          engine.state.must_equal :init
+        end
+
+        describe "#start" do
+
+          before { engine.start(Grid::X) }
 
-      it 'works as follows' do
-        observer = Object.new
+          it "changes state to :playing" do
+            engine.state.must_equal :playing
+          end
+
+          it "sets turn to the value passed in" do
+            engine.turn.must_equal Grid::X
+          end
+
+          it "starts with an empty grid" do
+            engine.grid.empty?.must_equal true
+          end
+
+          it "sets last event" do
+            event = engine.last_event
 
-        def observer.handle_event(e)
-          if e[:event] == :game_over && e[:type] == :winner
-            @winner = e[:who]
+            event[:name].must_equal :game_started
           end
+
+          describe "#next_turn" do
+
+            it "returns O" do
+              engine.next_turn.must_equal Grid::O
+            end
+          end
+        end
+
+        it "only allows #start to be called" do
+          proc { engine.stop }.must_raise Engine::IllegalStateError
+          proc { engine.play(1, 1) }.must_raise Engine::IllegalStateError
+          proc { engine.continue_playing(Grid::X) }.must_raise Engine::IllegalStateError
+        end
+      end
+
+      describe "state :playing" do
+
+        before do
+          engine.start(Grid::X)
         end
 
-        engine.add_observer(observer, :handle_event)
+        it "is in state :playing" do
+          engine.state.must_equal :playing
+        end
+
+        describe "#play" do
+
+          describe "valid moves" do
+
+            describe "when given (1, 1)" do
+
+              before { engine.play(1, 1) }
+
+              it "remains in state :playing" do
+                engine.state.must_equal :playing
+              end
+
+              it "sets turn to O" do
+                engine.turn.must_equal Grid::O
+              end
+
+              it "updates the grid at that position" do
+                engine.grid[1, 1].must_equal Grid::X
+              end
+
+              it "sets last event" do
+                event = engine.last_event
+
+                event[:name].must_equal :next_turn
+                event[:last_move][:turn].must_equal Grid::X
+                event[:last_move][:r].must_equal 1
+                event[:last_move][:c].must_equal 1
+              end
+            end
+
+            describe "when the next move results in the game being over" do
+
+              describe "winning" do
+
+                before do
+                  engine.play(1, 1).play(2, 1).play(1, 2).play(2, 2).play(1, 3)
+                end
+
+                it "changes state to :game_over" do
+                  engine.state.must_equal :game_over
+                end
+
+                it "sets turn to the winner" do
+                  engine.turn.must_equal Grid::X
+                end
+
+                it "leaves the grid unchanged" do
+                  engine.grid.inspect.must_equal 'xxxoo    '
+                end
+
+                it "sets last event" do
+                  event = engine.last_event
+
+                  event[:name].must_equal :game_over
+                  event[:type].must_equal :winner
+                  event[:last_move][:turn].must_equal Grid::X
+                  event[:last_move][:r].must_equal 1
+                  event[:last_move][:c].must_equal 3
+                  event[:details].must_equal [
+                    { where: :row, index: 1, positions: [[1, 1], [1, 2], [1, 3]] }
+                  ]
+                end
+              end
+
+              describe "squashed" do
+
+                before do
+                  engine.play(1, 1).play(1, 2).play(1, 3).play(2, 2).play(3, 2).play(2, 1).play(2, 3).play(3, 3).play(3, 1)
+                end
+
+                it "changes state to :game_over" do
+                  engine.state.must_equal :game_over
+                end
+
+                it "leaves turn set to the last one played" do
+                  engine.turn.must_equal Grid::X
+                end
+
+                it "leaves the grid unchanged" do
+                  engine.grid.inspect.must_equal 'xoxooxxxo'
+                end
+
+                it "sets last event" do
+                  event = engine.last_event
+
+                  event[:name].must_equal :game_over
+                  event[:type].must_equal :squashed
+                  event[:last_move][:turn].must_equal Grid::X
+                  event[:last_move][:r].must_equal 3
+                  event[:last_move][:c].must_equal 1
+                end
+              end
+            end
+          end
+
+          describe "invalid moves" do
+
+            describe "when given (0, 0)" do
+
+              it "sets last event to out of bounds" do
+                event = engine.play(0, 0).last_event
+
+                event[:name].must_equal :invalid_move
+                event[:type].must_equal :out_of_bounds
+              end
+            end
+
+            describe "when given (1, 1) and it already has a token there" do
+
+              it "sets last event to occupied" do
+                event = engine.play(1, 1).play(1, 1).last_event
+
+                event[:name].must_equal :invalid_move
+                event[:type].must_equal :occupied
+              end
+            end
+          end
+        end
+
+        describe "#stop" do
+
+          before { engine.stop }
+
+          it "changes state to :init" do
+            engine.state.must_equal :init
+          end
+
+          it "sets turn to :nobody" do
+            engine.turn.must_equal :nobody
+          end
+
+          it "clears the grid" do
+            engine.grid.empty?.must_equal true
+          end
+
+          it "sets last event" do
+            event = engine.last_event
+
+            event[:name].must_equal :game_stopped
+          end
+        end
+
+        it "only allows #play and #stop to be called" do
+          proc { engine.start(Grid::O) }.must_raise Engine::IllegalStateError
+          proc { engine.continue_playing(Grid::O) }.must_raise Engine::IllegalStateError
+        end
+      end
+
+      describe "state :game_over" do
+
+        before do
+          engine
+            .start(Grid::O)
+            .play(1, 1).play(2, 1).play(1, 2).play(2, 2).play(1, 3)
+        end
+
+        it "is in state :game_over" do
+          engine.state.must_equal :game_over
+        end
+
+        describe "#continue_playing" do
+
+          before { engine.continue_playing(Grid::O) }
+
+          it "changes state to :playing" do
+            engine.state.must_equal :playing
+          end
+
+          it "sets turn to O" do
+            engine.turn.must_equal Grid::O
+          end
+
+          it "clears the grid" do
+            engine.grid.empty?.must_equal true
+          end
+
+          it "sets last event" do
+            event = engine.last_event
+
+            event[:name].must_equal :game_started
+            event[:type].must_equal :continue_playing
+          end
+        end
+
+        describe "#stop" do
+
+          before { engine.stop }
+
+          it "changes state to :init" do
+            engine.state.must_equal :init
+          end
+
+          it "sets turn to :nobody" do
+            engine.turn.must_equal :nobody
+          end
+
+          it "clears the grid" do
+            engine.grid.empty?.must_equal true
+          end
+
+          it "sets last event" do
+            event = engine.last_event
+
+            event[:name].must_equal :game_stopped
+          end
+        end
+
+        it "only allows #continue_playing and #stop to be called" do
+          proc { engine.start(Grid::X) }.must_raise Engine::IllegalStateError
+          proc { engine.play(1, 1) }.must_raise Engine::IllegalStateError
+        end
+      end
+    end
+
+    describe "#start with invalid input" do
+
+      it "raises an ArgumentError" do
+        proc { engine.start(:invalid_input) }.must_raise ArgumentError
+      end
+    end
 
-        engine.start(X).play(1, 1).play(2, 1).play(1, 2).play(2, 2).play(1, 3)
+    describe "#continue_playing with invalid input" do
 
-        observer.instance_variable_get(:@winner).must_equal X
+      it "raises an ArgumentError" do
+        proc { engine.continue_playing(:invalid_input) }.must_raise ArgumentError
       end
     end
   end

data/spec/xo/evaluator_spec.rb

@@ -4,40 +4,33 @@ module XO
 
   describe Evaluator do
 
-    describe 'analyze' do
+    describe ".analyze" do
 
+      let (:evaluator) { Evaluator.instance }
       let (:grid) { Grid.new }
 
-      describe 'error statuses' do
+      describe "standard play" do
 
-        it 'returns too many moves ahead' do
-          grid[1, 1] = grid[1, 2] = grid[1, 3] = X
-          grid[2, 1] = O
-
-          result = { status: :error, type: :too_many_moves_ahead }
-
-          Evaluator.analyze(grid, X).must_equal result
-          Evaluator.analyze(grid, O).must_equal result
-        end
+        it "returns ok" do
+          result = { status: :ok }
 
-        it 'returns two winners' do
-          grid[1, 1] = grid[1, 2] = grid[1, 3] = X
-          grid[2, 1] = grid[2, 2] = grid[2, 3] = O
+          evaluator.analyze(grid, Grid::X).must_equal result
+          evaluator.analyze(grid, Grid::O).must_equal result
 
-          result = { status: :error, type: :two_winners }
+          grid[1, 1] = Grid::X
 
-          Evaluator.analyze(grid, X).must_equal result
-          Evaluator.analyze(grid, O).must_equal result
+          evaluator.analyze(grid, Grid::X).must_equal result
+          evaluator.analyze(grid, Grid::O).must_equal result
         end
       end
 
-      describe 'game over statuses' do
+      describe "game over" do
 
-        describe 'wins and losses' do
+        describe "winners and losers" do
 
-          it 'returns a win/loss in the first row' do
-            grid[1, 1] = grid[1, 2] = grid[1, 3] = X
-            grid[2, 1] = grid[2, 2] = O
+          it "returns a row 1 winner/loser" do
+            grid[1, 1] = grid[1, 2] = grid[1, 3] = Grid::X
+            grid[2, 1] = grid[2, 2] = Grid::O
 
             result = {
               status: :game_over,
@@ -49,40 +42,218 @@ module XO
               }]
             }
 
-            Evaluator.analyze(grid, X).must_equal result
+            evaluator.analyze(grid, Grid::X).must_equal result
+
+            result[:type] = :loser
+            evaluator.analyze(grid, Grid::O).must_equal result
+          end
+
+          it "returns a row 2 winner/loser" do
+            grid[2, 1] = grid[2, 2] = grid[2, 3] = Grid::X
+            grid[1, 1] = grid[1, 2] = Grid::O
+
+            result = {
+              status: :game_over,
+              type: :winner,
+              details: [{
+                where: :row,
+                index: 2,
+                positions: [[2, 1], [2, 2], [2, 3]]
+              }]
+            }
+
+            evaluator.analyze(grid, Grid::X).must_equal result
+
+            result[:type] = :loser
+            evaluator.analyze(grid, Grid::O).must_equal result
+          end
+
+          it "returns a row 3 winner/loser" do
+            grid[3, 1] = grid[3, 2] = grid[3, 3] = Grid::X
+            grid[1, 1] = grid[1, 2] = Grid::O
+
+            result = {
+              status: :game_over,
+              type: :winner,
+              details: [{
+                where: :row,
+                index: 3,
+                positions: [[3, 1], [3, 2], [3, 3]]
+              }]
+            }
+
+            evaluator.analyze(grid, Grid::X).must_equal result
+
+            result[:type] = :loser
+            evaluator.analyze(grid, Grid::O).must_equal result
+          end
+
+          it "returns a column 1 winner/loser" do
+            grid[1, 1] = grid[2, 1] = grid[3, 1] = Grid::X
+            grid[1, 2] = grid[2, 2] = Grid::O
+
+            result = {
+              status: :game_over,
+              type: :winner,
+              details: [{
+                where: :column,
+                index: 1,
+                positions: [[1, 1], [2, 1], [3, 1]]
+              }]
+            }
+
+            evaluator.analyze(grid, Grid::X).must_equal result
+
+            result[:type] = :loser
+            evaluator.analyze(grid, Grid::O).must_equal result
+          end
+
+          it "returns a column 2 winner/loser" do
+            grid[1, 2] = grid[2, 2] = grid[3, 2] = Grid::X
+            grid[1, 1] = grid[2, 1] = Grid::O
+
+            result = {
+              status: :game_over,
+              type: :winner,
+              details: [{
+                where: :column,
+                index: 2,
+                positions: [[1, 2], [2, 2], [3, 2]]
+              }]
+            }
+
+            evaluator.analyze(grid, Grid::X).must_equal result
+
+            result[:type] = :loser
+            evaluator.analyze(grid, Grid::O).must_equal result
+          end
+
+          it "returns a column 3 winner/loser" do
+            grid[1, 3] = grid[2, 3] = grid[3, 3] = Grid::X
+            grid[1, 1] = grid[2, 1] = Grid::O
+
+            result = {
+              status: :game_over,
+              type: :winner,
+              details: [{
+                where: :column,
+                index: 3,
+                positions: [[1, 3], [2, 3], [3, 3]]
+              }]
+            }
+
+            evaluator.analyze(grid, Grid::X).must_equal result
+
+            result[:type] = :loser
+            evaluator.analyze(grid, Grid::O).must_equal result
+          end
+
+          it "returns a diagonal 1 winner/loser" do
+            grid[1, 1] = grid[2, 2] = grid[3, 3] = Grid::X
+            grid[1, 2] = grid[2, 1] = Grid::O
+
+            result = {
+              status: :game_over,
+              type: :winner,
+              details: [{
+                where: :diagonal,
+                index: 1,
+                positions: [[1, 1], [2, 2], [3, 3]]
+              }]
+            }
+
+            evaluator.analyze(grid, Grid::X).must_equal result
+
+            result[:type] = :loser
+            evaluator.analyze(grid, Grid::O).must_equal result
+          end
+
+          it "returns a diagonal 2 winner/loser" do
+            grid[1, 3] = grid[2, 2] = grid[3, 1] = Grid::X
+            grid[1, 2] = grid[2, 3] = Grid::O
+
+            result = {
+              status: :game_over,
+              type: :winner,
+              details: [{
+                where: :diagonal,
+                index: 2,
+                positions: [[1, 3], [2, 2], [3, 1]]
+              }]
+            }
+
+            evaluator.analyze(grid, Grid::X).must_equal result
 
             result[:type] = :loser
-            Evaluator.analyze(grid, O).must_equal result
+            evaluator.analyze(grid, Grid::O).must_equal result
           end
+        end
+
+        describe "a highly unlikely but definitely possible two-way winner/loser" do
+          # I mean you have to be real messed up to lose a game in this manner. :P
+
+          # The X win
+          it "returns a diagonal 1 and 2 winner/loser" do
+            grid[1, 1] = grid[1, 3] = grid[2, 2] = grid[3, 1] = grid[3, 3] = Grid::X
+            grid[1, 2] = grid[2, 1] = grid[2, 3] = grid[3, 2] = Grid::O
 
-          # TODO: Test the winners/losers in the other rows, the columns and the diagonals.
+            result = {
+              status: :game_over,
+              type: :winner,
+              details: [{
+                where: :diagonal,
+                index: 1,
+                positions: [[1, 1], [2, 2], [3, 3]]
+              }, {
+                where: :diagonal,
+                index: 2,
+                positions: [[1, 3], [2, 2], [3, 1]]
+              }]
+            }
+          end
         end
 
-        describe 'squashed' do
+        describe "a squashed grid" do
 
-          it 'returns squashed' do
-            grid[1, 1] = grid[1, 2] = grid[2, 3] = grid[3, 1] = grid[3, 3] = X
-            grid[1, 3] = grid[2, 1] = grid[2, 2] = grid[3, 2] = O
+          it "returns squashed" do
+            grid[1, 1] = grid[1, 2] = grid[2, 3] = grid[3, 1] = grid[3, 3] = Grid::X
+            grid[1, 3] = grid[2, 1] = grid[2, 2] = grid[3, 2] = Grid::O
 
             result = { status: :game_over, type: :squashed }
 
-            Evaluator.analyze(grid, X).must_equal result
-            Evaluator.analyze(grid, O).must_equal result
+            evaluator.analyze(grid, Grid::X).must_equal result
+            evaluator.analyze(grid, Grid::O).must_equal result
           end
         end
       end
 
-      describe 'ok status' do
+      describe "invalid token input" do
 
-        it 'returns ok' do
-          result = { status: :ok }
+        it "raises ArgumentError" do
+          proc { evaluator.analyze(Grid.new, :not_a_token) }.must_raise ArgumentError
+        end
+      end
+
+      describe "invalid grid input" do
+
+        it "returns too many moves ahead" do
+          grid[1, 1] = grid[1, 2] = grid[1, 3] = Grid::X
+          grid[2, 1] = Grid::O
+
+          result = { status: :invalid_grid, type: :too_many_moves_ahead }
+
+          evaluator.analyze(grid, Grid::X).must_equal result
+          evaluator.analyze(grid, Grid::O).must_equal result
+        end
+
+        it "returns two winners" do
+          grid[1, 1] = grid[1, 2] = grid[1, 3] = Grid::X
+          grid[2, 1] = grid[2, 2] = grid[2, 3] = Grid::O
 
-          Evaluator.analyze(grid, X).must_equal result
-          Evaluator.analyze(grid, O).must_equal result
+          result = { status: :invalid_grid, type: :two_winners }
 
-          grid[1, 1] = X
-          Evaluator.analyze(grid, X).must_equal result
-          Evaluator.analyze(grid, O).must_equal result
+          evaluator.analyze(grid, Grid::X).must_equal result
+          evaluator.analyze(grid, Grid::O).must_equal result
         end
       end
     end