rubyrep 1.2.0 → 2.0.0

data/spec/replication_helper_spec.rb

@@ -1,178 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe ReplicationHelper do
-  before(:each) do
-    Initializer.configuration = standard_config
-  end
-
-  it "initialize should initialize the correct committer" do
-    session = Session.new
-    rep_run = ReplicationRun.new(session, TaskSweeper.new(1))
-    helper = ReplicationHelper.new(rep_run)
-    c = helper.instance_eval {@committer}
-    c.should be_an_instance_of(Committers::DefaultCommitter)
-    c.session.should == helper.session
-  end
-
-  it "session should return the session" do
-    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
-    helper = ReplicationHelper.new(rep_run)
-    helper.session.should == rep_run.session
-  end
-
-  it "type_cast should convert the row values correctly" do
-    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
-
-    helper = ReplicationHelper.new(rep_run)
-    helper.type_cast('scanner_records', 'id' => '1', 'name' => 'bla').
-      should == {'id' => 1, 'name' => 'bla'}
-
-    string_row = {
-      'id' => '1',
-      'decimal_test' => '1.234',
-      'timestamp' => 'Sat Nov 10 20:15:01 +0900 2007',
-      'binary_test' => "\004\b[\n\"\bbla:\ndummyi\006i\ai\b"
-    }
-    row = helper.type_cast('extender_type_check', string_row)
-    row.should == {
-      'id' => 1,
-      'decimal_test' => BigDecimal.new("1.234"),
-      'timestamp' => Time.local(2007,"nov",10,20,15,1),
-      'binary_test' => Marshal.dump(['bla',:dummy,1,2,3])
-    }
-  end
-
-  it "new_transaction? should delegate to the committer" do
-    session = Session.new
-    rep_run = ReplicationRun.new(session, TaskSweeper.new(1))
-    helper = ReplicationHelper.new(rep_run)
-    c = helper.instance_eval {@committer}
-    c.should_receive(:new_transaction?).and_return(true)
-    helper.new_transaction?.should be_true
-  end
-
-  it "replication_run should return the current ReplicationRun instance" do
-    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
-    helper = ReplicationHelper.new(rep_run)
-    helper.replication_run.should == rep_run
-  end
-
-  it "options should return the correct options" do
-    session = Session.new
-    rep_run = ReplicationRun.new(session, TaskSweeper.new(1))
-    helper = ReplicationHelper.new(rep_run)
-    helper.options.should == session.configuration.options
-  end
-
-  it "insert_record should insert the given record" do
-    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
-    helper = ReplicationHelper.new(rep_run)
-    c = helper.instance_eval {committer}
-    c.should_receive(:insert_record).with(:right, 'scanner_records', :dummy_record)
-    helper.insert_record :right, 'scanner_records', :dummy_record
-  end
-
-  it "update_record should update the given record" do
-    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
-    helper = ReplicationHelper.new(rep_run)
-    c = helper.instance_eval {committer}
-    c.should_receive(:update_record).with(:right, 'scanner_records', :dummy_record, nil)
-    helper.update_record :right, 'scanner_records', :dummy_record
-  end
-
-  it "update_record should update the given record with the provided old key" do
-    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
-    helper = ReplicationHelper.new(rep_run)
-    c = helper.instance_eval {committer}
-    c.should_receive(:update_record).with(:right, 'scanner_records', :dummy_record, :old_key)
-    helper.update_record :right, 'scanner_records', :dummy_record, :old_key
-  end
-
-  it "delete_record should delete the given record" do
-    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
-    helper = ReplicationHelper.new(rep_run)
-    c = helper.instance_eval {committer}
-    c.should_receive(:delete_record).with(:right, 'scanner_records', :dummy_record)
-    helper.delete_record :right, 'scanner_records', :dummy_record
-  end
-
-  it "load_record should load the specified record (values converted to original data types)" do
-    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
-    helper = ReplicationHelper.new(rep_run)
-    helper.load_record(:right, 'scanner_records', 'id' => '2').should == {
-      'id' => 2, # Note: it's a number, not a string...
-      'name' => 'Bob - right database version'
-    }
-  end
-
-  it "options_for_table should return the correct options for the table" do
-    Initializer.configuration.options = {:a => 1, :b => 2}
-    Initializer.configuration.add_table_options 'scanner_records', {:b => 3}
-    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
-    helper = ReplicationHelper.new(rep_run)
-    options = helper.options_for_table('scanner_records')
-    options[:a].should == 1
-    options[:b].should == 3
-  end
-
-  it "options_for_table should merge the configured options into the default two way replicator options" do
-    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
-    helper = ReplicationHelper.new(rep_run)
-    helper.options_for_table('scanner_records').include?(:left_change_handling).should be_true
-    helper.options_for_table('scanner_records').include?(:right_change_handling).should be_true
-    helper.options_for_table('scanner_records').include?(:replication_conflict_handling).should be_true
-  end
-
-  it "log_replication_outcome should log the replication outcome correctly" do
-    session = Session.new
-    session.left.begin_db_transaction
-    begin
-      rep_run = ReplicationRun.new(session, TaskSweeper.new(1))
-      helper = ReplicationHelper.new(rep_run)
-
-      loaders = LoggedChangeLoaders.new(session)
-
-      left_change = LoggedChange.new loaders[:left]
-      right_change = LoggedChange.new loaders[:right]
-      diff = ReplicationDifference.new loaders
-      diff.changes.replace :left => left_change, :right => right_change
-      diff.type = :conflict
-
-      left_change.type, right_change.type = :update, :delete
-      left_change.table = right_change.table = 'extender_combined_key'
-      left_change.key = right_change.key = {'first_id' => 1, 'second_id' => 2}
-
-      # Verify that the log information are made fitting
-      helper.should_receive(:fit_description_columns).
-        with('ignore', 'ignored').
-        and_return(['ignoreX', 'ignoredY'])
-
-      helper.log_replication_outcome diff, 'ignore', 'ignored'
-
-      row = session.left.select_one("select * from rr_logged_events order by id desc")
-      row['activity'].should == 'replication'
-      row['change_table'].should == 'extender_combined_key'
-      row['diff_type'].should == 'conflict'
-      row['change_key'].should == '"first_id"=>"1", "second_id"=>"2"'
-      row['left_change_type'].should == 'update'
-      row['right_change_type'].should == 'delete'
-      row['description'].should == 'ignoreX'
-      row['long_description'].should == 'ignoredY'
-      Time.parse(row['event_time']).should >= 10.seconds.ago
-      row['diff_dump'].should == diff.to_yaml
-    ensure
-      session.left.rollback_db_transaction if session
-    end
-  end
-
-  it "finalize should be delegated to the committer" do
-    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
-    helper = ReplicationHelper.new(rep_run)
-
-    c = helper.instance_eval {@committer}
-    c.should_receive(:finalize).with(false)
-    helper.finalize(false)
-  end
-end

data/spec/replication_initializer_spec.rb

@@ -1,509 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe ReplicationInitializer do
-  before(:each) do
-    Initializer.configuration = standard_config
-  end
-
-  after(:each) do
-  end
-
-  it "initializer should store the session" do
-    session = Session.new
-    initializer = ReplicationInitializer.new session
-    initializer.session.should == session
-  end
-
-  it "options should return the table specific options if table is given" do
-    session = Session.new deep_copy(Initializer.configuration)
-    initializer = ReplicationInitializer.new session
-    session.configuration.should_receive(:options_for_table).
-      with('my_table').
-      and_return(:dummy_options)
-    initializer.options('my_table').should == :dummy_options
-  end
-
-  it "options should return the general options if no table is given" do
-    session = Session.new deep_copy(Initializer.configuration)
-    initializer = ReplicationInitializer.new session
-    session.configuration.should_receive(:options).
-      and_return(:dummy_options)
-    initializer.options.should == :dummy_options
-  end
-
-  it "create_trigger should create a working trigger" do
-    session = nil
-    begin
-      session = Session.new
-      session.left.begin_db_transaction
-      initializer = ReplicationInitializer.new(session)
-      initializer.create_trigger(:left, 'trigger_test')
-
-      session.left.insert_record 'trigger_test', {
-        'first_id' => 1,
-        'second_id' => 2,
-        'name' => 'bla'
-      }
-
-      row = session.left.select_one("select * from rr_pending_changes")
-      row.delete 'id'
-      row.delete 'change_time'
-      row.should == {
-        'change_table' => 'trigger_test',
-        'change_key' => 'first_id|1|second_id|2',
-        'change_new_key' => nil,
-        'change_type' => 'I'
-      }
-    ensure
-      session.left.execute 'delete from trigger_test' if session
-      session.left.execute 'delete from rr_pending_changes' if session
-      session.left.rollback_db_transaction if session
-    end
-  end
-
-  it "trigger_exists? and drop_trigger should work correctly" do
-    session = nil
-    begin
-      session = Session.new
-      initializer = ReplicationInitializer.new(session)
-      if initializer.trigger_exists?(:left, 'trigger_test')
-        initializer.drop_trigger(:left, 'trigger_test')
-      end
-      session.left.begin_db_transaction
-
-      initializer.create_trigger :left, 'trigger_test'
-      initializer.trigger_exists?(:left, 'trigger_test').
-        should be_true
-      initializer.drop_trigger(:left, 'trigger_test')
-      initializer.trigger_exists?(:left, 'trigger_test').
-        should be_false
-    ensure
-      session.left.rollback_db_transaction if session
-    end
-  end
-
-  it "ensure_sequence_setup should not do anything if :adjust_sequences option is not given" do
-    config = deep_copy(Initializer.configuration)
-    config.add_table_options 'sequence_test', :adjust_sequences => false
-    session = Session.new(config)
-    initializer = ReplicationInitializer.new(session)
-
-    session.left.should_not_receive(:update_sequences)
-    session.right.should_not_receive(:update_sequences)
-
-    table_pair = {:left => 'sequence_test', :right => 'sequence_test'}
-    initializer.ensure_sequence_setup table_pair, 3, 2, 2
-  end
-
-  it "ensure_sequence_setup should ensure that a table's auto generated ID values have the correct increment and offset" do
-    session = nil
-    begin
-      session = Session.new
-      initializer = ReplicationInitializer.new(session)
-      session.left.begin_db_transaction
-      session.right.begin_db_transaction
-
-      session.left.execute "delete from sequence_test"
-      session.right.execute "delete from sequence_test"
-
-      # Note:
-      # Calling ensure_sequence_setup twice with different values to ensure that
-      # it is actually does something.
-
-      table_pair = {:left => 'sequence_test', :right => 'sequence_test'}
-
-      initializer.ensure_sequence_setup table_pair, 3, 2, 2
-      initializer.ensure_sequence_setup table_pair, 5, 2, 1
-      id1, id2 = get_example_sequence_values(session)
-      (id2 - id1).should == 5
-      (id1 % 5).should == 2
-    ensure
-      [:left, :right].each do |database|
-        initializer.clear_sequence_setup database, 'sequence_test' if session
-        session.send(database).execute "delete from sequence_test" if session
-        session.send(database).rollback_db_transaction if session
-      end
-    end
-  end
-
-  it "clear_sequence_setup should not do anything if :adjust_sequences option is not given" do
-    config = deep_copy(Initializer.configuration)
-    config.add_table_options 'sequence_test', :adjust_sequences => false
-    session = Session.new(config)
-    initializer = ReplicationInitializer.new(session)
-
-    session.left.should_not_receive(:clear_sequence_setup)
-
-    initializer.clear_sequence_setup :left, 'sequence_test'
-  end
-
-  it "clear_sequence_setup should remove custom sequence settings" do
-    session = nil
-    begin
-      session = Session.new
-      initializer = ReplicationInitializer.new(session)
-      session.left.begin_db_transaction
-      session.right.begin_db_transaction
-      table_pair = {:left => 'sequence_test', :right => 'sequence_test'}
-      initializer.ensure_sequence_setup table_pair, 5, 2, 2
-      initializer.clear_sequence_setup :left, 'sequence_test'
-      id1, id2 = get_example_sequence_values(session)
-      (id2 - id1).should == 1
-    ensure
-      [:left, :right].each do |database|
-        initializer.clear_sequence_setup database, 'sequence_test' if session
-        session.send(database).execute "delete from sequence_test" if session
-        session.send(database).rollback_db_transaction if session
-      end
-    end
-  end
-
-  it "change_log_exists? should return true if replication log exists" do
-    config = deep_copy(standard_config)
-    initializer = ReplicationInitializer.new(Session.new(config))
-    initializer.change_log_exists?(:left).should be_true
-    config.options[:rep_prefix] = 'r2'
-    initializer = ReplicationInitializer.new(Session.new(config))
-    initializer.change_log_exists?(:left).should be_false
-  end
-
-  it "event_log_exists? should return true if event log exists" do
-    config = deep_copy(standard_config)
-    initializer = ReplicationInitializer.new(Session.new(config))
-    initializer.event_log_exists?.should be_true
-    config.options[:rep_prefix] = 'r2'
-    initializer = ReplicationInitializer.new(Session.new(config))
-    initializer.event_log_exists?.should be_false
-  end
-
-  it "create_event_log / drop_event_log should create / drop the event log" do
-    config = deep_copy(standard_config)
-    config.options[:rep_prefix] = 'r2'
-    session = Session.new(config)
-    initializer = ReplicationInitializer.new(session)
-    initializer.drop_logged_events if initializer.event_log_exists?
-
-    $stderr.stub! :write
-    initializer.event_log_exists?.should be_false
-    initializer.create_event_log
-    initializer.event_log_exists?.should be_true
-
-    # verify that replication log has 8 byte, auto-generating primary key
-    session.left.insert_record 'r2_logged_events', {'id' => 1e18.to_i, 'change_key' => 'blub'}
-    session.left.select_one("select id from r2_logged_events where change_key = 'blub'")['id'].
-      to_i.should == 1e18.to_i
-
-    initializer.drop_event_log
-    initializer.event_log_exists?.should be_false
-  end
-
-  it "create_change_log / drop_change_log should create / drop the replication log" do
-    config = deep_copy(standard_config)
-    config.options[:rep_prefix] = 'r2'
-    session = Session.new(config)
-    initializer = ReplicationInitializer.new(session)
-    initializer.drop_change_log(:left) if initializer.change_log_exists?(:left)
-
-    $stderr.stub! :write
-    initializer.change_log_exists?(:left).should be_false
-    initializer.create_change_log(:left)
-    initializer.change_log_exists?(:left).should be_true
-
-    # verify that replication log has 8 byte, auto-generating primary key
-    session.left.insert_record 'r2_pending_changes', {'change_key' => 'bla'}
-    session.left.select_one("select id from r2_pending_changes where change_key = 'bla'")['id'].
-      to_i.should > 0
-    session.left.insert_record 'r2_pending_changes', {'id' => 1e18.to_i, 'change_key' => 'blub'}
-    session.left.select_one("select id from r2_pending_changes where change_key = 'blub'")['id'].
-      to_i.should == 1e18.to_i
-
-    initializer.drop_change_log(:left)
-    initializer.change_log_exists?(:left).should be_false
-  end
-
-  it "ensure_activity_markers should not create the tables if they already exist" do
-    session = Session.new
-    initializer = ReplicationInitializer.new(session)
-    session.left.should_not_receive(:create_table)
-    initializer.ensure_activity_markers
-  end
-
-  it "ensure_activity_markers should create the marker tables" do
-    begin
-      config = deep_copy(standard_config)
-      config.options[:rep_prefix] = 'rx'
-      session = Session.new(config)
-      initializer = ReplicationInitializer.new(session)
-      initializer.ensure_activity_markers
-      session.left.tables.include?('rx_running_flags').should be_true
-      session.right.tables.include?('rx_running_flags').should be_true
-
-      # right columns?
-      columns = session.left.columns('rx_running_flags')
-      columns.size.should == 1
-      columns[0].name.should == 'active'
-    ensure
-      if session
-        session.left.drop_table 'rx_running_flags'
-        session.right.drop_table 'rx_running_flags'
-      end
-    end
-  end
-
-  it "ensure_infrastructure should not create the infrastructure tables if they already exist" do
-    session = Session.new
-    initializer = ReplicationInitializer.new(session)
-    session.left.should_not_receive(:create_table)
-    initializer.ensure_infrastructure
-  end
-
-  it "drop_change_logs should drop the change_log tables" do
-    session = Session.new
-    initializer = ReplicationInitializer.new session
-    initializer.should_receive(:drop_change_log).with(:left)
-    initializer.should_receive(:drop_change_log).with(:right)
-
-    initializer.drop_change_logs
-  end
-
-  it "drop_change_logs should not do anything if change_log tables do not exist" do
-    config = deep_copy(standard_config)
-    config.options[:rep_prefix] = 'rx'
-    session = Session.new(config)
-    initializer = ReplicationInitializer.new session
-    initializer.should_not_receive(:drop_change_log).with(:left)
-    initializer.should_not_receive(:drop_change_log).with(:right)
-
-    initializer.drop_change_logs
-  end
-
-  it "drop_activity_markers should drop the activity_marker tables" do
-    session = Session.new
-    initializer = ReplicationInitializer.new session
-    session.left.should_receive(:drop_table).with('rr_running_flags')
-    session.right.should_receive(:drop_table).with('rr_running_flags')
-
-    initializer.drop_activity_markers
-  end
-
-  it "drop_activity_markers should not do anything if the activity_marker tables do not exist" do
-    config = deep_copy(standard_config)
-    config.options[:rep_prefix] = 'rx'
-    session = Session.new(config)
-    initializer = ReplicationInitializer.new session
-    session.left.should_not_receive(:drop_table).with('rr_running_flags')
-    session.right.should_not_receive(:drop_table).with('rr_running_flags')
-
-    initializer.drop_change_logs
-  end
-
-  it "drop_infrastructure should drop all infrastructure tables" do
-    session = Session.new
-    initializer = ReplicationInitializer.new session
-    initializer.should_receive(:drop_event_log)
-    initializer.should_receive(:drop_change_logs)
-    initializer.should_receive(:drop_activity_markers)
-
-    initializer.drop_infrastructure
-  end
-
-  it "ensure_change_logs should create the change_log tables" do
-    session = nil
-    begin
-      config = deep_copy(standard_config)
-      config.options[:rep_prefix] = 'rx'
-      session = Session.new(config)
-      initializer = ReplicationInitializer.new(session)
-      initializer.ensure_change_logs
-    ensure
-      if session
-        session.left.drop_table 'rx_pending_changes'
-        session.right.drop_table 'rx_pending_changes'
-      end
-    end
-  end
-
-  it "ensure_change_logs should do nothing if the change_log tables already exist" do
-    session = Session.new
-    initializer = ReplicationInitializer.new session
-    initializer.should_not_receive(:create_change_log)
-
-    initializer.ensure_change_logs
-  end
-
-  it "ensure_event_log should create the event_log table" do
-    session = nil
-    begin
-      config = deep_copy(standard_config)
-      config.options[:rep_prefix] = 'rx'
-      session = Session.new(config)
-      initializer = ReplicationInitializer.new(session)
-      initializer.ensure_event_log
-    ensure
-      session.left.drop_table 'rx_logged_events' if session
-    end
-  end
-
-  it "ensure_event_log should do nothing if the event_log table already exist" do
-    session = Session.new
-    initializer = ReplicationInitializer.new session
-    initializer.should_not_receive(:create_event_log)
-
-    initializer.ensure_event_log
-  end
-
-  it "ensure_infrastructure should create the infrastructure tables" do
-    session = Session.new
-    initializer = ReplicationInitializer.new(session)
-    initializer.should_receive :ensure_activity_markers
-    initializer.should_receive :ensure_change_logs
-    initializer.should_receive :ensure_event_log
-    initializer.ensure_infrastructure
-  end
-
-  it "call_after_init_handler should call the according handler" do
-    config = deep_copy(standard_config)
-    received_session = nil
-    config.options[:after_infrastructure_setup] = lambda do |session|
-      received_session = session
-    end
-    session = Session.new config
-    initializer = ReplicationInitializer.new session
-    initializer.call_after_infrastructure_setup_handler
-
-    received_session.should == session
-  end
-
-  it "exclude_ruby_rep_tables should exclude the correct system tables" do
-    config = deep_copy(standard_config)
-    initializer = ReplicationInitializer.new(Session.new(config))
-    initializer.exclude_rubyrep_tables
-    initializer.session.configuration.excluded_table_specs.include?(/^rr_.*/).should be_true
-  end
-
-  it "restore_unconfigured_tables should remove triggers and sequences setups of unconfigured tables" do
-    session = Session.new
-    initializer = ReplicationInitializer.new session
-    begin
-      ['scanner_left_records_only', 'scanner_records'].each do |table|
-        initializer.create_trigger(:left, table)
-        initializer.create_trigger(:right, table)
-        initializer.ensure_sequence_setup(
-          {:left => table, :right => table},
-          2, 0, 1
-        )
-        session.right.insert_record table, {'id' => 100, 'name' => 'bla'}
-      end
-
-      # verify that the unconfigured tables are restored and pending changes deleted
-      initializer.restore_unconfigured_tables
-      initializer.trigger_exists?(:right, 'scanner_records').should be_false
-      session.right.sequence_values('rr', 'scanner_records').values[0][:increment].should == 1
-      session.right.select_one("select * from rr_pending_changes where change_table = 'scanner_records'").should be_nil
-
-      # verify that the configured tables are not touched
-      initializer.trigger_exists?(:right, 'scanner_left_records_only').should be_true
-      session.right.sequence_values('rr', 'scanner_left_records_only').values[0][:increment].should == 2
-      session.right.select_one("select * from rr_pending_changes where change_table = 'scanner_left_records_only'").should_not be_nil
-    ensure
-      ['scanner_left_records_only', 'scanner_records'].each do |table|
-        [:left, :right].each do |database|
-          if initializer.trigger_exists?(database, table)
-            initializer.drop_trigger(database, table)
-          end
-          initializer.clear_sequence_setup database, table
-        end
-        session.right.delete_record table, {'id' => 100}
-      end
-      session.right.execute "delete from rr_pending_changes"
-    end
-  end
-
-  it "prepare_replication should prepare the replication" do
-    session = nil
-    initializer = nil
-    org_stdout = $stdout
-
-    config = deep_copy(standard_config)
-    config.options[:committer] = :buffered_commit
-    config.options[:use_ansi] = false
-
-    received_session = nil
-    config.options[:after_infrastructure_setup] = lambda do |session|
-      received_session = session
-    end
-
-    config.include_tables 'rr_pending_changes' # added to verify that it is ignored
-
-    # added to verify that a disabled :initial_sync is honored
-    config.add_table_options 'table_with_manual_key', :initial_sync => false
-
-    session = Session.new(config)
-
-    # dummy data to verify that 'table_with_manual_key' is indeed not synced
-    session.left.insert_record 'table_with_manual_key', :id => 1, :name => 'bla'
-
-    $stdout = StringIO.new
-    begin
-      initializer = ReplicationInitializer.new(session)
-      initializer.should_receive(:ensure_infrastructure).any_number_of_times
-      initializer.should_receive(:restore_unconfigured_tables).any_number_of_times
-      initializer.prepare_replication
-
-      received_session.should == session
-      
-      # verify sequences have been setup
-      session.left.sequence_values('rr','scanner_left_records_only').values[0][:increment].should == 2
-      session.right.sequence_values('rr','scanner_left_records_only').values[0][:increment].should == 2
-
-      # verify table was synced
-      left_records = session.left.select_all("select * from  scanner_left_records_only order by id")
-      right_records = session.left.select_all("select * from  scanner_left_records_only order by id")
-      left_records.should == right_records
-
-      # verify rubyrep activity is _not_ logged
-      session.right.select_all("select * from rr_pending_changes").should be_empty
-
-      # verify other data changes are logged
-      initializer.trigger_exists?(:left, 'scanner_left_records_only').should be_true
-      session.left.insert_record 'scanner_left_records_only', {'id' => 10, 'name' => 'bla'}
-      changes = session.left.select_all("select change_key from rr_pending_changes")
-      changes.size.should == 1
-      changes[0]['change_key'].should == 'id|10'
-
-      # verify that the 'rr_pending_changes' table was not touched
-      initializer.trigger_exists?(:left, 'rr_pending_changes').should be_false
-
-      # verify that :initial_sync => false is honored
-      session.right.select_all("select * from table_with_manual_key").should be_empty
-
-      # verify that syncing is done only for unsynced tables
-      SyncRunner.should_not_receive(:new)
-      initializer.prepare_replication
-
-    ensure
-      $stdout = org_stdout
-      if session
-        session.left.execute "delete from table_with_manual_key"
-        session.left.execute "delete from scanner_left_records_only where id = 10"
-        session.right.execute "delete from scanner_left_records_only"
-        [:left, :right].each do |database|
-          session.send(database).execute "delete from rr_pending_changes"
-        end
-      end
-      if initializer
-        [:left, :right].each do |database|
-          initializer.clear_sequence_setup database, 'scanner_left_records_only'
-          initializer.clear_sequence_setup database, 'table_with_manual_key'
-          ['scanner_left_records_only', 'table_with_manual_key'].each do |table|
-            if initializer.trigger_exists?(database, table)
-              initializer.drop_trigger database, table
-            end
-          end
-        end
-      end
-    end
-  end
-end