rubyrep 1.0.0

data/spec/session_spec.rb

@@ -0,0 +1,212 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'yaml'
+
+include RR
+
+describe Session do # database connection caching is disabled
+  before(:each) do
+    Initializer.configuration = standard_config
+    @@old_cache_status = ConnectionExtenders.use_db_connection_cache(false)
+  end
+  
+  after(:each) do
+    ConnectionExtenders.use_db_connection_cache(@@old_cache_status)
+  end
+  
+  it "initialize should keep a reference of the Configuration object" do
+    mock_active_record :twice
+    
+    session = Session.new(Initializer.configuration)
+    session.configuration.should == Initializer.configuration
+  end
+  
+  it "initialize should establish the database connections" do
+    mock_active_record :twice
+    
+    session = Session.new
+  end
+    
+  it "'left=' should store a Connection object and 'left' should return it" do
+    mock_active_record :twice
+    
+    session = Session.new
+    
+    session.left = :dummy
+    session.left.should == :dummy
+  end
+
+  it "'right=' should store a Connection object and 'right' should return it" do
+    mock_active_record :twice
+    
+    session = Session.new
+    
+    session.right = :dummy
+    session.right.should == :dummy
+  end
+
+  it "initialize shouldn't create the same database connection twice" do
+    mock_active_record :once
+
+    Initializer.configuration = deep_copy(Initializer.configuration)
+    Initializer.configuration.right = Initializer.configuration.left.clone
+    
+    session = Session.new
+  end
+end
+
+describe Session do   # here database connection caching is _not_ disabled
+  before(:each) do
+    Initializer.configuration = standard_config
+  end
+
+  after(:each) do
+  end
+
+  it "initialize should create (fake) proxy connections as per configuration" do
+    dummy_proxy = Object.new
+    dummy_connection = mock("dummy connection")
+    dummy_connection.stub!(:tables).and_return([])
+    dummy_connection.stub!(:manual_primary_keys=)
+    dummy_proxy.should_receive(:create_session).and_return(dummy_connection)
+    DRbObject.should_receive(:new).with(nil,"druby://localhost:9876").and_return(dummy_proxy)
+
+    session = Session.new proxied_config
+
+    session.proxies[:left].should == dummy_proxy
+    session.proxies[:right].should be_an_instance_of(DatabaseProxy)
+
+    session.left.should == dummy_connection
+    session.right.should be_an_instance_of(ProxyConnection)
+  end
+
+  it "initialize should assign manual primary keys to the proxy connections" do
+    config = deep_copy(standard_config)
+    config.included_table_specs.clear
+    config.include_tables "table_with_manual_key, extender_without_key", :primary_key_names => ['id']
+    session = Session.new config
+    session.left.manual_primary_keys.should == {'table_with_manual_key'=>['id']}
+    session.right.manual_primary_keys.should == {'extender_without_key'=>['id']}
+  end
+
+  it "refresh should reestablsih the database connections if no more active" do
+    session = Session.new
+    session.right.destroy
+    session.right.connection.should_not be_active
+    session.refresh
+    session.right.connection.should be_active
+  end
+
+  it "refresh should not do anyting if the connection is still active" do
+    session = Session.new
+    old_connection_id = session.right.connection.object_id
+    session.refresh
+    session.right.connection.object_id.should == old_connection_id
+  end
+
+  it "manual_primary_keys should return the specified manual primary keys" do
+    config = deep_copy(standard_config)
+    config.included_table_specs.clear
+    config.include_tables "table_with_manual_key, extender_without_key", :key => ['id']
+    session = Session.new config
+    session.manual_primary_keys(:left).should == {'table_with_manual_key'=>['id']}
+    session.manual_primary_keys(:right).should == {'extender_without_key'=>['id']}
+  end
+
+  it "manual_primary_keys should accept keys that are not packed into an array" do
+    config = deep_copy(standard_config)
+    config.included_table_specs.clear
+    config.include_tables "table_with_manual_key", :key => 'id'
+    session = Session.new config
+    session.manual_primary_keys(:left).should == {'table_with_manual_key'=>['id']}
+  end
+
+  it "manual_primary_keys should follow the :auto_key_limit option" do
+    config = deep_copy(standard_config)
+    config.included_table_specs.clear
+    config.include_tables "scanner_records"
+    config.include_tables "extender_without_key"
+    config.include_tables "table_with_manual_key", :key => 'id'
+
+    config.options[:auto_key_limit] = 2
+    session = Session.new config
+    session.manual_primary_keys(:left).should == {
+      'table_with_manual_key' => ['id'],
+      'extender_without_key' => ['first_id', 'second_id']
+    }
+    session.left.primary_key_names('extender_without_key').should == ['first_id', 'second_id']
+
+    config.options[:auto_key_limit] = 1
+    session = Session.new config
+    session.manual_primary_keys(:left).should == {
+      'table_with_manual_key' => ['id']
+    }
+  end
+
+  it "corresponding_table should return the correct corresponding table" do
+    config = deep_copy(standard_config)
+    config.included_table_specs.clear
+    config.include_tables "/scanner/"
+    config.include_tables "table_with_manual_key, extender_without_key"
+    session = Session.new config
+    
+    session.corresponding_table(:left, 'scanner_records').should == 'scanner_records'
+    session.corresponding_table(:right, 'scanner_records').should == 'scanner_records'
+    session.corresponding_table(:left, 'table_with_manual_key').should == 'extender_without_key'
+    session.corresponding_table(:right, 'extender_without_key').should == 'table_with_manual_key'
+  end
+
+  it "corresponding_table should return the given table if no corresponding table can be found" do
+    session = Session.new
+    session.corresponding_table(:left, 'not_existing_table').should == 'not_existing_table'
+  end
+
+  it "configured_table_pairs should return the table pairs as per included_table_specs parameter" do
+    session = Session.new
+    session.configured_table_pairs(['scanner_records']).should == [
+      {:left => 'scanner_records', :right => 'scanner_records'},
+    ]
+  end
+
+  it "configured_table_pairs should return the table pairs as per configuration if included_table_specs paramter is an empty array" do
+    session = Session.new
+    session.configured_table_pairs([]).should == [
+      {:left => 'scanner_left_records_only', :right => 'scanner_left_records_only'},
+      {:left => 'table_with_manual_key', :right => 'table_with_manual_key'}
+    ]
+  end
+
+  def convert_table_array_to_table_pair_array(tables)
+    tables.map {|table| {:left => table, :right => table}}
+  end
+
+  it "sort_table_pairs should sort the tables correctly" do
+    table_pairs = convert_table_array_to_table_pair_array([
+        'scanner_records',
+        'referencing_table',
+        'referenced_table',
+        'scanner_text_key',
+      ])
+    sorted_table_pairs = convert_table_array_to_table_pair_array([
+        'scanner_records',
+        'referenced_table',
+        'referencing_table',
+        'scanner_text_key',
+      ])
+
+    Session.new.sort_table_pairs(table_pairs).should == sorted_table_pairs
+  end
+
+  it "sort_table_pairs should not sort the tables if table_ordering is not enabled in the configuration" do
+    table_pairs = convert_table_array_to_table_pair_array([
+        'scanner_records',
+        'referencing_table',
+        'referenced_table',
+        'scanner_text_key',
+      ])
+    config = deep_copy(standard_config)
+    config.options[:table_ordering] = false
+    session = Session.new config
+    session.sort_table_pairs(table_pairs).should == table_pairs
+  end
+end
+

data/spec/spec.opts

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

data/spec/spec_helper.rb

@@ -0,0 +1,295 @@
+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'
+
+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)
+    
+  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
+    rrproxy_path = File.join(File.dirname(__FILE__), "..", "bin", "rrproxy.rb")
+    ruby = RUBY_PLATFORM =~ /java/ ? 'jruby' : 'ruby'
+    cmd = "#{ruby} #{rrproxy_path} -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/sync_helper_spec.rb

@@ -0,0 +1,157 @@
+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 "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)
+
+      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_outcome'
+      row['long_description'].should == 'my_long_description'
+      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, :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, :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, :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, :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