deferring 0.2.1 → 0.3.0

data/lib/deferring.rb

@@ -1,5 +1,3 @@
-# encoding: UTF-8
-
 require 'deferring/version'
 require 'deferring/deferred_association'
 require 'deferring/deferred_callback_listener'
@@ -86,8 +84,10 @@ module Deferring
 
             # TODO: Implement value_to_boolean code from rails for checking _destroy field.
             if attributes['_destroy'] == '1' && options[:allow_destroy]
-              # remove from existing records
-              send(:"#{association_name}").destroy(existing_record)
+              # remove from existing records and mark for destruction upon
+              # saving
+              send(:"#{association_name}").delete(existing_record)
+              existing_record.mark_for_destruction
             end
           end
 
@@ -127,34 +127,49 @@ module Deferring
     define_method :deferred_unassignable_keys do
       %w(_destroy id)
     end
-
-    generate_find_or_create_deferred_association_method
   end
 
   private
 
   def generate_deferred_association_methods(association_name, listeners, options = {})
-    inverse_association_name = options[:inverse_association_name]
-    autosave = options.fetch(:autosave, true)
-    type = options.fetch(:type)
-    validate = options.fetch(:validate, true)
-    dependent = options[:dependent]
+    deferred_association_name = :"deferred_#{association_name}"
+    inverse_association_name  = options[:inverse_association_name]
+    autosave                  = options.fetch(:autosave, true)
+    type                      = options.fetch(:type)
+    validate                  = options.fetch(:validate, true)
+    dependent                 = options[:dependent]
 
     # Store the original accessor methods of the association.
     alias_method :"original_#{association_name}", :"#{association_name}"
     alias_method :"original_#{association_name}=", :"#{association_name}="
 
     # Accessor for our own association.
-    attr_accessor :"deferred_#{association_name}"
+    define_method(deferred_association_name) do
+      return instance_variable_get(:"@#{deferred_association_name}") if instance_variable_defined?(:"@#{deferred_association_name}")
+
+      klass = self.class.reflect_on_association(:"#{association_name}").klass
+      deferred_association = DeferredAssociation.new(send(:"original_#{association_name}"),
+                                                     klass,
+                                                     self,
+                                                     inverse_association_name,
+                                                     dependent)
+      listeners.each do |event_name, callback_method|
+        deferred_association.add_callback_listener(event_name, callback_method)
+      end
+
+      instance_variable_set(:"@#{deferred_association_name}", deferred_association)
+    end
+
+    define_method :"#{deferred_association_name}=" do |deferred_association|
+      instance_variable_set(:"@#{deferred_association_name}", deferred_association)
+    end
 
     # collection
     #
     # Returns an array of all the associated objects. An empty array is returned
     # if none are found.
-    # TODO: add force_reload argument?
     define_method :"#{association_name}" do
-      find_or_create_deferred_association(association_name, listeners, inverse_association_name, dependent)
-      send(:"deferred_#{association_name}")
+      send(deferred_association_name)
     end
 
     # collection=objects
@@ -162,8 +177,7 @@ module Deferring
     # Replaces the collection's content by deleting and adding objects as
     # appropriate.
     define_method :"#{association_name}=" do |objects|
-      find_or_create_deferred_association(association_name, listeners, inverse_association_name, dependent)
-      send(:"deferred_#{association_name}").objects = objects
+      send(deferred_association_name).objects = objects
     end
 
     # collection_singular_ids=
@@ -171,21 +185,18 @@ module Deferring
     # Replace the collection by the objects identified by the primary keys in
     # ids.
     define_method :"#{association_name.singularize}_ids=" do |ids|
-      find_or_create_deferred_association(association_name, listeners, inverse_association_name, dependent)
-
       ids ||= []
       klass = self.class.reflect_on_association(:"#{association_name}").klass
       objects = klass.find(ids.reject(&:blank?))
 
-      send(:"deferred_#{association_name}").objects = objects
+      send(deferred_association_name).objects = objects
     end
 
     # collection_singular_ids
     #
     # Returns an array of the associated objects' ids.
     define_method :"#{association_name.singularize}_ids" do
-      find_or_create_deferred_association(association_name, listeners, inverse_association_name, dependent)
-      send(:"deferred_#{association_name}").ids
+      send(deferred_association_name).ids
     end
 
     # collection_singular_checked
@@ -196,22 +207,27 @@ module Deferring
       send(:"#{association_name.singularize}_ids=", ids.split(','))
     end
 
-    after_validation :"perform_deferred_#{association_name}_validation!"
-    define_method :"perform_deferred_#{association_name}_validation!" do
-      find_or_create_deferred_association(association_name, listeners, inverse_association_name, dependent)
+    # changed_for_autosave?
+    define_method(:"changed_for_autosave_with_#{deferred_association_name}?") do
+      changed = send(:"changed_for_autosave_without_#{deferred_association_name}?")
+      changed || send(deferred_association_name).changed_for_autosave?
+    end
+    alias_method_chain :changed_for_autosave?, deferred_association_name
 
+    after_validation :"perform_#{deferred_association_name}_validation!"
+    define_method :"perform_#{deferred_association_name}_validation!" do
       # Do not perform validations for HABTM associations as they are always
       # validated by Rails upon saving.
       return true if type == :habtm
 
       # Do not perform validation when the association has not been loaded
       # (performance improvement).
-      return true unless send(:"deferred_#{association_name}").loaded?
+      return true unless send(deferred_association_name).loaded?
 
       # Do not perform validations when validate: false.
       return true if validate == false
 
-      all_records_valid = send(:"deferred_#{association_name}").objects.inject(true) do |valid, record|
+      all_records_valid = send(deferred_association_name).objects.inject(true) do |valid, record|
         unless record.valid?
           valid = false
           if autosave
@@ -232,49 +248,37 @@ module Deferring
     end
 
     #  the save after the parent object has been saved
-    after_save :"perform_deferred_#{association_name}_save!"
-    define_method :"perform_deferred_#{association_name}_save!" do
-      find_or_create_deferred_association(association_name, listeners, inverse_association_name, dependent)
-
+    after_save :"perform_#{deferred_association_name}_save!"
+    define_method :"perform_#{deferred_association_name}_save!" do
       # Send the objects of our delegated association to the original
       # association and store the result.
-      send(:"original_#{association_name}=", send(:"deferred_#{association_name}").objects)
+      deferred_association = send(deferred_association_name)
+      if deferred_association.send(:objects_loaded?)
+        send(:"original_#{association_name}=", deferred_association.objects)
+      end
 
       # Store the new value of the association into our delegated association.
       update_deferred_association(association_name, listeners, inverse_association_name, dependent)
     end
 
-    define_method :"reload_with_deferred_#{association_name}" do |*args|
-      find_or_create_deferred_association(association_name, listeners, inverse_association_name, dependent)
-
-      send(:"reload_without_deferred_#{association_name}", *args).tap do
+    define_method :"reload_with_#{deferred_association_name}" do |*args|
+      send(:"reload_without_#{deferred_association_name}", *args).tap do
         update_deferred_association(association_name, listeners, inverse_association_name, dependent)
       end
     end
-    alias_method_chain :reload, :"deferred_#{association_name}"
+    alias_method_chain :reload, deferred_association_name
 
     generate_update_deferred_assocation_method
-    generate_find_or_create_deferred_association_method
   end
 
   def generate_update_deferred_assocation_method
     define_method :update_deferred_association do |name, listeners, inverse_association_name, dependent|
       klass = self.class.reflect_on_association(:"#{name}").klass
-      send(
-        :"deferred_#{name}=",
-        DeferredAssociation.new(send(:"original_#{name}"), klass, self, inverse_association_name, dependent))
+      deferred_association = DeferredAssociation.new(send(:"original_#{name}"), klass, self, inverse_association_name, dependent)
       listeners.each do |event_name, callback_method|
-        l = DeferredCallbackListener.new(event_name, self, callback_method)
-        send(:"deferred_#{name}").add_callback_listener(l)
-      end
-    end
-  end
-
-  def generate_find_or_create_deferred_association_method
-    define_method :find_or_create_deferred_association do |name, listeners, inverse_association_name, dependent|
-      if send(:"deferred_#{name}").nil?
-        update_deferred_association(name, listeners, inverse_association_name, dependent)
+        deferred_association.add_callback_listener(event_name, callback_method)
       end
+      send(:"deferred_#{name}=", deferred_association)
     end
   end
 
@@ -284,7 +288,6 @@ module Deferring
       [event_name, callback_method] if callback_method
     end.compact
   end
-
 end
 
 ActiveRecord::Base.send(:extend, Deferring)

data/lib/deferring/deferred_association.rb

@@ -1,10 +1,7 @@
-# encoding: UTF-8
-
 require 'delegate'
 
 module Deferring
   class DeferredAssociation < SimpleDelegator
-    # TODO: Write tests for enumerable.
     include Enumerable
 
     attr_reader :load_state,
@@ -187,14 +184,19 @@ module Deferring
     # Returns the associated records to which the links will be deleted after
     # saving the parent of the assocation.
     def unlinks
-      # TODO: Write test for it.
       return [] unless objects_loaded?
       original_objects - objects
     end
     alias_method :pending_deletes, :unlinks
 
-    def add_callback_listener(listener)
-      (@listeners ||= []) << listener
+    # Returns true if there are links that will be created or deleted when
+    # saving the parent of the association.
+    def changed_for_autosave?
+      links.any? || unlinks.any?
+    end
+
+    def add_callback_listener(event_name, callback_method)
+      (@listeners ||= []) << DeferredCallbackListener.new(event_name, parent_record, callback_method)
     end
 
     private

data/lib/deferring/deferred_callback_listener.rb

@@ -1,11 +1,17 @@
 module Deferring
-  class DeferredCallbackListener < Struct.new(:event_name, :callee, :callback)
+  class DeferredCallbackListener
+    attr_reader :event_name, :callee, :callback_method
+
+    def initialize(event_name, callee, callback_method)
+      @event_name = event_name
+      @callee = callee
+      @callback_method = callback_method
+    end
 
     [:before_link, :before_unlink, :after_link, :after_unlink].each do |event_name|
       define_method(event_name) do |record|
-        callee.public_send(callback, record)
+        callee.public_send(callback_method, record)
       end
     end
-
   end
 end

data/lib/deferring/version.rb

@@ -1,5 +1,3 @@
-# encoding: UTF-8
-
 module Deferring
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

data/spec/lib/deferring_habtm_spec.rb

@@ -2,26 +2,37 @@ require 'spec_helper'
 
 RSpec.describe 'deferred has_and_belongs_to_many associations' do
 
-  before :each do
+  before(:example) do
     Person.create!(name: 'Alice')
     Person.create!(name: 'Bob')
 
     Team.create!(name: 'Database Administration')
     Team.create!(name: 'End-User Support')
     Team.create!(name: 'Operations')
+
+    bob; dba; support; operations
   end
 
-  let(:bob) { Person.where(name: 'Bob').first }
+  def bob
+    @bob ||= Person.where(name: 'Bob').first
+  end
 
-  let(:dba) { Team.where(name: 'Database Administration').first }
-  let(:support) { Team.where(name: 'End-User Support').first }
-  let(:operations) { Team.where(name: 'Operations').first }
+  def dba
+    @dba ||= Team.where(name: 'Database Administration').first
+  end
 
-  describe 'deferring' do
+  def support
+    @support ||= Team.where(name: 'End-User Support').first
+  end
 
+  def operations
+    @operations ||= Team.where(name: 'Operations').first
+  end
+
+  describe 'deferring' do
     it 'does not create a link until parent is saved' do
       bob.teams << dba << support
-      expect{ bob.save! }.to change{ Person.find(bob.id).teams.size }.from(0).to(2)
+      expect { bob.save! }.to change { Person.find(bob.id).teams.size }.from(0).to(2)
     end
 
     it 'does not unlink until parent is saved' do
@@ -33,14 +44,14 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
         Team.find(operations.id)
       ])
 
-      expect{ bob.save }.to change{ Person.find(bob.id).teams.size }.from(3).to(1)
+      expect { bob.save }.to change { Person.find(bob.id).teams.size }.from(3).to(1)
     end
 
     it 'does not create a link when parent is not valid' do
       bob.name = nil # Person.name should be present, Person should not be saved.
       bob.teams << dba
 
-      expect{ bob.save }.not_to change{ Person.find(bob.id).teams.size }
+      expect { bob.save }.not_to change { Person.find(bob.id).teams.size }
     end
 
     it 'replaces existing records when assigning a new set of records' do
@@ -51,7 +62,7 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
 
       # The initial assignment of Bob to the DBA team did not get saved, so
       # at this moment Bob is not assigned to any team in the database.
-      expect{ bob.save }.to change{ Person.find(bob.id).teams.size }.from(0).to(2)
+      expect { bob.save }.to change { Person.find(bob.id).teams.size }.from(0).to(2)
     end
 
     it 'drops nil records' do
@@ -68,23 +79,25 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
       expect(bob.teams).to be_empty
     end
 
-    describe '#collection_singular_ids' do
+    it 'does not load the deferred associations when saving the parent' do
+      _, queries = catch_queries { bob.save! }
+      expect(queries.size).to eq(0)
+    end
 
+    describe '#collection_singular_ids' do
       it 'returns ids of saved & unsaved associated records' do
         bob.teams = [dba, operations]
         expect(bob.team_ids.size).to eq(2)
         expect(bob.team_ids).to eq [dba.id, operations.id]
 
-        expect{ bob.save }.to change{ Person.find(bob.id).team_ids.size }.from(0).to(2)
+        expect { bob.save }.to change { Person.find(bob.id).team_ids.size }.from(0).to(2)
 
         expect(bob.team_ids.size).to eq(2)
         expect(bob.team_ids).to eq [dba.id, operations.id]
       end
-
     end
 
     describe '#collections_singular_ids=' do
-
       it 'sets associated records' do
         bob.team_ids = [dba.id, operations.id]
         bob.save
@@ -105,14 +118,14 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
         bob.team_ids = [support.id, operations.id]
         expect(bob.teams.length).to eq(2)
 
-        expect{ bob.save }.to change{ Person.find(bob.id).teams.size }.from(0).to(2)
+        expect { bob.save }.to change { Person.find(bob.id).teams.size }.from(0).to(2)
       end
 
       it 'clears empty values from the ids to be assigned' do
         bob.team_ids = [dba.id, '']
         expect(bob.teams.length).to eq(1)
 
-        expect{ bob.save }.to change{ Person.where(name: 'Bob').first.teams.size }.from(0).to(1)
+        expect { bob.save }.to change { Person.where(name: 'Bob').first.teams.size }.from(0).to(1)
       end
 
       it 'unlinks all records when assigning empty array' do
@@ -122,7 +135,7 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
         bob.team_ids = []
         expect(bob.teams.length).to eq(0)
 
-        expect{ bob.save }.to change{ Person.where(name: 'Bob').first.teams.size }.from(2).to(0)
+        expect { bob.save }.to change { Person.where(name: 'Bob').first.teams.size }.from(2).to(0)
       end
 
       it 'unlinks all records when assigning nil' do
@@ -132,15 +145,14 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
         bob.team_ids = nil
         expect(bob.teams.length).to eq(0)
 
-        expect{ bob.save }.to change{ Person.where(name: 'Bob').first.teams.size }.from(2).to(0)
+        expect { bob.save }.to change { Person.where(name: 'Bob').first.teams.size }.from(2).to(0)
       end
     end
 
     describe '#collection_checked=' do
-
       it 'set associated records' do
         bob.teams_checked = "#{dba.id},#{operations.id}"
-        expect{ bob.save }.to change{ Person.where(name: 'Bob').first.teams.size }.from(0).to(2)
+        expect { bob.save }.to change { Person.where(name: 'Bob').first.teams.size }.from(0).to(2)
       end
 
       it 'replace existing records when assigning a new set of ids of records' do
@@ -175,13 +187,50 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
 
         expect{ bob.save }.to change{ Person.where(name: 'Bob').first.teams.size }.from(2).to(0)
       end
-
     end
 
+    describe '#changed_for_autosave?' do
+      it 'return false if nothing has changed' do
+        changed, queries = catch_queries { bob.changed_for_autosave? }
+        expect(queries).to be_empty
+        expect(changed).to eq(false)
+      end
+
+      it 'does not query anything if the objects have not been loaded' do
+        bob.name = 'James'
+        changed, queries = catch_queries { bob.changed_for_autosave? }
+        expect(queries).to be_empty
+        expect(changed).to eq(true)
+      end
+
+      it 'returns true if there is a pending create' do
+        bob.teams = [dba]
+        changed, queries = catch_queries { bob.changed_for_autosave? }
+        expect(queries).to be_empty
+        expect(changed).to eq(true)
+      end
+
+      it 'returns true if there is a pending delete' do
+        bob.teams = [dba]
+        bob.save!
+
+        bob = Person.where(name: 'Bob').first
+        bob.teams.delete(dba)
+        changed, queries = catch_queries { bob.changed_for_autosave? }
+        expect(queries).to be_empty
+        expect(changed).to eq(true)
+      end
+
+      it 'does not perform any queries if the original association has not been loaded' do
+        bob.teams = [dba]
+        changed, queries = catch_queries { bob.changed_for_autosave? }
+        expect(queries).to be_empty
+        expect(changed).to eq(true)
+      end
+    end
   end
 
   describe 'validating' do
-
     xit 'does not add duplicate values' do
       pending 'uniq does not work correctly yet' do
         dba = Team.first
@@ -228,54 +277,39 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
         expect(alice.teams.size).to eq 1
       end
     end
-
   end
 
   describe 'preloading' do
-
     before do
       bob.teams << dba << support
       bob.save!
     end
 
-    if rails30 # old-style preload
-      it 'loads the association' do
-        person = Person.where(name: 'Bob').first
-        Person.send(:preload_associations, person, [:teams])
-        expect(person.teams.loaded?).to be_truthy
-        expect(person.team_ids).to eq [dba.id, support.id]
-      end
+    it 'loads the association when pre-loading' do
+      person = Person.preload(:teams).where(name: 'Bob').first
+      expect(person.teams.loaded?).to be_truthy
+      expect(person.team_ids).to eq [dba.id, support.id]
     end
 
-    if rails32 || rails4
-      it 'loads the association when pre-loading' do
-        person = Person.preload(:teams).where(name: 'Bob').first
-        expect(person.teams.loaded?).to be_truthy
-        expect(person.team_ids).to eq [dba.id, support.id]
-      end
-
-      it 'loads the association when eager loading' do
-        person = Person.eager_load(:teams).where(name: 'Bob').first
-        expect(person.teams.loaded?).to be_truthy
-        expect(person.team_ids).to eq [dba.id, support.id]
-      end
+    it 'loads the association when eager loading' do
+      person = Person.eager_load(:teams).where(name: 'Bob').first
+      expect(person.teams.loaded?).to be_truthy
+      expect(person.team_ids).to eq [dba.id, support.id]
+    end
 
-      it 'loads the association when joining' do
-        person = Person.includes(:teams).where(name: 'Bob').first
-        expect(person.teams.loaded?).to be_truthy
-        expect(person.team_ids).to eq [dba.id, support.id]
-      end
+    it 'loads the association when joining' do
+      person = Person.includes(:teams).where(name: 'Bob').first
+      expect(person.teams.loaded?).to be_truthy
+      expect(person.team_ids).to eq [dba.id, support.id]
     end
 
     it 'does not load the association when using a regular query' do
       person = Person.where(name: 'Bob').first
       expect(person.teams.loaded?).to be_falsey
     end
-
   end
 
   describe 'reloading' do
-
     before do
       bob.teams << operations
       bob.save!
@@ -315,7 +349,6 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
   end
 
   describe 'resetting' do
-
     before do
       bob.teams << operations
       bob.save!
@@ -342,11 +375,9 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
       bob.teams.reset
       expect(bob.teams).to eq [operations, dba]
     end
-
   end
 
   describe 'enumerable methods that conflict with ActiveRecord' do
-
     describe '#select' do
       before do
         bob.teams << dba << support << operations
@@ -373,11 +404,9 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
     describe 'first' do
       # TODO: Write some tests.
     end
-
   end
 
   describe 'callbacks' do
-
     before(:example) do
       bob = Person.where(name: 'Bob').first
       bob.teams = [Team.find(3)]
@@ -498,26 +527,23 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
         'Before adding new team',  'After adding team 4'
       ])
     end
-
   end
 
-  describe 'pending creates & deletes (aka links and unlinks)' do
-
-    describe 'pending creates' do
-
+  describe 'links & unlinks (aka pending creates and deletes)' do
+    describe 'links' do
       it 'returns newly build records' do
         bob.teams.build(name: 'Service Desk')
-        expect(bob.teams.pending_creates.size).to eq(1)
+        expect(bob.teams.links.size).to eq(1)
       end
 
       it 'does not return newly created records' do
         bob.teams.create!(name: 'Service Desk')
-        expect(bob.teams.pending_creates).to be_empty
+        expect(bob.teams.links).to be_empty
       end
 
       it 'returns associated records that need to be linked to parent' do
         bob.teams = [dba]
-        expect(bob.teams.pending_creates).to eq [dba]
+        expect(bob.teams.links).to eq [dba]
       end
 
       it 'does not return associated records that already have a link' do
@@ -526,8 +552,8 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
 
         bob.teams << operations
 
-        expect(bob.teams.pending_creates).to_not include dba
-        expect(bob.teams.pending_creates).to include operations
+        expect(bob.teams.links).to_not include dba
+        expect(bob.teams.links).to include operations
       end
 
       it 'does not return associated records that are to be deleted' do
@@ -535,7 +561,7 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
         bob.save!
         bob.teams.delete(dba)
 
-        expect(bob.teams.pending_creates).to be_empty
+        expect(bob.teams.links).to be_empty
       end
 
       it 'does not return a record that has just been removed (and has not been saved)' do
@@ -545,42 +571,58 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
         bob.teams.delete(dba)
         bob.teams << dba
 
-        expect(bob.teams.pending_deletes).to be_empty
-        expect(bob.teams.pending_creates).to be_empty
+        expect(bob.teams.unlinks).to be_empty
+        expect(bob.teams.links).to be_empty
       end
-    end
 
-    describe 'pending deletes' do
+      it 'does not load the objects if the original association has not been loaded' do
+        bob.teams = [dba, operations]
+        bob.save!
+        bob = Person.where(name: 'Bob').first
 
+        unlinks, queries = catch_queries { bob.teams.links }
+        expect(queries).to be_empty
+        expect(unlinks).to eq([])
+      end
+    end
+
+    describe 'unlinks' do
       it 'returns associated records that need to be unlinked from parent' do
         bob.teams = [dba]
         bob.save!
         bob.teams.delete(dba)
 
-        expect(bob.teams.pending_deletes).to eq [dba]
+        expect(bob.teams.unlinks).to eq [dba]
       end
 
       it 'returns an empty array when no records are to be deleted' do
         bob.teams = [dba]
         bob.save!
 
-        expect(bob.teams.pending_deletes).to be_empty
+        expect(bob.teams.unlinks).to be_empty
       end
 
       it 'does not return a record that has just been added (and has not been saved)' do
         bob.teams = [dba]
         bob.teams.delete(dba)
 
-        expect(bob.teams.pending_deletes).to be_empty
-        expect(bob.teams.pending_creates).to be_empty
+        expect(bob.teams.unlinks).to be_empty
+        expect(bob.teams.links).to be_empty
       end
 
-    end
+      it 'does not load the objects if the original association has not been loaded' do
+        bob.teams = [dba, operations]
+        bob.save!
+        bob = Person.where(name: 'Bob').first
 
+        unlinks, queries = catch_queries { bob.teams.unlinks }
+        expect(queries).to be_empty
+        expect(unlinks).to eq([])
+      end
+    end
   end
 
   describe 'active record api' do
-
     # it 'should execute first on deferred association' do
     #   p = Person.first
     #   p.team_ids = [dba.id, support.id, operations.id]
@@ -598,7 +640,6 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
     # end
 
     describe '#build' do
-
       it 'builds a new record' do
         p = Person.first
         p.teams.build(name: 'Service Desk')
@@ -606,11 +647,9 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
         expect(p.teams[0]).to be_new_record
         expect{ p.save }.to change{ Person.first.teams.count }.from(0).to(1)
       end
-
     end
 
     describe '#create!' do
-
       it 'should create a persisted record' do
         p = Person.first
         p.teams.create!(:name => 'Service Desk')
@@ -623,7 +662,6 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
         expect(Person.first.teams.size).to eq(1)
         expect{ p.save }.to_not change{ Person.first.teams.count }
       end
-
     end
 
     describe '#destroy' do
@@ -719,22 +757,34 @@ RSpec.describe 'deferred has_and_belongs_to_many associations' do
     it 'should allow ActiveRecord::QueryMethods' do
       p = Person.first
       p.teams << dba << operations
-      p.save
+      p.save!
       expect(Person.first.teams.where(name: 'Operations').first).to eq(operations)
     end
 
     it 'should find one without loading collection' do
       p = Person.first
       p.teams = [Team.first, Team.find(3)]
-      p.save
-      teams = Person.first.teams
-      expect(teams.loaded?).to eq(false)
-      expect(teams.find(3)).to eq(Team.find(3))
-      expect(teams.first).to eq(Team.first)
-      expect(teams.last).to eq(Team.find(3))
-      expect(teams.loaded?).to eq(false)
-    end
+      p.save!
 
-  end
+      p = Person.first
+      _, queries = catch_queries { p.teams }
+      expect(queries).to be_empty
+      expect(p.teams.loaded?).to eq(false)
 
+      team, queries = catch_queries { p.teams.find(3) }
+      expect(queries.size).to eq(1)
+      expect(team).to eq(Team.find(3))
+      expect(p.teams.loaded?).to eq(false)
+
+      team, queries = catch_queries { p.teams.first }
+      expect(queries.size).to eq(1)
+      expect(team).to eq(Team.first)
+      expect(p.teams.loaded?).to eq(false)
+
+      team, queries = catch_queries { p.teams.last }
+      expect(queries.size).to eq(1)
+      expect(team).to eq(Team.find(3))
+      expect(p.teams.loaded?).to eq(false)
+    end
+  end
 end