mcmire-shoulda-matchers 2.5.0 → 2.6.1.docs.1

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

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module Shoulda::Matchers::Doublespeak
+  describe StubImplementation do
+    describe '#call' do
+      it 'calls #record_call on the double' do
+        implementation = described_class.new
+        double = build_double
+
+        double.expects(:record_call).with(:args, :block)
+
+        implementation.call(double, :object, :args, :block)
+      end
+
+      context 'if no explicit implementation was set' do
+        it 'returns nil' do
+          implementation = described_class.new
+          double = build_double
+
+          return_value = implementation.call(double, :object, :args, :block)
+
+          expect(return_value).to eq nil
+        end
+      end
+
+      context 'if the implementation was set as a value' do
+        it 'returns the set return value' do
+          implementation = described_class.new
+          implementation.returns(42)
+          double = build_double
+
+          return_value = implementation.call(double, :object, :args, :block)
+
+          expect(return_value).to eq 42
+        end
+      end
+
+      context 'if the implementation was set as a block' do
+        it 'calls the block with the object and args/block passed to the method' do
+          double = build_double
+          expected_object, expected_args, expected_block = :object, :args, :block
+          actual_object, actual_args, actual_block = []
+          implementation = described_class.new
+          implementation.returns do |object, args, block|
+            actual_object, actual_args, actual_block = object, args, block
+          end
+
+          implementation.call(
+            double,
+            expected_object,
+            expected_args,
+            expected_block
+          )
+
+          expect(actual_object).to eq expected_object
+          expect(actual_args).to eq expected_args
+          expect(actual_block).to eq expected_block
+        end
+
+        it 'returns the return value of the block' do
+          implementation = described_class.new
+          implementation.returns { 42 }
+          double = build_double
+
+          return_value = implementation.call(double, :object, :args, :block)
+
+          expect(return_value).to eq 42
+        end
+      end
+
+      context 'if the implementation was set as both a value and a block' do
+        it 'prefers the block over the value' do
+          implementation = described_class.new
+          implementation.returns(:something_else) { 42 }
+          double = build_double
+
+          return_value = implementation.call(double, :object, :args, :block)
+
+          expect(return_value).to eq 42
+        end
+      end
+    end
+
+    def build_double
+      stub(record_call: nil)
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module Shoulda::Matchers::Doublespeak
+  describe World do
+    describe '#register_double_collection' do
+      it 'calls DoubleCollection.new with the given class' do
+        DoubleCollection.expects(:new).with(:klass)
+        world = described_class.new
+        world.register_double_collection(:klass)
+      end
+
+      it 'returns the newly created DoubleCollection' do
+        double_collection = Object.new
+        DoubleCollection.stubs(:new).with(:klass).returns(double_collection)
+        world = described_class.new
+        expect(world.register_double_collection(: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.register_double_collection(:klass1)
+        world.register_double_collection(:klass2)
+        world.register_double_collection(: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.register_double_collection(:klass)
+
+        begin
+          world.with_doubles_activated { raise 'error' }
+        rescue RuntimeError
+        end
+      end
+
+      it 'does not allow multiple DoubleCollections to be registered that represent the same class' do
+        double_collections = [stub, stub]
+        sequence = sequence('with_doubles_activated')
+        double_collections[0].expects(:activate).never
+        double_collections[0].expects(:deactivate).never
+        double_collections[1].expects(:activate).in_sequence(sequence)
+        double_collections[1].expects(:deactivate).in_sequence(sequence)
+
+        world = described_class.new
+
+        DoubleCollection.stubs(:new).
+          returns(double_collections[0]).then.
+          returns(double_collections[1])
+        world.register_double_collection(:klass1)
+        world.register_double_collection(:klass1)
+
+        world.with_doubles_activated { }
+      end
+    end
+  end
+end

data/spec/shoulda/matchers/doublespeak_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Shoulda::Matchers
+  describe Doublespeak do
+    describe '.register_double_collection' do
+      it 'delegates to its world' do
+        Doublespeak.world.expects(:register_double_collection).with(:klass)
+        described_class.register_double_collection(:klass)
+      end
+    end
+
+    describe '.with_doubles_activated' do
+      it 'delegates to its world' do
+        Doublespeak.world.expects(:with_doubles_activated)
+        described_class.with_doubles_activated
+      end
+    end
+  end
+end

data/spec/shoulda/matchers/independent/delegate_matcher/stubbed_target_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::Independent::DelegateMatcher::StubbedTarget do
+  subject(:target) { described_class.new(:stubbed_method) }
+
+  describe '#has_received_method?' do
+    it 'returns true when the method has been called on the target' do
+      target.stubbed_method
+
+      expect(target).to have_received_method
+    end
+
+    it 'returns false when the method has not been called on the target' do
+      expect(target).not_to have_received_method
+    end
+  end
+
+  describe '#has_received_arguments?' do
+    context 'method is called with specified arguments' do
+      it 'returns true' do
+        target.stubbed_method(:arg1, :arg2)
+
+        expect(target).to have_received_arguments(:arg1, :arg2)
+      end
+    end
+
+    context 'method is not called with specified arguments' do
+      it 'returns false' do
+        target.stubbed_method
+
+        expect(target).not_to have_received_arguments(:arg1)
+      end
+    end
+
+    context 'method is called with arguments in incorrect order' do
+      it 'returns false' do
+        target.stubbed_method(:arg2, :arg1)
+
+        expect(target).not_to have_received_arguments(:arg1, :arg2)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,250 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::Independent::DelegateMatcher do
+  describe '#description' do
+    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 #method_name to :target'
+      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 #method_name to :target 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 #method_name to :target with arguments: [:foo, {:bar=>[1, 2]}]'
+
+        expect(matcher.description).to eq message
+      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#deliver_mail to delegate to PostOffice#mailman',
+        'Calls on 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.deliver_mail to delegate to PostOffice.mailman',
+        'Calls on 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#deliver_mail not to delegate to PostOffice#mailman, 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 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#deliver_mail not to delegate to PostOffice#mailman with 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#deliver_mail to delegate to PostOffice#mailman with arguments: ["123 Nowhere Ln."]',
+          'Calls on 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#deliver_mail not to delegate to PostOffice#mailman 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#deliver_mail to delegate to PostOffice#mailman as #watch_tv',
+          'Calls on 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

data/spec/spec_helper.rb

@@ -1,9 +1,24 @@
 require File.expand_path('../support/test_application', __FILE__)
 
+def monkey_patch_minitest_to_do_nothing
+  # Rails 3.1's test_help file requires Turn, which loads Minitest in autorun
+  # mode. This means that Minitest tests will run after these RSpec tests are
+  # finished running. This will break on CI since we pass --color to the `rspec`
+  # command.
+
+  if defined?(MiniTest)
+    MiniTest::Unit.class_eval do
+      def run(*); end
+    end
+  end
+end
+
 $test_app = TestApplication.new
 $test_app.create
 $test_app.load
 
+monkey_patch_minitest_to_do_nothing
+
 ENV['BUNDLE_GEMFILE'] ||= app.gemfile_path
 ENV['RAILS_ENV'] = 'test'
 

data/spec/support/activemodel_helpers.rb

@@ -1,11 +1,15 @@
 module ActiveModelHelpers
-  def custom_validation(&block)
-    define_model(:example, attr: :integer) do
+  def custom_validation(options = {}, &block)
+    attribute_name = options.fetch(:attribute_name, :attr)
+    attribute_type = options.fetch(:attribute_type, :integer)
+
+    define_model(:example, attribute_name => attribute_type) do
       validate :custom_validation
 
       define_method(:custom_validation, &block)
     end.new
   end
+  alias record_with_custom_validation custom_validation
 
   def validating_format(options)
     define_model :example, attr: :string do

data/spec/support/controller_builder.rb

@@ -21,7 +21,7 @@ module ControllerBuilder
     end
   end
 
-  def build_response(opts = {}, &block)
+  def build_fake_response(opts = {}, &block)
     action = opts[:action] || 'example'
     partial = opts[:partial] || '_partial'
     block ||= lambda { render nothing: true }
@@ -58,6 +58,34 @@ module ControllerBuilder
     $test_app.create_temp_view(path, contents)
   end
 
+  def controller_for_resource_with_strong_parameters(options = {}, &action_body)
+    model_name = options.fetch(:model_name, 'User')
+    controller_name = options.fetch(:controller_name, 'UsersController')
+    collection_name = controller_name.
+      to_s.sub(/Controller$/, '').underscore.
+      to_sym
+    action_name = options.fetch(:action, :some_action)
+    routes ||= options.fetch(:routes, -> { resources collection_name })
+
+    define_model(model_name)
+
+    controller_class = define_controller(controller_name) do
+      define_method action_name do
+        if action_body
+          instance_eval(&action_body)
+        end
+
+        render nothing: true
+      end
+    end
+
+    setup_rails_controller_test(controller_class)
+
+    define_routes(&routes)
+
+    controller_class
+  end
+
   private
 
   def delete_temporary_views

data/spec/support/rails_versions.rb

@@ -10,6 +10,10 @@ module RailsVersions
   def rails_4_x?
     Gem::Requirement.new('~> 4.0').satisfied_by?(rails_version)
   end
+
+  def rails_gte_4_1?
+    Gem::Requirement.new('>= 4.1').satisfied_by?(rails_version)
+  end
 end
 
 RSpec.configure do |config|

data/spec/support/test_application.rb

@@ -92,7 +92,7 @@ EOT
   end
 
   def install_gems
-    retrying('bundle install') do |command|
+    retrying('bundle install --local') do |command|
       Bundler.with_clean_env { `#{command}` }
     end
   end