shoulda-matchers 2.8.0.rc1 → 2.8.0.rc2

data/lib/shoulda/matchers/active_record/have_db_column_matcher.rb

@@ -263,6 +263,7 @@ module Shoulda
           "#{model_class.name} to #{description}"
         end
 
+        # @private
         class DecoratedColumn < SimpleDelegator
           def initialize(model, column)
             @model = model

data/lib/shoulda/matchers/active_record/uniqueness/model.rb

@@ -1,6 +1,7 @@
 module Shoulda
   module Matchers
     module ActiveRecord
+      # @private
       module Uniqueness
         # @private
         class Model

data/lib/shoulda/matchers/active_record/uniqueness/namespace.rb

@@ -1,6 +1,7 @@
 module Shoulda
   module Matchers
     module ActiveRecord
+      # @private
       module Uniqueness
         # @private
         class Namespace

data/lib/shoulda/matchers/active_record/uniqueness/test_model_creator.rb

@@ -3,6 +3,7 @@ require 'thread'
 module Shoulda
   module Matchers
     module ActiveRecord
+      # @private
       module Uniqueness
         # @private
         class TestModelCreator

data/lib/shoulda/matchers/active_record/uniqueness/test_models.rb

@@ -3,6 +3,7 @@ require 'thread'
 module Shoulda
   module Matchers
     module ActiveRecord
+      # @private
       module Uniqueness
         # @private
         module TestModels

data/lib/shoulda/matchers/active_record/validate_uniqueness_of_matcher.rb

@@ -374,21 +374,7 @@ module Shoulda
               # Assume the scope is a foreign key if the field is nil
               previous_value ||= correct_type_for_column(@subject.class.columns_hash[scope.to_s])
 
-              next_value =
-                if @subject.class.respond_to?(:defined_enums) && @subject.defined_enums[scope.to_s]
-                  available_values = @subject.defined_enums[scope.to_s].reject do |key, _|
-                    key == previous_value
-                  end
-                  available_values.keys.last
-                elsif scope.to_s =~ /_type$/ && model_class?(previous_value)
-                  Uniqueness::TestModels.create(previous_value).to_s
-                elsif previous_value.respond_to?(:next)
-                  previous_value.next
-                elsif previous_value.respond_to?(:to_datetime)
-                  previous_value.to_datetime.next
-                else
-                  previous_value.to_s.next
-                end
+              next_value = next_value_for(scope, previous_value)
 
               @subject.__send__("#{scope}=", next_value)
 
@@ -418,6 +404,27 @@ module Shoulda
           end
         end
 
+        def next_value_for(scope, previous_value)
+          if @subject.class.respond_to?(:defined_enums) && @subject.defined_enums[scope.to_s]
+            available_values = available_enum_values_for(scope, previous_value)
+            available_values.keys.last
+          elsif scope.to_s =~ /_type$/ && model_class?(previous_value)
+            Uniqueness::TestModels.create(previous_value).to_s
+          elsif previous_value.respond_to?(:next)
+            previous_value.next
+          elsif previous_value.respond_to?(:to_datetime)
+            previous_value.to_datetime.next
+          else
+            previous_value.to_s.next
+          end
+        end
+
+        def available_enum_values_for(scope, previous_value)
+          @subject.defined_enums[scope.to_s].reject do |key, _|
+            key == previous_value
+          end
+        end
+
         def class_name
           @subject.class.name
         end

data/lib/shoulda/matchers/matcher_context.rb

@@ -1,5 +1,6 @@
 module Shoulda
   module Matchers
+    # @private
     class MatcherContext
       def initialize(context)
         @context = context

data/lib/shoulda/matchers/rails_shim.rb

@@ -65,6 +65,28 @@ module Shoulda
         end
       end
 
+      def self.generate_validation_message(record, attribute, type, model_name, options)
+        if record && record.errors.respond_to?(:generate_message)
+          record.errors.generate_message(attribute.to_sym, type, options)
+        else
+          simply_generate_validation_message(attribute, type, model_name, options)
+        end
+      rescue RangeError
+        simply_generate_validation_message(attribute, type, model_name, options)
+      end
+
+      def self.simply_generate_validation_message(attribute, type, model_name, options)
+        default_translation_keys = [
+          :"activerecord.errors.models.#{model_name}.#{type}",
+          :"activerecord.errors.messages.#{type}",
+          :"errors.attributes.#{attribute}.#{type}",
+          :"errors.messages.#{type}"
+        ]
+        primary_translation_key = :"activerecord.errors.models.#{model_name}.attributes.#{attribute}.#{type}"
+        translate_options = { default: default_translation_keys }.merge(options)
+        I18n.translate(primary_translation_key, translate_options)
+      end
+
       def self.active_record_major_version
         ::ActiveRecord::VERSION::MAJOR
       end

data/lib/shoulda/matchers/util.rb

@@ -23,6 +23,11 @@ module Shoulda
           end
         end
       end
+
+      def self.indent(string, width)
+        indentation = ' ' * width
+        string.split(/[\n\r]/).map { |line| indentation + line }.join("\n")
+      end
     end
   end
 end

data/lib/shoulda/matchers/version.rb

@@ -1,6 +1,6 @@
 module Shoulda
   module Matchers
     # @private
-    VERSION = '2.8.0.rc1'.freeze
+    VERSION = '2.8.0.rc2'.freeze
   end
 end

data/script/update_gem_in_all_appraisals

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+SUPPORTED_VERSIONS=$(<script/SUPPORTED_VERSIONS)
+gem="$1"
+
+update-gem-for-version() {
+  local version="$1"
+  (export RBENV_VERSION=$version; bundle update "$gem" && bundle exec appraisal update "$gem")
+}
+
+for version in $SUPPORTED_VERSIONS; do
+  echo
+  echo "*** Updating $gem for $version ***"
+  update-gem-for-version $version
+done

data/shoulda-matchers.gemspec

@@ -5,7 +5,7 @@ Gem::Specification.new do |s|
   s.name        = "shoulda-matchers"
   s.version     = Shoulda::Matchers::VERSION.dup
   s.authors     = ["Tammer Saleh", "Joe Ferris", "Ryan McGeary", "Dan Croak",
-                   "Matt Jankowski", "Stafford Brunk"]
+                   "Matt Jankowski", "Stafford Brunk", "Elliot Winkler"]
   s.date        = Time.now.strftime("%Y-%m-%d")
   s.email       = "support@thoughtbot.com"
   s.homepage    = "http://thoughtbot.com/community/"

data/spec/support/unit/helpers/active_model_helpers.rb

@@ -7,8 +7,10 @@ module UnitTests
     def custom_validation(options = {}, &block)
       attribute_name = options.fetch(:attribute_name, :attr)
       attribute_type = options.fetch(:attribute_type, :integer)
+      column_options = options.fetch(:column_options, {})
+      attribute_options = { type: attribute_type, options: column_options }
 
-      define_model(:example, attribute_name => attribute_type) do
+      define_model(:example, attribute_name => attribute_options) do
         validate :custom_validation
 
         define_method(:custom_validation, &block)

data/spec/support/unit/helpers/active_model_versions.rb

@@ -5,6 +5,10 @@ module UnitTests
       example_group.extend(self)
     end
 
+    def active_model_version
+      Tests::Version.new(::ActiveModel::VERSION::STRING)
+    end
+
     def active_model_3_1?
       (::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 1) || active_model_4_0?
     end
@@ -16,5 +20,9 @@ module UnitTests
     def active_model_4_0?
       ::ActiveModel::VERSION::MAJOR == 4
     end
+
+    def active_model_supports_strict?
+      active_model_version >= 3.2
+    end
   end
 end

data/spec/support/unit/helpers/active_record_versions.rb

@@ -0,0 +1,16 @@
+module UnitTests
+  module ActiveRecordVersions
+    def self.configure_example_group(example_group)
+      example_group.include(self)
+      example_group.extend(self)
+    end
+
+    def active_record_version
+      Tests::Version.new(ActiveRecord::VERSION::STRING)
+    end
+
+    def active_record_can_raise_range_error?
+      active_record_version >= 4.2
+    end
+  end
+end

data/spec/support/unit/helpers/rails_versions.rb

@@ -6,19 +6,19 @@ module UnitTests
     end
 
     def rails_version
-      Gem::Version.new(Rails::VERSION::STRING)
+      Tests::Version.new(Rails::VERSION::STRING)
     end
 
     def rails_3_x?
-      Gem::Requirement.new('~> 3.0').satisfied_by?(rails_version)
+      rails_version =~ '~> 3.0'
     end
 
     def rails_4_x?
-      Gem::Requirement.new('~> 4.0').satisfied_by?(rails_version)
+      rails_version =~ '~> 4.0'
     end
 
     def rails_gte_4_1?
-      Gem::Requirement.new('>= 4.1').satisfied_by?(rails_version)
+      rails_version >= 4.1
     end
 
     def active_record_supports_enum?

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

@@ -20,15 +20,17 @@ module UnitTests
       end
 
       def failure_message
-        msg = "Expectation should have failed with message '#{expected}'"
+        lines = ['Expectation should have failed with message:']
+        lines << Shoulda::Matchers::Util.indent(expected, 2)
 
         if @actual
-          msg << ",\nactually failed with '#{@actual}'"
+          lines << 'Actually failed with:'
+          lines << Shoulda::Matchers::Util.indent(@actual, 2)
         else
-          msg << ", but did not fail."
+          lines << 'However, the expectation did not fail.'
         end
 
-        msg
+        lines.join("\n")
       end
 
       def failure_message_for_should
@@ -36,10 +38,9 @@ module UnitTests
       end
 
       def failure_message_when_negated
-        msg  = "Expectation should not have failed with message '#{expected}'"
-        msg << ", but did."
-
-        msg
+        lines = ['Expectation should not have failed with message:']
+        lines << Shoulda::Matchers::Util.indent(expected, 2)
+        lines.join("\n")
       end
 
       def failure_message_for_should_not

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

@@ -227,4 +227,78 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
       end
     end
   end
+
+  if active_record_can_raise_range_error?
+    context 'when the value is outside of the range of the column' do
+      context 'not qualified with strict' do
+        it 'rejects, failing with the correct message' do
+          attribute_options = { type: :integer, options: { limit: 2 } }
+          record = define_model(:example, attr: attribute_options).new
+          assertion = -> { expect(record).to allow_value(100000).for(:attr) }
+          message = <<-MESSAGE.strip_heredoc.strip
+            Did not expect errors when attr is set to 100000,
+            got RangeError: "100000 is out of range for ActiveRecord::Type::Integer with limit 2"
+          MESSAGE
+          expect(&assertion).to fail_with_message(message)
+        end
+
+        context 'qualified with a message' do
+          it 'ignores any specified message, failing with the correct message' do
+            attribute_options = { type: :integer, options: { limit: 2 } }
+            record = define_model(:example, attr: attribute_options).new
+            assertion = -> do
+              expect(record).
+                to allow_value(100000).
+                for(:attr).
+                with_message('some message')
+            end
+            message = <<-MESSAGE.strip_heredoc.strip
+              Did not expect errors to include "some message" when attr is set to 100000,
+              got RangeError: "100000 is out of range for ActiveRecord::Type::Integer with limit 2"
+            MESSAGE
+            expect(&assertion).to fail_with_message(message)
+          end
+        end
+      end
+
+      if active_model_supports_strict?
+        context 'qualified with strict' do
+          it 'rejects, failing with the correct message' do
+            attribute_options = { type: :integer, options: { limit: 2 } }
+            record = define_model(:example, attr: attribute_options).new
+            assertion = -> do
+              expect(record).
+                to allow_value(100000).
+                for(:attr).
+                strict
+            end
+            message = <<-MESSAGE.strip_heredoc.strip
+              Did not expect an exception to have been raised when attr is set to 100000,
+              got RangeError: "100000 is out of range for ActiveRecord::Type::Integer with limit 2"
+            MESSAGE
+            expect(&assertion).to fail_with_message(message)
+          end
+
+          context 'qualified with a message' do
+            it 'ignores any specified message' do
+              attribute_options = { type: :integer, options: { limit: 2 } }
+              record = define_model(:example, attr: attribute_options).new
+              assertion = -> do
+                expect(record).
+                  to allow_value(100000).
+                  for(:attr).
+                  with_message('some message').
+                  strict
+              end
+              message = <<-MESSAGE.strip_heredoc.strip
+                Did not expect exception to include "some message" when attr is set to 100000,
+                got RangeError: "100000 is out of range for ActiveRecord::Type::Integer with limit 2"
+              MESSAGE
+              expect(&assertion).to fail_with_message(message)
+            end
+          end
+        end
+      end
+    end
+  end
 end

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

@@ -79,7 +79,82 @@ describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher, type: :model do
     end
   end
 
+  if active_record_can_raise_range_error?
+    context 'when the value is outside of the range of the column' do
+      context 'not qualified with strict' do
+        it 'accepts, failing with the correct message' do
+          attribute_options = { type: :integer, options: { limit: 2 } }
+          record = define_model(:example, attr: attribute_options).new
+          assertion = -> { expect(record).not_to disallow_value(100000).for(:attr) }
+          message = <<-MESSAGE.strip_heredoc.strip
+            Did not expect errors when attr is set to 100000,
+            got RangeError: "100000 is out of range for ActiveRecord::Type::Integer with limit 2"
+          MESSAGE
+          expect(&assertion).to fail_with_message(message)
+        end
+
+        context 'qualified with a message' do
+          it 'ignores any specified message, failing with the correct message' do
+            attribute_options = { type: :integer, options: { limit: 2 } }
+            record = define_model(:example, attr: attribute_options).new
+            assertion = -> do
+              expect(record).
+                not_to disallow_value(100000).
+                for(:attr).
+                with_message('some message')
+            end
+            message = <<-MESSAGE.strip_heredoc.strip
+              Did not expect errors to include "some message" when attr is set to 100000,
+              got RangeError: "100000 is out of range for ActiveRecord::Type::Integer with limit 2"
+            MESSAGE
+            expect(&assertion).to fail_with_message(message)
+          end
+        end
+      end
+
+      if active_model_supports_strict?
+        context 'qualified with strict' do
+          it 'accepts, failing with the correct message' do
+            attribute_options = { type: :integer, options: { limit: 2 } }
+            record = define_model(:example, attr: attribute_options).new
+            assertion = -> do
+              expect(record).
+                not_to disallow_value(100000).
+                for(:attr).
+                strict
+            end
+            message = <<-MESSAGE.strip_heredoc.strip
+              Did not expect an exception to have been raised when attr is set to 100000,
+              got RangeError: "100000 is out of range for ActiveRecord::Type::Integer with limit 2"
+            MESSAGE
+            expect(&assertion).to fail_with_message(message)
+          end
+
+          context 'qualified with a message' do
+            it 'ignores any specified message' do
+              attribute_options = { type: :integer, options: { limit: 2 } }
+              record = define_model(:example, attr: attribute_options).new
+              assertion = -> do
+                expect(record).
+                  not_to disallow_value(100000).
+                  for(:attr).
+                  with_message('some message').
+                  strict
+              end
+              message = <<-MESSAGE.strip_heredoc.strip
+                Did not expect exception to include "some message" when attr is set to 100000,
+                got RangeError: "100000 is out of range for ActiveRecord::Type::Integer with limit 2"
+              MESSAGE
+              expect(&assertion).to fail_with_message(message)
+            end
+          end
+        end
+      end
+    end
+  end
+
   def matcher(value)
     described_class.new(value)
   end
+  alias_method :disallow_value, :matcher
 end