shoulda-matchers 2.8.0 → 3.0.0.rc1

data/spec/unit/shoulda/matchers/action_controller/set_flash_matcher_spec.rb

@@ -1,167 +1,43 @@
 require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActionController, type: :controller do
-  describe '#set_the_flash' do
-    it 'is deprecated in favor of #set_flash' do
-      expect { set_the_flash }.to deprecate(:set_the_flash, :set_flash)
+describe Shoulda::Matchers::ActionController::SetFlashMatcher, type: :controller do
+  it_behaves_like 'set session or flash matcher' do
+    def store_name
+      'flash'
     end
 
-    it 'still works regardless' do
-      silence_warnings do
-        expect(controller_with_flash(notice: 'hi')).to set_the_flash
-      end
-    end
-  end
-
-  describe '#set_flash' do
-    it 'fails with unmatchable #to' do
-      expect { set_flash.to(1) }.to raise_error('cannot match against 1')
+    def set_store
+      set_flash
     end
 
-    context 'a controller that sets a flash message' do
-      it 'accepts setting any flash message' do
-        expect(controller_with_flash(notice: 'hi')).to set_flash
-      end
-
-      it 'accepts setting the exact flash message' do
-        expect(controller_with_flash(notice: 'hi')).to set_flash.to('hi')
-      end
-
-      it 'accepts setting a matched flash message' do
-        expect(controller_with_flash(notice: 'hello')).to set_flash.to(/he/)
-      end
-
-      it 'rejects setting a different flash message' do
-        expect(controller_with_flash(notice: 'hi')).
-          not_to set_flash.to('other')
-      end
-
-      it 'rejects setting a different pattern' do
-        expect(controller_with_flash(notice: 'hi')).
-          not_to set_flash.to(/other/)
-      end
+    def store_within(controller)
+      controller.flash
     end
+  end
 
-    context 'a controller that sets a flash.now message' do
-      it 'rejects setting any flash message' do
-        expect(controller_with_flash_now).not_to set_flash
-      end
-
-      it 'accepts setting any flash.now message' do
-        expect(controller_with_flash_now).to set_flash.now
-      end
-
-      it 'accepts setting the exact flash.now message' do
-        expect(controller_with_flash_now(notice: 'hi')).
-          to set_flash.now.to('hi')
-      end
-
-      it 'accepts setting a matched flash.now message' do
-        expect(controller_with_flash_now(notice: 'flasher')).
-          to set_flash.now.to(/lash/)
-      end
-
-      it 'rejects setting a different flash.now message' do
-        expect(controller_with_flash_now(notice: 'hi')).
-          not_to set_flash.now.to('other')
-      end
-
-      it 'rejects setting a different flash.now pattern' do
-        expect(controller_with_flash_now(notice: 'hi')).
-          not_to set_flash.now.to(/other/)
-      end
-    end
-
-    context 'a controller that sets flash messages for multiple keys' do
-      it 'accepts flash message for either key' do
-        controller = controller_with_flash(notice: 'one', alert: 'two')
-
-        expect(controller).to set_flash[:notice]
-        expect(controller).to set_flash[:alert]
-      end
-
-      it 'rejects a flash message that is not one of the set keys' do
-        expect(controller_with_flash(notice: 'one', alert: 'two')).
-          not_to set_flash[:warning]
-      end
-
-      it 'accepts exact flash message of notice' do
-        expect(controller_with_flash(notice: 'one', alert: 'two')).
-          to set_flash[:notice].to('one')
-      end
-
-      it 'accepts setting a matched flash message of notice' do
-        expect(controller_with_flash(notice: 'one', alert: 'two')).
-          to set_flash[:notice].to(/on/)
-      end
-
-      it 'rejects setting a different flash message of notice' do
-        expect(controller_with_flash(notice: 'one', alert: 'two')).
-          not_to set_flash[:notice].to('other')
-      end
-
-      it 'rejects setting a different pattern' do
-        expect(controller_with_flash(notice: 'one', alert: 'two')).
-          not_to set_flash[:notice].to(/other/)
-      end
+  it_behaves_like 'set session or flash matcher' do
+    def store_name
+      'flash.now'
     end
 
-    context 'a controller that sets flash and flash.now' do
-      it 'accepts setting any flash.now message' do
-        controller = build_fake_response do
-          flash.now[:notice] = 'value'
-          flash[:success] = 'great job'
-        end
-
-        expect(controller).to set_flash.now
-        expect(controller).to set_flash
-      end
-
-      it 'accepts setting a matched flash.now message' do
-        controller = build_fake_response do
-          flash.now[:notice] = 'value'
-          flash[:success] = 'great job'
-        end
-
-        expect(controller).to set_flash.now.to(/value/)
-        expect(controller).to set_flash.to(/great/)
-      end
-
-      it 'rejects setting a different flash.now message' do
-        controller = build_fake_response do
-          flash.now[:notice] = 'value'
-          flash[:success] = 'great job'
-        end
-
-        expect(controller).not_to set_flash.now.to('other')
-        expect(controller).not_to set_flash.to('other')
-      end
+    def set_store
+      set_flash.now
     end
 
-    context 'a controller that does not set a flash message' do
-      it 'rejects setting any flash message' do
-        expect(controller_with_no_flashes).not_to set_flash
-      end
+    def store_within(controller)
+      controller.flash.now
     end
   end
 
-  def controller_with_no_flashes
-    build_fake_response
-  end
-
-  def controller_with_flash(flash_hash)
-    build_fake_response do
-      flash_hash.each do |key, value|
-        flash[key] = value
+  context 'when the controller sets both flash and flash.now' do
+    it 'does not mix flash and flash.now' do
+      controller = build_fake_response do
+        flash['key for flash'] = 'value for flash'
+        flash.now['key for flash.now'] = 'value for flash.now'
       end
-    end
-  end
 
-  def controller_with_flash_now(flash_hash = { notice: 'hi' })
-    build_fake_response do
-      flash_hash.each do |key, value|
-        flash.now[key] = value
-      end
+      expect(controller).not_to set_flash['key for flash.now']
+      expect(controller).not_to set_flash.now['key for flash']
     end
   end
 end

data/spec/unit/shoulda/matchers/action_controller/set_session_matcher_spec.rb

@@ -1,294 +1,17 @@
 require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActionController, '#set_session', type: :controller do
-  context 'passing an argument to the initializer' do
-    it 'is deprecated in favor of using #[]' do
-      expectation = proc { set_session(:foo) }
-
-      expect(&expectation).to print_warning_including(
-        'Passing a key to set_session is deprecated'
-      )
-    end
-
-    it 'still works regardless' do
-      silence_warnings do
-        expect(controller_with_session(var: 'hi')).to set_session(:var)
-      end
-    end
-  end
-
-  context 'a controller that sets a session variable' do
-    context 'without any qualifiers' do
-      it 'accepts' do
-        expect(controller_with_session(var: 'hi')).to set_session
-      end
-    end
-
-    context 'with #to' do
-      context 'given a static value' do
-        context 'when any key in session has the given value' do
-          it 'accepts' do
-            expect(controller_with_session(var: 'hi')).
-              to set_session.to('hi')
-          end
-
-          it 'accepts given nil' do
-            silence_warnings do
-              expect(controller_with_session(var: nil)).
-                to set_session.to(nil)
-            end
-          end
-
-          it 'accepts given false' do
-            expect(controller_with_session(var: false)).
-              to set_session.to(false)
-          end
-        end
-
-        context 'when no key in session has the given value' do
-          it 'rejects' do
-            expect(controller_with_session(var: 'hi')).
-              not_to set_session.to('different')
-          end
-        end
-      end
-
-      context 'given a dynamic value' do
-        context 'when any key in session has the given value' do
-          it 'accepts' do
-            context = double(expected: 'hi')
-            expect(controller_with_session(var: 'hi')).
-              to set_session.in_context(context).to { expected }
-          end
-
-          it 'accepts given nil' do
-            silence_warnings do
-              context = double(expected: nil)
-              expect(controller_with_session(var: nil)).
-                to set_session.in_context(context).to { expected }
-            end
-          end
-
-          it 'accepts given false' do
-            context = double(expected: false)
-            expect(controller_with_session(var: false)).
-              to set_session.in_context(context).to { expected }
-          end
-        end
-
-        context 'when no key in session has the given value' do
-          it 'rejects' do
-            context = double(expected: 'different')
-            expect(controller_with_session(var: 'hi')).
-              not_to set_session.in_context(context).to { expected }
-          end
-        end
-      end
-
-      context 'given a regexp' do
-        context 'when any value in session matches the regexp' do
-          it 'accepts' do
-            expect(controller_with_session(var: 'hello')).
-              to set_session.to(/ello/)
-          end
-        end
-
-        context 'when no value in session matches the regexp' do
-          it 'rejects' do
-            expect(controller_with_session(var: 'hello')).
-              not_to set_session.to(/different/)
-          end
-        end
-      end
-    end
-
-    context 'with #[]' do
-      context 'when the given key is present in session' do
-        it 'accepts' do
-          expect(controller_with_session(var: 'hi')).to set_session[:var]
-        end
-
-        it 'accepts when expected key is a string' do
-          expect(controller_with_session(var: 'hi')).to set_session['var']
-        end
-      end
-
-      context 'when the given key is not present in session' do
-        it 'rejects' do
-          expect(controller_with_session(var: 'hi')).not_to set_session[:other]
-        end
-      end
-    end
-
-    context 'with #[] + #to' do
-      context 'given a static value' do
-        context 'when the given key and value are present in session' do
-          it 'accepts' do
-            expect(controller_with_session(var: 'hi')).
-              to set_session[:var].to('hi')
-          end
-
-          it 'accepts given nil' do
-            silence_warnings do
-              expect(controller_with_session(var: nil)).
-                to set_session[:var].to(nil)
-            end
-          end
-
-          it 'accepts given false' do
-            expect(controller_with_session(var: false)).
-              to set_session[:var].to(false)
-          end
-        end
-
-        context 'when the given key is present in session but not the given value' do
-          it 'rejects' do
-            expect(controller_with_session(var: 'hi')).
-              not_to set_session[:var].to('other')
-          end
-
-          it 'rejects given nil' do
-            expect(controller_with_session(var: 'hi')).
-              not_to set_session[:var].to(nil)
-          end
-        end
-
-        context 'when the given key is not present in session' do
-          it 'accepts given nil' do
-            silence_warnings do
-              expect(controller_with_session(var: 'hi')).
-                to set_session[:other].to(nil)
-            end
-          end
-
-          it 'rejects given false' do
-            expect(controller_with_session(var: false)).
-              not_to set_session[:other].to(false)
-          end
-        end
-      end
-
-      context 'given a dynamic value' do
-        context 'when the given key and value are present in session' do
-          it 'accepts' do
-            context = double(expected: 'value')
-
-            expect(controller_with_session(var: 'value')).
-              to set_session[:var].in_context(context).to { expected }
-          end
-
-          it 'accepts given nil' do
-            silence_warnings do
-              context = double(expected: nil)
-
-              expect(controller_with_session(var: nil)).
-                to set_session[:var].in_context(context).to { expected }
-            end
-          end
-
-          it 'accepts given false' do
-            context = double(expected: false)
-
-            expect(controller_with_session(var: false)).
-              to set_session[:var].in_context(context).to { expected }
-          end
-        end
-
-        context 'when the given key is present in session but not the given value' do
-          it 'rejects given nil' do
-            context = double(expected: nil)
-
-            expect(controller_with_session(var: 'hi')).
-              not_to set_session[:var].in_context(context).to { expected }
-          end
-
-          it 'rejects given false' do
-            context = double(expected: false)
-
-            expect(controller_with_session(var: 'hi')).
-              not_to set_session[:var].in_context(context).to { expected }
-          end
-        end
-
-        context 'when the given key is not present in session' do
-          it 'rejects' do
-            context = double(expected: 'other')
-
-            expect(controller_with_session(var: 'unexpected')).
-              not_to set_session[:var].in_context(context).to { expected }
-          end
-
-          it 'accepts given nil' do
-            silence_warnings do
-              context = double(expected: nil)
-
-              expect(controller_with_session(var: 'hi')).
-                to set_session[:other].in_context(context).to { expected }
-            end
-          end
-
-          it 'rejects given false' do
-            context = double(expected: false)
-
-            expect(controller_with_session(var: false)).
-              not_to set_session[:other].in_context(context).to { expected }
-          end
-        end
-      end
-    end
-  end
-
-  context 'a controller that does not set any session variables' do
-    context 'without any qualifiers' do
-      it 'rejects' do
-        expect(controller_without_session).not_to set_session
-      end
-    end
-
-    context 'with #[]' do
-      it 'rejects' do
-        expect(controller_without_session).
-          not_to set_session['any key']
-      end
-    end
-
-    context 'with #to' do
-      it 'rejects' do
-        expect(controller_without_session).
-          not_to set_session.to('any value')
-      end
+describe Shoulda::Matchers::ActionController::SetSessionMatcher, type: :controller do
+  it_behaves_like 'set session or flash matcher' do
+    def store_name
+      'session'
     end
 
-    context 'with #[] + #to' do
-      it 'rejects' do
-        expect(controller_without_session).
-          not_to set_session['any key'].to('any value')
-      end
-
-      it 'prints a warning when using .to(nil) to assert that a variable is unset' do
-        expectation = proc do
-          expect(controller_without_session).to set_session['any key'].to(nil)
-        end
-
-        expected_warning = <<EOT
-  Using `should set_session[...].to(nil)` to assert that a variable is unset is deprecated.
-  Please use `should_not set_session[...]` instead.
-EOT
-
-        expect(&expectation).to print_warning_including(expected_warning)
-      end
+    def set_store
+      set_session
     end
-  end
-
-  def controller_without_session
-    build_fake_response
-  end
 
-  def controller_with_session(session_hash)
-    build_fake_response do
-      session_hash.each do |key, value|
-        session[key] = value
-      end
+    def store_within(controller)
+      controller.session
     end
   end
 end