text2048 0.5.0 → 0.6.0

data/spec/text2048/app_spec.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+
+require 'text2048/app'
+
+describe Text2048::App do
+  describe '.new' do
+    context 'with no arguments' do
+      When(:result) { Text2048::App.new }
+      Then { result.view.is_a?(Text2048::CursesView) }
+    end
+
+    context 'with custom view' do
+      Given(:view) { double('view') }
+      When(:result) { Text2048::App.new(view) }
+      Then { result.view == view }
+    end
+  end
+
+  describe '#generate' do
+    Given(:view) { double('view', update: nil, zoom_tiles: nil) }
+    Given(:app) { Text2048::App.new(view) }
+
+    context 'with no arguments' do
+      When { app.generate }
+      Then { app.board.generated_tiles.size == 1 }
+    end
+
+    context 'with 2' do
+      When { app.generate(2) }
+      Then { app.board.generated_tiles.size == 2 }
+    end
+  end
+
+  describe '#step' do
+    Given(:new_board) do
+      double('new_board', merged_tiles: nil, generate?: nil)
+    end
+
+    context 'with command = :larger' do
+      Given(:view) { double('view', command: :larger, larger: nil) }
+      Given(:app) { Text2048::App.new(view) }
+      When { app.step }
+      Then { expect(view).to have_received(:larger) }
+    end
+
+    context 'with command = :smaller' do
+      Given(:view) { double('view', command: :smaller, smaller: nil) }
+      Given(:app) { Text2048::App.new(view) }
+      When { app.step }
+      Then { expect(view).to have_received(:smaller) }
+    end
+
+    context 'with command = :left' do
+      Given(:view) do
+        double('view', command: :left, update: nil, pop_tiles: nil)
+      end
+      Given(:board) { double('board', left: new_board, win?: nil, lose?: nil) }
+      Given(:app) { Text2048::App.new(view, board) }
+      When { app.step }
+      Then { expect(board).to have_received(:left) }
+      And { expect(view).to have_received(:update) }
+    end
+
+    context 'with command = :right' do
+      Given(:view) do
+        double('view', command: :right, update: nil, pop_tiles: nil)
+      end
+      Given(:board) do
+        double('board', right: new_board, win?: nil, lose?: nil)
+      end
+      Given(:app) { Text2048::App.new(view, board) }
+      When { app.step }
+      Then { expect(board).to have_received(:right) }
+      And { expect(view).to have_received(:update) }
+    end
+
+    context 'with command = :up' do
+      Given(:view) do
+        double('view', command: :up, update: nil, pop_tiles: nil)
+      end
+      Given(:board) { double('board', up: new_board, win?: nil, lose?: nil) }
+      Given(:app) { Text2048::App.new(view, board) }
+      When { app.step }
+      Then { expect(board).to have_received(:up) }
+      And { expect(view).to have_received(:update) }
+    end
+
+    context 'with command = :down' do
+      Given(:view) do
+        double('view', command: :down, update: nil, pop_tiles: nil)
+      end
+      Given(:board) { double('board', down: new_board, win?: nil, lose?: nil) }
+      Given(:app) { Text2048::App.new(view, board) }
+      When { app.step }
+      Then { expect(board).to have_received(:down) }
+      And { expect(view).to have_received(:update) }
+    end
+
+    context 'with command = :quit' do
+      Given(:view) { double('view', command: :quit) }
+      Given(:app) { Text2048::App.new(view) }
+      When(:result) { app.step }
+      Then { result == Failure(SystemExit) }
+    end
+  end
+end

data/spec/text2048/board_spec.rb

@@ -2,63 +2,71 @@
 
 require 'text2048'
 
-describe Text2048::Board, '.new' do
-  context 'without arguments' do
-    Given(:board) { Text2048::Board.new }
+describe Text2048::Board do
+  Given(:board) do
+    initial_tiles ? Text2048::Board.new(initial_tiles) : Text2048::Board.new
+  end
+  Invariant { board.score == 0 }
+  Invariant { board.generated_tiles.empty? }
+  Invariant { board.merged_tiles.empty? }
+
+  context 'with no arguments' do
+    Given(:initial_tiles) {}
 
-    Then { board.generated_tiles.empty? }
-    And { board.merged_tiles.empty? }
-    And { board.score == 0 }
+    describe '#tiles' do
+      When(:tiles) { board.tiles }
+      Then { tiles.empty? }
+    end
 
     describe '#generate' do
-      When { board.generate }
-      Then { board.generated_tiles.size == 1 }
+      When(:new_board) { board.generate }
+      Then { new_board.generated_tiles.size == 1 }
     end
-  end
 
-  context 'with one 2048 tile' do
-    Given(:board) do
-      Text2048::Board.new([[0, 0, 0, 0],
-                           [0, 0, 0, 0],
-                           [0, 2048, 0, 0],
-                           [0, 0, 0, 0]])
+    describe '#generate?' do
+      context 'with empty board' do
+        Given(:other) { Text2048::Board.new }
+        When(:result) { board.generate?(other) }
+        Then { result == false }
+      end
     end
 
-    Then { board.win? }
-  end
+    describe '#win?' do
+      When(:result) { board.win? }
+      Then { result == false }
+    end
 
-  context 'with tiles which cannot be merged' do
-    Given(:board) do
-      Text2048::Board.new([[2, 4, 8, 16],
-                           [4, 8, 16, 32],
-                           [8, 16, 32, 64],
-                           [16, 32, 64, 128]])
+    describe '#lose?' do
+      When(:result) { board.lose? }
+      Then { result == false }
     end
 
-    Then { board.lose? }
-  end
+    describe '#right' do
+      When(:result) { board.right }
 
-  context 'with all zeroes' do
-    Given(:board) do
-      Text2048::Board.new([[0, 0, 0, 0],
-                           [0, 0, 0, 0],
-                           [0, 0, 0, 0],
-                           [0, 0, 0, 0]])
+      Then do
+        result.to_a == [[0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0]]
+      end
+      And { result.score == 0 }
     end
 
-    describe '#to_a' do
-      When(:result) { board.to_a }
+    describe '#left' do
+      When(:result) { board.left }
 
       Then do
-        result == [[0, 0, 0, 0],
-                   [0, 0, 0, 0],
-                   [0, 0, 0, 0],
-                   [0, 0, 0, 0]]
+        result.to_a == [[0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0]]
       end
+      And { result.score == 0 }
     end
 
-    describe '#right' do
-      When(:result) { board.right }
+    describe '#up' do
+      When(:result) { board.up }
 
       Then do
         result.to_a == [[0, 0, 0, 0],
@@ -68,14 +76,68 @@ describe Text2048::Board, '.new' do
       end
       And { result.score == 0 }
     end
+
+    describe '#down' do
+      When(:result) { board.down }
+
+      Then do
+        result.to_a == [[0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0]]
+      end
+      And { result.score == 0 }
+    end
+
+    describe '#to_a' do
+      When(:result) { board.to_a }
+      Then do
+        result == [[0, 0, 0, 0],
+                   [0, 0, 0, 0],
+                   [0, 0, 0, 0],
+                   [0, 0, 0, 0]]
+      end
+    end
   end
 
-  context 'with four 2s' do
-    Given(:board) do
-      Text2048::Board.new([[2, 0, 0, 0],
-                           [0, 2, 0, 0],
-                           [0, 0, 2, 0],
-                           [0, 0, 0, 2]])
+  context 'with four 2s in diagonal' do
+    Given(:initial_tiles) do
+      [[2, 0, 0, 0],
+       [0, 2, 0, 0],
+       [0, 0, 2, 0],
+       [0, 0, 0, 2]]
+    end
+
+    describe '#tiles' do
+      When(:tiles) { board.tiles }
+      Then { board.tiles.size == 4 }
+      And { board.tiles[[0, 0]] == 2 }
+      And { board.tiles[[1, 1]] == 2 }
+      And { board.tiles[[2, 2]] == 2 }
+      And { board.tiles[[3, 3]] == 2 }
+    end
+
+    describe '#generate' do
+      When(:new_board) { board.generate }
+      Then { new_board.generated_tiles.size == 1 }
+    end
+
+    describe '#generate?' do
+      context 'with empty board' do
+        Given(:other) { Text2048::Board.new }
+        When(:result) { board.generate?(other) }
+        Then { result == true }
+      end
+    end
+
+    describe '#win?' do
+      When(:result) { board.win? }
+      Then { result == false }
+    end
+
+    describe '#lose?' do
+      When(:result) { board.lose? }
+      Then { result == false }
     end
 
     describe '#right' do
@@ -87,16 +149,100 @@ describe Text2048::Board, '.new' do
                         [0, 0, 0, 2],
                         [0, 0, 0, 2]]
       end
+      And { result.merged_tiles.empty? }
       And { result.score == 0 }
     end
+
+    describe '#left' do
+      When(:result) { board.left }
+
+      Then do
+        result.to_a == [[2, 0, 0, 0],
+                        [2, 0, 0, 0],
+                        [2, 0, 0, 0],
+                        [2, 0, 0, 0]]
+      end
+      And { result.merged_tiles.empty? }
+      And { result.score == 0 }
+    end
+
+    describe '#up' do
+      When(:result) { board.up }
+
+      Then do
+        result.to_a == [[2, 2, 2, 2],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0]]
+      end
+      And { result.merged_tiles.empty? }
+      And { result.score == 0 }
+    end
+
+    describe '#down' do
+      When(:result) { board.down }
+
+      Then do
+        result.to_a == [[0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [2, 2, 2, 2]]
+      end
+      And { result.merged_tiles.empty? }
+      And { result.score == 0 }
+    end
+
+    describe '#to_a' do
+      When(:result) { board.to_a }
+      Then do
+        result == [[2, 0, 0, 0],
+                   [0, 2, 0, 0],
+                   [0, 0, 2, 0],
+                   [0, 0, 0, 2]]
+      end
+    end
   end
 
   context 'with six 2s that can be merged' do
-    Given(:board) do
-      Text2048::Board.new([[2, 0, 2, 0],
-                           [0, 2, 0, 0],
-                           [0, 2, 0, 2],
-                           [0, 0, 0, 2]])
+    Given(:initial_tiles) do
+      [[2, 0, 2, 0],
+       [0, 2, 0, 0],
+       [0, 2, 0, 2],
+       [0, 0, 0, 2]]
+    end
+
+    describe '#tiles' do
+      When(:tiles) { board.tiles }
+      Then { board.tiles.size == 6 }
+      And { board.tiles[[0, 0]] == 2 }
+      And { board.tiles[[0, 2]] == 2 }
+      And { board.tiles[[1, 1]] == 2 }
+      And { board.tiles[[2, 1]] == 2 }
+      And { board.tiles[[2, 3]] == 2 }
+      And { board.tiles[[3, 3]] == 2 }
+    end
+
+    describe '#generate' do
+      When(:new_board) { board.generate }
+      Then { new_board.generated_tiles.size == 1 }
+    end
+
+    describe '#generate?' do
+      context 'with empty board' do
+        Given(:other) { Text2048::Board.new }
+        When(:result) { board.generate?(other) }
+        Then { result == true }
+      end
+    end
+
+    describe '#win?' do
+      When(:result) { board.win? }
+      Then { result == false }
+    end
+
+    describe '#lose?' do
+      When(:result) { board.lose? }
+      Then { result == false }
     end
 
     describe '#right' do
@@ -108,8 +254,143 @@ describe Text2048::Board, '.new' do
                         [0, 0, 0, 4],
                         [0, 0, 0, 2]]
       end
-      And { result[[0, 3]].merged? }
+      And { result.to_a[0][3].merged? }
+      And { result.to_a[2][3].merged? }
+      And { result.merged_tiles == [[0, 3], [2, 3]] }
+      And { result.score == 8 }
+    end
+
+    describe '#left' do
+      When(:result) { board.left }
+
+      Then do
+        result.to_a == [[4, 0, 0, 0],
+                        [2, 0, 0, 0],
+                        [4, 0, 0, 0],
+                        [2, 0, 0, 0]]
+      end
+      And { result.to_a[0][0].merged? }
+      And { result.to_a[2][0].merged? }
+      And { result.merged_tiles == [[0, 0], [2, 0]] }
+      And { result.score == 8 }
+    end
+
+    describe '#up' do
+      When(:result) { board.up }
+
+      Then do
+        result.to_a == [[2, 4, 2, 4],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0]]
+      end
+      And { result.to_a[0][1].merged? }
+      And { result.to_a[0][3].merged? }
+      And { result.merged_tiles == [[0, 1], [0, 3]] }
+      And { result.score == 8 }
+    end
+
+    describe '#down' do
+      When(:result) { board.down }
+
+      Then do
+        result.to_a == [[0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [2, 4, 2, 4]]
+      end
+      And { result.to_a[3][1].merged? }
+      And { result.to_a[3][3].merged? }
+      And { result.merged_tiles == [[3, 1], [3, 3]] }
       And { result.score == 8 }
     end
+
+    describe '#to_a' do
+      When(:result) { board.to_a }
+      Then do
+        result == [[2, 0, 2, 0],
+                   [0, 2, 0, 0],
+                   [0, 2, 0, 2],
+                   [0, 0, 0, 2]]
+      end
+    end
+  end
+
+  context 'with one 2048 tile' do
+    Given(:initial_tiles) do
+      [[0, 0, 0, 0],
+       [0, 0, 0, 0],
+       [0, 2048, 0, 0],
+       [0, 0, 0, 0]]
+    end
+
+    describe '#win?' do
+      When(:result) { board.win? }
+      Then { result == true }
+    end
+
+    describe '#lose?' do
+      When(:result) { board.lose? }
+      Then { result == false }
+    end
+  end
+
+  context 'with 16 tiles which cannot be merged' do
+    Given(:initial_tiles) do
+      [[2, 4, 8, 16],
+       [4, 8, 16, 32],
+       [8, 16, 32, 64],
+       [16, 32, 64, 128]]
+    end
+
+    describe '#tiles' do
+      When(:result) { board.tiles }
+      Then { result.size == 16 }
+    end
+
+    describe '#generate' do
+      When(:result) { board.generate }
+      Then { result == Failure(RuntimeError) }
+    end
+
+    describe '#win?' do
+      When(:result) { board.win? }
+      Then { result == false }
+    end
+
+    describe '#lose?' do
+      When(:result) { board.lose? }
+      Then { result == true }
+    end
+
+    describe '#right' do
+      When(:result) { board.right }
+      Then { result.to_a == board.to_a }
+    end
+
+    describe '#left' do
+      When(:result) { board.left }
+      Then { result.to_a == board.to_a }
+    end
+
+    describe '#up' do
+      When(:result) { board.up }
+      Then { result.to_a == board.to_a }
+    end
+
+    describe '#down' do
+      When(:result) { board.down }
+      Then { result.to_a == board.to_a }
+    end
+
+    describe '#to_a' do
+      When(:result) { board.to_a }
+      Then do
+        result == [[2, 4, 8, 16],
+                   [4, 8, 16, 32],
+                   [8, 16, 32, 64],
+                   [16, 32, 64, 128]]
+      end
+    end
   end
 end