deferred_associations 0.5.7 → 0.5.8

data/spec/db/schema.rb

@@ -2,39 +2,37 @@
 # migrations feature of ActiveRecord to incrementally modify your database, and
 # then regenerate this schema definition.
 
-ActiveRecord::Schema.define(:version => 1) do
-
-  create_table "people", :force => true do |t|
-    t.column "name", :string
+ActiveRecord::Schema.define(version: 1) do
+  create_table 'people', force: true do |t|
+    t.column 'name', :string
   end
 
-  create_table "people_rooms", :id => false, :force => true do |t|
-    t.column "person_id", :integer
-    t.column "room_id",   :integer
+  create_table 'people_rooms', id: false, force: true do |t|
+    t.column 'person_id', :integer
+    t.column 'room_id',   :integer
   end
 
-  create_table "rooms", :force => true do |t|
-    t.column "name",              :string
-    t.column "maximum_occupancy", :integer
+  create_table 'rooms', force: true do |t|
+    t.column 'name',              :string
+    t.column 'maximum_occupancy', :integer
   end
 
-  create_table "doors_rooms", :id => false, :force => true do |t|
-    t.column "door_id",   :integer
-    t.column "room_id",   :integer
+  create_table 'doors_rooms', id: false, force: true do |t|
+    t.column 'door_id',   :integer
+    t.column 'room_id',   :integer
   end
 
-  create_table "doors", :force => true do |t|
-    t.column "name",              :string
+  create_table 'doors', force: true do |t|
+    t.column 'name', :string
   end
 
-  create_table "tables", :force => true do |t|
-    t.column "name", :string
-    t.column "room_id", :integer
+  create_table 'tables', force: true do |t|
+    t.column 'name', :string
+    t.column 'room_id', :integer
   end
 
-  create_table "chairs", :force => true do |t|
-    t.column "name", :string
-    t.column "table_id", :integer
+  create_table 'chairs', force: true do |t|
+    t.column 'name', :string
+    t.column 'table_id', :integer
   end
-
 end

data/spec/habtm_ar4_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'has_and_belongs_to_many_with_deferred_save'
+
+if ar4?
+  describe 'ActiveRecord4 specials' do
+    before :all do
+      #ActiveRecord::Base.logger = Logger.new(STDOUT) # uncomment for debugging statements
+      @people = []
+      @people << Person.create(name: 'Filbert')
+      @people << Person.create(name: 'Miguel')
+      @people << Person.create(name: 'Rainer')
+      @room1 = Room.create! maximum_occupancy: 2, people: @people[1..2]
+      @room2 = Room.create! maximum_occupancy: 2, people: @people[0..1]
+      @room3 = Room.create! maximum_occupancy: 2
+    end
+
+    after :all do
+      Person.delete_all
+      Room.delete_all
+      Person.connection.execute('DELETE FROM people_rooms')
+    end
+
+    describe 'queries' do #
+      it 'should not preload, if option is not specified' do
+        rooms = Room.where(id: [@room1.id, @room2.id, @room3.id])
+        rooms = rooms.to_a # execute original query
+        room1 = rooms.first
+        room2 = rooms.second
+        room3 = rooms.third
+
+        # association is not autoloaded, but will be loaded on access
+        expect(room1.people_without_deferred_save.loaded?).to be false
+        expect(room2.people_without_deferred_save.loaded?).to be false
+        expect(room3.people_without_deferred_save.loaded?).to be false
+
+        # accessing the deferred assotiation will load it anyway
+        expect(ActiveRecord::Base).to receive(:connection).at_least(:once).and_call_original
+        expect(room1.people.loaded?).to be true
+
+        expect(room1.people.map(&:name)).to match_array(%w(Miguel Rainer))
+        expect(room2.people.map(&:name)).to match_array(%w(Filbert Miguel))
+        expect(room3.people.map(&:name)).to match_array(%w())
+      end
+
+      it 'should preload, if option is specified' do
+        rooms = Room.where(id: [@room1.id, @room2.id, @room3.id]).preload(:people)
+        rooms = rooms.to_a # execute original query, together with preloading the association
+        room1 = rooms.first
+        room2 = rooms.second
+        room3 = rooms.third
+
+        # association is autoloaded
+        expect(room1.people_without_deferred_save.loaded?).to be true
+        expect(room2.people_without_deferred_save.loaded?).to be true
+        expect(room3.people_without_deferred_save.loaded?).to be true
+
+        expect(ActiveRecord::Base).not_to receive(:connection)
+        # deferred association is also already loaded
+        expect(room1.people.loaded?).to be true
+
+        expect(room1.people.map(&:name)).to match_array(%w(Miguel Rainer))
+        expect(room2.people.map(&:name)).to match_array(%w(Filbert Miguel))
+        expect(room3.people.map(&:name)).to match_array(%w())
+      end
+
+      it 'should preload with non-deferred association' do
+        rooms = Room.where(id: [@room1.id, @room2.id, @room3.id]).preload(:people2)
+        rooms = rooms.to_a # execute original query, together with preloading the association
+        room1 = rooms.first
+        room2 = rooms.second
+        room3 = rooms.third
+        # association is autoloaded
+        expect(room1.people2.loaded?).to be true
+        expect(room2.people2.loaded?).to be true
+        expect(room3.people2.loaded?).to be true
+
+        expect(ActiveRecord::Base).not_to receive(:connection)
+
+        expect(room1.people2.map(&:name)).to match_array(%w(Miguel Rainer))
+        expect(room2.people2.map(&:name)).to match_array(%w(Filbert Miguel))
+        expect(room3.people2.map(&:name)).to match_array(%w())
+      end
+    end
+  end
+end

data/spec/has_and_belongs_to_many_with_deferred_save_spec.rb

@@ -1,192 +1,193 @@
-require "spec_helper"
+require 'spec_helper'
 require 'has_and_belongs_to_many_with_deferred_save'
 
-describe "has_and_belongs_to_many_with_deferred_save" do
-  describe "room maximum_occupancy" do
+describe 'has_and_belongs_to_many_with_deferred_save' do
+  describe 'room maximum_occupancy' do
     before :all do
       @people = []
-      @people << Person.create(:name => 'Filbert')
-      @people << Person.create(:name => 'Miguel')
-      @people << Person.create(:name => 'Rainer')
-      @room = Room.new(:maximum_occupancy => 2)
+      @people << Person.create(name: 'Filbert')
+      @people << Person.create(name: 'Miguel')
+      @people << Person.create(name: 'Rainer')
+      @room = Room.new(maximum_occupancy: 2)
     end
     after :all do
       Person.delete_all
       Room.delete_all
     end
 
-    it "passes initial checks" do
-      Room  .count.should == 0
-      Person.count.should == 3
+    it 'passes initial checks' do
+      expect(Room  .count).to eq(0)
+      expect(Person.count).to eq(3)
 
-      @room.people.should == []
-      @room.people_without_deferred_save.should == []
-      @room.people_without_deferred_save.object_id.should_not ==
+      expect(@room.people).to eq([])
+      expect(@room.people_without_deferred_save).to eq([])
+      expect(@room.people_without_deferred_save.object_id).not_to eq(
         @room.unsaved_people.object_id
+      )
     end
 
-    it "after adding people to room, it should not have saved anything to the database" do
+    it 'after adding people to room, it should not have saved anything to the database' do
       @room.people << @people[0]
       @room.people << @people[1]
 
       # Still not saved to the association table!
-      Room.count_by_sql("select count(*) from people_rooms").should == 0
-      @room.people_without_deferred_save.size.               should == 0
+      expect(Room.count_by_sql('select count(*) from people_rooms')).to eq(0)
+      expect(@room.people_without_deferred_save.size).               to eq(0)
     end
 
-    it "but room.people.size should still report the current size of 2" do
-      @room.people.size.should == 2        # 2 because this looks at unsaved_people and not at the database
+    it 'but room.people.size should still report the current size of 2' do
+      expect(@room.people.size).to eq(2) # 2 because this looks at unsaved_people and not at the database
     end
 
-    it "after saving the model, the association should be saved in the join table" do
-      @room.save    # Only here is it actually saved to the association table!
-      @room.errors.full_messages.should == []
-      Room.count_by_sql("select count(*) from people_rooms").should == 2
-      @room.people.size.                                     should == 2
-      @room.people_without_deferred_save.size.               should == 2
+    it 'after saving the model, the association should be saved in the join table' do
+      @room.save # Only here is it actually saved to the association table!
+      expect(@room.errors.full_messages).to eq([])
+      expect(Room.count_by_sql('select count(*) from people_rooms')).to eq(2)
+      expect(@room.people.size).                                     to eq(2)
+      expect(@room.people_without_deferred_save.size).               to eq(2)
     end
 
-    it "when we try to add a 3rd person, it should add a validation error to the errors object like any other validation error" do
-      lambda { @room.people << @people[2] }.should_not raise_error
-      @room.people.size.       should == 3
+    it 'when we try to add a 3rd person, it should add a validation error to the errors object like any other validation error' do
+      expect { @room.people << @people[2] }.not_to raise_error
+      expect(@room.people.size).       to eq(3)
 
-      Room.count_by_sql("select count(*) from people_rooms").should == 2
+      expect(Room.count_by_sql('select count(*) from people_rooms')).to eq(2)
       @room.valid?
-      @room.get_error(:people).should == "This room has reached its maximum occupancy"
-      @room.people.size.       should == 3 # Just like with normal attributes that fail validation... the attribute still contains the invalid data but we refuse to save until it is changed to something that is *valid*.
+      expect(@room.get_error(:people)).to eq('This room has reached its maximum occupancy')
+      expect(@room.people.size).       to eq(3) # Just like with normal attributes that fail validation... the attribute still contains the invalid data but we refuse to save until it is changed to something that is *valid*.
     end
 
-    it "when we try to save, it should fail, because room.people is still invalid" do
-      @room.save.should == false
-      Room.count_by_sql("select count(*) from people_rooms").should == 2 # It's still not there, because it didn't pass the validation.
-      @room.get_error(:people).should == "This room has reached its maximum occupancy"
-      @room.people.size.       should == 3
-      @people.map {|p| p.reload; p.rooms.size}.should == [1, 1, 0]
+    it 'when we try to save, it should fail, because room.people is still invalid' do
+      expect(@room.save).to eq(false)
+      expect(Room.count_by_sql('select count(*) from people_rooms')).to eq(2) # It's still not there, because it didn't pass the validation.
+      expect(@room.get_error(:people)).to eq('This room has reached its maximum occupancy')
+      expect(@room.people.size).       to eq(3)
+      expect(@people.map { |p| p.reload; p.rooms.size }).to eq([1, 1, 0])
     end
 
-    it "when we reload, it should go back to only having 2 people in the room" do
+    it 'when we reload, it should go back to only having 2 people in the room' do
       @room.reload
-      @room.people.size.                                     should == 2
-      @room.people_without_deferred_save.size.               should == 2
-      @people.map {|p| p.reload; p.rooms.size}.              should == [1, 1, 0]
+      expect(@room.people.size).                                     to eq(2)
+      expect(@room.people_without_deferred_save.size).               to eq(2)
+      expect(@people.map { |p| p.reload; p.rooms.size }). to eq([1, 1, 0])
     end
 
-    it "if they try to go around our accessors and use the original accessors, then (and only then) will the exception be raised in before_adding_person..." do
-      lambda do
+    it 'if they try to go around our accessors and use the original accessors, then (and only then) will the exception be raised in before_adding_person...' do
+      expect do
         @room.people_without_deferred_save << @people[2]
-      end.should raise_error(RuntimeError)
+      end.to raise_error(RuntimeError)
     end
 
-    it "lets you bypass the validation on Room if we add the association from the other side (person.rooms <<)?" do
+    it 'lets you bypass the validation on Room if we add the association from the other side (person.rooms <<)?' do
       @people[2].rooms << @room
-      @people[2].rooms.size.should == 1
+      expect(@people[2].rooms.size).to eq(1)
 
       # Adding it from one direction does not add it to the other object's association (@room.people), so the validation passes.
-      @room.reload.people.size.should == 2
+      expect(@room.reload.people.size).to eq(2)
       @people[2].valid?
-      @people[2].errors.full_messages.should == []
-      @people[2].save.should == true
+      expect(@people[2].errors.full_messages).to eq([])
+      expect(@people[2].save).to eq(true)
 
       # It is only after reloading that @room.people has this 3rd object, causing it to be invalid, and by then it's too late to do anything about it.
-      @room.reload.people.size.should == 3
-      @room.valid?.should == false
+      expect(@room.reload.people.size).to eq(3)
+      expect(@room.valid?).to eq(false)
     end
 
-    it "only if you add the validation to both sides, can you ensure that the size of the association does not exceed some limit" do
-      @room.reload.people.size.should == 3
+    it 'only if you add the validation to both sides, can you ensure that the size of the association does not exceed some limit' do
+      expect(@room.reload.people.size).to eq(3)
       @room.people.delete(@people[2])
-      @room.save.should == true
-      @room.reload.people.size.should == 2
-      @people[2].reload.rooms.size.should == 0
+      expect(@room.save).to eq(true)
+      expect(@room.reload.people.size).to eq(2)
+      expect(@people[2].reload.rooms.size).to eq(0)
 
       obj = @people[2]
       obj.do_extra_validation = true
 
       @people[2].rooms << @room
-      @people[2].rooms.size.should == 1
+      expect(@people[2].rooms.size).to eq(1)
 
-      @room.reload.people.size.should == 2
-      @people[2].valid?.should be_false
-      @people[2].get_error(:rooms).should == "This room has reached its maximum occupancy"
-      @room.reload.people.size.should == 2
+      expect(@room.reload.people.size).to eq(2)
+      expect(@people[2].valid?).to be false
+      expect(@people[2].get_error(:rooms)).to eq('This room has reached its maximum occupancy')
+      expect(@room.reload.people.size).to eq(2)
     end
 
-    it "still lets you do find" do
+    it 'still lets you do find' do
       if ar4?
-        @room.people2.where(:name => 'Filbert').first.should == @people[0]
-        @room.people_without_deferred_save.where(:name => 'Filbert').first.should == @people[0]
-        @room.people.where(:name => 'Filbert').first.should == @people[0]
+        expect(@room.people2.where(name: 'Filbert').first).to eq(@people[0])
+        expect(@room.people_without_deferred_save.where(name: 'Filbert').first).to eq(@people[0])
+        expect(@room.people.where(name: 'Filbert').first).to eq(@people[0])
       else
-        @room.people2.                     find(:first, :conditions => {:name => 'Filbert'}).should == @people[0]
-        @room.people_without_deferred_save.find(:first, :conditions => {:name => 'Filbert'}).should == @people[0]
-        @room.people2.first(:conditions                      => {:name => 'Filbert'}).should == @people[0]
-        @room.people_without_deferred_save.first(:conditions => {:name => 'Filbert'}).should == @people[0]
-
-        @room.people.find(:first, :conditions => {:name => 'Filbert'}).should == @people[0]
-        @room.people.first(:conditions => {:name => 'Filbert'}).       should == @people[0]
-        @room.people.last(:conditions => {:name => 'Filbert'}).        should == @people[0]
+        expect(@room.people2.                     find(:first, conditions: { name: 'Filbert' })).to eq(@people[0])
+        expect(@room.people_without_deferred_save.find(:first, conditions: { name: 'Filbert' })).to eq(@people[0])
+        expect(@room.people2.first(conditions: { name: 'Filbert' })).to eq(@people[0])
+        expect(@room.people_without_deferred_save.first(conditions: { name: 'Filbert' })).to eq(@people[0])
+
+        expect(@room.people.find(:first, conditions: { name: 'Filbert' })).to eq(@people[0])
+        expect(@room.people.first(conditions: { name: 'Filbert' })).       to eq(@people[0])
+        expect(@room.people.last(conditions: { name: 'Filbert' })).        to eq(@people[0])
       end
 
-      @room.people.first.                                        should == @people[0]
-      @room.people.last.                                         should == @people[1] # @people[2] was removed before
-      @room.people.find_by_name('Filbert').                      should == @people[0]
-      @room.people_without_deferred_save.find_by_name('Filbert').should == @people[0]
+      expect(@room.people.first).                                        to eq(@people[0])
+      expect(@room.people.last).                                         to eq(@people[1]) # @people[2] was removed before
+      expect(@room.people.find_by_name('Filbert')).                      to eq(@people[0])
+      expect(@room.people_without_deferred_save.find_by_name('Filbert')).to eq(@people[0])
     end
 
-    it "should be dumpable with Marshal" do
-      lambda { Marshal.dump(@room.people) }.should_not raise_exception
-      lambda { Marshal.dump(Room.new.people) }.should_not raise_exception
+    it 'should be dumpable with Marshal' do
+      expect { Marshal.dump(@room.people) }.not_to raise_exception
+      expect { Marshal.dump(Room.new.people) }.not_to raise_exception
     end
 
-    it "should detect difference in association" do
+    it 'should detect difference in association' do
       @room = Room.find(@room.id)
-      @room.bs_diff_before_module.should be_nil
-      @room.bs_diff_after_module.should  be_nil
-      @room.bs_diff_method.should        be_nil
+      expect(@room.bs_diff_before_module).to be_nil
+      expect(@room.bs_diff_after_module).to  be_nil
+      expect(@room.bs_diff_method).to        be_nil
 
-      @room.people.size.should == 2
+      expect(@room.people.size).to eq(2)
       @room.people = [@room.people[0]]
-      @room.save.should be_true
+      expect(@room.save).to be true
 
-      @room.bs_diff_before_module.should be_true
-      @room.bs_diff_after_module.should  be_true
+      expect(@room.bs_diff_before_module).to be true
+      expect(@room.bs_diff_after_module).to  be true
       if ar2?
-        @room.bs_diff_method.should      be_true
+        expect(@room.bs_diff_method).to      be true
       else
-        @room.bs_diff_method.should      be_nil # Rails 3.2: nil (before_save filter is not supported)
+        expect(@room.bs_diff_method).to      be_nil # Rails 3.2: nil (before_save filter is not supported)
       end
     end
 
-    it "should act like original habtm when using ID array with array manipulation" do
+    it 'should act like original habtm when using ID array with array manipulation' do
       @room = Room.find(@room.id)
       @room.people = [@people[0]]
       @room.save
       @room = Room.find(@room.id) # we don't want to let id and object setters interfere with each other
       @room.people2_ids << @people[1].id
-      @room.people2_ids.should == [@people[0].id] # ID array manipulation is ignored
+      expect(@room.people2_ids).to eq([@people[0].id]) # ID array manipulation is ignored
 
-      @room.person_ids.size.should == 1
+      expect(@room.person_ids.size).to eq(1)
       @room.person_ids << @people[1].id
-      @room.person_ids.should == [@people[0].id]
-      Room.find(@room.id).person_ids.should == [@people[0].id]
-      @room.save.should be_true
-      Room.find(@room.id).person_ids.should == [@people[0].id] # ID array manipulation is ignored, too
+      expect(@room.person_ids).to eq([@people[0].id])
+      expect(Room.find(@room.id).person_ids).to eq([@people[0].id])
+      expect(@room.save).to be true
+      expect(Room.find(@room.id).person_ids).to eq([@people[0].id]) # ID array manipulation is ignored, too
     end
 
-    it "should work with id setters" do
+    it 'should work with id setters' do
       @room = Room.find(@room.id)
       @room.people = [@people[0], @people[1]]
       @room.save
       @room = Room.find(@room.id)
-      @room.person_ids.should == [@people[0].id, @people[1].id]
+      expect(@room.person_ids).to eq([@people[0].id, @people[1].id])
       @room.person_ids = [@people[1].id]
-      @room.person_ids.should == [@people[1].id]
-      Room.find(@room.id).person_ids.should == [@people[0].id,@people[1].id]
-      @room.save.should be_true
-      Room.find(@room.id).person_ids.should == [@people[1].id]
+      expect(@room.person_ids).to eq([@people[1].id])
+      expect(Room.find(@room.id).person_ids).to eq([@people[0].id, @people[1].id])
+      expect(@room.save).to be true
+      expect(Room.find(@room.id).person_ids).to eq([@people[1].id])
     end
 
-    it "should work with multiple id setters and object setters" do
+    it 'should work with multiple id setters and object setters' do
       @room = Room.find(@room.id)
       @room.people     = [@people[0]]
       @room.person_ids = [@people[0].id, @people[1].id]
@@ -195,50 +196,46 @@ describe "has_and_belongs_to_many_with_deferred_save" do
       @room.people     = [@people[1]]
       @room.save
       @room = Room.find(@room.id)
-      @room.people.should == [@people[1]]
+      expect(@room.people).to eq([@people[1]])
     end
 
-    it "should give klass in AR 3/4" do
-      unless ar2?
-        @room.people.klass.should == Person
-      end
+    it 'should give klass in AR 3/4' do
+      expect(@room.people.klass).to eq(Person) unless ar2?
     end
 
-    it "should give aliased_table_name in AR 2.3" do
-      if ar2?
-        @room.people.aliased_table_name.should == "people"
-      end
+    it 'should give aliased_table_name in AR 2.3' do
+      expect(@room.people.aliased_table_name).to eq('people') if ar2?
     end
 
-    it "should support reload both with and without params" do
+    it 'should support reload both with and without params' do
       # find options are deprecated with AR 4, but reload still
       # supports them
-      @room.reload.id.should == @room.id
-      with_param = @room.reload(:select => 'id')
-      with_param.id.should == @room.id
+      expect(@room.reload.id).to eq(@room.id)
+      with_param = @room.reload(select: 'id')
+      expect(with_param.id).to eq(@room.id)
     end
   end
 
-  describe "doors" do
+  describe 'doors' do
     before :all do
       @rooms = []
-      @rooms << Room.create(:name => 'Kitchen',     :maximum_occupancy => 1)
-      @rooms << Room.create(:name => 'Dining room', :maximum_occupancy => 10)
-      @door =   Door.new(:name => 'Kitchen-Dining-room door')
+      @rooms << Room.create(name: 'Kitchen',     maximum_occupancy: 1)
+      @rooms << Room.create(name: 'Dining room', maximum_occupancy: 10)
+      @door =   Door.new(name: 'Kitchen-Dining-room door')
     end
 
-    it "passes initial checks" do
-      Room.count.should == 2
-      Door.count.should == 0
+    it 'passes initial checks' do
+      expect(Room.count).to eq(2)
+      expect(Door.count).to eq(0)
 
-      @door.rooms.should == []
-      @door.rooms_without_deferred_save.should == []
+      expect(@door.rooms).to eq([])
+      expect(@door.rooms_without_deferred_save).to eq([])
     end
 
-    it "the association has an include? method" do
+    it 'the association has an include? method' do
       @door.rooms << @rooms[0]
-      @door.rooms.include?(@rooms[0]).should be_true
-      @door.rooms.include?(@rooms[1]).should be_false
+      expect(@door.rooms.include?(@rooms[0])).to be true
+      expect(@door.rooms.include?(@rooms[1])).to be false
     end
   end
 end