mcmire-shoulda-matchers 2.5.0

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

@@ -0,0 +1,9 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # @private
+      module AssociationMatchers
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_record/association_matchers/counter_cache_matcher.rb

@@ -0,0 +1,41 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class CounterCacheMatcher
+          attr_accessor :missing_option
+
+          def initialize(counter_cache, name)
+            @counter_cache = counter_cache
+            @name = name
+            @missing_option = ''
+          end
+
+          def description
+            "counter_cache => #{counter_cache}"
+          end
+
+          def matches?(subject)
+            self.subject = ModelReflector.new(subject, name)
+
+            if option_verifier.correct_for_string?(:counter_cache, counter_cache)
+              true
+            else
+              self.missing_option = "#{name} should have #{description}"
+              false
+            end
+          end
+
+          private
+
+          attr_accessor :subject, :counter_cache, :name
+
+          def option_verifier
+            @option_verifier ||= OptionVerifier.new(subject)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_record/association_matchers/dependent_matcher.rb

@@ -0,0 +1,41 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class DependentMatcher
+          attr_accessor :missing_option
+
+          def initialize(dependent, name)
+            @dependent = dependent
+            @name = name
+            @missing_option = ''
+          end
+
+          def description
+            "dependent => #{dependent}"
+          end
+
+          def matches?(subject)
+            self.subject = ModelReflector.new(subject, name)
+
+            if option_verifier.correct_for_string?(:dependent, dependent)
+              true
+            else
+              self.missing_option = "#{name} should have #{dependent} dependency"
+              false
+            end
+          end
+
+          private
+
+          attr_accessor :subject, :dependent, :name
+
+          def option_verifier
+            @option_verifier ||= OptionVerifier.new(subject)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_record/association_matchers/model_reflection.rb

@@ -0,0 +1,81 @@
+require 'delegate'
+
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class ModelReflection < SimpleDelegator
+          def initialize(reflection)
+            super(reflection)
+            @reflection = reflection
+            @subject = reflection.active_record
+          end
+
+          def associated_class
+            reflection.klass
+          end
+
+          def through?
+            reflection.options[:through]
+          end
+
+          def join_table
+            join_table =
+              if reflection.respond_to?(:join_table)
+                reflection.join_table
+              else
+                reflection.options[:join_table]
+              end
+
+            join_table.to_s
+          end
+
+          def association_relation
+            if reflection.respond_to?(:scope)
+              convert_scope_to_relation(reflection.scope)
+            else
+              convert_options_to_relation(reflection.options)
+            end
+          end
+
+          private
+
+          attr_reader :reflection, :subject
+
+          def convert_scope_to_relation(scope)
+            relation = associated_class.all
+
+            if scope
+              # Source: AR::Associations::AssociationScope#eval_scope
+              relation.instance_exec(subject, &scope)
+            else
+              relation
+            end
+          end
+
+          def convert_options_to_relation(options)
+            relation = associated_class.scoped
+            relation = extend_relation_with(relation, :where, options[:conditions])
+            relation = extend_relation_with(relation, :includes, options[:include])
+            relation = extend_relation_with(relation, :order, options[:order])
+            relation = extend_relation_with(relation, :group, options[:group])
+            relation = extend_relation_with(relation, :having, options[:having])
+            relation = extend_relation_with(relation, :limit, options[:limit])
+            relation = extend_relation_with(relation, :offset, options[:offset])
+            relation = extend_relation_with(relation, :select, options[:select])
+            relation
+          end
+
+          def extend_relation_with(relation, method_name, value)
+            if value
+              relation.__send__(method_name, value)
+            else
+              relation
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_record/association_matchers/model_reflector.rb

@@ -0,0 +1,65 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class ModelReflector
+          delegate :associated_class, :through?, :join_table,
+            :association_relation, to: :reflection
+
+          def initialize(subject, name)
+            @subject = subject
+            @name = name
+          end
+
+          def reflection
+            @reflection ||= reflect_on_association(name)
+          end
+
+          def reflect_on_association(name)
+            reflection = model_class.reflect_on_association(name)
+
+            if reflection
+              ModelReflection.new(reflection)
+            end
+          end
+
+          def model_class
+            subject.class
+          end
+
+          def build_relation_with_clause(name, value)
+            case name
+              when :conditions then associated_class.where(value)
+              when :order      then associated_class.order(value)
+              else                  raise ArgumentError, "Unknown clause '#{name}'"
+            end
+          end
+
+          def extract_relation_clause_from(relation, name)
+            case name
+            when :conditions
+              relation.where_values_hash
+            when :order
+              relation.order_values.map { |value| value_as_sql(value) }.join(', ')
+            else
+              raise ArgumentError, "Unknown clause '#{name}'"
+            end
+          end
+
+          private
+
+          attr_reader :subject, :name
+
+          def value_as_sql(value)
+            if value.respond_to?(:to_sql)
+              value.to_sql
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_record/association_matchers/option_verifier.rb

@@ -0,0 +1,94 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class OptionVerifier
+          delegate :reflection, to: :reflector
+
+          attr_reader :reflector
+
+          RELATION_OPTIONS = [:conditions, :order]
+
+          def initialize(reflector)
+            @reflector = reflector
+          end
+
+          def correct_for_string?(name, expected_value)
+            correct_for?(:string, name, expected_value)
+          end
+
+          def correct_for_boolean?(name, expected_value)
+            correct_for?(:boolean, name, expected_value)
+          end
+
+          def correct_for_hash?(name, expected_value)
+            correct_for?(:hash, name, expected_value)
+          end
+
+          def correct_for_relation_clause?(name, expected_value)
+            correct_for?(:relation_clause, name, expected_value)
+          end
+
+          def actual_value_for(name)
+            if RELATION_OPTIONS.include?(name)
+              actual_value_for_relation_clause(name)
+            else
+              method_name = "actual_value_for_#{name}"
+              if respond_to?(method_name, true)
+                __send__(method_name)
+              else
+                reflection.options[name]
+              end
+            end
+          end
+
+          private
+
+          attr_reader :reflector
+
+          def correct_for?(*args)
+            expected_value, name, type = args.reverse
+            if expected_value.nil?
+              true
+            else
+              expected_value = type_cast(type, expected_value_for(name, expected_value))
+              actual_value = type_cast(type, actual_value_for(name))
+              expected_value == actual_value
+            end
+          end
+
+          def type_cast(type, value)
+            case type
+              when :string, :relation_clause then value.to_s
+              when :boolean                  then !!value
+              when :hash                     then Hash(value).stringify_keys
+              else                                value
+            end
+          end
+
+          def expected_value_for(name, value)
+            if RELATION_OPTIONS.include?(name)
+              expected_value_for_relation_clause(name, value)
+            else
+              value
+            end
+          end
+
+          def expected_value_for_relation_clause(name, value)
+            relation = reflector.build_relation_with_clause(name, value)
+            reflector.extract_relation_clause_from(relation, name)
+          end
+
+          def actual_value_for_relation_clause(name)
+            reflector.extract_relation_clause_from(reflector.association_relation, name)
+          end
+
+          def actual_value_for_class_name
+            reflector.associated_class
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_record/association_matchers/order_matcher.rb

@@ -0,0 +1,41 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class OrderMatcher
+          attr_accessor :missing_option
+
+          def initialize(order, name)
+            @order = order
+            @name = name
+            @missing_option = ''
+          end
+
+          def description
+            "order => #{order}"
+          end
+
+          def matches?(subject)
+            self.subject = ModelReflector.new(subject, name)
+
+            if option_verifier.correct_for_relation_clause?(:order, order)
+              true
+            else
+              self.missing_option = "#{name} should be ordered by #{order}"
+              false
+            end
+          end
+
+          private
+
+          attr_accessor :subject, :order, :name
+
+          def option_verifier
+            @option_verifier ||= OptionVerifier.new(subject)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_record/association_matchers/source_matcher.rb

@@ -0,0 +1,41 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class SourceMatcher
+          attr_accessor :missing_option
+
+          def initialize(source, name)
+            @source = source
+            @name = name
+            @missing_option = ''
+          end
+
+          def description
+            "source => #{source}"
+          end
+
+          def matches?(subject)
+            self.subject = ModelReflector.new(subject, name)
+
+            if option_verifier.correct_for_string?(:source, source)
+              true
+            else
+              self.missing_option = "#{name} should have #{source} as source option"
+              false
+            end
+          end
+
+          private
+
+          attr_accessor :subject, :source, :name
+
+          def option_verifier
+            @option_verifier ||= OptionVerifier.new(subject)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_record/association_matchers/through_matcher.rb

@@ -0,0 +1,63 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class ThroughMatcher
+          attr_accessor :missing_option
+
+          def initialize(through, name)
+            @through = through
+            @name = name
+            @missing_option = ''
+          end
+
+          def description
+            "through #{through}"
+          end
+
+          def matches?(subject)
+            self.subject = ModelReflector.new(subject, name)
+            through.nil? || association_set_properly?
+          end
+
+          def association_set_properly?
+            through_association_exists? && through_association_correct?
+          end
+
+          def through_association_exists?
+            if through_reflection.present?
+              true
+            else
+              self.missing_option = "#{name} does not have any relationship to #{through}"
+              false
+            end
+          end
+
+          def through_reflection
+            @through_reflection ||= subject.reflect_on_association(through)
+          end
+
+          def through_association_correct?
+            if option_verifier.correct_for_string?(:through, through)
+              true
+            else
+              self.missing_option =
+                "Expected #{name} to have #{name} through #{through}, " +
+                "but got it through #{option_verifier.actual_value_for(:through)}"
+              false
+            end
+          end
+
+          private
+
+          attr_accessor :through, :name, :subject
+
+          def option_verifier
+            @option_verifier ||= OptionVerifier.new(subject)
+          end
+        end
+      end
+    end
+  end
+end