remarkable_activerecord 3.0.4 → 3.0.5

data/README

@@ -4,13 +4,17 @@ Remarkable ActiveRecord is a collection of matchers to ActiveRecord. Why use
 Remarkable?
 
 * The only one with matchers for all ActiveRecord validations, with support to
-  all options;
+  all options (except :on and the option :with in validates_format_of);
 
 * Matchers for all ActiveRecord associations. The only one which supports all
   these options:
 
-    :through, :class_name, :foreign_key, :dependent, :join_table, :uniq,
-    :readonly, :validate, :autosave, :counter_cache, :polymorphic
+    :through, :source, :source_type, :class_name, :foreign_key, :dependent,
+    :join_table, :uniq, :readonly, :validate, :autosave, :counter_cache, :polymorphic
+
+  Plus SQL options:
+
+    :select, :conditions, :include, :group, :having, :order, :limit, :offset
 
   Besides in Remarkable 3.0 matchers became much smarter. Whenever :join_table
   or :through is given as option, it checks if the given table exists. Whenever

data/lib/remarkable_activerecord/base.rb

@@ -60,14 +60,7 @@ module Remarkable
         # to be used as default.
         #
         def allow_nil?(message_key=:message) #:nodoc:
-          valid, options = assert_good_or_bad_if_key(:allow_nil, nil, message_key)
-
-          unless valid
-            default = Remarkable.t "remarkable.active_record.allow_nil", default_i18n_options.except(:scope).merge(options)
-            return false, options.merge(:default => default)
-          end
-
-          true
+          assert_good_or_bad_if_key(:allow_nil, nil, message_key)
         end
 
         # Default allow_blank? validation. It accepts the message_key which is
@@ -77,14 +70,7 @@ module Remarkable
         # to be used as default.
         #
         def allow_blank?(message_key=:message) #:nodoc:
-          valid, options = assert_good_or_bad_if_key(:allow_blank, '', message_key)
-
-          unless valid
-            default = Remarkable.t "remarkable.active_record.allow_blank", default_i18n_options.except(:scope).merge(options)
-            return false, options.merge(:default => default)
-          end
-
-          true
+          assert_good_or_bad_if_key(:allow_blank, '', message_key)
         end
 
         # Shortcut for assert_good_value.

data/lib/remarkable_activerecord/matchers/association_matcher.rb

@@ -4,15 +4,13 @@ module Remarkable
       class AssociationMatcher < Remarkable::ActiveRecord::Base #:nodoc:
         arguments :macro, :collection => :associations, :as => :association
 
-        optionals :through, :class_name, :foreign_key, :dependent, :join_table, :as
+        optionals :through, :source, :source_type, :class_name, :foreign_key, :dependent, :join_table, :as
+        optionals :select, :conditions, :include, :group, :having, :order, :limit, :offset, :finder_sql, :counter_sql
         optionals :uniq, :readonly, :validate, :autosave, :polymorphic, :counter_cache, :default => true
 
-        # Stores optionals declared above in a CONSTANT to generate assertions
-        ASSOCIATION_OPTIONS = self.matcher_optionals
-
-        collection_assertions :association_exists?, :macro_matches?, :through_exists?,
+        collection_assertions :association_exists?, :macro_matches?, :through_exists?, :source_exists?,
                               :join_table_exists?, :foreign_key_exists?, :polymorphic_exists?,
-                              :counter_cache_exists?
+                              :counter_cache_exists?, :options_match?
 
         protected
 
@@ -25,16 +23,22 @@ module Remarkable
           end
 
           def through_exists?
-            return true unless @options.key?(:through)
-            subject_class.reflect_on_association(@options[:through])
+            return true unless @options.key?(:through)
+            reflection.through_reflection rescue false
+          end
+
+          def source_exists?
+            return true unless @options.key?(:through)
+            reflection.source_reflection rescue false
           end
 
           def join_table_exists?
-            return true unless has_join_table?
-            ::ActiveRecord::Base.connection.tables.include?(reflection_join_table)
+            return true unless reflection.macro == :has_and_belongs_to_many
+            ::ActiveRecord::Base.connection.tables.include?(reflection.options[:join_table])
           end
 
-          def foreign_key_exists?
+          def foreign_key_exists?
+            return true unless foreign_key_table
             table_has_column?(foreign_key_table, reflection_foreign_key)
           end
 
@@ -47,18 +51,18 @@ module Remarkable
             return true unless @options[:counter_cache]
             table_has_column?(reflection.klass.table_name, reflection.counter_cache_column.to_s)
           end
-
-          ASSOCIATION_OPTIONS.each do |option|
-            collection_assertion :"#{option}_matches?"
-
-            class_eval <<-METHOD, __FILE__, __LINE__
-              def #{option}_matches?
-                return true unless @options.key?(#{option.inspect})
-                actual_value = respond_to?(:reflection_#{option}, true) ? reflection_#{option} : reflection.options[#{option.inspect}].to_s
-
-                return true if @options[#{option.inspect}].to_s == actual_value
-              end
-            METHOD
+
+          def options_match?
+            actual_options = {}
+
+            @options.keys.each do |key|
+              method = :"reflection_#{key}"
+
+              @options[key]       = @options[key].to_s
+              actual_options[key] = (respond_to?(method, true) ? send(method) : reflection.options[key]).to_s
+            end
+
+            return @options == actual_options, :actual => actual_options.inspect
           end
 
         private
@@ -76,27 +80,25 @@ module Remarkable
             reflection.primary_key_name.to_s
           end
 
-          def reflection_join_table
-            (reflection.options[:join_table] || reflection.options[:through]).to_s
-          end
-
-          def has_join_table?
-            reflection.options.key?(:through) || reflection.macro == :has_and_belongs_to_many
-          end
-
           def table_has_column?(table_name, column)
             ::ActiveRecord::Base.connection.columns(table_name, 'Remarkable column retrieval').any?{|c| c.name == column }
           end
 
+          # In through we don't check the foreign_key, because it's spread
+          # accross the through and the source reflection which should be tested
+          # with their own macros.
+          #
           # In cases a join table exists (has_and_belongs_to_many and through
           # associations), we check the foreign key in the join table.
           #
           # On belongs to, the foreign_key is in the subject class table and in
           # other cases it's on the reflection class table.
           #
-          def foreign_key_table
-            if has_join_table?
-              reflection_join_table
+          def foreign_key_table
+            if reflection.options.key?(:through)
+              nil
+            elsif reflection.macro == :has_and_belongs_to_many
+              reflection.options[:join_table]
             elsif reflection.macro == :belongs_to
               subject_class.table_name
             else
@@ -105,7 +107,7 @@ module Remarkable
           end
 
           def interpolation_options
-            options = { :macro => Remarkable.t(@macro, :scope => matcher_i18n_scope, :default => @macro.to_s) }
+            options = { :macro => Remarkable.t(@macro, :scope => matcher_i18n_scope, :default => @macro.to_s), :options => @options.inspect }
 
             if @subject && reflection
               options.merge!(
@@ -114,14 +116,10 @@ module Remarkable
                 :reflection_table     => reflection.klass.table_name.inspect,
                 :foreign_key_table    => foreign_key_table.inspect,
                 :polymorphic_column   => reflection_foreign_key.sub(/_id$/, '_type').inspect,
-                :counter_cache_column => reflection.counter_cache_column.to_s.inspect
+                :counter_cache_column => reflection.counter_cache_column.to_s.inspect,
+                :join_table           => reflection.options[:join_table].inspect,
+                :foreign_key          => reflection_foreign_key.inspect
               ) rescue nil # rescue to allow specs to run properly
-
-              ASSOCIATION_OPTIONS.each do |option|
-                value_to_compare = respond_to?(:"reflection_#{option}", true) ? send(:"reflection_#{option}") : reflection.options[option].to_s
-                options[:"actual_#{option}"] = value_to_compare.inspect
-              end
-
             end
 
             options
@@ -143,6 +141,9 @@ module Remarkable
       #   It also checks if the column actually exists in the table.
       # * <tt>:polymorphic</tt> - if the association should be polymorphic or not.
       #   When true it also checks for the association_type column in the subject table.
+      #
+      # Plus all supported sql conditions options: :select, :conditions, :order,
+      # :limit, :offset, :include, :group, :having.
       #
       # == Examples
       #
@@ -164,7 +165,10 @@ module Remarkable
       # * <tt>:uniq</tt>     - checks wether uniq is true or false.
       # * <tt>:readonly</tt> - checks wether readonly is true or false.
       # * <tt>:validate</tt> - checks wether validate is true or false.
-      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      #
+      # Plus all supported sql conditions options: :select, :conditions, :order,
+      # :limit, :offset, :include, :group, :having.
       #
       # == Examples
       #
@@ -183,14 +187,19 @@ module Remarkable
       #
       # * <tt>:class_name</tt>  - the expected associted class name.
       # * <tt>:through</tt>     - the expected join model which to perform the query.
-      #   It also checks if the through table exists.
+      #   It also checks if the through table exists.
+      # * <tt>:source</tt>      - the source of the through association.
+      # * <tt>:source_type</tt> - the source type of the through association.
       # * <tt>:foreign_key</tt> - the expected foreign key in the associated table.
       #   When used with :through, it will check for the foreign key in the join table.
       # * <tt>:dependent</tt>   - the expected dependent value for the association.
       # * <tt>:uniq</tt>     - checks wether uniq is true or false.
       # * <tt>:readonly</tt> - checks wether readonly is true or false.
       # * <tt>:validate</tt> - checks wether validate is true or false.
-      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      #
+      # Plus all supported sql conditions options: :select, :conditions, :order,
+      # :limit, :offset, :include, :group, :having.
       #
       # == Examples
       #
@@ -214,12 +223,17 @@ module Remarkable
       #
       # * <tt>:class_name</tt>  - the expected associted class name.
       # * <tt>:through</tt>     - the expected join model which to perform the query.
-      #   It also checks if the through table exists.
+      #   It also checks if the through table exists.
+      # * <tt>:source</tt>      - the source of the through association.
+      # * <tt>:source_type</tt> - the source type of the through association.
       # * <tt>:foreign_key</tt> - the expected foreign key in the associated table.
       #   When used with :through, it will check for the foreign key in the join table.
       # * <tt>:dependent</tt>   - the expected dependent value for the association.
       # * <tt>:validate</tt> - checks wether validate is true or false.
-      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      #
+      # Plus all supported sql conditions options: :select, :conditions, :order,
+      # :limit, :offset, :include, :group, :having.
       #
       # == Examples
       #

data/locale/en.yml

@@ -1,20 +1,21 @@
 en:
   remarkable:
-    active_record:
-      allow_nil: "{{subject_name}} to {{not}}allow nil values for {{attribute}}"
-      allow_blank: "{{subject_name}} to {{not}}allow blank values for {{attribute}}"
+    active_record:
+      expectations:
+        allow_nil: "{{subject_name}} to {{not}}allow nil values for {{attribute}}"
+        allow_blank: "{{subject_name}} to {{not}}allow blank values for {{attribute}}"
+      optionals:
+        allow_nil:
+          positive: "allowing nil values"
+          negative: "not allowing nil values"
+        allow_blank:
+          positive: "allowing blank values"
+          negative: "not allowing blank values"
 
       allow_values_for:
         description: "allow {{in}} as values for {{attributes}}"
         expectations:
           is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
-        optionals:
-          allow_nil:
-            positive: "allowing nil values"
-            negative: "not allowing nil values"
-          allow_blank:
-            positive: "allowing blank values"
-            negative: "not allowing blank values"
 
       allow_mass_assignment_of:
         description: "allow mass assignment of {{attributes}}"
@@ -31,26 +32,20 @@ en:
         expectations:
           association_exists: "{{subject_name}} records {{macro}} {{association}}, got no association"
           macro_matches: "{{subject_name}} records {{macro}} {{association}}, got {{subject_name}} records {{actual_macro}} {{association}}"
-          through_exists: "{{subject_name}} records {{macro}} {{association}} through {{through}}, through association does not exist"
-          join_table_exists: "join table {{actual_join_table}} to exist, but does not"
-          foreign_key_exists: "foreign key {{actual_foreign_key}} to exist on {{foreign_key_table}}, but does not"
+          through_exists: "{{subject_name}} records {{macro}} {{association}} through {{through}}, through association does not exist"
+          source_exists: "{{subject_name}} records {{macro}} {{association}} through {{through}}, source association does not exist"
+          join_table_exists: "join table {{join_table}} to exist, but does not"
+          foreign_key_exists: "foreign key {{foreign_key}} to exist on {{foreign_key_table}}, but does not"
           polymorphic_exists: "{{subject_table}} to have {{polymorphic_column}} as column, but does not"
-          counter_cache_exists: "{{reflection_table}} to have {{counter_cache_column}} as column, but does not"
-          through_matches: "{{association}} association through {{through}}, got {{actual_through}}"
-          class_name_matches: "{{association}} association with class name {{class_name}}, got {{actual_class_name}}"
-          foreign_key_matches: "{{association}} association with foreign key {{foreign_key}}, got {{actual_foreign_key}}"
-          dependent_matches: "{{association}} association with dependent {{dependent}}, got {{actual_dependent}}"
-          join_table_matches: "{{association}} association with join table {{join_table}}, got {{actual_join_table}}"
-          uniq_matches: "{{association}} association with uniq equals to {{uniq}}, got {{actual_uniq}}"
-          readonly_matches: "{{association}} association with readonly equals to {{readonly}}, got {{actual_readonly}}"
-          validate_matches: "{{association}} association with validate equals to {{validate}}, got {{actual_validate}}"
-          autosave_matches: "{{association}} association with autosave equals to {{autosave}}, got {{actual_autosave}}"
-          polymorphic_matches: "{{association}} association with polymorphic equals to {{polymorphic}}, got {{actual_polymorphic}}"
-          as_matches: "{{association}} association with polymorphic interface {{as}}, got {{actual_as}}"
-          counter_cache_matches: "{{association}} association with counter cache {{counter_cache}}, got {{actual_counter_cache}}"
+          counter_cache_exists: "{{reflection_table}} to have {{counter_cache_column}} as column, but does not"
+          options_match: "{{subject_name}} records {{macro}} {{association}} with options {{options}}, got {{actual}}"
         optionals:
           through:
-            positive: "through {{value}}"
+            positive: "through {{value}}"
+          source:
+            positive: "with source {{inspect}}"
+          source_type:
+            positive: "with source type {{inspect}}"
           class_name:
             positive: "with class name {{inspect}}"
           foreign_key:
@@ -75,7 +70,23 @@ en:
             positive: "through the polymorphic interface {{inspect}}"
           counter_cache:
             positive: "with counter cache {{inspect}}"
-            negative: "without counter cache"
+            negative: "without counter cache"
+          select:
+            positive: "selecting {{inspect}}"
+          conditions:
+            positive: "with conditions {{inspect}}"
+          include:
+            positive: "including {{inspect}}"
+          group:
+            positive: "grouping by {{inspect}}"
+          having:
+            positive: "having {{inspect}}"
+          order:
+            positive: "with order {{inspect}}"
+          limit:
+            positive: "with limit {{inspect}}"
+          offset:
+            positive: "with offset {{inspect}}"
 
       have_column:
         description: "have column(s) named {{columns}}"
@@ -126,9 +137,6 @@ en:
         optionals:
           accept:
             positive: "with value {{inspect}}"
-          allow_nil:
-            positive: "allowing nil values"
-            negative: "not allowing nil values"
 
       validate_associated:
         description: "require associated {{associations}} to be valid"
@@ -146,26 +154,12 @@ en:
         expectations:
           is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
           is_invalid: "{{subject_name}} to be invalid when {{attribute}} is set to {{value}}"
-        optionals:
-          allow_nil:
-            positive: "allowing nil values"
-            negative: "not allowing nil values"
-          allow_blank:
-            positive: "allowing blank values"
-            negative: "not allowing blank values"
 
       validate_inclusion_of:
         description: "ensure inclusion of {{attributes}} in {{in}}"
         expectations:
           is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
           is_invalid: "{{subject_name}} to be invalid when {{attribute}} is set to {{value}}"
-        optionals:
-          allow_nil:
-            positive: "allowing nil values"
-            negative: "not allowing nil values"
-          allow_blank:
-            positive: "allowing blank values"
-            negative: "not allowing blank values"
 
       validate_length_of:
         description: "ensure length of {{attributes}}"
@@ -183,12 +177,6 @@ en:
             positive: "is minimum {{inspect}} characters"
           is:
             positive: "is equal to {{inspect}} characters"
-          allow_nil:
-            positive: "allowing nil values"
-            negative: "not allowing nil values"
-          allow_blank:
-            positive: "allowing blank values"
-            negative: "not allowing blank values"
 
       validate_numericality_of:
         description: "ensure numericality of {{attributes}}"
@@ -217,12 +205,6 @@ en:
             positive: "is less than or equal to {{inspect}}"
           greater_than_or_equal_to:
             positive: "is greater than or equal to {{inspect}}"
-          allow_nil:
-            positive: "allowing nil values"
-            negative: "not allowing nil values"
-          allow_blank:
-            positive: "allowing blank values"
-            negative: "not allowing blank values"
 
       validate_presence_of:
         description: "require {{attributes}} to be set"
@@ -242,10 +224,4 @@ en:
           case_sensitive:
             positive: "case sensitive"
             negative: "case insensitive"
-          allow_nil:
-            positive: "allowing nil values"
-            negative: "not allowing nil values"
-          allow_blank:
-            positive: "allowing blank values"
-            negative: "not allowing blank values"
-
+

data/spec/association_matcher_spec.rb

@@ -75,36 +75,16 @@ describe 'association_matcher' do
         matcher.failure_message.should == 'Expected "companies" to have "projects_count" as column, but does not'
       end
 
-      it 'should set validate_matches? message' do
-        matcher = define_and_validate(:validate => false)
-        matcher.validate.matches?(@model)
-        matcher.failure_message.should == 'Expected company association with validate equals to true, got "false"'
-      end
-
-      it 'should set readonly_matches? message' do
-        matcher = define_and_validate(:readonly => false)
-        matcher.readonly.matches?(@model)
-        matcher.failure_message.should == 'Expected company association with readonly equals to true, got "false"'
-      end
-
-      if RAILS_VERSION =~ /^2.3/
-        it 'should set autosave_matches? message' do
-          matcher = define_and_validate(:autosave => false)
-          matcher.autosave.matches?(@model)
-          matcher.failure_message.should == 'Expected company association with autosave equals to true, got "false"'
-        end
-      end
-
-      it 'should set polymorphic_matches? message' do
+      it 'should set options_matches? message when polymorphic is given' do
         matcher = define_and_validate(:polymorphic => false)
         matcher.polymorphic.matches?(@model)
-        matcher.failure_message.should == 'Expected company association with polymorphic equals to true, got "false"'
+        matcher.failure_message.should == 'Expected Project records belong to company with options {:polymorphic=>"true"}, got {:polymorphic=>"false"}'
       end
 
-      it 'should set counter_cache_matches? message' do
+      it 'should set options_matches? message when counter_cache is given' do
         matcher = define_and_validate(:counter_cache => true)
         matcher.counter_cache(false).matches?(@model)
-        matcher.failure_message.should == 'Expected company association with counter cache false, got "true"'
+        matcher.failure_message.should == 'Expected Project records belong to company with options {:counter_cache=>"false"}, got {:counter_cache=>"true"}'
       end
     end
 
@@ -244,31 +224,11 @@ describe 'association_matcher' do
         matcher.failure_message.should == 'Expected foreign key "project_id" to exist on "labels_projects", but does not'
       end
 
-      it 'should set validate_matches? message' do
-        matcher = define_and_validate(:validate => false)
-        matcher.validate.matches?(@model)
-        matcher.failure_message.should == 'Expected labels association with validate equals to true, got "false"'
-      end
-
-      it 'should set readonly_matches? message' do
-        matcher = define_and_validate(:readonly => false)
-        matcher.readonly.matches?(@model)
-        matcher.failure_message.should == 'Expected labels association with readonly equals to true, got "false"'
-      end
-
-      if RAILS_VERSION =~ /^2.3/
-        it 'should set autosave_matches? message' do
-          matcher = define_and_validate(:autosave => false)
-          matcher.autosave.matches?(@model)
-          matcher.failure_message.should == 'Expected labels association with autosave equals to true, got "false"'
-        end
-      end
-
-      it 'should set uniq_matches? message' do
+      it 'should set options_matches? message' do
         matcher = define_and_validate(:uniq => false)
         matcher.uniq.matches?(@model)
-        matcher.failure_message.should == 'Expected labels association with uniq equals to true, got "false"'
-      end
+        matcher.failure_message.should == 'Expected Project records have and belong to many labels with options {:uniq=>"true"}, got {:uniq=>"false"}'
+      end
     end
 
     describe 'matchers' do
@@ -348,17 +308,19 @@ describe 'association_matcher' do
 
     # Defines a model, create a validation and returns a raw matcher
     def define_and_validate(options={})
-      columns = options.delete(:association_columns) || { :task_id => :integer, :project_id => :integer }
-      define_model :task, columns
+      columns = options.delete(:association_columns) || { :task_id => :integer, :project_id => :integer, :todo_id => :integer }
+      define_model :task, columns
+      define_model :todo, columns
 
       define_model :project_task, columns do
         belongs_to :task
-        belongs_to :project
-      end unless options.delete(:skip_through)
+        belongs_to :project
+        belongs_to :todo
+      end unless options.delete(:skip_source)
 
-      @model = define_model :project, options.delete(:model_columns) || {} do
+      @model = define_model :project, options.delete(:model_columns) || {} do
+        has_many :project_tasks unless options.delete(:skip_through)
         has_many :tasks, options
-        has_many :project_tasks
       end
 
       have_many :tasks
@@ -403,15 +365,28 @@ describe 'association_matcher' do
       end
 
       it 'should set through_exists? message' do
-        matcher = define_and_validate(:through => 'project_tasks')
-        matcher.through(:another).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have many tasks through :another, through association does not exist'
-      end
-
-      it 'should set join_table_exists? message' do
-        matcher = define_and_validate(:through => 'project_tasks', :skip_through => true)
+        matcher = define_and_validate(:through => :project_tasks, :skip_through => true)
+        matcher.through(:project_tasks).matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have many tasks through :project_tasks, through association does not exist'
+      end
+
+      it 'should set source_exists? message' do
+        matcher = define_and_validate(:through => :project_tasks, :skip_source => true)
         matcher.through(:project_tasks).matches?(@model)
-        matcher.failure_message.should == 'Expected join table "project_tasks" to exist, but does not'
+        matcher.failure_message.should == 'Expected Project records have many tasks through :project_tasks, source association does not exist'
+      end
+
+      it 'should set options_matches? message when dependent is given' do
+        matcher = define_and_validate(:dependent => :destroy)
+        matcher.dependent(:nullify).matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have many tasks with options {:dependent=>"nullify"}, got {:dependent=>"destroy"}'
+      end
+
+      it 'should set options_matches? message when source is given' do
+        matcher = define_and_validate(:through => :project_tasks, :source => :todo)
+        matcher.through(:project_tasks).source(:task).matches?(@model)
+        matcher.failure_message.should match(/:source=>"task"/)
+        matcher.failure_message.should match(/:source=>"todo"/)
       end
     end
 
@@ -456,11 +431,16 @@ describe 'association_matcher' do
       end
 
       describe 'with through option' do
-        it { should define_and_validate(:through => 'project_tasks') }
-        it { should define_and_validate(:through => 'project_tasks').through(:project_tasks) }
+        it { should define_and_validate(:through => :project_tasks) }
+        it { should define_and_validate(:through => :project_tasks).through(:project_tasks) }
 
-        it { should_not define_and_validate(:through => 'project_tasks').through(:something) }
-        it { should_not define_and_validate(:through => 'project_tasks', :skip_through => true).through(:project_tasks) }
+        it { should_not define_and_validate(:through => :project_tasks).through(:something) }
+        it { should_not define_and_validate(:through => :project_tasks, :skip_through => true).through(:project_tasks) }
+      end
+
+      describe 'with source option' do
+        it { should define_and_validate(:through => :project_tasks, :source => :todo).source(:todo) }
+        it { should_not define_and_validate(:through => :project_tasks, :source => :todo).source(:task) }
       end
 
       create_optional_boolean_specs(:uniq, self)
@@ -470,7 +450,7 @@ describe 'association_matcher' do
     end
 
     describe 'macros' do
-      before(:each){ define_and_validate(:through => 'project_tasks', :readonly => true, :validate => true) } 
+      before(:each){ define_and_validate(:through => :project_tasks, :readonly => true, :validate => true) } 
 
       should_have_many :tasks
       should_have_many :tasks, :readonly => true
@@ -487,17 +467,19 @@ describe 'association_matcher' do
 
     # Defines a model, create a validation and returns a raw matcher
     def define_and_validate(options={})
-      columns = options.delete(:association_columns) || { :manager_id => :integer, :project_id => :integer }
-      define_model :manager, columns
+      columns = options.delete(:association_columns) || { :manager_id => :integer, :project_id => :integer, :boss_id => :integer }
+      define_model :manager, columns
+      define_model :boss,    columns
 
       define_model :project_manager, columns do
         belongs_to :manager
-        belongs_to :project
-      end unless options.delete(:skip_through)
+        belongs_to :project
+        belongs_to :boss
+      end unless options.delete(:skip_source)
 
-      @model = define_model :project, options.delete(:model_columns) || {} do
+      @model = define_model :project, options.delete(:model_columns) || {} do
+        has_many :project_managers unless options.delete(:skip_through)
         has_one  :manager, options
-        has_many :project_managers
       end
 
       have_one :manager
@@ -536,15 +518,28 @@ describe 'association_matcher' do
       end
 
       it 'should set through_exists? message' do
-        matcher = define_and_validate(:through => 'project_managers')
-        matcher.through(:another).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have one manager through :another, through association does not exist'
-      end
-
-      it 'should set join_table_exists? message' do
-        matcher = define_and_validate(:through => 'project_managers', :skip_through => true)
+        matcher = define_and_validate(:through => :project_managers, :skip_through => true)
+        matcher.through(:project_managers).matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have one manager through :project_managers, through association does not exist'
+      end
+
+      it 'should set source_exists? message' do
+        matcher = define_and_validate(:through => :project_managers, :skip_source => true)
         matcher.through(:project_managers).matches?(@model)
-        matcher.failure_message.should == 'Expected join table "project_managers" to exist, but does not'
+        matcher.failure_message.should == 'Expected Project records have one manager through :project_managers, source association does not exist'
+      end
+
+      it 'should set options_matches? message when dependent is given' do
+        matcher = define_and_validate(:dependent => :destroy)
+        matcher.dependent(:nullify).matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have one manager with options {:dependent=>"nullify"}, got {:dependent=>"destroy"}'
+      end
+
+      it 'should set options_matches? message when source is given' do
+        matcher = define_and_validate(:through => :project_managers, :source => :boss)
+        matcher.through(:project_managers).source(:manager).matches?(@model)
+        matcher.failure_message.should match(/:source=>"manager"/)
+        matcher.failure_message.should match(/:source=>"boss"/)
       end
     end
 
@@ -589,11 +584,16 @@ describe 'association_matcher' do
       end
 
       describe 'with through option' do
-        it { should define_and_validate(:through => 'project_managers') }
-        it { should define_and_validate(:through => 'project_managers').through(:project_managers) }
+        it { should define_and_validate(:through => :project_managers) }
+        it { should define_and_validate(:through => :project_managers).through(:project_managers) }
 
-        it { should_not define_and_validate(:through => 'project_managers').through(:something) }
-        it { should_not define_and_validate(:through => 'project_managers', :skip_through => true).through(:project_managers) }
+        it { should_not define_and_validate(:through => :project_managers).through(:something) }
+        it { should_not define_and_validate(:through => :project_managers, :skip_through => true).through(:project_managers) }
+      end
+
+      describe 'with source option' do
+        it { should define_and_validate(:through => :project_managers, :source => :boss).source(:boss) }
+        it { should_not define_and_validate(:through => :project_managers, :source => :boss).source(:manager) }
       end
 
       create_optional_boolean_specs(:validate, self)
@@ -601,7 +601,7 @@ describe 'association_matcher' do
     end
 
     describe 'macros' do
-      before(:each){ define_and_validate(:through => 'project_managers', :validate => true) } 
+      before(:each){ define_and_validate(:through => :project_managers, :validate => true) } 
 
       should_have_one :manager
       should_have_one :manager, :validate => true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: remarkable_activerecord
 version: !ruby/object:Gem::Version 
-  version: 3.0.4
+  version: 3.0.5
 platform: ruby
 authors: 
 - Carlos Brando
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-18 00:00:00 +02:00
+date: 2009-04-20 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,7 +22,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 3.0.4
+        version: 3.0.5
     version: 
 description: "Remarkable ActiveRecord: collection of matchers and macros with I18n for ActiveRecord"
 email: