andyjeffries-rubyrep 1.2.1

data/spec/table_sync_spec.rb

@@ -0,0 +1,140 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe TableSync do
+  it "sync_options should return the correct table specific sync options" do
+    config = deep_copy(standard_config)
+    old_table_specific_options = config.tables_with_options
+    begin
+      config.options = {:syncer => :bla}
+      config.include_tables 'scanner_records', {:syncer => :blub}
+      TableSync.new(Session.new(config), 'scanner_records').sync_options[:syncer] \
+        .should == :blub
+    ensure
+      config.instance_eval {@tables_with_options = old_table_specific_options}
+    end
+  end
+
+  it "execute_sync_hook should work if the hook is not configured" do
+    session = Session.new standard_config
+    sync = TableSync.new(session, 'scanner_records')
+    sync.execute_sync_hook(:before_table_sync)
+  end
+
+  it "execute_sync_hook should execute the given SQL command" do
+    config = deep_copy(standard_config)
+    config.add_table_options 'scanner_records', :before_table_sync => 'dummy_command'
+    session = Session.new config
+    sync = TableSync.new(session, 'scanner_records')
+
+    session.left.should_receive(:execute).with('dummy_command')
+    session.right.should_receive(:execute).with('dummy_command')
+
+    sync.execute_sync_hook(:before_table_sync)
+  end
+
+  it "execute_sync_hook should execute the given Proc" do
+    config = deep_copy(standard_config)
+    received_handler = nil
+    config.add_table_options 'scanner_records',
+      :before_table_sync => lambda {|helper| received_handler = helper}
+    session = Session.new config
+    sync = TableSync.new(session, 'scanner_records')
+    sync.helper = :dummy_helper
+
+    sync.execute_sync_hook(:before_table_sync)
+
+    received_handler.should == :dummy_helper
+  end
+
+  it "event_filtered? should return false if there is no event filter" do
+    session = Session.new standard_config
+    sync = TableSync.new(session, 'scanner_records')
+
+    sync.event_filtered?(:left, 'id' => 1).should be_false
+  end
+
+  it "event_filtered? should return false if event filter does not filter sync events" do
+    config = deep_copy(standard_config)
+    config.add_table_options 'scanner_records', :event_filter => Object.new
+    session = Session.new config
+    sync = TableSync.new(session, 'scanner_records')
+
+    sync.event_filtered?(:left, 'id' => 1).should be_false
+  end
+
+  it "event_filtered? should signal filtering (i. e. return true) if the event filter result is false" do
+    filter = Object.new
+    def filter.before_sync(table, key, helper, type, row)
+      false
+    end
+    config = deep_copy(standard_config)
+    config.add_table_options 'scanner_records', :event_filter => filter
+    session = Session.new config
+    sync = TableSync.new(session, 'scanner_records')
+    sync.helper = SyncHelper.new(sync)
+    sync.event_filtered?(:left, 'id' => 1).should be_true
+  end
+
+  it "event_filtered? should return false if the event filter result is true" do
+    filter = {}
+    def filter.before_sync(table, key, helper, type, row)
+      self[:args] = [table, key, helper, type, row]
+      true
+    end
+    config = deep_copy(standard_config)
+    config.add_table_options 'scanner_records', :event_filter => filter
+    session = Session.new config
+    sync = TableSync.new(session, 'scanner_records')
+    sync.helper = SyncHelper.new(sync)
+    sync.event_filtered?(:left, 'id' => 1, 'name' => 'bla').should be_false
+
+    # verify correct parameter assignment
+    filter[:args].should == ['scanner_records', {'id' => 1}, sync.helper, :left, {'id' => 1, 'name' => 'bla'}]
+  end
+
+  it "run should synchronize the databases" do
+    config = deep_copy(standard_config)
+    config.options[:committer] = :never_commit
+    config.options[:logged_sync_events] = [:all_conflicts]
+    before_hook_called = false
+    after_hook_called = false
+    config.options[:before_table_sync] = lambda {|helper| before_hook_called = true}
+    config.options[:after_table_sync] = lambda { |helper| after_hook_called = true}
+
+    filter = Object.new
+    def filter.before_sync(table, key, helper, type, row)
+      key['id'] != 6
+    end
+    config.options[:event_filter] = filter
+    session = Session.new(config)
+    begin
+      sync = TableSync.new(session, 'scanner_records')
+      sync.run
+
+      # Verify that sync events are logged
+      row = session.left.select_one("select * from rr_logged_events where change_key = '2' order by id")
+      row['change_table'].should == 'scanner_records'
+      row['diff_type'].should == 'conflict'
+      row['description'].should == 'left_wins'
+
+      # verify that the table was synchronized
+      left_records = session.left.select_all("select * from scanner_records where id <> 6 order by id")
+      right_records = session.right.select_all("select * from scanner_records where id <> 6 order by id")
+      left_records.should == right_records
+
+      # verify that the filtered out record was not synced
+      session.left.select_one("select * from scanner_records where id = 6").
+        should be_nil
+
+      # verify that hooks where called
+      before_hook_called.should be_true
+      after_hook_called.should be_true
+    ensure
+      Committers::NeverCommitter.rollback_current_session
+      session.left.execute "delete from rr_logged_events"
+    end
+  end
+
+end

data/spec/task_sweeper_spec.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe TaskSweeper do
+  before(:each) do
+  end
+
+  it "should execute the given task" do
+    x = nil
+    TaskSweeper.timeout(1) {|sweeper| x = 1}
+    x.should == 1
+  end
+
+  it "should raise exceptions thrown by the task" do
+    lambda {
+      TaskSweeper.timeout(1) {raise "bla"}
+    }.should raise_error("bla")
+  end
+
+  it "should return if task stalls" do
+    start = Time.now
+    TaskSweeper.timeout(0.01) {sleep 10}.should be_terminated
+    (Time.now - start < 5).should be_true
+  end
+
+  it "should not return if task is active" do
+    start = Time.now
+    TaskSweeper.timeout(0.1) do |sweeper|
+      10.times do
+        sleep 0.05
+        sweeper.ping
+      end
+    end.should_not be_terminated
+    (Time.now - start > 0.4).should be_true
+
+  end
+
+  it "should notify a stalled task about it's termination" do
+    terminated = false
+    TaskSweeper.timeout(0.01) do |sweeper|
+      sleep 0.05
+      terminated = sweeper.terminated?
+    end.join
+    terminated.should be_true
+  end
+end

data/spec/trigger_mode_switcher_spec.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe TriggerModeSwitcher do
+  before(:each) do
+    Initializer.configuration = standard_config
+  end
+
+  it "initialize should save the session and initialize triggers hash" do
+    session = Session.new
+    switcher = TriggerModeSwitcher.new(session)
+    switcher.session.should == session
+  end
+
+  it "exclude_rr_activity should switch the trigger for the given table" do
+    switcher = TriggerModeSwitcher.new(Session.new)
+
+    switcher.should_receive(:switch_trigger_mode).with(:right, 'right1', true).once
+    switcher.exclude_rr_activity(:right, 'right1')
+
+    # Verify that for a given table, the trigger is not modified multiple times
+    switcher.exclude_rr_activity(:right, 'right1')
+  end
+
+  it "restore_triggers should restore the triggers" do
+    switcher = TriggerModeSwitcher.new(Session.new)
+
+    switcher.stub!(:switch_trigger_mode)
+    switcher.exclude_rr_activity :left, 'left1'
+    switcher.should_receive(:switch_trigger_mode).with(:left, 'left1', false).once
+    switcher.restore_triggers
+    switcher.restore_triggers # ensure the restore is only done once
+  end
+
+  it "switch_trigger_mode should switch the exclude_rr_activity mode as specified" do
+    session = nil
+    initializer = nil
+    begin
+      session = Session.new
+      initializer = ReplicationInitializer.new(session)
+      initializer.create_trigger(:left, 'trigger_test')
+
+      switcher = TriggerModeSwitcher.new session
+      switcher.switch_trigger_mode :left, 'trigger_test', true
+      
+      session.left.insert_record 'trigger_test', {
+        'first_id' => 1,
+        'second_id' => 2,
+        'name' => 'blub'
+      }
+      session.left.execute "insert into rr_running_flags values(1)"
+      session.left.insert_record 'trigger_test', {
+        'first_id' => 1,
+        'second_id' => 3,
+        'name' => 'bla'
+      }
+
+      rows = session.left.select_all("select * from rr_pending_changes order by id")
+      rows.each {|row| row.delete 'id'; row.delete 'change_time'}
+      rows.should == [{
+        'change_table' => 'trigger_test',
+        'change_key' => 'first_id|1|second_id|2',
+        'change_new_key' => nil,
+        'change_type' => 'I'
+      }]
+    ensure
+      initializer.drop_trigger :left, 'trigger_test' if initializer
+      if session
+        session.left.execute 'delete from rr_running_flags'
+        session.left.execute 'delete from trigger_test'
+        session.left.execute 'delete from rr_pending_changes'
+      end
+    end
+  end
+
+  it "switch_trigger_mode should not switch the trigger mode if the table has no trigger" do
+    session = Session.new
+    switcher = TriggerModeSwitcher.new session
+    session.left.should_not_receive(:execute)
+    switcher.switch_trigger_mode(:left, 'scanner_records', true)
+  end
+end

data/spec/two_way_replicator_spec.rb

@@ -0,0 +1,721 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe Replicators::TwoWayReplicator do
+  before(:each) do
+    Initializer.configuration = deep_copy(standard_config)
+    Initializer.configuration.options = {:replicator => :two_way}
+  end
+
+  it "should register itself" do
+    Replicators::replicators[:two_way].should == Replicators::TwoWayReplicator
+  end
+
+  it "initialize should store the replication helper" do
+    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
+    helper = ReplicationHelper.new(rep_run)
+    replicator = Replicators::TwoWayReplicator.new(helper)
+    replicator.rep_helper.should == helper
+  end
+
+  it "verify_option should raise descriptive errors" do
+    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
+    helper = ReplicationHelper.new(rep_run)
+    replicator = Replicators::TwoWayReplicator.new(helper)
+    lambda {replicator.verify_option(nil, [:valid_value], :my_key, :my_value)}.
+      should raise_error(ArgumentError, ':my_value not a valid :my_key option')
+    lambda {replicator.verify_option(/my_spec/, [:valid_value], :my_key, :my_value)}.
+      should raise_error(ArgumentError, '/my_spec/: :my_value not a valid :my_key option')
+  end
+
+  it "initialize should throw an error if options are invalid" do
+    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
+    helper = ReplicationHelper.new(rep_run)
+    base_options = {
+      :replicator => :two_way,
+      :left_change_handling => :ignore,
+      :right_change_handling => :ignore,
+      :replication_conflict_handling => :ignore,
+      :logged_replication_events => [:ignored_conflicts]
+    }
+
+    # Verify that correct options don't raise errors.
+    helper.stub!(:options).and_return(base_options)
+    lambda {Replicators::TwoWayReplicator.new(helper)}.should_not raise_error
+
+    # Also lambda options should not raise errors.
+    l = lambda {}
+    helper.stub!(:options).and_return(base_options.merge(
+        {
+          :left_change_handling => l,
+          :right_change_handling => l,
+          :repliction_conflict_handling => l
+        })
+    )
+    lambda {Replicators::TwoWayReplicator.new(helper)}.should_not raise_error
+
+    # Invalid options should raise errors
+    invalid_options = [
+      {:left_change_handling => :invalid_left_option},
+      {:right_change_handling => :invalid_right_option},
+      {:replication_conflict_handling => :invalid_conflict_option},
+      {:logged_replication_events => :invalid_logging_option},
+    ]
+    invalid_options.each do |options|
+      helper.session.configuration.stub!(:options).and_return(base_options.merge(options))
+      lambda {Replicators::TwoWayReplicator.new(helper)}.should raise_error(ArgumentError)
+    end
+  end
+
+  it "clear_conflicts should update the correct database with the correct action" do
+    Initializer.configuration.include_tables 'left_table, right_table'
+    session = Session.new
+    session.left.begin_db_transaction
+    session.right.begin_db_transaction
+    begin
+      rep_run = ReplicationRun.new(session, TaskSweeper.new(1))
+      helper = ReplicationHelper.new(rep_run)
+      replicator = Replicators::TwoWayReplicator.new(helper)
+
+      loaders = LoggedChangeLoaders.new(session)
+
+      left_change = LoggedChange.new loaders[:left]
+      left_change.table = 'left_table'
+      left_change.key = {'id' => '1'}
+      right_change = LoggedChange.new loaders[:right]
+      right_change.table = 'right_table'
+      right_change.key = {'id' => '1'}
+
+      diff = ReplicationDifference.new(loaders)
+      diff.changes[:left] = left_change
+      diff.changes[:right] = right_change
+
+
+      # verify that an insert is dealt correctly with
+      left_change.type = :insert
+      right_change.type = :insert
+
+      helper.should_receive(:load_record).ordered.
+        with(:left, 'left_table', {'id' => '1'}).
+        and_return(:dummy_values)
+      helper.should_receive(:update_record).ordered.
+        with(:right, 'right_table', :dummy_values, {'id' => '1'})
+      replicator.clear_conflict :left, diff, 1
+
+      # verify that an update is dealt correctly with
+      left_change.type = :delete
+      right_change.type = :update
+      right_change.new_key = {'id' => '2'}
+
+
+      helper.should_receive(:load_record).ordered.
+        with(:right, 'right_table', {'id' => '2'}).
+        and_return(:dummy_values)
+      helper.should_receive(:insert_record).ordered.
+        with(:left, 'left_table', :dummy_values)
+      replicator.clear_conflict :right, diff, 1
+
+    
+      # verify that a delete is dealt correctly with
+      left_change.type = :delete
+      right_change.type = :update
+
+      helper.should_receive(:delete_record).ordered.
+        with(:right, 'right_table', {'id' => '2'})
+      replicator.clear_conflict :left, diff, 1
+    ensure
+      session.left.rollback_db_transaction
+      session.right.rollback_db_transaction
+    end
+  end
+
+  it "log_replication_outcome should log conflicts correctly" do
+    session = Session.new
+    rep_run = ReplicationRun.new(session, TaskSweeper.new(1))
+
+    loaders = LoggedChangeLoaders.new(session)
+
+    diff = ReplicationDifference.new loaders
+    diff.type = :conflict
+    diff.changes[:left] = LoggedChange.new loaders[:left]
+    diff.changes[:left].table = 'scanner_records'
+
+    # should only log events if so configured
+    helper = ReplicationHelper.new(rep_run)
+    replicator = Replicators::TwoWayReplicator.new(helper)
+    helper.should_not_receive(:log_replication_outcome)
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => []})
+    replicator.log_replication_outcome :ignore, diff
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => [:ignored_conflicts]})
+    replicator.log_replication_outcome :left, diff
+
+    # should log ignored conflicts correctly
+    helper = ReplicationHelper.new(rep_run)
+    replicator = Replicators::TwoWayReplicator.new(helper)
+    helper.should_receive(:log_replication_outcome).with(diff, 'ignored')
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => [:ignored_conflicts]})
+    replicator.log_replication_outcome :ignore, diff
+
+    # should log conflicts correctly
+    helper = ReplicationHelper.new(rep_run)
+    replicator = Replicators::TwoWayReplicator.new(helper)
+    helper.should_receive(:log_replication_outcome).with(diff, 'left_won')
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => [:all_conflicts]})
+    replicator.log_replication_outcome :left, diff
+  end
+
+  it "log_replication_outcome should log changes correctly" do
+    session = Session.new
+    rep_run = ReplicationRun.new(session, TaskSweeper.new(1))
+
+    loaders = LoggedChangeLoaders.new(session)
+
+    diff = ReplicationDifference.new loaders
+    diff.type = :left
+    diff.changes[:left] = LoggedChange.new loaders[:left]
+    diff.changes[:left].table = 'scanner_records'
+
+    # should only log events if so configured
+    helper = ReplicationHelper.new(rep_run)
+    replicator = Replicators::TwoWayReplicator.new(helper)
+    helper.should_not_receive(:log_replication_outcome)
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => []})
+    replicator.log_replication_outcome :ignore, diff
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => [:ignored_changes]})
+    replicator.log_replication_outcome :left, diff
+
+    # should log changes correctly
+    helper = ReplicationHelper.new(rep_run)
+    replicator = Replicators::TwoWayReplicator.new(helper)
+    helper.should_receive(:log_replication_outcome).with(diff, 'replicated')
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => [:all_changes]})
+    replicator.log_replication_outcome :right, diff
+
+    # should log changes correctly
+    helper = ReplicationHelper.new(rep_run)
+    replicator = Replicators::TwoWayReplicator.new(helper)
+    helper.should_receive(:log_replication_outcome).with(diff, 'ignored')
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => [:ignored_changes]})
+    replicator.log_replication_outcome :ignore, diff
+  end
+
+  it "replicate_difference should not do anything if ignore option is given" do
+    session = Session.new
+    rep_run = ReplicationRun.new(session, TaskSweeper.new(1))
+    helper = ReplicationHelper.new(rep_run)
+    replicator = Replicators::TwoWayReplicator.new(helper)
+    helper.stub!(:options_for_table).and_return(
+      {
+        :left_change_handling => :ignore,
+        :right_change_handling => :ignore,
+        :replication_conflict_handling => :ignore,
+        :logged_replication_events => [:ignored_changes, :ignored_conflicts]
+      }
+    )
+
+    loaders = LoggedChangeLoaders.new(session)
+
+    diff = ReplicationDifference.new(loaders)
+    diff.changes[:left] = LoggedChange.new loaders[:left]
+    diff.changes[:left].table = 'scanner_records'
+
+    # but logging should still happen
+    replicator.should_receive(:log_replication_outcome).
+      with(:ignore, diff).
+      exactly(3).times
+
+    helper.should_not_receive :insert_record
+    helper.should_not_receive :update_record
+    helper.should_not_receive :delete_record
+
+    diff.type = :conflict
+    replicator.replicate_difference diff
+    diff.type = :left
+    replicator.replicate_difference diff
+    diff.type = :right
+    replicator.replicate_difference diff
+  end
+
+  it "replicate_difference should call the provided Proc objects" do
+    session = Session.new
+    rep_run = ReplicationRun.new(session, TaskSweeper.new(1))
+    helper = ReplicationHelper.new(rep_run)
+
+    lambda_parameters = []
+    l = lambda do |rep_helper, diff|
+      lambda_parameters << [rep_helper, diff]
+    end
+    replicator = Replicators::TwoWayReplicator.new(helper)
+    helper.stub!(:options_for_table).and_return(
+      {
+        :left_change_handling => l,
+        :right_change_handling => l,
+        :replication_conflict_handling => l
+      }
+    )
+
+    loaders = LoggedChangeLoaders.new(session)
+
+    change = LoggedChange.new loaders[:left]
+    change.table = 'scanner_records'
+
+    d1 = ReplicationDifference.new(loaders)
+    d1.type = :conflict
+    d1.changes[:left] = change
+    replicator.replicate_difference d1
+
+    d2 = ReplicationDifference.new(loaders)
+    d2.type = :left
+    d2.changes[:left] = change
+    replicator.replicate_difference d2
+
+    d3 = ReplicationDifference.new(loaders)
+    d3.type = :right
+    d3.changes[:left] = change
+    replicator.replicate_difference d3
+
+    lambda_parameters.should == [
+      [helper, d1],
+      [helper, d2],
+      [helper, d3],
+    ]
+  end
+
+  it "replicate_difference should clear conflicts as per provided options" do
+    session = Session.new
+    rep_run = ReplicationRun.new(session, TaskSweeper.new(1))
+    helper = ReplicationHelper.new(rep_run)
+
+    left_change = LoggedChange.new LoggedChangeLoader.new(session, :left)
+    left_change.table = 'scanner_records'
+    right_change = LoggedChange.new LoggedChangeLoader.new(session, :right)
+    right_change.table = 'scanner_records'
+    diff = ReplicationDifference.new(session)
+    diff.type = :conflict
+    diff.changes[:left] = left_change
+    diff.changes[:right] = right_change
+
+    replicator = Replicators::TwoWayReplicator.new(helper)
+    helper.stub!(:options_for_table).and_return({:replication_conflict_handling => :left_wins})
+    replicator.should_receive(:clear_conflict).with(:left, diff, 1)
+    replicator.replicate_difference diff, 1
+
+    replicator = Replicators::TwoWayReplicator.new(helper)
+    helper.stub!(:options_for_table).and_return({:replication_conflict_handling => :right_wins})
+    replicator.should_receive(:clear_conflict).with(:right, diff, 1)
+    replicator.replicate_difference diff, 1
+
+    replicator = Replicators::TwoWayReplicator.new(helper)
+    helper.stub!(:options_for_table).and_return({:replication_conflict_handling => :later_wins})
+    replicator.should_receive(:clear_conflict).with(:left, diff, 1).twice
+    left_change.last_changed_at = 5.seconds.from_now
+    right_change.last_changed_at = Time.now
+    replicator.replicate_difference diff, 1
+    left_change.last_changed_at = right_change.last_changed_at = Time.now
+    replicator.replicate_difference diff, 1
+    replicator.should_receive(:clear_conflict).with(:right, diff, 1)
+    right_change.last_changed_at = 5.seconds.from_now
+    replicator.replicate_difference diff, 1
+
+    replicator = Replicators::TwoWayReplicator.new(helper)
+    helper.stub!(:options_for_table).and_return({:replication_conflict_handling => :earlier_wins})
+    replicator.should_receive(:clear_conflict).with(:left, diff, 1).twice
+    left_change.last_changed_at = 5.seconds.ago
+    right_change.last_changed_at = Time.now
+    replicator.replicate_difference diff, 1
+    left_change.last_changed_at = right_change.last_changed_at = Time.now
+    replicator.replicate_difference diff, 1
+    replicator.should_receive(:clear_conflict).with(:right, diff, 1)
+    right_change.last_changed_at = 5.seconds.ago
+    replicator.replicate_difference diff, 1
+  end
+
+  it "replicate_difference should replicate :left / :right changes correctly" do
+    Initializer.configuration.include_tables 'left_table, right_table'
+    session = Session.new
+    session.left.begin_db_transaction
+    session.right.begin_db_transaction
+    begin
+      rep_run = ReplicationRun.new(session, TaskSweeper.new(1))
+
+      left_change = LoggedChange.new LoggedChangeLoader.new(session, :left)
+      left_change.table = 'left_table'
+      left_change.key = {'id' => '1'}
+      right_change = LoggedChange.new LoggedChangeLoader.new(session, :right)
+      right_change.table = 'right_table'
+      right_change.key = {'id' => '1'}
+
+      diff = ReplicationDifference.new(session)
+
+      # verify insert behaviour
+      left_change.type = :insert
+      diff.type = :left
+      diff.changes[:left] = left_change
+      diff.changes[:right] = nil
+    
+      helper = ReplicationHelper.new(rep_run)
+      replicator = Replicators::TwoWayReplicator.new(helper)
+      replicator.should_receive(:log_replication_outcome).with(:left, diff)
+      helper.should_receive(:load_record).with(:left, 'left_table', {'id' => '1'}).
+        and_return(:dummy_values)
+      helper.should_receive(:insert_record).with(:right, 'right_table', :dummy_values)
+      replicator.replicate_difference diff
+
+      # verify update behaviour
+      right_change.type = :update
+      right_change.new_key = {'id' => '2'}
+      diff.type = :right
+      diff.changes[:right] = right_change
+
+      helper = ReplicationHelper.new(rep_run)
+      replicator = Replicators::TwoWayReplicator.new(helper)
+      replicator.should_receive(:log_replication_outcome).with(:right, diff)
+      helper.should_receive(:load_record).with(:right, 'right_table', {'id' => '2'}).
+        and_return(:dummy_values)
+      helper.should_receive(:update_record).with(:left, 'left_table', :dummy_values, {'id' => '1'})
+      replicator.replicate_difference diff
+
+      # verify delete behaviour
+      right_change.type = :delete
+
+      helper = ReplicationHelper.new(rep_run)
+      replicator = Replicators::TwoWayReplicator.new(helper)
+      replicator.should_receive(:log_replication_outcome).with(:right, diff)
+      helper.should_receive(:delete_record).with(:left, 'left_table', {'id' => '1'})
+      replicator.replicate_difference diff
+    ensure
+      session.left.rollback_db_transaction
+      session.right.rollback_db_transaction
+    end
+  end
+
+  it "replicate_difference should handle inserts failing due duplicate records getting created after the original diff was loaded" do
+    begin
+      config = deep_copy(standard_config)
+      config.options[:committer] = :never_commit
+      config.options[:replication_conflict_handling] = :right_wins
+
+      session = Session.new(config)
+
+      session.left.insert_record 'extender_no_record', {
+        'id' => '1',
+        'name' => 'bla'
+      }
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'extender_no_record',
+        'change_key' => 'id|1',
+        'change_type' => 'I',
+        'change_time' => Time.now
+      }
+
+
+      rep_run = ReplicationRun.new session, TaskSweeper.new(1)
+      helper = ReplicationHelper.new(rep_run)
+      replicator = Replicators::TwoWayReplicator.new(helper)
+
+      diff = ReplicationDifference.new LoggedChangeLoaders.new(session)
+      diff.load
+
+      session.right.insert_record 'extender_no_record', {
+        'id' => '1',
+        'name' => 'blub'
+      }
+      session.right.insert_record 'rr_pending_changes', {
+        'change_table' => 'extender_no_record',
+        'change_key' => 'id|1',
+        'change_type' => 'I',
+        'change_time' => Time.now
+      }
+      replicator.replicate_difference diff, 2
+
+      session.left.select_record(:table => "extender_no_record").should == {
+        'id' => 1,
+        'name' => 'blub'
+      }
+    ensure
+      Committers::NeverCommitter.rollback_current_session
+      if session
+        session.left.execute "delete from extender_no_record"
+        session.right.execute "delete from extender_no_record"
+        session.left.execute "delete from rr_pending_changes"
+      end
+    end
+  end
+
+  it "replicate_difference should handle inserts failing due the new record being deleted after the original diff was loaded" do
+    begin
+      config = deep_copy(standard_config)
+      config.options[:committer] = :never_commit
+
+      session = Session.new(config)
+
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'extender_no_record',
+        'change_key' => 'id|1',
+        'change_type' => 'I',
+        'change_time' => Time.now
+      }
+
+      rep_run = ReplicationRun.new session, TaskSweeper.new(1)
+      helper = ReplicationHelper.new(rep_run)
+      replicator = Replicators::TwoWayReplicator.new(helper)
+
+      diff = ReplicationDifference.new LoggedChangeLoaders.new(session)
+      diff.load
+
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'extender_no_record',
+        'change_key' => 'id|1',
+        'change_type' => 'D',
+        'change_time' => Time.now
+      }
+      replicator.replicate_difference diff, 2
+
+      # no rspec expectation: success is when we get till here without exception
+    ensure
+      Committers::NeverCommitter.rollback_current_session
+      session.left.execute "delete from rr_pending_changes" if session
+    end
+  end
+
+  it "replicate_difference should raise Exception if all replication attempts have been exceeded" do
+    rep_run = ReplicationRun.new Session.new, TaskSweeper.new(1)
+    helper = ReplicationHelper.new(rep_run)
+    replicator = Replicators::TwoWayReplicator.new(helper)
+    lambda {replicator.replicate_difference :dummy_diff, 0}.
+      should raise_error(Exception, "max replication attempts exceeded")
+  end
+  
+  it "replicate_difference should handle updates rejected by the database" do
+    begin
+      config = deep_copy(standard_config)
+      config.options[:committer] = :never_commit
+      config.options[:replication_conflict_handling] = :left_wins
+
+      session = Session.new(config)
+      session.left.execute "delete from rr_logged_events"
+
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'scanner_records',
+        'change_key' => 'id|1',
+        'change_new_key' => 'id|2',
+        'change_type' => 'U',
+        'change_time' => Time.now
+      }
+
+      rep_run = ReplicationRun.new session, TaskSweeper.new(1)
+      helper = ReplicationHelper.new(rep_run)
+      replicator = Replicators::TwoWayReplicator.new(helper)
+
+      diff = ReplicationDifference.new LoggedChangeLoaders.new(session)
+      diff.load
+
+      lambda {replicator.replicate_difference diff, 1}.should raise_error(/duplicate/i)
+
+      # Verify that the transaction has not become invalid
+      helper.log_replication_outcome diff, "bla", "blub"
+
+      row = session.left.select_one("select * from rr_logged_events")
+      row['change_table'].should == 'scanner_records'
+      row['change_key'].should == '1'
+      row['description'].should == 'bla'
+      
+    ensure
+      Committers::NeverCommitter.rollback_current_session
+      if session
+        session.left.execute "delete from rr_pending_changes"
+        session.left.execute "delete from rr_logged_events"
+      end
+    end
+  end
+
+  it "replicate_difference should handle deletes rejected by the database" do
+    begin
+      config = deep_copy(standard_config)
+      config.options[:committer] = :never_commit
+      config.options[:replication_conflict_handling] = :left_wins
+
+      session = Session.new(config)
+
+      session.left.select_all("select * from rr_logged_events").should == []
+
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'referenced_table',
+        'change_key' => 'first_id|1|second_id|2',
+        'change_new_key' => nil,
+        'change_type' => 'D',
+        'change_time' => Time.now
+      }
+
+      rep_run = ReplicationRun.new session, TaskSweeper.new(1)
+      helper = ReplicationHelper.new(rep_run)
+      replicator = Replicators::TwoWayReplicator.new(helper)
+
+      diff = ReplicationDifference.new LoggedChangeLoaders.new(session)
+      diff.load
+
+      lambda {replicator.replicate_difference diff, 1}.should raise_error(/referencing_table_fkey/)
+
+      # Verify that the transaction has not become invalid
+      helper.log_replication_outcome diff, "bla", "blub"
+
+      row = session.left.select_one("select * from rr_logged_events")
+      row['change_table'].should == 'referenced_table'
+      row['change_key'].should =~ /first_id.*1.*second_id.*2/
+      row['description'].should == 'bla'
+
+    ensure
+      Committers::NeverCommitter.rollback_current_session
+      if session
+        session.left.execute "delete from rr_pending_changes"
+        session.left.execute "delete from rr_logged_events"
+      end
+    end
+  end
+
+  it "replicate_difference should handle deletes failing due to the target record vanishing" do
+    begin
+      config = deep_copy(standard_config)
+      config.options[:committer] = :never_commit
+      config.options[:replication_conflict_handling] = :left_wins
+
+      session = Session.new(config)
+
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'scanner_records',
+        'change_key' => 'id|3',
+        'change_new_key' => nil,
+        'change_type' => 'D',
+        'change_time' => Time.now
+      }
+
+      rep_run = ReplicationRun.new session, TaskSweeper.new(1)
+      helper = ReplicationHelper.new(rep_run)
+      replicator = Replicators::TwoWayReplicator.new(helper)
+
+      diff = ReplicationDifference.new LoggedChangeLoaders.new(session)
+      diff.load
+
+      session.right.insert_record 'rr_pending_changes', {
+        'change_table' => 'scanner_records',
+        'change_key' => 'id|3',
+        'change_new_key' => 'id|4',
+        'change_type' => 'U',
+        'change_time' => Time.now
+      }
+
+      replicator.replicate_difference diff, 2
+      
+      session.right.select_one("select * from scanner_records where id = 4").
+        should be_nil
+    ensure
+      Committers::NeverCommitter.rollback_current_session
+      if session
+        session.left.execute "delete from rr_pending_changes"
+        session.left.execute "delete from rr_logged_events"
+      end
+    end
+  end
+
+  it "replicate_difference should handle updates failing due to the source record being deleted after the original diff was loaded" do
+    begin
+      config = deep_copy(standard_config)
+      config.options[:committer] = :never_commit
+      config.options[:replication_conflict_handling] = :left_wins
+
+      session = Session.new(config)
+
+      session.left.insert_record 'extender_no_record', {
+        'id' => '2',
+        'name' => 'bla'
+      }
+      session.right.insert_record 'extender_no_record', {
+        'id' => '2',
+        'name' => 'blub'
+      }
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'extender_no_record',
+        'change_key' => 'id|1',
+        'change_new_key' => 'id|2',
+        'change_type' => 'U',
+        'change_time' => Time.now
+      }
+
+      rep_run = ReplicationRun.new session, TaskSweeper.new(1)
+      helper = ReplicationHelper.new(rep_run)
+      replicator = Replicators::TwoWayReplicator.new(helper)
+
+      diff = ReplicationDifference.new LoggedChangeLoaders.new(session)
+      diff.load
+
+      session.left.delete_record 'extender_no_record', {'id' => '2'}
+
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'extender_no_record',
+        'change_key' => 'id|2',
+        'change_type' => 'D',
+        'change_time' => Time.now
+      }
+      replicator.replicate_difference diff, 2
+
+      session.right.select_one("select * from extender_no_record").should be_nil
+    ensure
+      Committers::NeverCommitter.rollback_current_session
+      if session
+        session.left.execute "delete from extender_no_record"
+        session.right.execute "delete from extender_no_record"
+        session.left.execute "delete from rr_pending_changes"
+      end
+    end
+  end
+
+  it "replicate_difference should handle updates failing due to the target record being deleted after the original diff was loaded" do
+    begin
+      config = deep_copy(standard_config)
+      config.options[:committer] = :never_commit
+      config.options[:replication_conflict_handling] = :left_wins
+
+      session = Session.new(config)
+
+      session.left.insert_record 'extender_no_record', {
+        'id' => '2',
+        'name' => 'bla'
+      }
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'extender_no_record',
+        'change_key' => 'id|1',
+        'change_new_key' => 'id|2',
+        'change_type' => 'U',
+        'change_time' => Time.now
+      }
+
+      rep_run = ReplicationRun.new session, TaskSweeper.new(1)
+      helper = ReplicationHelper.new(rep_run)
+      replicator = Replicators::TwoWayReplicator.new(helper)
+
+      diff = ReplicationDifference.new LoggedChangeLoaders.new(session)
+      diff.load
+
+      session.right.insert_record 'rr_pending_changes', {
+        'change_table' => 'extender_no_record',
+        'change_key' => 'id|1',
+        'change_type' => 'D',
+        'change_time' => Time.now
+      }
+      replicator.replicate_difference diff, 2
+
+      session.right.select_record(:table => "extender_no_record").should == {
+        'id' => 2,
+        'name' => 'bla'
+      }
+    ensure
+      Committers::NeverCommitter.rollback_current_session
+      if session
+        session.left.execute "delete from extender_no_record"
+        session.right.execute "delete from extender_no_record"
+        session.left.execute "delete from rr_pending_changes"
+      end
+    end
+  end
+end