andyjeffries-rubyrep 1.2.1

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

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

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

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