graph_mediator 0.2.1

data/spec/integration/changes_spec.rb

@@ -0,0 +1,159 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe "GraphMediator change tracking scenarios" do
+
+  before(:all) do
+    create_schema do |conn|
+      conn.create_table(:changes_roots, :force => true) do |t|
+        t.string :name
+        t.string :state
+        t.integer :changes_dependents_count
+      end
+      conn.create_table(:changes_dependents, :force => true) do |t|
+        t.string :name
+        t.integer :number
+        t.belongs_to :changes_root
+      end
+    end
+    
+    class ChangesDependent < ActiveRecord::Base
+      belongs_to :changes_root, :counter_cache => true
+    end
+    class ChangesRoot < ActiveRecord::Base
+      cattr_accessor :tests
+      has_many :changes_dependents
+      include GraphMediator
+      mediate :dependencies => [ChangesDependent]
+      mediate_reconciles :reconciles do |instance| 
+        instance.tests.call(instance) unless instance.tests.nil?
+      end
+      def reconciles; :reconciles; end
+    end
+  end
+
+  before(:each) do
+    ChangesRoot.tests = nil
+    @today = Date.today
+  end
+
+  it "should track changes to mediated instance" do
+    r = ChangesRoot.new(:name => :foo)
+    r.save_without_mediation!
+    r.state = :one
+    changes = r.changes
+    run = false
+    r.tests = Proc.new do |instance|
+      instance.changes.should == {}
+      instance.mediated_changes.should == { ChangesRoot => { r.id => changes } }
+      run = true
+    end
+    r.save!
+    run.should be_true 
+  end
+
+  it "should track changes to a newly created mediated instance" do
+    r = ChangesRoot.new(:name => :foo)
+    changes = r.changes
+    run = false
+    r.tests = Proc.new do |instance|
+      instance.should equal(r)
+      instance.changes.should == {}
+      instance.mediated_changes.should == { ChangesRoot => { :_created => [changes] } }
+      run = true
+    end
+    r.save!
+    run.should be_true
+  end
+
+  it "should track addition of a dependent" do
+    r = ChangesRoot.new(:name => :foo)
+    r.save_without_mediation!
+    d = r.changes_dependents.build(:name => :bar)
+    changes = d.changes
+    run = false
+    r.tests = Proc.new do |instance|
+      instance.mediated_changes.should == { ChangesDependent => { :_created => [ changes ] } }
+      run = true
+    end
+    d.save!
+    run.should be_true
+  end
+
+  it "should track changes to a dependent" do
+    r = ChangesRoot.new(:name => :foo)
+    r.save_without_mediation!
+    d = r.changes_dependents.create!(:name => :bar)
+    d.number = 2
+    changes = d.changes
+    run = false
+    r.tests = Proc.new do |instance|
+      instance.mediated_changes.should == { ChangesDependent => { d.id => changes } }
+      run = true
+    end
+    d.save!
+    run.should be_true
+  end
+
+  it "should track deletion of a dependent" do
+    r = ChangesRoot.new(:name => :foo)
+    r.save_without_mediation!
+    d = r.changes_dependents.create!(:name => :bar)
+    run = false
+    r.tests = Proc.new do |instance|
+      instance.mediated_changes.should == { ChangesDependent => { :_destroyed => [d.id] } }
+      run = true
+    end
+    d.destroy
+    run.should be_true
+  end
+
+  it "should differentiate changes to attributes with the same name in different classes." do
+    r = ChangesRoot.new(:name => :foo)
+    r.save_without_mediation!
+    d = r.changes_dependents.create!(:name => :bar)
+
+    d.number = 3
+    dep_changes = d.changes
+    r.name = 'different'
+    root_changes = r.changes
+    run = false
+    mediated_changes = nil
+    r.tests = Proc.new do |instance|
+      d.save!
+      mediated_changes = instance.mediated_changes
+      mediated_changes.should == { ChangesRoot => { r.id => root_changes }, ChangesDependent => { d.id => dep_changes } }
+      run = true
+    end
+    r.save!
+    run.should be_true
+    mediated_changes.changed_name?.should be_true
+    mediated_changes.attribute_changed?(:name, ChangesDependent).should be_false
+    mediated_changes.changes_dependent_changed_name?.should be_false
+    mediated_changes.changes_root_changed_name?.should be_true 
+
+    r.state = :new_state
+    root_changes = r.changes 
+    d.name = 'also different'
+    dep_changes = d.changes
+    r.save!
+    run.should be_true
+    mediated_changes.changed_name?.should be_true
+    mediated_changes.changes_dependent_changed_name?.should be_true
+    mediated_changes.changes_root_changed_name?.should be_false
+  end
+
+  it "should handle attribute queries for classes that have had no changes recorded" do
+    r = ChangesRoot.new(:name => :foo)
+    r.save_without_mediation!
+    run = false
+    r.tests = Proc.new do |instance|
+      mediated_changes = instance.mediated_changes
+      mediated_changes.should == { ChangesRoot => { r.id => {} }}
+      mediated_changes.changes_dependent_changed_name?.should be_false
+      run = true
+    end
+    r.save! 
+    run.should be_true 
+  end
+
+end

data/spec/integration/locking_tests_spec.rb

@@ -0,0 +1,214 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+require 'reservations/party_lodging'
+require 'reservations/lodging'
+require 'reservations/party'
+require 'reservations/reservation'
+
+describe "GraphMediator locking scenarios" do
+
+  before(:all) do
+    load 'reservations/schema.rb'
+  end
+
+  before(:each) do
+    @today = Date.today
+    @handle1_r1 = Reservation.create!(:starts => @today, :ends => @today + 1, :name => 'foo')
+    @handle2_r1 = Reservation.find(@handle1_r1.id)
+  end
+
+  it "should be possible to create an unattached dependent object" do
+    Lodging.create!.should_not be_nil
+  end
+
+  it "should increment lock_version for save_without_mediation" do
+    lambda {
+      @handle1_r1.starts = @today - 1
+      @handle1_r1.save_without_mediation
+    }.should change(@handle1_r1, :lock_version).by(1)
+  end
+
+  context "with optimistic locking for the graph" do
+
+    it "should raise Stale for conflicts updating root" do
+      @handle2_r1.update_attributes(:name => 'bar')
+      lambda { @handle1_r1.update_attributes(:name => 'baz') }.should raise_error(ActiveRecord::StaleObjectError)
+      @handle1_r1.reload
+      @handle1_r1.name.should == 'bar' 
+    end
+
+    # Creating root cannot conflict
+    # because the rows do not exist until the mediation transaction completes
+    # so no one else is in a position to write first
+
+    # not possible?  ActiveRecord::Locking::Optimistic does not decorate :destroy
+    # it "should raise stale for conflicts deleting root" do
+
+    it "should raise Stale for conflicts creating children" do
+      @handle2_r1.parties.create(:name => 'Bob')
+      lambda { @handle1_r1.update_attributes(:name => 'baz') }.should raise_error(ActiveRecord::StaleObjectError)
+    end
+
+    context "with children" do
+      
+      before(:each) do
+        @handle1_r1.mediated_transaction do
+          @party1 = @handle1_r1.parties.create(:name => 'Bob')
+          @party2 = @handle1_r1.parties.create(:name => 'Joe')
+          @room1  = @handle1_r1.lodgings.create(:room_number => 1)
+          @room2  = @handle1_r1.lodgings.create(:room_number => 2)
+        end
+        @handle2_r1.reload
+      end
+
+      it "should raise Stale for conflicts updating children and root" do
+        @handle2_r1.parties.first.update_attributes(:name => 'Frank')
+        lambda { @handle1_r1.update_attributes(:name => 'baz') }.should raise_error(ActiveRecord::StaleObjectError)
+      end
+ 
+      it "should raise Stale for conflicts updating just children" do
+        @handle2_r1.parties.first.update_attributes(:name => 'Frank')
+        # version has incremented because of update to party, so, :versioning touch fails
+        lambda { @handle1_r1.mediated_transaction {} }.should raise_error(ActiveRecord::StaleObjectError)
+      end
+
+      it "should raise Stale for conflicts deleting children and touching root" do
+        @handle2_r1.parties.first.destroy
+        lambda { @handle1_r1.update_attributes(:name => 'baz') }.should raise_error(ActiveRecord::StaleObjectError)
+      end
+
+      it "should not raise stale because of updates to its own children counter_caches" do
+        @handle1_r1.mediated_transaction do
+          @handle1_r1.lodge(@party1, :in => @room1)
+          @handle1_r1.parties.first.touch
+        end 
+      end
+
+      it "should increment lock_version for the graph if a dependent is changed" do
+        lambda {
+          @handle1_r1.parties.first.touch
+          @handle1_r1.reload
+        }.should change(@handle1_r1, :lock_version).by(1)
+      end
+
+      context "with lock_version for dependent children" do
+
+        before(:all) do
+          create_schema do |conn|
+            conn.add_column(:parties, :lock_version, :integer)
+          end  
+          Party.reset_column_information
+        end
+
+        after(:all) do
+          create_schema do |conn|
+            conn.remove_column(:parties, :lock_version)
+          end
+          Party.reset_column_information
+        end
+
+        it "will raise stale because of updates to its own children counter_caches" do
+#          Reservation::MediatorProxy._graph_mediator_logger = TestLogger.new
+          Reservation::MediatorProxy._graph_mediator_log_level = 0
+          r = Reservation.create!(:starts => @today, :ends => @today)
+          party, room = nil, nil
+          r.mediated_transaction do
+            party = r.parties.create(:name => 'Joe')
+            room  = r.lodgings.create(:room_number => 1)
+          end
+          r.mediated_transaction do
+            r.lodge(party, :in => room)
+            lambda { party.touch }.should raise_error(ActiveRecord::StaleObjectError)
+          end
+        end
+
+      end
+    end
+
+    context "within a mediated transaction" do
+
+      it "should not raise stale for changes made within a mediated transaction" do
+        lambda { @handle1_r1.mediated_transaction do
+          @handle1_r1.parties.create(:name => 'Bob')          
+        end }. should change(@handle1_r1, :lock_version).by(1)
+      end
+
+      it "should not raise stale for counter_caches within a mediated transaction" do
+        lambda { @handle1_r1.mediated_transaction do
+          @handle1_r1.parties.create(:name => 'Bob')
+          @handle1_r1.update_attributes(:name => 'baz')
+        end }.should change(@handle1_r1, :lock_version).by(1)
+      end
+    end
+  end
+
+end
+
+module GraphMediatorLocking # namespace to prevent helper class conflicts
+
+describe "GraphMediator locking scenarios for classes without counter_caches" do
+
+  before(:all) do
+    create_schema do |connection|
+      connection.create_table(:foos, :force => true) do |t|
+        t.string :name
+        t.integer :lock_version, :default => 0
+        t.timestamps
+      end
+  
+      connection.create_table(:bars, :force => true) do |t|
+        t.string :name
+        t.belongs_to :foo
+        t.timestamps
+      end
+    end
+  end
+
+  class Bar < ActiveRecord::Base
+    belongs_to :foo
+  end
+
+  class Foo < ActiveRecord::Base
+    include GraphMediator
+    mediate :dependencies => Bar
+    has_many :bars
+  end
+
+  before(:each) do
+    @h1_foo1 = Foo.create(:name => 'one')
+    @h2_foo1 = Foo.find(@h1_foo1.id)
+  end
+
+  it "should also raise Stale for conflicts updating root" do
+# nothing to touch...
+    @h2_foo1.update_attributes(:name => 'bar')
+    lambda { @h1_foo1.update_attributes(:name => 'baz') }.should raise_error(ActiveRecord::StaleObjectError)
+    @h1_foo1.reload
+    @h1_foo1.name.should == 'bar' 
+  end
+
+  it "should raise Stale for conflicts deleting children and touching root" do
+    @h1_foo1.bars << Bar.create! 
+    @h2_foo1.bars.first.destroy
+    lambda { @h1_foo1.update_attributes(:name => 'baz') }.should raise_error(ActiveRecord::StaleObjectError)
+  end
+
+  it "should increment lock_version for the graph if a dependent is added" do
+    lambda {
+      @h1_foo1.bars << Bar.create!
+      @h1_foo1.reload
+    }.should change(@h1_foo1, :lock_version).by(1)
+  end
+
+  it "should increment lock_version for the graph if a dependent is deleted" do
+    @h1_foo1.bars << Bar.create!
+    @h1_foo1.reload
+    lambda {
+      @h1_foo1.bars.first.destroy
+      @h1_foo1.reload
+    }.should change(@h1_foo1, :lock_version).by(1)
+  end
+
+end
+
+end

data/spec/integration/nesting_spec.rb

@@ -0,0 +1,113 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe "Nesting of mediated_transactions" do
+
+  before(:all) do
+    #@old_logger = GraphMediator::Configuration.logger
+    #GraphMediator::Configuration.logger = TestLogger.new
+    @old_log_level = GraphMediator::Configuration.log_level
+    GraphMediator::Configuration.log_level = ActiveSupport::BufferedLogger::DEBUG
+  end
+
+  after(:all) do
+    #GraphMediator::Configuration.logger = @old_logger
+    GraphMediator::Configuration.log_level = @old_log_level
+  end
+
+  before(:each) do
+    load_traceable_callback_tester
+    @t = Traceable.new(:name => :gizmo)
+    @t.save_without_mediation! 
+  end
+
+  after(:each) do
+    Object.__send__(:remove_const, :Traceable)
+  end
+
+  it "should only perform a single after_mediation even with nested mediated_transactions" do
+    @t.mediated_transaction do
+      @t.mediated_transaction {}
+    end
+    @traceables_callbacks.should == [:before, :reconcile, :cache]
+  end
+
+  it "should only perform a single after_mediation even with implicitly nested mediated transactions" do
+
+    @t.mediated_transaction do
+      @t.update_attributes(:name => 'foo')
+    end
+    @traceables_callbacks.should == [:before, :reconcile, :cache]
+  end
+
+  it "should handle deeper nesting" do
+    @t.mediated_transaction do
+      @t.mediated_transaction do
+        @t.update_attributes(:name => 'foo')
+      end
+    end
+    @t.__send__(:current_mediator).should be_nil
+    @traceables_callbacks.should == [:before, :reconcile, :cache]
+  end
+
+  it "should handle errors raised while deeply nested" do
+    lambda { @t.mediated_transaction do
+      @t.mediated_transaction do
+        @t.mediated_transaction { raise }
+      end
+    end }.should raise_error(RuntimeError)
+    @t.__send__(:current_mediator).should be_nil
+    @traceables_callbacks.should == [:before]
+  end
+
+  it "should handle errors raised and recovered while deeply nested" do
+    @t.mediated_transaction do
+      @t.mediated_transaction do
+        lambda { @t.mediated_transaction { raise } }.should raise_error(RuntimeError)
+      end
+    end
+    @t.__send__(:current_mediator).should be_nil
+    @traceables_callbacks.should == [:before, :reconcile, :cache]
+  end
+
+  it "should call after_mediation only once even if mediated_transaction is called on a new instance" do
+    Traceable.logger.debug "\n\n\nnew test"
+    new_t = Traceable.new(:name => 'new')
+    new_t.mediated_transaction { new_t.save }
+    @traceables_callbacks.should == [:before, :reconcile, :cache]
+  end
+
+  it "should clear mediator if unrecovered error raised in nested transaction" do
+    lambda { @t.mediated_transaction do
+      @t.mediated_transaction { raise }
+    end }.should raise_error(RuntimeError)
+    @t.__send__(:current_mediator).should be_nil
+    @traceables_callbacks.should == [:before]
+  end
+
+  it "should finish mediation if error raised and recovered in nested transaction" do
+    @t.mediated_transaction do
+      lambda { @t.mediated_transaction { raise } }.should raise_error(RuntimeError)
+    end
+    @t.__send__(:current_mediator).should be_nil
+    @traceables_callbacks.should == [:before, :reconcile, :cache]
+  end
+
+  it "should run no callbacks if disabled, regardless of nesting" do
+    @t.disable_mediation!
+    @t.mediated_transaction do
+      @t.mediated_transaction { }
+    end
+    @traceables_callbacks.should == []
+  end
+
+  it "should continue to be disabled if error raised and recovered in a nested transaction when mediation is disabled" do
+    @t.disable_mediation!
+    @t.mediated_transaction do
+      lambda { @t.mediated_transaction { raise } }.should raise_error(RuntimeError)
+    end
+    @t.__send__(:current_mediator).should be_nil
+    @traceables_callbacks.should == []
+  end
+
+  
+end