rubyrep 1.2.0 → 2.0.0

data/spec/spec_helper.rb

@@ -1,305 +0,0 @@
-begin
-  require 'spec'
-rescue LoadError
-  require 'rubygems'
-  gem 'rspec'
-  require 'spec'
-end
-
-require 'drb'
-require 'digest/sha1'
-
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib")
-$LOAD_PATH.unshift File.dirname(__FILE__)
-
-require 'rubyrep'
-require 'connection_extender_interface_spec'
-
-unless self.class.const_defined?('STRANGE_TABLE')
-  if ENV['RR_TEST_DB'] == 'postgres' || ENV['RR_TEST_DB'] == nil
-    STRANGE_TABLE = 'table_with.stränge Name山'
-  else
-    STRANGE_TABLE = 'table_with_stränge Name山'
-  end
-  STRANGE_COLUMN = 'stränge. Column山'
-end
-
-class Module
-  # Used to verify that an instance of the class / module receives a call of the
-  # specified method.
-  # This is for cases where a method call has to be mocked of an object that is 
-  # not yet created. 
-  # (Couldn't find out how to do that using existing rspec mocking features.)
-  def any_instance_should_receive(method, &blck)
-    tmp_method = "original_before_mocking_#{method}".to_sym
-    logger_key = "#{self.name}_#{method}"
-    $mock_method_marker ||= {}
-    $mock_method_marker[logger_key] = Spec::Mocks::Mock.new("#{name} Instance")
-    $mock_method_marker[logger_key].should_receive(method).at_least(:once)
-    self.send :alias_method, tmp_method, method
-    self.class_eval "def #{method}(*args); $mock_method_marker['#{logger_key}'].#{method}; end"
-    blck.call
-  ensure
-    $mock_method_marker.delete logger_key
-    self.send :alias_method, method, tmp_method rescue nil
-  end
-
-  # Used to verify that an instance of the class / module does not receive a 
-  # call of the specified method.
-  # This is for cases where a method call has to be mocked of an object that is 
-  # not yet created. 
-  # (Couldn't find out how to do that using existing rspec mocking features.)
-  def any_instance_should_not_receive(method, &blck)
-    tmp_method = "original_before_mocking_#{method}".to_sym
-    logger_key = "#{self.name}_#{method}"
-    $mock_method_marker ||= {}
-    $mock_method_marker[logger_key] = Spec::Mocks::Mock.new("#{name} Instance")
-    $mock_method_marker[logger_key].should_not_receive(method)
-    self.send :alias_method, tmp_method, method
-    self.class_eval "def #{method}(*args); $mock_method_marker['#{logger_key}'].#{method}; end"
-    blck.call
-  ensure
-    $mock_method_marker.delete logger_key
-    self.send :alias_method, method, tmp_method rescue nil
-  end
-end
-
-class RR::Session
-  # To keep rspec output of failed tests managable
-  def inspect; 'session'; end
-end
-
-class ActiveRecord::Base
-  class << self
-    # Hack:
-    # The default inspect method (as per activerecord version 2.2.2) tries to
-    # send commands to the database.
-    # This leads to rcov failing.
-    # As workaround this is disabling the attempts to connect to the database.
-    def inspect
-      super
-    end
-  end
-end
-
-# If number_of_calls is :once, mock ActiveRecord for 1 call.
-# If number_of_calls is :twice, mock ActiveRecord for 2 calls.
-def mock_active_record(number_of_calls)
-  ConnectionExtenders::DummyActiveRecord.should_receive(:establish_connection).send(number_of_calls) \
-    .and_return {|config| $used_config = config}
-    
-  dummy_connection = Object.new
-  # We have a spec testing behaviour for non-existing extenders.
-  # So extend might not be called in all cases
-  dummy_connection.stub!(:extend)
-  dummy_connection.stub!(:tables).and_return([])
-  dummy_connection.stub!(:initialize_search_path)
-  dummy_connection.stub!(:select_one).and_return({'x' => '2'})
-    
-  ConnectionExtenders::DummyActiveRecord.should_receive(:connection).send(number_of_calls) \
-    .and_return {dummy_connection}
-end
-
-# Creates a mock ProxyConnection with the given
-#   * mock_table: name of the mock table
-#   * primary_key_names: array of mock primary column names
-#   * column_names: array of mock column names, if nil: doesn't mock this function
-def create_mock_proxy_connection(mock_table, primary_key_names, column_names = nil)
-  session = mock("ProxyConnection")
-  if primary_key_names
-    session.should_receive(:primary_key_names) \
-      .with(mock_table) \
-      .and_return(primary_key_names)
-  end
-  if column_names
-    session.should_receive(:column_names) \
-      .with(mock_table) \
-      .and_return(column_names)
-  end
-  session.should_receive(:quote_value) \
-    .any_number_of_times \
-    .with(an_instance_of(String), an_instance_of(String), anything) \
-    .and_return { |table, column, value| value}
-  
-  session.should_receive(:connection) \
-    .any_number_of_times \
-    .and_return {dummy_connection}
-  
-  session.should_receive(:quote_column_name) \
-    .any_number_of_times \
-    .with(an_instance_of(String)) \
-    .and_return { |column_name| "'#{column_name}'" }
-      
-  session.should_receive(:quote_table_name) \
-    .any_number_of_times \
-    .with(an_instance_of(String)) \
-    .and_return { |table_name| "'#{table_name}'" }
-      
-  session
-end
-
-# Turns an SQL query into a regular expression:
-#   * Handles quotes (differing depending on DBMS).
-#   * Handles round brackets (escaping with backslash to make them literals).
-#   * Removes line breaks and double spaces 
-#     (allowing use of intendation and line continuation)
-# Returns the regular expression created from the provided +sql+ string.
-def sql_to_regexp(sql)
-  Regexp.new(sql.strip.squeeze(" ") \
-      .gsub("(", "\\(").gsub(")", "\\)") \
-      .gsub("'", 'E?.') \
-      .gsub('"', 'E?.'))
-end
-  
-# Returns a deep copy of the provided object. Works also for Proc objects or
-# objects referencing Proc objects.
-def deep_copy(object)
-  Proc.send :define_method, :_dump, lambda { |depth|
-    @@proc_store ||= {}
-    @@proc_key ||= "000000000"
-    @@proc_key.succ!
-    @@proc_store[@@proc_key] = self
-    @@proc_key
-  }
-  Proc.class.send :define_method, :_load, lambda { |key|
-    proc = @@proc_store[key]
-    @@proc_store.delete key
-    proc
-  }
-
-  Marshal.restore(Marshal.dump(object))
-ensure
-  Proc.send :remove_method, :_dump if Proc.method_defined? :_dump
-  Proc.class.send :remove_method, :_load if Proc.class.method_defined? :_load
-end
-
-# Allows the temporary faking of RUBY_PLATFORM to the given value
-# Needs to be called with a block. While the block is executed, RUBY_PLATFORM
-# is set to the given fake value
-def fake_ruby_platform(fake_ruby_platform)
-  old_ruby_platform = RUBY_PLATFORM
-  old_verbose, $VERBOSE = $VERBOSE, nil
-  Object.const_set 'RUBY_PLATFORM', fake_ruby_platform
-  $VERBOSE = old_verbose
-  yield
-ensure
-  $VERBOSE = nil
-  Object.const_set 'RUBY_PLATFORM', old_ruby_platform
-  $VERBOSE = old_verbose
-end
-
-# Reads the database configuration from the config folder for the specified config key
-# E.g. if config is :postgres, tries to read the config from 'postgres_config.rb'
-def read_config(config)
-  $config_cache ||= {}
-  cache_key = "#{config.to_s}_#{ENV['RR_TEST_DB']}"
-  unless $config_cache[cache_key]
-    # load the proxied config but ensure that the original configuration is restored
-    old_config = RR::Initializer.configuration
-    RR::Initializer.reset
-    begin
-      load File.dirname(__FILE__) + "/../config/#{config}_config.rb"
-      $config_cache[cache_key] = RR::Initializer.configuration
-    ensure
-      RR::Initializer.configuration = old_config
-    end
-  end
-  $config_cache[cache_key]
-end
-
-# Removes all cached database configurations
-def clear_config_cache
-  $config_cache = {}
-end
-
-# Retrieves the proxied database config as specified in config/proxied_test_config.rb
-def proxied_config
-  read_config :proxied_test
-end
-
-# Retrieves the standard (non-proxied) database config as specified in config/test_config.rb
-def standard_config
-  read_config :test
-end
-
-# Inserts two records into 'sequence_test' and returns the generated id values
-# * session: the active Session
-# * table: name of the table which is to be tested
-def get_example_sequence_values(session, table = 'sequence_test')
-  session.left.insert_record table, { 'name' => 'bla' }
-  id1 = session.left.select_one("select max(id) as id from #{table}")['id'].to_i
-  session.left.insert_record table, { 'name' => 'blub' }
-  id2 = session.left.select_one("select max(id) as id from #{table}")['id'].to_i
-  return id1, id2
-end
-
-# If true, start proxy as external process (more realistic test but also slower).
-# Otherwise start in the current process as thread.
-$start_proxy_as_external_process ||= false
-
-# Starts a proxy under the given host and post
-def start_proxy(host, port)
-  if $start_proxy_as_external_process
-    bin_path = File.join(File.dirname(__FILE__), "..", "bin", "rubyrep")
-    ruby = RUBY_PLATFORM =~ /java/ ? 'jruby' : 'ruby'
-    cmd = "#{ruby} #{bin_path} proxy -h #{host} -p #{port}"
-    Thread.new {system cmd}    
-  else
-    url = "druby://#{host}:#{port}"
-    DRb.start_service(url, DatabaseProxy.new)    
-  end
-end
-
-# Set to true if the proxy as per SPEC_PROXY_CONFIG is running 
-$proxy_confirmed_running = false
-
-# Starts a proxy as per left proxy settings defined in config/proxied_test_config.rb.
-# Only starts the proxy though if none is running yet at the according host / port.
-# If it starts a proxy child process, it also prepares automatic termination
-# after the spec run is finished.
-def ensure_proxy
-  # only execute the network verification once per spec run
-  unless $proxy_confirmed_running
-    drb_url = "druby://#{proxied_config.left[:proxy_host]}:#{proxied_config.left[:proxy_port]}"
-    # try to connect to the proxy
-    begin
-      proxy = DRbObject.new nil, drb_url
-      proxy.ping
-      $proxy_confirmed_running = true
-    rescue DRb::DRbConnError => e
-      # Proxy not yet running ==> start it
-      start_proxy proxied_config.left[:proxy_host], proxied_config.left[:proxy_port]
-      
-      maximum_startup_time = 5 # maximum time in seconds for the proxy to start
-      waiting_time = 0.1 # time to wait between connection attempts
-      
-      time = 0.0
-      ping_response = ''
-      # wait for the proxy to start up and become operational
-      while ping_response != 'pong' and time < maximum_startup_time
-        begin
-          proxy = DRbObject.new nil, drb_url
-          ping_response = proxy.ping
-          break
-        rescue DRb::DRbConnError => e
-          # do nothing (just try again)
-        end
-        sleep waiting_time
-        time += waiting_time
-      end
-      if ping_response == 'pong'
-        #puts "Proxy started (took #{time} seconds)"
-        # Ensure that the started proxy is terminated with the completion of the spec run.
-        at_exit do
-          proxy = DRbObject.new nil, drb_url
-          proxy.terminate! rescue DRb::DRbConnError
-        end if $start_proxy_as_external_process
-      else
-        raise "Could not start proxy"
-      end
-    end
-    
-    # if we got till here, then a proxy is running or was successfully started
-    $proxy_confirmed_running = true
-  end
-end

data/spec/strange_name_support_spec.rb

@@ -1,135 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe "Unusual table and column name support" do
-  before(:each) do
-    Initializer.configuration = standard_config
-  end
-
-  it "should be able to insert, update and delete records" do
-    session = Session.new
-    session.left.begin_db_transaction
-    begin
-      select_row = Proc.new {
-        session.left.
-          select_one(
-          "select #{session.left.quote_column_name(STRANGE_COLUMN)}
-           from #{session.left.quote_table_name(STRANGE_TABLE)}")
-      }
-
-      session.left.insert_record STRANGE_TABLE, 'id' => 1, STRANGE_COLUMN => 'bla'
-      select_row.call[STRANGE_COLUMN].should == 'bla'
-
-      session.left.update_record STRANGE_TABLE, 'id' => 1, STRANGE_COLUMN => 'blub'
-      select_row.call[STRANGE_COLUMN].should == 'blub'
-
-      session.left.delete_record STRANGE_TABLE, 'id' => 1
-      select_row.call.should be_nil
-    ensure
-      session.left.rollback_db_transaction
-    end
-  end
-
-  it "should be able to identify primary keys" do
-    session = Session.new
-    session.left.primary_key_names(STRANGE_TABLE).should == ['id']
-  end
-
-  it "should be able to identify referenced tables" do
-    session = Session.new
-    referenced_tables = session.left.referenced_tables([STRANGE_TABLE])
-    referenced_tables.size.should == 1
-    referenced_tables[STRANGE_TABLE].sort.
-      should == ["referenced_table"]
-  end
-
-  it "should support sequence operations" do
-    session = Session.new
-    begin
-      left_sequence_values = session.left.sequence_values('rr', STRANGE_TABLE)
-      right_sequence_values = session.right.sequence_values('rr', STRANGE_TABLE)
-      session.left.update_sequences(
-        'rr', STRANGE_TABLE, 10, 7, left_sequence_values, right_sequence_values, 1)
-
-      sequence_props = session.left.sequence_values('rr', STRANGE_TABLE).values.first
-      sequence_props[:increment].should == 10
-      (sequence_props[:value] % 10).should == 7
-
-      session.left.clear_sequence_setup 'rr', STRANGE_TABLE
-
-      session.left.sequence_values('rr', STRANGE_TABLE).values.first[:increment].should == 1
-    ensure
-      session.left.clear_sequence_setup 'rr', STRANGE_TABLE
-    end
-  end
-
-  it "should support trigger operations for strange tables" do
-    trigger_name = 'rr_' + STRANGE_TABLE
-    session = Session.new
-    begin
-      session.left.replication_trigger_exists?(trigger_name, STRANGE_TABLE).should be_false
-      session.left.create_replication_trigger({
-          :trigger_name => trigger_name,
-          :table => STRANGE_TABLE,
-          :keys => ['id'],
-          :log_table => 'rr_pending_changes',
-          :activity_table => 'rr_running_flags',
-          :key_sep => '|',
-          :exclude_rr_activity => true
-        })
-      session.left.replication_trigger_exists?(trigger_name, STRANGE_TABLE).should be_true
-      session.left.insert_record STRANGE_TABLE, {
-        'id' => 11,
-        STRANGE_COLUMN => 'blub'
-      }
-      log_record = session.left.select_one(
-        "select * from rr_pending_changes where change_table = '#{STRANGE_TABLE}'")
-      log_record['change_key'].should == 'id|11'
-      log_record['change_type'].should == 'I'
-
-      session.left.drop_replication_trigger trigger_name, STRANGE_TABLE
-      session.left.replication_trigger_exists?(trigger_name, STRANGE_TABLE).should be_false
-    ensure
-      if session.left.replication_trigger_exists?(trigger_name, STRANGE_TABLE)
-        session.left.drop_replication_trigger trigger_name, STRANGE_TABLE
-      end
-      session.left.execute "delete from #{session.left.quote_table_name(STRANGE_TABLE)}"
-      session.left.execute "delete from rr_pending_changes"
-    end
-  end
-
-  it "should support trigger operations for table with strange primary keys" do
-    trigger_name = 'rr_table_with_strange_key'
-    session = Session.new
-    begin
-      session.left.replication_trigger_exists?(trigger_name, :table_with_strange_key).should be_false
-      session.left.create_replication_trigger({
-          :trigger_name => trigger_name,
-          :table => :table_with_strange_key,
-          :keys => [STRANGE_COLUMN],
-          :log_table => 'rr_pending_changes',
-          :activity_table => 'rr_running_flags',
-          :key_sep => '|',
-          :exclude_rr_activity => true
-        })
-      session.left.replication_trigger_exists?(trigger_name, :table_with_strange_key).should be_true
-      session.left.insert_record 'table_with_strange_key', {
-        STRANGE_COLUMN => '11'
-      }
-      log_record = session.left.select_one(
-        "select * from rr_pending_changes where change_table = 'table_with_strange_key'")
-      log_record['change_key'].should == "#{STRANGE_COLUMN}|11"
-      log_record['change_type'].should == 'I'
-
-      session.left.drop_replication_trigger trigger_name, :table_with_strange_key
-      session.left.replication_trigger_exists?(trigger_name, :table_with_strange_key).should be_false
-    ensure
-      if session.left.replication_trigger_exists?(trigger_name, :table_with_strange_key)
-        session.left.drop_replication_trigger trigger_name, :table_with_strange_key
-      end
-      session.left.execute "delete from #{session.left.quote_table_name(:table_with_strange_key)}"
-      session.left.execute "delete from rr_pending_changes"
-    end
-  end
-end

data/spec/sync_helper_spec.rb

@@ -1,169 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe SyncHelper do
-  before(:each) do
-    Initializer.configuration = standard_config
-  end
-
-  it "initialize should initialize the correct committer" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    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
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    helper.session.should == sync.session
-  end
-
-  it "extract_key should extract the primary key column_name => value pairs" do
-    sync = TableSync.new(Session.new, 'extender_combined_key')
-    helper = SyncHelper.new(sync)
-    helper.extract_key('first_id' => 1, 'second_id' => 2, 'name' => 'bla').
-      should == {'first_id' => 1, 'second_id' => 2}
-  end
-
-  it "ensure_event_log should ask the replication_initializer to ensure the event log" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    ReplicationInitializer.any_instance_should_receive(:ensure_event_log) do
-      helper.ensure_event_log
-    end
-  end
-
-  it "log_sync_outcome should log the replication outcome correctly" do
-    session = Session.new
-    session.left.begin_db_transaction
-    begin
-      sync = TableSync.new(Session.new, 'scanner_records')
-      helper = SyncHelper.new(sync)
-
-      # Verify that the log information are made fitting
-      helper.should_receive(:fit_description_columns).
-        with('my_outcome', 'my_long_description').
-        and_return(['my_outcomeX', 'my_long_descriptionY'])
-
-      helper.log_sync_outcome(
-        {'bla' => 'blub', 'id' => 1},
-        'my_sync_type',
-        'my_outcome',
-        'my_long_description'
-      )
-      
-      row = session.left.select_one("select * from rr_logged_events order by id desc")
-      row['activity'].should == 'sync'
-      row['change_table'].should == 'scanner_records'
-      row['diff_type'].should == 'my_sync_type'
-      row['change_key'].should == '1'
-      row['left_change_type'].should be_nil
-      row['right_change_type'].should be_nil
-      row['description'].should == 'my_outcomeX'
-      row['long_description'].should == 'my_long_descriptionY'
-      Time.parse(row['event_time']).should >= 10.seconds.ago
-      row['diff_dump'].should == nil
-    ensure
-      session.left.rollback_db_transaction if session
-    end
-  end
-
-  it "log_sync_outcome should log events for combined primary key tables correctly" do
-    session = Session.new
-    session.left.begin_db_transaction
-    begin
-      sync = TableSync.new(Session.new, 'extender_combined_key')
-      helper = SyncHelper.new(sync)
-
-      helper.log_sync_outcome(
-        {'bla' => 'blub', 'first_id' => 1, 'second_id' => 2},
-        'my_sync_type',
-        'my_outcome',
-        'my_long_description'
-      )
-
-      row = session.left.select_one("select * from rr_logged_events order by id desc")
-      row['change_key'].should == '"first_id"=>"1", "second_id"=>"2"'
-    ensure
-      session.left.rollback_db_transaction if session
-    end
-  end
-
-  it "left_table and right_table should return the correct table names" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    helper.left_table.should == 'scanner_records'
-    helper.right_table.should == 'scanner_records'
-
-    sync = TableSync.new(Session.new, 'scanner_records', 'right_table')
-    helper = SyncHelper.new(sync)
-    helper.left_table.should == 'scanner_records'
-    helper.right_table.should == 'right_table'
-  end
-
-  it "tables should return the correct table name hash" do
-    sync = TableSync.new(Session.new, 'scanner_records', 'right_table')
-    helper = SyncHelper.new(sync)
-    helper.tables.should == {:left => 'scanner_records', :right => 'right_table'}
-  end
-
-  it "table_sync should return the current table sync instance" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    helper.table_sync.should == sync
-  end
-
-  it "sync_options should return the correct sync options" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    helper.sync_options.should == sync.sync_options
-  end
-
-  it "insert_record should insert the given record" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    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
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    c = helper.instance_eval {committer}
-    c.should_receive(:update_record).with(:right, 'scanner_records', :dummy_record, nil)
-    helper.update_record :right, 'scaner_records', :dummy_record
-  end
-
-  it "update_record should update the given record with the provided old key" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    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
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    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 "finalize should be delegated to the committer" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-
-    # finalize itself should not lead to creation of committer
-    helper.finalize
-    helper.instance_eval {@committer}.should be_nil
-    
-    c = helper.instance_eval {committer}
-    c.should_receive(:finalize).with(false)
-    helper.finalize(false)
-  end
-end

data/spec/sync_runner_spec.rb

@@ -1,78 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe SyncRunner do
-  before(:each) do
-  end
-
-  it "should register itself with CommandRunner" do
-    CommandRunner.commands['sync'][:command].should == SyncRunner
-    CommandRunner.commands['sync'][:description].should be_an_instance_of(String)
-  end
-
-  it "prepare_table_pairs should sort the tables" do
-    session = Session.new standard_config
-    session.should_receive(:sort_table_pairs).
-      with(:dummy_table_pairs).
-      and_return(:sorted_dummy_table_pairs)
-
-    sync_runner = SyncRunner.new
-    sync_runner.stub!(:session).and_return(session)
-
-    sync_runner.prepare_table_pairs(:dummy_table_pairs).should == :sorted_dummy_table_pairs
-  end
-
-  it "execute should sync the specified tables" do
-    org_stdout = $stdout
-    session = nil
-
-    # This is necessary to avoid the cached RubyRep configurations from getting
-    # overwritten by the sync run
-    old_config, Initializer.configuration = Initializer.configuration, Configuration.new
-
-    session = Session.new(standard_config)
-    session.left.begin_db_transaction
-    session.right.begin_db_transaction
-
-    $stdout = StringIO.new
-    begin
-      sync_runner = SyncRunner.new
-      sync_runner.options = {
-        :config_file => "#{File.dirname(__FILE__)}/../config/test_config.rb",
-        :table_specs => ["scanner_records"]
-      }
-
-      sync_runner.execute
-
-      $stdout.string.should =~
-        /scanner_records .* 5\n/
-
-      left_records = session.left.connection.select_all("select * from scanner_records order by id")
-      right_records = session.right.connection.select_all("select * from scanner_records order by id")
-      left_records.should == right_records
-    ensure
-      $stdout = org_stdout
-      Initializer.configuration = old_config if old_config
-      if session
-        session.left.rollback_db_transaction
-        session.right.rollback_db_transaction
-      end
-    end
-  end
-
-  it "create_processor should create the TableSync instance" do
-    TableSync.should_receive(:new).
-      with(:dummy_session, "left_table", "right_table").
-      and_return(:dummy_table_sync)
-    sync_runner = SyncRunner.new
-    sync_runner.should_receive(:session).and_return(:dummy_session)
-    sync_runner.create_processor("left_table", "right_table").
-      should == :dummy_table_sync
-  end
-
-  it "summary_description should return a description" do
-    SyncRunner.new.summary_description.should be_an_instance_of(String)
-  end
-
-end