rubyrep 1.2.0 → 2.0.0

data/spec/syncers_spec.rb

@@ -1,171 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe Syncers do
-  before(:each) do
-    @old_syncers = Syncers.syncers
-  end
-
-  after(:each) do
-    Syncers.instance_variable_set :@syncers, @old_syncers
-  end
-
-  it "syncers should return empty hash if nil" do
-    Syncers.instance_variable_set :@syncers, nil
-    Syncers.syncers.should == {}
-  end
-
-  it "syncers should return the registered syncers" do
-    Syncers.instance_variable_set :@syncers, :dummy_data
-    Syncers.syncers.should == :dummy_data
-  end
-
-  it "configured_syncer should return the correct syncer as per :syncer option, if both :syncer and :replicator is configured" do
-    options = {
-      :syncer => :two_way,
-      :replicator => :key2
-    }
-    Syncers.configured_syncer(options).should == Syncers::TwoWaySyncer
-  end
-
-  it "configured_syncer should return the correct syncer as per :replicator option if no :syncer option is provided" do
-    options = {:replicator => :two_way}
-    Syncers.configured_syncer(options).should == Syncers::TwoWaySyncer
-  end
-
-  it "register should register the provided commiter" do
-    Syncers.instance_variable_set :@syncers, nil
-    Syncers.register :a_key => :a
-    Syncers.register :b_key => :b
-    Syncers.syncers[:a_key].should == :a
-    Syncers.syncers[:b_key].should == :b
-  end
-end
-
-describe Syncers::OneWaySyncer do
-  before(:each) do
-    Initializer.configuration = standard_config
-  end
-
-  it "should register itself" do
-    Syncers::syncers[:one_way].should == Syncers::OneWaySyncer
-  end
-
-  it "initialize should store sync_helper" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    syncer = Syncers::OneWaySyncer.new(helper)
-    syncer.sync_helper.should == helper
-  end
-
-  it "initialize should calculate course source, target and source_record_index" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-
-    # verify correct behaviour if syncing to the left
-    helper.stub!(:sync_options).and_return({:direction => :left})
-    syncer = Syncers::OneWaySyncer.new(helper)
-    syncer.source.should == :right
-    syncer.target.should == :left
-    syncer.source_record_index.should == 1
-
-    # verify correct behaviour if syncing to the right
-    helper.stub!(:sync_options).and_return({:direction => :right})
-    syncer = Syncers::OneWaySyncer.new(helper)
-    syncer.source.should == :left
-    syncer.target.should == :right
-    syncer.source_record_index.should == 0
-  end
-
-  it "default_option should return the correct default options" do
-    Syncers::OneWaySyncer.default_options.should == {
-      :direction => :right,
-      :delete => false, :update => true, :insert => true
-    }
-  end
-
-  it "sync_difference should only delete if :delete option is given" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    helper.stub!(:sync_options).and_return({:direction => :left})
-    syncer = Syncers::OneWaySyncer.new(helper)
-    helper.should_not_receive(:delete_record)
-    helper.should_not_receive(:update_record)
-    helper.should_not_receive(:insert_record)
-    syncer.sync_difference(:left, :dummy_record)
-  end
-
-  it "sync_difference should delete in the right database" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    helper.stub!(:sync_options).and_return({:direction => :left, :delete => true})
-    syncer = Syncers::OneWaySyncer.new(helper)
-    helper.should_receive(:delete_record).with(:left, 'scanner_records', :dummy_record)
-    helper.should_not_receive(:update_record)
-    helper.should_not_receive(:insert_record)
-    syncer.sync_difference(:left, :dummy_record)
-
-    helper = SyncHelper.new(sync)
-    helper.stub!(:sync_options).and_return({:direction => :right, :delete => true})
-    syncer = Syncers::OneWaySyncer.new(helper)
-    helper.should_receive(:delete_record).with(:right, 'scanner_records', :dummy_record)
-    syncer.sync_difference(:right, :dummy_record)
-  end
-
-  it "sync_difference should not insert if :insert option is not true" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    helper.stub!(:sync_options).and_return({:direction => :left, :insert => false})
-    syncer = Syncers::OneWaySyncer.new(helper)
-    helper.should_not_receive(:delete_record)
-    helper.should_not_receive(:update_record)
-    helper.should_not_receive(:insert_record)
-    syncer.sync_difference(:right, :dummy_record)
-  end
-
-  it "sync_difference should insert in the right database" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    helper.stub!(:sync_options).and_return({:direction => :left, :insert => true})
-    syncer = Syncers::OneWaySyncer.new(helper)
-    helper.should_not_receive(:delete_record)
-    helper.should_not_receive(:update_record)
-    helper.should_receive(:insert_record).with(:left, 'scanner_records', :dummy_record)
-    syncer.sync_difference(:right, :dummy_record)
-
-    helper = SyncHelper.new(sync)
-    helper.stub!(:sync_options).and_return({:direction => :right, :insert => true})
-    syncer = Syncers::OneWaySyncer.new(helper)
-    helper.should_receive(:insert_record).with(:right, 'scanner_records', :dummy_record)
-    syncer.sync_difference(:left, :dummy_record)
-  end
-
-  it "sync_difference should not update if :update option is not true" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    helper.stub!(:sync_options).and_return({:direction => :left, :update => false})
-    syncer = Syncers::OneWaySyncer.new(helper)
-    helper.should_not_receive(:delete_record)
-    helper.should_not_receive(:update_record)
-    helper.should_not_receive(:insert_record)
-    syncer.sync_difference(:conflict, :dummy_records)
-  end
-
-  it "sync_difference should update the right values in the right database" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    helper.stub!(:sync_options).and_return({:direction => :left, :update => true})
-    syncer = Syncers::OneWaySyncer.new(helper)
-    helper.should_not_receive(:delete_record)
-    helper.should_receive(:update_record).with(:left, 'scanner_records', :right_record)
-    helper.should_not_receive(:insert_record)
-    syncer.sync_difference(:conflict, [:left_record, :right_record])
-
-    helper = SyncHelper.new(sync)
-    helper.stub!(:sync_options).and_return({:direction => :right, :update => true})
-    syncer = Syncers::OneWaySyncer.new(helper)
-    helper.should_receive(:update_record).with(:right, 'scanner_records', :left_record)
-    syncer.sync_difference(:conflict, [:left_record, :right_record])
-  end
-end

data/spec/table_scan_helper_spec.rb

@@ -1,36 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe TableScanHelper do
-  before(:each) do
-    @scan = Object.new
-    @scan.extend TableScanHelper
-  end
-
-  it "rank_rows should calculate the correct rank of rows based on their primary keys" do
-    @scan.stub!(:primary_key_names).and_return(['first_id', 'second_id'])
-    @scan.rank_rows({'first_id' => 1, 'second_id' => 1}, {'first_id' => 1, 'second_id' => 1}).should == 0
-    @scan.rank_rows({'first_id' => 1, 'second_id' => 1}, {'first_id' => 1, 'second_id' => 2}).should == -1
-    @scan.rank_rows({'first_id' => 2, 'second_id' => 1}, {'first_id' => 1, 'second_id' => 1}).should == 1
-
-    # should rank strings according to database logic ('a' < 'A')
-    # instead of the Ruby logic (which is the other way round)
-    @scan.rank_rows({'first_id' => 'a', 'second_id' => 1}, {'first_id' => 'B', 'second_id' => 1}).should == -1
-    @scan.rank_rows({'first_id' => 'a', 'second_id' => 1}, {'first_id' => 'A', 'second_id' => 1}).should == -1
-    @scan.rank_rows({'first_id' => 'a', 'second_id' => 1}, {'first_id' => 'a', 'second_id' => 1}).should == 0
-
-    lambda {@scan.rank_rows(nil,nil)}.should raise_error(RuntimeError, 'At least one of left_row and right_row must not be nil!')
-    @scan.rank_rows(nil, {'first_id' => 1, 'second_id' => 1}).should == 1
-    @scan.rank_rows({'first_id' => 1, 'second_id' => 1}, nil).should == -1
-  end
-
-  it "table_scan_class should return TableScan for non-proxied sessions" do
-    TableScanHelper.scan_class(Session.new(standard_config)).should == DirectTableScan
-  end
-
-  it "table_scan_class should return ProxiedTableScan for proxied sessions" do
-    ensure_proxy
-    TableScanHelper.scan_class(Session.new(proxied_config)).should == ProxiedTableScan
-  end
-end

data/spec/table_scan_spec.rb

@@ -1,49 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe TableScan do
-  before(:each) do
-    Initializer.configuration = standard_config
-  end
-
-  it "initialize should raise exception if table doesn't have primary keys" do
-    session = Session.new
-    lambda {TableScan.new session, 'extender_without_key'} \
-      .should raise_error(RuntimeError, /.*extender_without_key.*primary key/)
-  end
-
-  it "initialize should cache the primary keys of the given table" do
-    session = Session.new
-    scann = TableScan.new session, 'scanner_records'
-    scann.primary_key_names.should == ['id']
-  end
-
-  it "initialize should use the name of the left table as overwritable default for right table" do
-    session = Session.new
-    TableScan.new(session, 'scanner_records').right_table.should == 'scanner_records'
-    TableScan.new(session, 'scanner_records', 'dummy').right_table.should == 'dummy'
-  end
-
-  it "progress_printer= should store the progress printer class" do
-    session = Session.new
-    TableScan.new(session, 'scanner_records').progress_printer = :dummy_printer_class
-  end
-
-  it "update_progres should create the progress printer and report the progress" do
-    session = Session.new
-    scan = TableScan.new(session, 'extender_one_record', 'extender_no_record')
-
-    progress_printer_class = mock("progress printer class")
-    progress_printer = mock("progress printer")
-    progress_printer_class.should_receive(:new).
-      with(1, scan.session, 'extender_one_record', 'extender_no_record').
-      and_return(progress_printer)
-    progress_printer.should_receive(:step).with(2)
-    progress_printer.should_receive(:step).with(3)
-
-    scan.progress_printer = progress_printer_class
-    scan.update_progress 2
-    scan.update_progress 3
-  end
-end

data/spec/table_sorter_spec.rb

@@ -1,30 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe TableSorter do
-  before(:each) do
-  end
-
-  it "sort should order the tables correctly" do
-    tables = [
-      'scanner_records',
-      'referencing_table',
-      'referenced_table',
-      'scanner_text_key',
-    ]
-
-    sorter = TableSorter.new Session.new(standard_config), tables
-    sorted_tables = sorter.sort
-
-    # make sure it contains the original tables
-    sorted_tables.sort.should == tables.sort
-
-    # make sure the referenced table comes before the referencing table
-    sorted_tables.grep(/referenc/).should == ['referenced_table', 'referencing_table']
-
-    # verify that we are using TSort#tsort to get that result
-    sorter.should_not_receive(:tsort)
-    sorter.sort
-  end
-end

data/spec/table_spec_resolver_spec.rb

@@ -1,111 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe TableSpecResolver do
-  before(:each) do
-    Initializer.configuration = standard_config
-    @session = Session.new
-    @resolver = TableSpecResolver.new @session
-  end
-
-  it "initialize should store the session and cache the tables of the session" do
-    @resolver.session.should == @session
-  end
-
-  it "tables should return the tables of the specified database" do
-    @resolver.tables(:left).should == @session.left.tables
-    @resolver.tables(:right).should == @session.right.tables
-  end
-  
-  it "resolve should resolve direct table names correctly" do
-    @resolver.resolve(['scanner_records', 'referenced_table']).should == [
-      {:left => 'scanner_records', :right => 'scanner_records'},
-      {:left => 'referenced_table', :right => 'referenced_table'}
-    ]
-  end
-  
-  it "resolve should resolve table name pairs correctly" do
-    @resolver.resolve(['left_table , right_table']).should == [
-      {:left => 'left_table', :right => 'right_table'}
-    ]
-  end
-  
-  it "resolve should complain about non-existing tables" do
-    lambda {@resolver.resolve(['dummy, scanner_records'])}.
-      should raise_error(/non-existing.*dummy/)
-    lambda {@resolver.resolve(['left_table, left_table'])}.
-      should raise_error(/non-existing.*left_table/)
-    lambda {@resolver.resolve(['left_table'])}.
-      should raise_error(/non-existing.*left_table/)
-  end
-
-  it "resolve should not complain about regexp specified tables not existing in right database" do
-    @resolver.resolve([/^scanner_records$/, /left_table/]).
-      should == [{:left => 'scanner_records', :right => 'scanner_records'}]
-  end
-
-  it "resolve should not check for non-existing tables if that is disabled" do
-    lambda {@resolver.resolve(['dummy, scanner_records'], [], false)}.
-      should_not raise_error
-  end
-
-  it "resolve should resolve string in form of regular expression correctly" do
-    @resolver.resolve(['/SCANNER_RECORDS|scanner_text_key/']).sort { |a,b|
-      a[:left] <=> b[:left]
-    }.should == [
-      {:left => 'scanner_records', :right => 'scanner_records'},
-      {:left => 'scanner_text_key', :right => 'scanner_text_key'}
-    ]
-  end
-
-  it "resolve should resolve regular expressions correctly" do
-    @resolver.resolve([/SCANNER_RECORDS|scanner_text_key/]).sort { |a,b|
-      a[:left] <=> b[:left]
-    }.should == [
-      {:left => 'scanner_records', :right => 'scanner_records'},
-      {:left => 'scanner_text_key', :right => 'scanner_text_key'}
-    ]
-  end
-
-  it "resolve should should not return the same table multiple times" do
-    @resolver.resolve([
-        'scanner_records',
-        'scanner_records',
-        'scanner_records, bla',
-        '/scanner_records/'
-      ]
-    ).should == [
-      {:left => 'scanner_records', :right => 'scanner_records'}
-    ]
-  end
-
-  it "resolve should not return tables that are excluded" do
-    @resolver.resolve(
-      [/SCANNER_RECORDS|scanner_text_key/],
-      [/scanner_text/]
-    ).should == [
-      {:left => 'scanner_records', :right => 'scanner_records'},
-    ]
-  end
-
-  it "non_existing_tables should return an empty hash if all tables exist" do
-    table_pairs = [{:left => 'scanner_records', :right => 'referenced_table'}]
-    @resolver.non_existing_tables(table_pairs).should == {}
-  end
-
-  it "non_existing_tables should return a hash of non-existing tables" do
-    table_pairs = [{:left => 'scanner_records', :right => 'bla'}]
-    @resolver.non_existing_tables(table_pairs).should == {:right => ['bla']}
-
-    table_pairs = [
-      {:left => 'blub', :right => 'bla'},
-      {:left => 'scanner_records', :right => 'xyz'}
-      ]
-    @resolver.non_existing_tables(table_pairs).should == {
-      :left => ['blub'],
-      :right => ['bla', 'xyz']
-    }
-  end
-
-end

data/spec/table_sync_spec.rb

@@ -1,140 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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