shoulda-matchers 3.1.3 → 4.0.0.rc1

data/spec/support/unit/matchers/fail_with_message_matcher.rb

@@ -24,13 +24,15 @@ module UnitTests
         lines << Shoulda::Matchers::Util.indent(expected, 2)
 
         if @actual
+          diff = differ.diff(@actual, expected)[1..-1]
+
           lines << 'Actually failed with:'
           lines << Shoulda::Matchers::Util.indent(@actual, 2)
-          lines << "Diff:"
-          lines << Shoulda::Matchers::Util.indent(
-            differ.diff(@actual, expected)[1..-1],
-            2
-          )
+
+          if diff
+            lines << 'Diff:'
+            lines << Shoulda::Matchers::Util.indent(diff, 2)
+          end
         else
           lines << 'However, the expectation did not fail at all.'
         end

data/spec/support/unit/matchers/print_warning_including.rb

@@ -11,43 +11,51 @@ module UnitTests
 
       def matches?(block)
         @captured_stderr = collapse_whitespace(capture(:stderr, &block))
+        @was_negated = false
         captured_stderr.include?(expected_warning)
       end
 
+      def does_not_match?(block)
+        !matches?(block).tap do
+          @was_negated = true
+        end
+      end
+
       def failure_message
-        "Expected block to #{expectation}\nbut actually printed#{actual_warning}"
+        "Expected block to #{expectation}\n\nHowever, #{aberration}"
       end
-      alias_method :failure_message_for_should, :failure_message
 
       def failure_message_when_negated
-        "Expected block not to #{expectation}, but it did."
+        "Expected block not to #{expectation}\n\nHowever, #{aberration}"
       end
-      alias_method :failure_message_for_should_not,
-        :failure_message_when_negated
 
       def description
-        "should #{expectation}"
+        "should print a warning containing #{expected_warning.inspect}"
       end
 
       def supports_block_expectations?
         true
       end
 
-      protected
+      private
 
       attr_reader :expected_warning, :captured_stderr
 
-      private
+      def was_negated?
+        @was_negated
+      end
 
       def expectation
-        "print a warning including:\n  #{expected_warning}"
+        "print a warning containing:\n\n  #{expected_warning}"
       end
 
-      def actual_warning
-        if captured_stderr.empty?
-          " nothing."
+      def aberration
+        if was_negated?
+          'it did.'
+        elsif captured_stderr.empty?
+          'it actually printed nothing.'
         else
-          ":\n  #{captured_stderr}"
+          "it actually printed:\n\n  #{captured_stderr}"
         end
       end
 

data/spec/support/unit/model_creation_strategies/active_record.rb

@@ -42,7 +42,7 @@ module UnitTests
           run_block(model, block)
         end
 
-        if whitelist_attributes?
+        if whitelist_attributes? && model.respond_to?(:attr_accessible)
           model.attr_accessible(*columns.keys)
         end
 

data/spec/support/unit/model_creators/active_record.rb

@@ -14,7 +14,6 @@ module UnitTests
         :arguments,
         :attribute_default_values_by_name,
         :attribute_name,
-        :customize_model,
         :model_name,
       )
 

data/spec/support/unit/model_creators/basic.rb

@@ -79,8 +79,13 @@ module UnitTests
                 overrides[:changing_values_with]
               )
 
-              if respond_to?(:write_attribute)
-                write_attribute(new_value)
+              if (
+                respond_to?(:write_attribute) && (
+                  !self.class.respond_to?(:reflect_on_association) ||
+                  !self.class.reflect_on_association(attribute_name)
+                )
+              )
+                write_attribute(attribute_name, new_value)
               else
                 super(new_value)
               end

data/spec/support/unit/rails_application.rb

@@ -2,6 +2,7 @@ require_relative '../tests/bundle'
 require_relative '../tests/command_runner'
 require_relative '../tests/database'
 require_relative '../tests/filesystem'
+require_relative 'helpers/rails_versions'
 
 require 'yaml'
 
@@ -74,7 +75,12 @@ module UnitTests
     def generate
       rails_new
       fix_available_locales_warning
+      remove_bootsnap
       write_database_configuration
+
+      if bundle.version_of("rails") >= 5
+        add_initializer_for_time_zone_aware_types
+      end
     end
 
     def rails_new
@@ -93,10 +99,29 @@ end
       end
     end
 
+    def remove_bootsnap
+      # Rails 5.2 introduced bootsnap, which is helpful when you're developing
+      # or deploying an app, but we don't really need it (and it messes with
+      # Zeus anyhow)
+      fs.comment_lines_matching(
+        'config/boot.rb',
+        %r{\Arequire 'bootsnap/setup'},
+      )
+    end
+
     def write_database_configuration
       YAML.dump(database.config.to_hash, fs.open('config/database.yml', 'w'))
     end
 
+    def add_initializer_for_time_zone_aware_types
+      path = 'config/initializers/configure_time_zone_aware_types.rb'
+      fs.write(path, <<-TEXT)
+Rails.application.configure do
+  config.active_record.time_zone_aware_types = [:datetime, :time]
+end
+      TEXT
+    end
+
     def load_environment
       require environment_file_path
     end

data/spec/support/unit/record_validating_confirmation_builder.rb

@@ -13,7 +13,7 @@ module UnitTests
     end
 
     def model_name
-      'Example'
+      options.fetch(:model_name, 'Example')
     end
 
     def record
@@ -29,7 +29,10 @@ module UnitTests
     end
 
     def confirmation_attribute
-      :"#{attribute_to_confirm}_confirmation"
+      options.fetch(
+        :confirmation_attribute,
+        :"#{attribute_to_confirm}_confirmation"
+      )
     end
 
     def attribute_that_receives_error

data/spec/support/unit/validation_matcher_scenario.rb

@@ -4,8 +4,6 @@ module UnitTests
   class ValidationMatcherScenario
     extend Forwardable
 
-    attr_reader :matcher
-
     def initialize(arguments)
       @arguments = arguments.dup
       @matcher_proc = @arguments.delete(:matcher_proc)

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

@@ -54,29 +54,29 @@ describe Shoulda::Matchers::ActionController::CallbackMatcher, type: :controller
     end
   end
 
-  describe '#use_before_filter' do
-    it_behaves_like 'CallbackMatcher', :before, :filter
-  end
+  if action_pack_lt_5?
+    describe '#use_before_filter' do
+      it_behaves_like 'CallbackMatcher', :before, :filter
+    end
 
-  describe '#use_after_filter' do
-    it_behaves_like 'CallbackMatcher', :after, :filter
-  end
+    describe '#use_after_filter' do
+      it_behaves_like 'CallbackMatcher', :after, :filter
+    end
 
-  describe '#use_around_filter' do
-    it_behaves_like 'CallbackMatcher', :around, :filter
+    describe '#use_around_filter' do
+      it_behaves_like 'CallbackMatcher', :around, :filter
+    end
   end
 
-  if rails_4_x?
-    describe '#use_before_action' do
-      it_behaves_like 'CallbackMatcher', :before, :action
-    end
+  describe '#use_before_action' do
+    it_behaves_like 'CallbackMatcher', :before, :action
+  end
 
-    describe '#use_after_action' do
-      it_behaves_like 'CallbackMatcher', :after, :action
-    end
+  describe '#use_after_action' do
+    it_behaves_like 'CallbackMatcher', :after, :action
+  end
 
-    describe '#use_around_action' do
-      it_behaves_like 'CallbackMatcher', :around, :action
-    end
+  describe '#use_around_action' do
+    it_behaves_like 'CallbackMatcher', :around, :action
   end
 end

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

@@ -498,7 +498,12 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
 
         matcher.matches?(controller)
 
-        expect(context).to have_received(:post).with(:create, {})
+        expect_to_have_made_controller_request(
+          verb: :post,
+          action: :create,
+          params: {},
+          context: context,
+        )
       end
     end
 
@@ -511,7 +516,12 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
 
           matcher.matches?(controller)
 
-          expect(context).to have_received(:patch).with(:update, {})
+          expect_to_have_made_controller_request(
+            verb: :patch,
+            action: :update,
+            params: {},
+            context: context,
+          )
         end
       else
         it 'PUTs to the controller' do
@@ -521,7 +531,12 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
 
           matcher.matches?(controller)
 
-          expect(context).to have_received(:put).with(:update, {})
+          expect_to_have_made_controller_request(
+            verb: :put,
+            action: :update,
+            params: {},
+            context: context,
+          )
         end
       end
     end
@@ -536,7 +551,12 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
 
         matcher.matches?(controller)
 
-        expect(context).to have_received(:delete).with(:hide, {})
+        expect_to_have_made_controller_request(
+          verb: :delete,
+          action: :hide,
+          params: {},
+          context: context,
+        )
       end
     end
   end
@@ -566,7 +586,7 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
           end
         end
 
-        render nothing: true
+        head :ok
       end
     end
 
@@ -598,4 +618,12 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
   def build_context
     double('context', post: nil, put: nil, patch: nil, delete: nil)
   end
+
+  def expect_to_have_made_controller_request(context:, verb:, action:, params:)
+    if action_pack_gte_5?
+      expect(context).to have_received(verb).with(action, params: params)
+    else
+      expect(context).to have_received(verb).with(action, params)
+    end
+  end
 end

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

@@ -69,7 +69,7 @@ describe Shoulda::Matchers::ActionController::RenderTemplateMatcher, type: :cont
 
   context 'a controller that does not render a template' do
     it 'rejects rendering a template' do
-      expect(build_fake_response { render nothing: true }).
+      expect(build_fake_response { head :ok }).
         not_to render_template(:show)
     end
   end

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

@@ -1,115 +1,117 @@
 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'
+  if action_pack_lt_5?
+    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
-    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'
+      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
-  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
+    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)
+        expect(model).not_to allow_mass_assignment_of(:blacklisted)
+      end
     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
+    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)
+        expect(model).not_to allow_mass_assignment_of(:not_whitelisted)
+      end
     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)
+    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
-  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
+    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)
+        expect(model).to allow_mass_assignment_of(:not_blacklisted)
+      end
     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
+    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)
+        it 'assigns a negative failure message' do
+          matcher = allow_mass_assignment_of(:attr)
 
-        expect(matcher.matches?(no_protected_attributes)).to eq true
+          expect(matcher.matches?(no_protected_attributes)).to eq true
 
-        expect(matcher.failure_message_when_negated).not_to be_nil
+          expect(matcher.failure_message_when_negated).not_to be_nil
+        end
       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
+      def no_protected_attributes
+        define_model(:example, attr: :string).new
+      end
     end
-  end
 
-  if active_model_3_1?
-    context 'an attribute included in the mass-assignment whitelist for admin role only' do
+    context 'an attribute on a class with all protected attributes' 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)
+        expect(all_protected_attributes).not_to allow_mass_assignment_of(:attr)
       end
 
-      def mass_assignable_as_admin
+      def all_protected_attributes
         define_model(:example, attr: :string) do
-          attr_accessible :attr, as: :admin
+          attr_accessible nil
         end.new
       end
     end
-  end
 
-  def define_model(name, columns, &block)
-    super(name, columns, whitelist_attributes: false, &block)
+    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
 end