RubyGems - shoulda-matchers - Versions diffs - 4.0.0.rc1 → 4.0.1 - Mend

shoulda-matchers 4.0.0.rc1 → 4.0.1

Files changed (209) hide show

data/spec/unit/shoulda/matchers/action_controller/route_params_spec.rb DELETED

@@ -1,30 +0,0 @@
-require 'unit_spec_helper'
-describe Shoulda::Matchers::ActionController::RouteParams, type: :controller do
-  describe "#normalize" do
-    context "when the route parameters is a hash" do
-      it "stringifies the values in the hash" do
-        expect(build_route_params(controller: :examples, action: 'example', id: '1').normalize).
-          to eq({ controller: "examples", action: "example", id: "1" })
-      end
-    end
-    context "when the route parameters is a string and a hash" do
-      it "produces a hash of route parameters" do
-        expect(build_route_params("examples#example", id: '1').normalize).
-          to eq({ controller: "examples", action: "example", id: "1" })
-      end
-    end
-    context "when the route params is a string" do
-      it "produces a hash of route params" do
-        expect(build_route_params("examples#index").normalize).
-          to eq({ controller: "examples", action: "index"})
-      end
-    end
-  end
-  def build_route_params(*params)
-    Shoulda::Matchers::ActionController::RouteParams.new(params)
-  end
-end

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

@@ -1,67 +0,0 @@
-require 'unit_spec_helper'
-describe Shoulda::Matchers::ActionController::SetFlashMatcher, type: :controller do
-  it_behaves_like 'set session or flash matcher' do
-    def store_name
-      'flash'
-    end
-    def set_store
-      set_flash
-    end
-    def store_within(controller)
-      controller.flash
-    end
-  end
-  it_behaves_like 'set session or flash matcher' do
-    def store_name
-      'flash.now'
-    end
-    def set_store
-      set_flash.now
-    end
-    def store_within(controller)
-      controller.flash.now
-    end
-  end
-  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
-      expect(controller).not_to set_flash['key for flash.now']
-      expect(controller).not_to set_flash.now['key for flash']
-    end
-  end
-  context 'when the now qualifier is called after the key is set' do
-    it 'raises a QualifierOrderError' do
-      controller = build_fake_response
-      usage = lambda do
-        expect(controller).to set_flash['any key'].now
-      end
-      expect(&usage).to raise_error(described_class::QualifierOrderError)
-    end
-  end
-  context 'when the now qualifier is called after the to qualifier' do
-    it 'raises a QualifierOrderError' do
-      controller = build_fake_response
-      usage = lambda do
-        expect(controller).to set_flash.to('any value').now
-      end
-      expect(&usage).to raise_error(described_class::QualifierOrderError)
-    end
-  end
-end

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

@@ -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 DELETED

@@ -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