shoulda-matchers 3.1.0 → 5.2.0

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

@@ -1,17 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActionController::SetSessionMatcher, type: :controller do
-  it_behaves_like 'set session or flash matcher' do
-    def store_name
-      'session'
-    end
-
-    def set_store
-      set_session
-    end
-
-    def store_within(controller)
-      controller.session
-    end
-  end
-end

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

@@ -1,562 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActionController::SetSessionOrFlashMatcher do
-  context 'without any qualifiers' do
-    it 'produces the right description' do
-      store = build_store(name: 'flash')
-      matcher = described_class.new(store)
-      expected_description = 'should set any key in flash'
-
-      expect(matcher.description).to eq expected_description
-    end
-
-    context 'in the positive' do
-      context 'if the store is not empty' do
-        it 'accepts' do
-          controller = define_class('MyController').new
-          store = build_store(empty?: false)
-          matcher = described_class.new(store)
-
-          expect(controller).to matcher
-        end
-      end
-
-      context 'if the store is empty' do
-        it 'rejects' do
-          controller = define_class('MyController').new
-          store = build_store(empty?: true)
-          matcher = described_class.new(store)
-
-          expect(controller).not_to matcher
-        end
-
-        it 'produces the correct failure message' do
-          controller = define_class('MyController').new
-          store = build_store(name: 'flash', empty?: true)
-          matcher = described_class.new(store)
-          expected_message = 'Expected MyController to set any key in flash, but it did not'
-
-          expect { expect(controller).to matcher }.
-            to fail_with_message(expected_message)
-        end
-      end
-    end
-
-    context 'in the negative' do
-      context 'if the given key is present in the store' do
-        it 'produces the correct failure message' do
-          controller = define_class('MyController').new
-          store = build_store(name: 'flash', empty?: false)
-          matcher = described_class.new(store)
-          expected_message = 'Expected MyController not to set any key in flash, but it did'
-
-          expect { expect(controller).not_to matcher }.
-            to fail_with_message(expected_message)
-        end
-      end
-    end
-  end
-
-  context 'with #[]' do
-    it 'produces the right description' do
-      store = build_store(name: 'flash')
-      matcher = described_class.new(store)['the key']
-      expected_description = 'should set flash["the key"]'
-
-      expect(matcher.description).to eq expected_description
-    end
-
-    context 'in the positive' do
-      context 'if the given key is present in the store' do
-        it 'accepts' do
-          controller = define_class('MyController').new
-          store = build_store
-          allow(store).to receive(:has_key?).
-            with('the key').
-            and_return(true)
-          matcher = described_class.new(store)['the key']
-
-          expect(controller).to matcher
-        end
-      end
-
-      context 'if the given key is not present in the store' do
-        it 'rejects' do
-          controller = define_class('MyController').new
-          store = build_store
-          allow(store).to receive(:has_key?).
-            with('the key').
-            and_return(false)
-          matcher = described_class.new(store)['the key']
-
-          expect(controller).not_to matcher
-        end
-
-        it 'produces the correct failure message' do
-          controller = define_class('MyController').new
-          store = build_store(name: 'flash')
-          allow(store).to receive(:has_key?).
-            with('the key').
-            and_return(false)
-          matcher = described_class.new(store)['the key']
-          expected_message = 'Expected MyController to set flash["the key"], but it did not'
-
-          expect { expect(controller).to matcher }.
-            to fail_with_message(expected_message)
-        end
-      end
-    end
-
-    context 'in the negative' do
-      context 'if the given key is present in the store' do
-        it 'produces the correct failure message' do
-          controller = define_class('MyController').new
-          store = build_store(name: 'flash')
-          allow(store).to receive(:has_key?).
-            with('the key').
-            and_return(true)
-          matcher = described_class.new(store)['the key']
-          expected_message = 'Expected MyController not to set flash["the key"], but it did'
-
-          expect { expect(controller).not_to matcher }.
-            to fail_with_message(expected_message)
-        end
-      end
-    end
-  end
-
-  context 'with #to' do
-    context 'given a static value' do
-      it 'produces the right description' do
-        store = build_store(name: 'flash')
-        matcher = described_class.new(store).to('the value')
-        expected_description = 'should set any key in flash to "the value"'
-
-        expect(matcher.description).to eq expected_description
-      end
-
-      context 'in the positive' do
-        context 'if the given value is present in the store' do
-          it 'accepts' do
-            controller = define_class('MyController').new
-            store = build_store
-            allow(store).to receive(:has_value?).
-              with('the value').
-              and_return(true)
-            matcher = described_class.new(store).to('the value')
-
-            expect(controller).to matcher
-          end
-
-          it 'accepts given a value of nil' do
-            controller = define_class('MyController').new
-            store = build_store
-            allow(store).to receive(:has_value?).
-              with(nil).
-              and_return(true)
-            matcher = described_class.new(store).to(nil)
-
-            expect(controller).to matcher
-          end
-
-          it 'accepts given a value of false' do
-            controller = define_class('MyController').new
-            store = build_store
-            allow(store).to receive(:has_value?).
-              with(false).
-              and_return(true)
-            matcher = described_class.new(store).to(false)
-
-            expect(controller).to matcher
-          end
-        end
-
-        context 'if the given value is not present in the store' do
-          it 'rejects' do
-            controller = define_class('MyController').new
-            store = build_store
-            allow(store).to receive(:has_value?).
-              with('the value').
-              and_return(false)
-            matcher = described_class.new(store).to('the value')
-
-            expect(controller).not_to matcher
-          end
-
-          it 'produces the correct failure message' do
-            controller = define_class('MyController').new
-            store = build_store(name: 'flash')
-            allow(store).to receive(:has_value?).
-              with('the value').
-              and_return(false)
-            matcher = described_class.new(store).to('the value')
-            expected_message = 'Expected MyController to set any key in flash to "the value", but it did not'
-
-            expect { expect(controller).to matcher }.
-              to fail_with_message(expected_message)
-          end
-        end
-      end
-
-      context 'in the negative' do
-        context 'if the given value is present in the store' do
-          it 'produces the correct failure message' do
-            controller = define_class('MyController').new
-            store = build_store(name: 'flash')
-            allow(store).to receive(:has_value?).
-              with('the value').
-              and_return(true)
-            matcher = described_class.new(store).to('the value')
-            expected_message = 'Expected MyController not to set any key in flash to "the value", but it did'
-
-            expect { expect(controller).not_to matcher }.
-              to fail_with_message(expected_message)
-          end
-        end
-      end
-    end
-
-    context 'given a regexp' do
-      it 'produces the right description' do
-        store = build_store(name: 'flash')
-        matcher = described_class.new(store).to(/the value/)
-        expected_description = 'should set any key in flash to a value matching /the value/'
-
-        expect(matcher.description).to eq expected_description
-      end
-
-      context 'in the positive' do
-        context 'if the given value is present in the store' do
-          it 'accepts' do
-            controller = define_class('MyController').new
-            store = build_store
-            allow(store).to receive(:has_value?).
-              with(/the value/).
-              and_return(true)
-            matcher = described_class.new(store).to(/the value/)
-
-            expect(controller).to matcher
-          end
-        end
-
-        context 'if the given value is not present in the store' do
-          it 'rejects' do
-            controller = define_class('MyController').new
-            store = build_store
-            allow(store).to receive(:has_value?).
-              with(/the value/).
-              and_return(false)
-            matcher = described_class.new(store).to(/the value/)
-
-            expect(controller).not_to matcher
-          end
-
-          it 'produces the correct failure message' do
-            controller = define_class('MyController').new
-            store = build_store(name: 'flash')
-            allow(store).to receive(:has_value?).
-              with(/the value/).
-              and_return(false)
-            matcher = described_class.new(store).to(/the value/)
-            expected_message = 'Expected MyController to set any key in flash to a value matching /the value/, but it did not'
-
-            expect { expect(controller).to matcher }.
-              to fail_with_message(expected_message)
-          end
-        end
-      end
-
-      context 'in the negative' do
-        context 'if the given value is present in the store' do
-          it 'produces the correct failure message' do
-            controller = define_class('MyController').new
-            store = build_store(name: 'flash')
-            allow(store).to receive(:has_value?).
-              with(/the value/).
-              and_return(true)
-            matcher = described_class.new(store).to(/the value/)
-            expected_message = 'Expected MyController not to set any key in flash to a value matching /the value/, but it did'
-
-            expect { expect(controller).not_to matcher }.
-              to fail_with_message(expected_message)
-          end
-        end
-      end
-    end
-
-    context 'given a dynamic value' do
-      it 'produces the right description' do
-        store = build_store(name: 'flash')
-        context = double('context', method_in_context: 'the value')
-        matcher = described_class.new(store).
-          in_context(context).
-          to { method_in_context }
-        expected_description = 'should set any key in flash to "the value"'
-
-        expect(matcher.description).to eq expected_description
-      end
-
-      it 'requires in_context to be specified beforehand' do
-        store = build_store(name: 'flash')
-        matcher = described_class.new(store)
-        expected_message = 'When specifying a value as a block, a context must be specified beforehand, e.g., flash.in_context(context).to { ... }'
-
-        expect { matcher.to { whatever } }.
-          to raise_error(ArgumentError, expected_message)
-      end
-
-      context 'in the positive' do
-        context 'if the value evaluated in the context is present in the store' do
-          it 'accepts' do
-            controller = define_class('MyController').new
-            store = build_store
-            allow(store).to receive(:has_value?).
-              with('the value').
-              and_return(true)
-            context = double('context', method_in_context: 'the value')
-            matcher = described_class.new(store).
-              in_context(context).
-              to { method_in_context }
-
-            expect(controller).to matcher
-          end
-        end
-
-        context 'if the value evaluated in the context is not present in the store' do
-          it 'rejects' do
-            controller = define_class('MyController').new
-            store = build_store
-            allow(store).to receive(:has_value?).
-              with('the value').
-              and_return(false)
-            context = double('context', method_in_context: 'the value')
-            matcher = described_class.new(store).
-              in_context(context).
-              to { method_in_context }
-
-            expect(controller).not_to matcher
-          end
-
-          it 'produces the correct failure message' do
-            controller = define_class('MyController').new
-            store = build_store(name: 'flash')
-            allow(store).to receive(:has_value?).
-              with('the value').
-              and_return(false)
-            context = double('context', method_in_context: 'the value')
-            matcher = described_class.new(store).
-              in_context(context).
-              to { method_in_context }
-            expected_message = 'Expected MyController to set any key in flash to "the value", but it did not'
-
-            expect { expect(controller).to matcher }.
-              to fail_with_message(expected_message)
-          end
-        end
-      end
-
-      context 'in the negative' do
-        context 'if the value evaluated in the context is present in the store' do
-          it 'produces the correct failure message' do
-            controller = define_class('MyController').new
-            store = build_store(name: 'flash')
-            allow(store).to receive(:has_value?).
-              with('the value').
-              and_return(true)
-            context = double('context', method_in_context: 'the value')
-            matcher = described_class.new(store).
-              in_context(context).
-              to { method_in_context }
-            expected_message = 'Expected MyController not to set any key in flash to "the value", but it did'
-
-            expect { expect(controller).not_to matcher }.
-              to fail_with_message(expected_message)
-          end
-        end
-      end
-    end
-  end
-
-  context 'with #[] + #to' do
-    context 'given a static value' do
-      it 'produces the right description' do
-        store = build_store(name: 'flash')
-        matcher = described_class.new(store)['the key'].to('the value')
-        expected_description = 'should set flash["the key"] to "the value"'
-
-        expect(matcher.description).to eq expected_description
-      end
-
-      context 'in the positive' do
-        context 'if the given value is present in the store' do
-          it 'accepts' do
-            controller = define_class('MyController').new
-            store = build_store
-            allow(store).to receive(:has_key?).
-              with('the key').
-              and_return(true)
-            allow(store).to receive(:has_value?).
-              with('the value').
-              and_return(true)
-            matcher = described_class.new(store)['the key'].to('the value')
-
-            expect(controller).to matcher
-          end
-        end
-
-        context 'if the given value is not present in the store' do
-          it 'rejects' do
-            controller = define_class('MyController').new
-            store = build_store
-            allow(store).to receive(:has_key?).
-              with('the key').
-              and_return(true)
-            allow(store).to receive(:has_value?).
-              with('the value').
-              and_return(false)
-            matcher = described_class.new(store)['the key'].to('the value')
-
-            expect(controller).not_to matcher
-          end
-
-          it 'produces the correct failure message' do
-            controller = define_class('MyController').new
-            store = build_store(name: 'flash')
-            allow(store).to receive(:has_key?).
-              with('the key').
-              and_return(true)
-            allow(store).to receive(:has_value?).
-              with('the value').
-              and_return(false)
-            matcher = described_class.new(store)['the key'].to('the value')
-            expected_message = 'Expected MyController to set flash["the key"] to "the value", but it did not'
-
-            expect { expect(controller).to matcher }.
-              to fail_with_message(expected_message)
-          end
-        end
-      end
-
-      context 'in the negative' do
-        context 'if the given value is present in the store' do
-          it 'produces the correct failure message' do
-            controller = define_class('MyController').new
-            store = build_store(name: 'flash')
-            allow(store).to receive(:has_key?).
-              with('the key').
-              and_return(true)
-            allow(store).to receive(:has_value?).
-              with('the value').
-              and_return(true)
-            matcher = described_class.new(store)['the key'].to('the value')
-            expected_message = 'Expected MyController not to set flash["the key"] to "the value", but it did'
-
-            expect { expect(controller).not_to matcher }.
-              to fail_with_message(expected_message)
-          end
-        end
-      end
-    end
-
-    context 'given a dynamic value' do
-      it 'produces the right description' do
-        store = build_store(name: 'flash')
-        context = double('context', method_in_context: 'the value')
-        matcher = described_class.new(store)['the key'].
-          in_context(context).
-          to { method_in_context }
-        expected_description = 'should set flash["the key"] to "the value"'
-
-        expect(matcher.description).to eq expected_description
-      end
-
-      context 'in the positive' do
-        context 'if the value evaluated in the context is present in the store' do
-          it 'accepts' do
-            controller = define_class('MyController').new
-            store = build_store
-            allow(store).to receive(:has_key?).
-              with('the key').
-              and_return(true)
-            allow(store).to receive(:has_value?).
-              with('the value').
-              and_return(true)
-            context = double('context', method_in_context: 'the value')
-            matcher = described_class.new(store)['the key'].
-              in_context(context).
-              to { method_in_context }
-
-            expect(controller).to matcher
-          end
-        end
-
-        context 'if the value evaluated in the context is not present in the store' do
-          it 'rejects' do
-            controller = define_class('MyController').new
-            store = build_store
-            allow(store).to receive(:has_key?).
-              with('the key').
-              and_return(false)
-            context = double('context', method_in_context: 'the value')
-            matcher = described_class.new(store)['the key'].
-              in_context(context).
-              to { method_in_context }
-
-            expect(controller).not_to matcher
-          end
-
-          it 'produces the correct failure message' do
-            controller = define_class('MyController').new
-            store = build_store(name: 'flash')
-            allow(store).to receive(:has_key?).
-              with('the key').
-              and_return(false)
-            context = double('context', method_in_context: 'the value')
-            matcher = described_class.new(store)['the key'].
-              in_context(context).
-              to { method_in_context }
-            expected_message = 'Expected MyController to set flash["the key"] to "the value", but it did not'
-
-            expect { expect(controller).to matcher }.
-              to fail_with_message(expected_message)
-          end
-        end
-      end
-
-      context 'in the negative' do
-        context 'if the value evaluated in the context is present in the store' do
-          it 'produces the correct failure message' do
-            controller = define_class('MyController').new
-            store = build_store(name: 'flash')
-            allow(store).to receive(:has_key?).
-              with('the key').
-              and_return(true)
-            allow(store).to receive(:has_value?).
-              with('the value').
-              and_return(true)
-            context = double('context', method_in_context: 'the value')
-            matcher = described_class.new(store)['the key'].
-              in_context(context).
-              to { method_in_context }
-            expected_message = 'Expected MyController not to set flash["the key"] to "the value", but it did'
-
-            expect { expect(controller).not_to matcher }.
-              to fail_with_message(expected_message)
-          end
-        end
-      end
-    end
-  end
-
-  def build_store(overrides = {})
-    defaults = {
-      :name => 'store',
-      :controller= => nil,
-      :has_key? => nil,
-      :has_value? => nil,
-      :empty? => nil,
-    }
-    methods = defaults.merge(overrides)
-    double('store', methods)
-  end
-end

data/spec/unit/shoulda/matchers/active_model/allow_mass_assignment_of_matcher_spec.rb

@@ -1,115 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::AllowMassAssignmentOfMatcher, type: :model do
-  context '#description' do
-    context 'without a role' do
-      it 'includes the attribute name' do
-        expect(described_class.new(:attr).description).
-          to eq 'allow mass assignment of attr'
-      end
-    end
-
-    if active_model_3_1?
-      context 'with a role' do
-        it 'includes the attribute name and the role' do
-          expect(described_class.new(:attr).as(:admin).description).
-            to eq 'allow mass assignment of attr as admin'
-        end
-      end
-    end
-  end
-
-  context 'an attribute that is blacklisted from mass-assignment' do
-    it 'rejects being mass-assignable' do
-      model = define_model(:example, blacklisted: :string) do
-        attr_protected :blacklisted
-      end.new
-
-      expect(model).not_to allow_mass_assignment_of(:blacklisted)
-    end
-  end
-
-  context 'an attribute that is not whitelisted for mass-assignment' do
-    it 'rejects being mass-assignable' do
-      model = define_model(:example, not_whitelisted: :string,
-        whitelisted: :string) do
-        attr_accessible :whitelisted
-      end.new
-
-      expect(model).not_to allow_mass_assignment_of(:not_whitelisted)
-    end
-  end
-
-  context 'an attribute that is whitelisted for mass-assignment' do
-    it 'accepts being mass-assignable' do
-      expect(define_model(:example, whitelisted: :string) do
-        attr_accessible :whitelisted
-      end.new).to allow_mass_assignment_of(:whitelisted)
-    end
-  end
-
-  context 'an attribute not included in the mass-assignment blacklist' do
-    it 'accepts being mass-assignable' do
-      model = define_model(:example, not_blacklisted: :string,
-        blacklisted: :string) do
-        attr_protected :blacklisted
-      end.new
-
-      expect(model).to allow_mass_assignment_of(:not_blacklisted)
-    end
-  end
-
-  unless active_model_3_2? || active_model_4_0?
-    context 'an attribute on a class with no protected attributes' do
-      it 'accepts being mass-assignable' do
-        expect(no_protected_attributes).to allow_mass_assignment_of(:attr)
-      end
-
-      it 'assigns a negative failure message' do
-        matcher = allow_mass_assignment_of(:attr)
-
-        expect(matcher.matches?(no_protected_attributes)).to eq true
-
-        expect(matcher.failure_message_when_negated).not_to be_nil
-      end
-    end
-
-    def no_protected_attributes
-      define_model(:example, attr: :string).new
-    end
-  end
-
-  context 'an attribute on a class with all protected attributes' do
-    it 'rejects being mass-assignable' do
-      expect(all_protected_attributes).not_to allow_mass_assignment_of(:attr)
-    end
-
-    def all_protected_attributes
-      define_model(:example, attr: :string) do
-        attr_accessible nil
-      end.new
-    end
-  end
-
-  if active_model_3_1?
-    context 'an attribute included in the mass-assignment whitelist for admin role only' do
-      it 'rejects being mass-assignable' do
-        expect(mass_assignable_as_admin).not_to allow_mass_assignment_of(:attr)
-      end
-
-      it 'accepts being mass-assignable for admin' do
-        expect(mass_assignable_as_admin).to allow_mass_assignment_of(:attr).as(:admin)
-      end
-
-      def mass_assignable_as_admin
-        define_model(:example, attr: :string) do
-          attr_accessible :attr, as: :admin
-        end.new
-      end
-    end
-  end
-
-  def define_model(name, columns, &block)
-    super(name, columns, whitelist_attributes: false, &block)
-  end
-end