shoulda-matchers 2.7.0 → 2.8.0.rc1

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

@@ -1,113 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActionController::SetSessionMatcher do
-  context 'a controller that sets a session variable' do
-    it 'accepts assigning to that variable' do
-      expect(controller_with_session(var: 'hi')).to set_session(:var)
-    end
-
-    it 'accepts assigning to that variable with specifying the key by string' do
-      expect(controller_with_session(var: 'hi')).to set_session('var')
-    end
-
-    it 'accepts assigning the correct value to that variable' do
-      expect(controller_with_session(var: 'hi')).to set_session(:var).to('hi')
-    end
-
-    it 'rejects assigning another value to that variable' do
-      expect(controller_with_session(var: 'hi')).not_to set_session(:var).to('other')
-    end
-
-    it 'rejects assigning to another variable' do
-      expect(controller_with_session(var: 'hi')).not_to set_session(:other)
-    end
-
-    it 'accepts assigning nil to another variable' do
-      expect(controller_with_session(var: 'hi')).to set_session(:other).to(nil)
-    end
-
-    it 'rejects assigning nil to that variable' do
-      expect(controller_with_session(var: 'hi')).not_to set_session(:var).to(nil)
-    end
-
-    it 'accepts assigning nil to cleared variable' do
-      expect(controller_with_session(var: nil)).to set_session(:var).to(nil)
-    end
-
-    it 'accepts assigning false to that variable' do
-      expect(controller_with_session(var: false)).to set_session(:var).to(false)
-    end
-
-    it 'rejects assigning false to other variable' do
-      expect(controller_with_session(var: false)).not_to set_session(:other).to(false)
-    end
-
-    it 'rejects assigning false to a variable with value' do
-      expect(controller_with_session(var: 'hi')).not_to set_session(:other).to(false)
-    end
-
-    it 'accepts assigning to the same value in the test context' do
-      context = stub(expected: 'value')
-
-      expect(controller_with_session(var: 'value')).
-        to set_session(:var).in_context(context).to { expected }
-    end
-
-    it 'rejects assigning to the another value in the test context' do
-      context = stub(expected: 'other')
-
-      expect(controller_with_session(var: 'unexpected')).
-        not_to set_session(:var).in_context(context).to { expected }
-    end
-
-    it 'accepts assigning nil to another variable in the test context' do
-      context = stub(expected: nil)
-
-      expect(controller_with_session(var: 'hi')).
-        to set_session(:other).in_context(context).to { expected }
-    end
-
-    it 'rejects assigning nil to that variable in the test context' do
-      context = stub(expected: nil)
-
-      expect(controller_with_session(var: 'hi')).
-        not_to set_session(:var).in_context(context).to { expected }
-    end
-
-    it 'accepts assigning nil to a cleared variable in the test context' do
-      context = stub(expected: nil)
-
-      expect(controller_with_session(var: nil)).
-        to set_session(:var).in_context(context).to { expected }
-    end
-
-    it 'accepts assigning false to that variable in the test context' do
-      context = stub(expected: false)
-
-      expect(controller_with_session(var: false)).
-        to set_session(:var).in_context(context).to { expected }
-    end
-
-    it 'accepts assigning false to other variable in the test context' do
-      context = stub(expected: false)
-
-      expect(controller_with_session(var: false)).
-        not_to set_session(:other).in_context(context).to { expected }
-    end
-
-    it 'accepts assigning false to other variable in the test context' do
-      context = stub(expected: false)
-
-      expect(controller_with_session(var: 'hi')).
-        not_to set_session(:var).in_context(context).to { expected }
-    end
-
-    def controller_with_session(session_hash)
-      build_fake_response do
-        session_hash.each do |key, value|
-          session[key] = value
-        end
-      end
-    end
-  end
-end

data/spec/shoulda/matchers/action_controller/set_the_flash_matcher_spec.rb

@@ -1,153 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActionController::SetTheFlashMatcher do
-  it 'fails with unmatchable #to' do
-    expect { set_the_flash.to(1) }.to raise_error('cannot match against 1')
-  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_the_flash
-    end
-
-    it 'accepts setting the exact flash message' do
-      expect(controller_with_flash(notice: 'hi')).to set_the_flash.to('hi')
-    end
-
-    it 'accepts setting a matched flash message' do
-      expect(controller_with_flash(notice: 'hello')).to set_the_flash.to(/he/)
-    end
-
-    it 'rejects setting a different flash message' do
-      expect(controller_with_flash(notice: 'hi')).
-        not_to set_the_flash.to('other')
-    end
-
-    it 'rejects setting a different pattern' do
-      expect(controller_with_flash(notice: 'hi')).
-        not_to set_the_flash.to(/other/)
-    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_the_flash
-    end
-
-    it 'accepts setting any flash.now message' do
-      expect(controller_with_flash_now).to set_the_flash.now
-    end
-
-    it 'accepts setting the exact flash.now message' do
-      expect(controller_with_flash_now(notice: 'hi')).
-        to set_the_flash.now.to('hi')
-    end
-
-    it 'accepts setting a matched flash.now message' do
-      expect(controller_with_flash_now(notice: 'flasher')).
-        to set_the_flash.now.to(/lash/)
-    end
-
-    it 'rejects setting a different flash.now message' do
-      expect(controller_with_flash_now(notice: 'hi')).
-        not_to set_the_flash.now.to('other')
-    end
-
-    it 'rejects setting a different flash.now pattern' do
-      expect(controller_with_flash_now(notice: 'hi')).
-        not_to set_the_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_the_flash[:notice]
-      expect(controller).to set_the_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_the_flash[:warning]
-    end
-
-    it 'accepts exact flash message of notice' do
-      expect(controller_with_flash(notice: 'one', alert: 'two')).
-        to set_the_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_the_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_the_flash[:notice].to('other')
-    end
-
-    it 'rejects setting a different pattern' do
-      expect(controller_with_flash(notice: 'one', alert: 'two')).
-        not_to set_the_flash[:notice].to(/other/)
-    end
-  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_the_flash.now
-      expect(controller).to set_the_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_the_flash.now.to(/value/)
-      expect(controller).to set_the_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_the_flash.now.to('other')
-      expect(controller).not_to set_the_flash.to('other')
-    end
-  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_the_flash
-    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
-      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
-    end
-  end
-end

data/spec/shoulda/matchers/active_model/validate_confirmation_of_matcher_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::ValidateConfirmationOfMatcher do
-  context '#description' do
-    it 'states that the confirmation must match its base attribute' do
-      expect(matcher.description).to eq 'require attr_confirmation to match attr'
-    end
-  end
-
-  context 'a model with a confirmation validation' do
-    it 'accepts' do
-      expect(validating_confirmation).to matcher
-    end
-
-    it 'does not override the default message with a blank' do
-      expect(validating_confirmation).to matcher.with_message(nil)
-    end
-  end
-
-  context 'a model without a confirmation validation' do
-    it 'rejects' do
-      expect(define_model(:example, attr: :string).new).not_to matcher
-    end
-  end
-
-  context 'a confirmation validation with a custom message' do
-    it 'accepts when the message matches' do
-      expect(validating_confirmation(message: 'custom')).
-        to matcher.with_message(/custom/)
-    end
-
-    it 'rejects when the messages do not match' do
-      expect(validating_confirmation(message: 'custom')).
-        not_to matcher.with_message(/wrong/)
-    end
-  end
-
-  def matcher
-    validate_confirmation_of(:attr)
-  end
-
-  def validating_confirmation(options = {})
-    define_model(:example, attr: :string) do
-      validates_confirmation_of :attr, options
-    end.new
-  end
-end

data/spec/shoulda/matchers/doublespeak/world_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-module Shoulda::Matchers::Doublespeak
-  describe World do
-    describe '#double_collection_for' do
-      it 'calls DoubleCollection.new once with the given class' do
-        DoubleCollection.expects(:new).with(:klass).returns(:klass).once
-        world = described_class.new
-        world.double_collection_for(:klass)
-        world.double_collection_for(:klass)
-      end
-
-      it 'returns the created DoubleCollection' do
-        double_collection = Object.new
-        DoubleCollection.stubs(:new).with(:klass).returns(double_collection)
-        world = described_class.new
-        expect(world.double_collection_for(:klass)).to be double_collection
-      end
-    end
-
-    describe '#with_doubles_activated' do
-      it 'installs all doubles, yields the block, then uninstalls them all' do
-        block_called = false
-
-        double_collections = Array.new(3) do
-          stub.tap do |double_collection|
-            sequence = sequence('with_doubles_activated')
-            double_collection.expects(:activate).in_sequence(sequence)
-            double_collection.expects(:deactivate).in_sequence(sequence)
-          end
-        end
-
-        world = described_class.new
-
-        DoubleCollection.stubs(:new).
-          with(:klass1).
-          returns(double_collections[0])
-        DoubleCollection.stubs(:new).
-          with(:klass2).
-          returns(double_collections[1])
-        DoubleCollection.stubs(:new).
-          with(:klass3).
-          returns(double_collections[2])
-        world.double_collection_for(:klass1)
-        world.double_collection_for(:klass2)
-        world.double_collection_for(:klass3)
-
-        world.with_doubles_activated { block_called = true }
-
-        expect(block_called).to eq true
-      end
-
-      it 'still makes sure to uninstall all doubles even if the block raises an error' do
-        double_collection = stub()
-        double_collection.stubs(:activate)
-        double_collection.expects(:deactivate)
-
-        world = described_class.new
-
-        DoubleCollection.stubs(:new).returns(double_collection)
-        world.double_collection_for(:klass)
-
-        begin
-          world.with_doubles_activated { raise 'error' }
-        rescue RuntimeError
-        end
-      end
-    end
-  end
-end

data/spec/shoulda/matchers/independent/delegate_method_matcher_spec.rb

@@ -1,309 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
-  describe '#description' do
-    context 'against an instance' do
-      subject { Object.new }
-
-      context 'by default' do
-        it 'states that it should delegate method to the right object' do
-          matcher = delegate_method(:method_name).to(:target)
-
-          expect(matcher.description).
-            to eq 'delegate #method_name to #target object'
-        end
-      end
-
-      context 'with #as chain' do
-        it 'states that it should delegate method to the right object and method' do
-          matcher = delegate_method(:method_name).to(:target).as(:alternate)
-          message = 'delegate #method_name to #target object as #alternate'
-
-          expect(matcher.description).to eq message
-        end
-      end
-
-      context 'with #with_argument chain' do
-        it 'states that it should delegate method to the right object with right argument' do
-          matcher = delegate_method(:method_name).to(:target).
-            with_arguments(:foo, bar: [1, 2])
-          message = 'delegate #method_name to #target object passing arguments [:foo, {:bar=>[1, 2]}]'
-
-          expect(matcher.description).to eq message
-        end
-      end
-    end
-
-    context 'against a class' do
-      subject { Object }
-
-      context 'by default' do
-        it 'states that it should delegate method to the right object' do
-          matcher = delegate_method(:method_name).to(:target)
-
-          expect(matcher.description).
-            to eq 'delegate .method_name to .target object'
-        end
-      end
-
-      context 'with #as chain' do
-        it 'states that it should delegate method to the right object and method' do
-          matcher = delegate_method(:method_name).to(:target).as(:alternate)
-          message = 'delegate .method_name to .target object as .alternate'
-
-          expect(matcher.description).to eq message
-        end
-      end
-
-      context 'with #with_argument chain' do
-        it 'states that it should delegate method to the right object with right argument' do
-          matcher = delegate_method(:method_name).to(:target).
-            with_arguments(:foo, bar: [1, 2])
-          message = 'delegate .method_name to .target object passing arguments [:foo, {:bar=>[1, 2]}]'
-
-          expect(matcher.description).to eq message
-        end
-      end
-    end
-  end
-
-  it 'raises an error if the target method was never specified before matching' do
-    expect {
-      expect(Object.new).to delegate_method(:name)
-    }.to raise_error described_class::TargetNotDefinedError
-  end
-
-  context 'stubbing an instance delegating method' do
-    it 'only happens temporarily and is removed after the match' do
-      define_class(:company) do
-        def name
-          'Acme Company'
-        end
-      end
-
-      define_class(:person) do
-        def company_name
-          company.name
-        end
-
-        def company
-          Company.new
-        end
-      end
-
-      person = Person.new
-      matcher = delegate_method(:company_name).to(:company).as(:name)
-      matcher.matches?(person)
-
-      expect(person.company.name).to eq 'Acme Company'
-    end
-  end
-
-  context 'given a method that does not delegate' do
-    before do
-      define_class(:post_office) do
-        def deliver_mail
-          :delivered
-        end
-      end
-    end
-
-    it 'rejects' do
-      post_office = PostOffice.new
-      expect(post_office).not_to delegate_method(:deliver_mail).to(:mailman)
-    end
-
-    it 'has a failure message that indicates which method should have been delegated' do
-      post_office = PostOffice.new
-      message = [
-        'Expected PostOffice to delegate #deliver_mail to #mailman object',
-        'Method calls sent to PostOffice#mailman: (none)'
-      ].join("\n")
-
-      expect {
-        expect(post_office).to delegate_method(:deliver_mail).to(:mailman)
-      }.to fail_with_message(message)
-    end
-
-    it 'uses the proper syntax for class methods in errors' do
-      message = [
-        'Expected PostOffice to delegate .deliver_mail to .mailman object',
-        'Method calls sent to PostOffice.mailman: (none)'
-      ].join("\n")
-
-      expect {
-        expect(PostOffice).to delegate_method(:deliver_mail).to(:mailman)
-      }.to fail_with_message(message)
-    end
-  end
-
-  context 'given a method that delegates properly' do
-    before do
-      define_class(:mailman)
-
-      define_class(:post_office) do
-        def deliver_mail
-          mailman.deliver_mail
-        end
-
-        def mailman
-          Mailman.new
-        end
-      end
-    end
-
-    it 'accepts' do
-      post_office = PostOffice.new
-      expect(post_office).to delegate_method(:deliver_mail).to(:mailman)
-    end
-
-    it 'produces the correct failure message if the assertion was negated' do
-      post_office = PostOffice.new
-      message = 'Expected PostOffice not to delegate #deliver_mail to #mailman object, but it did'
-
-      expect {
-        expect(post_office).not_to delegate_method(:deliver_mail).to(:mailman)
-      }.to fail_with_message(message)
-    end
-  end
-
-  context 'given a private method that delegates properly' do
-    before do
-      define_class(:mailman)
-
-      define_class(:post_office) do
-        def deliver_mail
-          mailman.deliver_mail
-        end
-
-        def mailman
-          Mailman.new
-        end
-
-        private :mailman
-      end
-    end
-
-    it 'accepts' do
-      post_office = PostOffice.new
-      expect(post_office).to delegate_method(:deliver_mail).to(:mailman)
-    end
-  end
-
-  context 'given a method that delegates properly with arguments' do
-    before do
-      define_class(:mailman)
-
-      define_class(:post_office) do
-        def deliver_mail(*args)
-          mailman.deliver_mail('221B Baker St.', hastily: true)
-        end
-
-        def mailman
-          Mailman.new
-        end
-      end
-    end
-
-    context 'when given the correct arguments' do
-      it 'accepts' do
-        post_office = PostOffice.new
-        expect(post_office).to delegate_method(:deliver_mail).
-          to(:mailman).with_arguments('221B Baker St.', hastily: true)
-      end
-
-      it 'produces the correct failure message if the assertion was negated' do
-        post_office = PostOffice.new
-        message = 'Expected PostOffice not to delegate #deliver_mail to #mailman object passing arguments ["221B Baker St.", {:hastily=>true}], but it did'
-
-        expect {
-          expect(post_office).
-            not_to delegate_method(:deliver_mail).
-            to(:mailman).
-            with_arguments('221B Baker St.', hastily: true)
-        }.to fail_with_message(message)
-      end
-    end
-
-    context 'when not given the correct arguments' do
-      it 'rejects' do
-        post_office = PostOffice.new
-        expect(post_office).
-          not_to delegate_method(:deliver_mail).to(:mailman).
-          with_arguments('123 Nowhere Ln.')
-      end
-
-      it 'has a failure message that indicates which arguments were expected' do
-        post_office = PostOffice.new
-        message = [
-          'Expected PostOffice to delegate #deliver_mail to #mailman object passing arguments ["123 Nowhere Ln."]',
-          'Method calls sent to PostOffice#mailman:',
-          '1) deliver_mail("221B Baker St.", {:hastily=>true})'
-        ].join("\n")
-
-        expect {
-          expect(post_office).to delegate_method(:deliver_mail).
-            to(:mailman).with_arguments('123 Nowhere Ln.')
-        }.to fail_with_message(message)
-      end
-    end
-  end
-
-  context 'given a method that delegates properly to a method of a different name' do
-    before do
-      define_class(:mailman)
-
-      define_class(:post_office) do
-        def deliver_mail
-          mailman.deliver_mail_and_avoid_dogs
-        end
-
-        def mailman
-          Mailman.new
-        end
-      end
-    end
-
-    context 'when given the correct method name' do
-      it 'accepts' do
-        post_office = PostOffice.new
-        expect(post_office).to delegate_method(:deliver_mail).
-          to(:mailman).as(:deliver_mail_and_avoid_dogs)
-      end
-
-      it 'produces the correct failure message if the assertion was negated' do
-        post_office = PostOffice.new
-        message = 'Expected PostOffice not to delegate #deliver_mail to #mailman object as #deliver_mail_and_avoid_dogs, but it did'
-
-        expect {
-          expect(post_office).
-            not_to delegate_method(:deliver_mail).
-            to(:mailman).
-            as(:deliver_mail_and_avoid_dogs)
-        }.to fail_with_message(message)
-      end
-    end
-
-    context 'when given an incorrect method name' do
-      it 'rejects' do
-        post_office = PostOffice.new
-        expect(post_office).
-          not_to delegate_method(:deliver_mail).to(:mailman).as(:watch_tv)
-      end
-
-      it 'has a failure message that indicates which method was expected' do
-        post_office = PostOffice.new
-        message = [
-          'Expected PostOffice to delegate #deliver_mail to #mailman object as #watch_tv',
-          'Method calls sent to PostOffice#mailman:',
-          '1) deliver_mail_and_avoid_dogs()'
-        ].join("\n")
-
-        expect {
-          expect(post_office).to delegate_method(:deliver_mail).
-            to(:mailman).as(:watch_tv)
-        }.to fail_with_message(message)
-      end
-    end
-  end
-end