shoulda-matchers 2.7.0 → 2.8.0.rc1

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

@@ -189,11 +189,11 @@ module Shoulda
         def correct_default?
           return true unless @options.key?(:default)
 
-          if matched_column.default.to_s == @options[:default].to_s
+          if matched_column.type_cast_default.to_s == @options[:default].to_s
             true
           else
             @missing = "#{model_class} has a db column named #{@column} " <<
-                       "of default #{matched_column.default}, " <<
+                       "of default #{matched_column.type_cast_default}, " <<
                        "not #{@options[:default]}."
             false
           end
@@ -227,7 +227,7 @@ module Shoulda
         def correct_primary?
           return true unless @options.key?(:primary)
 
-          if matched_column.primary == @options[:primary]
+          if matched_column.primary? == @options[:primary]
             true
           else
             @missing = "#{model_class} has a db column named #{@column} "
@@ -241,7 +241,10 @@ module Shoulda
         end
 
         def matched_column
-          model_class.columns.detect { |each| each.name == @column.to_s }
+          @_matched_column ||= begin
+            column = model_class.columns.detect { |each| each.name == @column.to_s }
+            DecoratedColumn.new(model_class, column)
+          end
         end
 
         def model_class
@@ -252,9 +255,32 @@ module Shoulda
           matched_column.scale
         end
 
+        def actual_primary?
+          model_class.primary_key == matched_column.name
+        end
+
         def expectation
           "#{model_class.name} to #{description}"
         end
+
+        class DecoratedColumn < SimpleDelegator
+          def initialize(model, column)
+            @model = model
+            super(column)
+          end
+
+          def type_cast_default
+            Shoulda::Matchers::RailsShim.type_cast_default_for(model, self)
+          end
+
+          def primary?
+            model.primary_key == name
+          end
+
+          protected
+
+          attr_reader :model
+        end
       end
     end
   end

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

@@ -130,7 +130,7 @@ module Shoulda
         protected
 
         def serialization_valid?
-          if model_class.serialized_attributes.keys.include?(@name)
+          if attribute_is_serialized?
             true
           else
             @missing = "no serialized attribute called :#{@name}"
@@ -140,7 +140,7 @@ module Shoulda
 
         def class_valid?
           if @options[:type]
-            klass = model_class.serialized_attributes[@name]
+            klass = serialization_coder
             if klass == @options[:type]
               true
             else
@@ -162,7 +162,7 @@ module Shoulda
 
         def instance_class_valid?
           if @options.key?(:instance_type)
-            if model_class.serialized_attributes[@name].class == @options[:instance_type]
+            if serialization_coder.is_a?(@options[:instance_type])
               true
             else
               @missing = ":#{@name} should be an instance of #{@options[:type]}"
@@ -183,6 +183,22 @@ module Shoulda
           expectation += " with an instance of #{@options[:instance_type]}" if @options[:instance_type]
           expectation
         end
+
+        def attribute_is_serialized?
+          serialized_attributes.include?(@name)
+        end
+
+        def serialization_coder
+          serialized_attributes[@name]
+        end
+
+        def serialized_attributes
+          Shoulda::Matchers::RailsShim.serialized_attributes_for(model)
+        end
+
+        def model
+          @subject.class
+        end
       end
     end
   end

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

@@ -0,0 +1,14 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      module Uniqueness
+      end
+    end
+  end
+end
+
+require 'shoulda/matchers/active_record/uniqueness/model'
+require 'shoulda/matchers/active_record/uniqueness/namespace'
+require 'shoulda/matchers/active_record/uniqueness/test_model_creator'
+require 'shoulda/matchers/active_record/uniqueness/test_models'

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

@@ -0,0 +1,45 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module Uniqueness
+        # @private
+        class Model
+          def self.next_unique_copy_of(model_name, namespace)
+            model = new(model_name, namespace)
+
+            while model.already_exists?
+              model = model.next
+            end
+
+            model
+          end
+
+          def initialize(name, namespace)
+            @name = name
+            @namespace = namespace
+          end
+
+          def already_exists?
+            namespace.has?(name)
+          end
+
+          def next
+            Model.new(name.next, namespace)
+          end
+
+          def symlink_to(parent)
+            namespace.set(name, parent.dup)
+          end
+
+          def to_s
+            [namespace, name].join('::')
+          end
+
+          protected
+
+          attr_reader :name, :namespace
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module Uniqueness
+        # @private
+        class Namespace
+          def initialize(constant)
+            @constant = constant
+          end
+
+          def has?(name)
+            constant.const_defined?(name)
+          end
+
+          def set(name, value)
+            constant.const_set(name, value)
+          end
+
+          def clear
+            constant.constants.each do |child_constant|
+              constant.__send__(:remove_const, child_constant)
+            end
+          end
+
+          def to_s
+            constant.to_s
+          end
+
+          protected
+
+          attr_reader :constant
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'thread'
+
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module Uniqueness
+        # @private
+        class TestModelCreator
+          def self.create(model_name, namespace)
+            Mutex.new.synchronize do
+              new(model_name, namespace).create
+            end
+          end
+
+          def initialize(model_name, namespace)
+            @model_name = model_name
+            @namespace = namespace
+          end
+
+          def create
+            new_model.tap do |new_model|
+              new_model.symlink_to(existing_model)
+            end
+          end
+
+          protected
+
+          attr_reader :model_name, :namespace
+
+          private
+
+          def model_name_without_namespace
+            model_name.demodulize
+          end
+
+          def new_model
+            @_new_model ||= Model.next_unique_copy_of(
+              model_name_without_namespace,
+              namespace
+            )
+          end
+
+          def existing_model
+            @_existing_model ||= model_name.constantize
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'thread'
+
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module Uniqueness
+        # @private
+        module TestModels
+          def self.create(model_name)
+            TestModelCreator.create(model_name, root_namespace)
+          end
+
+          def self.remove_all
+            root_namespace.clear
+          end
+
+          def self.root_namespace
+            @_root_namespace ||= Namespace.new(self)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/{active_model → active_record}/validate_uniqueness_of_matcher.rb

@@ -1,6 +1,6 @@
 module Shoulda
   module Matchers
-    module ActiveModel
+    module ActiveRecord
       # The `validate_uniqueness_of` matcher tests usage of the
       # `validates_uniqueness_of` validation. It first checks for an existing
       # instance of your model in the database, creating one if necessary. It
@@ -171,13 +171,33 @@ module Shoulda
       #
       # @return [ValidateUniquenessOfMatcher]
       #
+      # ##### allow_blank
+      #
+      # Use `allow_blank` to assert that the attribute allows a blank value.
+      #
+      #     class Post < ActiveRecord::Base
+      #       validates_uniqueness_of :author_id, allow_blank: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Post do
+      #       it { should validate_uniqueness_of(:author_id).allow_blank }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostTest < ActiveSupport::TestCase
+      #       should validate_uniqueness_of(:author_id).allow_blank
+      #     end
+      #
+      # @return [ValidateUniquenessOfMatcher]
+      #
       def validate_uniqueness_of(attr)
         ValidateUniquenessOfMatcher.new(attr)
       end
 
       # @private
-      class ValidateUniquenessOfMatcher < ValidationMatcher
-        include Helpers
+      class ValidateUniquenessOfMatcher < ActiveModel::ValidationMatcher
+        include ActiveModel::Helpers
 
         def initialize(attribute)
           super(attribute)
@@ -204,6 +224,11 @@ module Shoulda
           self
         end
 
+        def allow_blank
+          @options[:allow_blank] = true
+          self
+        end
+
         def description
           result = "require "
           result << "case sensitive " unless @options[:case_insensitive]
@@ -216,10 +241,14 @@ module Shoulda
           @original_subject = subject
           @subject = subject.class.new
           @expected_message ||= :taken
+
           set_scoped_attributes &&
-            validate_everything_except_duplicate_nils? &&
+            validate_everything_except_duplicate_nils_or_blanks? &&
             validate_after_scope_change? &&
-            allows_nil?
+            allows_nil? &&
+            allows_blank?
+        ensure
+          Uniqueness::TestModels.remove_all
         end
 
         private
@@ -233,6 +262,15 @@ module Shoulda
           end
         end
 
+        def allows_blank?
+          if @options[:allow_blank]
+            ensure_blank_record_in_database
+            allows_value_of('', @expected_message)
+          else
+            true
+          end
+        end
+
         def existing_record
           @existing_record ||= first_instance
         end
@@ -247,21 +285,26 @@ module Shoulda
           end
         end
 
+        def ensure_blank_record_in_database
+          unless existing_record_is_blank?
+            create_record_in_database(blank_value: true)
+          end
+        end
+
         def existing_record_is_nil?
           @existing_record.present? && existing_value.nil?
         end
 
-        def create_record_in_database(options = {})
-          if options[:nil_value]
-            value = nil
-          else
-            value = 'a'
-          end
+        def existing_record_is_blank?
+          @existing_record.present? && existing_value.strip == ''
+        end
 
+        def create_record_in_database(options = {})
           @original_subject.tap do |instance|
-            instance.__send__("#{@attribute}=", value)
+            instance.__send__("#{@attribute}=", value_for_new_record(options))
             ensure_secure_password_set(instance)
             instance.save(validate: false)
+            @created_record = instance
           end
         end
 
@@ -272,6 +315,14 @@ module Shoulda
           end
         end
 
+        def value_for_new_record(options = {})
+          case
+            when options[:nil_value] then nil
+            when options[:blank_value] then ''
+            else 'a'
+          end
+        end
+
         def has_secure_password?
           @subject.class.ancestors.map(&:to_s).include?('ActiveModel::SecurePassword::InstanceMethodsOnActivation')
         end
@@ -293,18 +344,25 @@ module Shoulda
           end
         end
 
-        def validate_everything_except_duplicate_nils?
-          if @options[:allow_nil] && existing_value.nil?
-            create_record_without_nil
+        def validate_everything_except_duplicate_nils_or_blanks?
+          if (@options[:allow_nil] && existing_value.nil?) ||
+             (@options[:allow_blank] && existing_value.blank?)
+            create_record_with_value
           end
 
           disallows_value_of(existing_value, @expected_message)
         end
 
-        def create_record_without_nil
+        def create_record_with_value
           @existing_record = create_record_in_database
         end
 
+        def model_class?(model_name)
+          model_name.constantize.ancestors.include?(::ActiveRecord::Base)
+        rescue NameError
+          false
+        end
+
         def validate_after_scope_change?
           if @options[:scopes].blank?
             true
@@ -322,6 +380,8 @@ module Shoulda
                     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)