shoulda-matchers 2.4.0 → 2.5.0

data/spec/shoulda/matchers/active_record/accept_nested_attributes_for_matcher_spec.rb

@@ -10,7 +10,7 @@ describe Shoulda::Matchers::ActiveRecord::AcceptNestedAttributesForMatcher do
 
     matcher.matches?(rejecting_children).should be_false
 
-    matcher.failure_message_for_should.
+    matcher.failure_message.
       should eq 'Expected Parent to accept nested attributes for children (is not declared)'
   end
 
@@ -32,7 +32,7 @@ describe Shoulda::Matchers::ActiveRecord::AcceptNestedAttributesForMatcher do
       matching = accepting_children(:allow_destroy => true)
 
       matcher.allow_destroy(false).matches?(matching).should be_false
-      matcher.failure_message_for_should.should =~ /should not allow destroy/
+      matcher.failure_message.should =~ /should not allow destroy/
     end
 
     it 'rejects an invalid falsey value' do
@@ -40,7 +40,7 @@ describe Shoulda::Matchers::ActiveRecord::AcceptNestedAttributesForMatcher do
       matching = accepting_children(:allow_destroy => false)
 
       matcher.allow_destroy(true).matches?(matching).should be_false
-      matcher.failure_message_for_should.should =~ /should allow destroy/
+      matcher.failure_message.should =~ /should allow destroy/
     end
   end
 
@@ -54,7 +54,7 @@ describe Shoulda::Matchers::ActiveRecord::AcceptNestedAttributesForMatcher do
       rejecting = accepting_children(:limit => 3)
 
       matcher.limit(2).matches?(rejecting).should be_false
-      matcher.failure_message_for_should.should =~ /limit should be 2, got 3/
+      matcher.failure_message.should =~ /limit should be 2, got 3/
     end
   end
 
@@ -74,7 +74,7 @@ describe Shoulda::Matchers::ActiveRecord::AcceptNestedAttributesForMatcher do
       rejecting = accepting_children(:update_only => true)
 
       matcher.matches?(rejecting).should be_false
-      matcher.failure_message_for_should.should =~ /should not be update only/
+      matcher.failure_message.should =~ /should not be update only/
     end
 
     it 'rejects an invalid falsey value' do
@@ -82,7 +82,7 @@ describe Shoulda::Matchers::ActiveRecord::AcceptNestedAttributesForMatcher do
       rejecting = accepting_children(:update_only => false)
 
       matcher.matches?(rejecting).should be_false
-      matcher.failure_message_for_should.should =~ /should be update only/
+      matcher.failure_message.should =~ /should be update only/
     end
   end
 

data/spec/shoulda/matchers/active_record/association_matcher_spec.rb

@@ -247,7 +247,7 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
       matcher.matches?(having_many_children).should be_false
 
-      matcher.failure_message_for_should.should =~ /does not have any relationship to conceptions/
+      matcher.failure_message.should =~ /does not have any relationship to conceptions/
     end
 
     it 'rejects an association that has the wrong :through option' do
@@ -266,7 +266,7 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
       matcher = have_many(:children).through(:relationships)
       matcher.matches?(Parent.new).should be_false
-      matcher.failure_message_for_should.should =~ /through relationships, but got it through conceptions/
+      matcher.failure_message.should =~ /through relationships, but got it through conceptions/
     end
 
     it 'accepts an association with a valid :dependent option' do
@@ -279,7 +279,20 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
       having_many_children.should_not matcher
 
-      matcher.failure_message_for_should.should =~ /children should have destroy dependency/
+      matcher.failure_message.should =~ /children should have destroy dependency/
+    end
+
+    it 'accepts an association with a valid :source option' do
+      having_many_children(:source => :user).
+        should have_many(:children).source(:user)
+    end
+
+    it 'rejects an association with a bad :source option' do
+      matcher = have_many(:children).source(:user)
+
+      having_many_children.should_not matcher
+
+      matcher.failure_message.should =~ /children should have user as source option/
     end
 
     it 'accepts an association with a valid :order option' do
@@ -292,7 +305,7 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
       having_many_children.should_not matcher
 
-      matcher.failure_message_for_should.should =~ /children should be ordered by id/
+      matcher.failure_message.should =~ /children should be ordered by id/
     end
 
     it 'accepts an association with a valid :conditions option' do
@@ -437,7 +450,7 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
       having_one_detail.should_not matcher
 
-      matcher.failure_message_for_should.should =~ /detail should have destroy dependency/
+      matcher.failure_message.should =~ /detail should have destroy dependency/
     end
 
     it 'accepts an association with a valid :order option' do
@@ -449,7 +462,7 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
       having_one_detail.should_not matcher
 
-      matcher.failure_message_for_should.should =~ /detail should be ordered by id/
+      matcher.failure_message.should =~ /detail should be ordered by id/
     end
 
     it 'accepts an association with a valid :conditions option' do
@@ -652,7 +665,7 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
   def define_association_with_conditions(model, macro, name, conditions, other_options={})
     args = []
     options = {}
-    if Shoulda::Matchers::RailsShim.rails_major_version == 4
+    if Shoulda::Matchers::RailsShim.active_record_major_version == 4
       args << lambda { where(conditions) }
     else
       options[:conditions] = conditions
@@ -664,7 +677,7 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
   def define_association_with_order(model, macro, name, order, other_options={})
     args = []
     options = {}
-    if Shoulda::Matchers::RailsShim.rails_major_version == 4
+    if Shoulda::Matchers::RailsShim.active_record_major_version == 4
       args << lambda { order(order) }
     else
       options[:order] = order

data/spec/shoulda/matchers/active_record/association_matchers/model_reflection_spec.rb

@@ -0,0 +1,247 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveRecord::AssociationMatchers::ModelReflection do
+  it 'delegates other methods to the given Reflection object' do
+    define_model(:country)
+    person_model = define_model(:person, country_id: :integer) do
+      belongs_to :country
+    end
+    delegate_reflection = person_model.reflect_on_association(:country)
+    delegate_reflection.stubs(foo: 'bar')
+    reflection = described_class.new(delegate_reflection)
+
+    expect(reflection.foo).to eq 'bar'
+  end
+
+  describe '#associated_class' do
+    it 'returns the model that the association refers to' do
+      define_model(:country)
+      person_model = define_model(:person, country_id: :integer) do
+        belongs_to :country
+      end
+      delegate_reflection = person_model.reflect_on_association(:country)
+      reflection = described_class.new(delegate_reflection)
+
+      expect(reflection.associated_class).to be Country
+    end
+  end
+
+  describe '#through?' do
+    it 'returns true if the reflection is for a has_many :through association' do
+      define_model(:city, person_id: :integer)
+      define_model(:person, country_id: :integer) do
+        has_many :cities
+      end
+      country_model = define_model(:country) do
+        has_many :people
+        has_many :cities, through: :people
+      end
+      delegate_reflection = country_model.reflect_on_association(:cities)
+      reflection = described_class.new(delegate_reflection)
+
+      expect(reflection).to be_through
+    end
+
+    it 'returns false if not' do
+      define_model(:person, country_id: :integer)
+      country_model = define_model(:country) do
+        has_many :people
+      end
+      delegate_reflection = country_model.reflect_on_association(:people)
+      reflection = described_class.new(delegate_reflection)
+
+      expect(reflection).not_to be_through
+    end
+  end
+
+  describe '#join_table' do
+    context 'when the association was defined with a :join_table option' do
+      it 'returns the value of the option' do
+        define_model(:person, country_id: :integer)
+        country_model = define_model(:country) do
+          has_and_belongs_to_many :people, join_table: 'foos'
+        end
+        delegate_reflection = country_model.reflect_on_association(:people)
+        reflection = described_class.new(delegate_reflection)
+
+        expect(reflection.join_table).to eq 'foos'
+      end
+    end
+
+    context 'when the association was not defined with :join_table' do
+      it 'returns the default join_table that ActiveRecord generates' do
+        define_model(:person, country_id: :integer)
+        country_model = define_model(:country) do
+          has_and_belongs_to_many :people
+        end
+        delegate_reflection = country_model.reflect_on_association(:people)
+        reflection = described_class.new(delegate_reflection)
+
+        expect(reflection.join_table).to eq 'countries_people'
+      end
+    end
+  end
+
+  describe '#association_relation' do
+    if rails_4_x?
+      context 'when the reflection object has a #scope method' do
+        context 'when the scope is a block' do
+          it 'executes the block in the context of an empty scope' do
+            define_model(:country, mood: :string)
+            person_model = define_model(:person, country_id: :integer) do
+              belongs_to :country, -> { where(mood: 'nice') }
+            end
+            delegate_reflection = person_model.reflect_on_association(:country)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Country.where(mood: 'nice').to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+
+        context 'when the scope is nil' do
+          it 'returns an empty scope' do
+            define_model(:country)
+            person_model = define_model(:person, country_id: :integer) do
+              belongs_to :country
+            end
+            delegate_reflection = person_model.reflect_on_association(:country)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Country.all.to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+      end
+    end
+
+    if rails_3_x?
+      context 'when the reflection object does not have a #scope method' do
+        context 'when the reflection options contain :conditions' do
+          it 'creates an ActiveRecord::Relation from the conditions' do
+            define_model(:country, mood: :string)
+            person_model = define_model(:person, country_id: :integer) do
+              belongs_to :country, conditions: { mood: 'nice' }
+            end
+            delegate_reflection = person_model.reflect_on_association(:country)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Country.where(mood: 'nice').to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+
+        context 'when the reflection options contain :order' do
+          it 'creates an ActiveRecord::Relation from the order' do
+            define_model(:person, country_id: :integer, age: :integer)
+            country_model = define_model(:country) do
+              has_many :people, order: 'age'
+            end
+            delegate_reflection = country_model.reflect_on_association(:people)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Person.order('age').to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+
+        context 'when the reflection options contain :include' do
+          it 'creates an ActiveRecord::Relation from the include' do
+            define_model(:city, country_id: :integer)
+            define_model(:country) do
+              has_many :cities
+            end
+            person_model = define_model(:person, country_id: :integer) do
+              belongs_to :country, include: :cities
+            end
+            delegate_reflection = person_model.reflect_on_association(:country)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_includes = reflection.association_relation.includes_values
+            expected_includes = Country.includes(:cities).includes_values
+            expect(actual_includes).to eq expected_includes
+          end
+        end
+
+        context 'when the reflection options contain :group' do
+          it 'creates an ActiveRecord::Relation from the group' do
+            country_model = define_model(:country, mood: :string) do
+              has_many :people, group: 'age'
+            end
+            define_model(:person, country_id: :integer, age: :integer)
+            delegate_reflection = country_model.reflect_on_association(:people)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Person.group('age').to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+
+        context 'when the reflection options contain :having' do
+          it 'creates an ActiveRecord::Relation from the having' do
+            country_model = define_model(:country) do
+              has_many :people, having: 'country_id > 1'
+            end
+            define_model(:person, country_id: :integer)
+            delegate_reflection = country_model.reflect_on_association(:people)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Person.having('country_id > 1').to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+
+        context 'when the reflection options contain :limit' do
+          it 'creates an ActiveRecord::Relation from the limit' do
+            country_model = define_model(:country) do
+              has_many :people, limit: 10
+            end
+            define_model(:person, country_id: :integer)
+            delegate_reflection = country_model.reflect_on_association(:people)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Person.limit(10).to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+
+        context 'when the reflection options contain :offset' do
+          it 'creates an ActiveRecord::Relation from the offset' do
+            country_model = define_model(:country) do
+              has_many :people, offset: 5
+            end
+            define_model(:person, country_id: :integer)
+            delegate_reflection = country_model.reflect_on_association(:people)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Person.offset(5).to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+
+        context 'when the reflection options contain :select' do
+          it 'creates an ActiveRecord::Relation from the select' do
+            country_model = define_model(:country) do
+              has_many :people, select: 'age'
+            end
+            define_model(:person, country_id: :integer, age: :integer)
+            delegate_reflection = country_model.reflect_on_association(:people)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Person.select('age').to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+      end
+    end
+  end
+end

data/spec/shoulda/matchers/active_record/have_readonly_attributes_matcher_spec.rb

@@ -29,7 +29,7 @@ describe Shoulda::Matchers::ActiveRecord::HaveReadonlyAttributeMatcher do
 
       matcher.matches?(model)
 
-      matcher.failure_message_for_should.should_not be_nil
+      matcher.failure_message.should_not be_nil
     end
   end
 

data/spec/shoulda/matchers/active_record/serialize_matcher_spec.rb

@@ -15,7 +15,7 @@ describe Shoulda::Matchers::ActiveRecord::SerializeMatcher do
 
       matcher.matches?(unserialized_model)
 
-      matcher.failure_message_for_should.should =~ /to serialize the attribute called :attr/
+      matcher.failure_message.should =~ /to serialize the attribute called :attr/
     end
 
     it 'assigns a helpful failure message when using #as' do
@@ -23,7 +23,7 @@ describe Shoulda::Matchers::ActiveRecord::SerializeMatcher do
 
       matcher.matches?(unserialized_model)
 
-      matcher.failure_message_for_should.should =~ /with a type of Hash/
+      matcher.failure_message.should =~ /with a type of Hash/
     end
 
     it 'assigns a helpful failure message when using #as_instance_of' do
@@ -31,7 +31,7 @@ describe Shoulda::Matchers::ActiveRecord::SerializeMatcher do
 
       matcher.matches?(unserialized_model)
 
-      matcher.failure_message_for_should.should =~ /with an instance of Hash/
+      matcher.failure_message.should =~ /with an instance of Hash/
     end
 
     def unserialized_model

data/spec/spec_helper.rb

@@ -1,28 +1,22 @@
-# Create Rails environment based on the version given from Appraisal
-TESTAPP_ROOT = File.join(File.dirname(__FILE__), '..', 'tmp', 'aruba', 'testapp')
-FileUtils.rm_rf(TESTAPP_ROOT) if File.exists?(TESTAPP_ROOT)
-`rails new #{TESTAPP_ROOT}`
+require File.expand_path('../support/test_application', __FILE__)
 
+$test_app = TestApplication.new
+$test_app.create
+$test_app.load
+
+ENV['BUNDLE_GEMFILE'] ||= app.gemfile_path
 ENV['RAILS_ENV'] = 'test'
-ENV['BUNDLE_GEMFILE'] ||= TESTAPP_ROOT + '/Gemfile'
 
-require "#{TESTAPP_ROOT}/config/environment"
 require 'bourne'
 require 'shoulda-matchers'
 require 'rspec/rails'
 
-PROJECT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..')).freeze
-
+PROJECT_ROOT = File.expand_path('../..', __FILE__)
 $LOAD_PATH << File.join(PROJECT_ROOT, 'lib')
-
-Dir[File.join(PROJECT_ROOT, 'spec', 'support', '**', '*.rb')].each { |file| require(file) }
-
-# Run the migrations
-ActiveRecord::Migration.verbose = false
-ActiveRecord::Migrator.migrate(Rails.root.join('db/migrate'))
+Dir[ File.join(PROJECT_ROOT, 'spec/support/**/*.rb') ].each { |file| require file }
 
 RSpec.configure do |config|
   config.mock_with :mocha
   config.include Shoulda::Matchers::ActionController,
-                 :example_group => { :file_path => /action_controller/ }
+                 example_group: { file_path: /action_controller/ }
 end