rubyrep 1.0.0

data/spec/committers_spec.rb

@@ -0,0 +1,174 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe Committers do
+  before(:each) do
+    @old_committers = Committers.committers
+  end
+
+  after(:each) do
+    Committers.instance_variable_set :@committers, @old_committers
+  end
+  
+  it "committers should return empty hash if nil" do
+    Committers.instance_variable_set :@committers, nil
+    Committers.committers.should == {}
+  end
+  
+  it "committers should return the registered committers" do
+    Committers.instance_variable_set :@committers, :dummy_data
+    Committers.committers.should == :dummy_data
+  end
+  
+  it "register should register the provided commiter" do
+    Committers.instance_variable_set :@committers, nil
+    Committers.register :a_key => :a
+    Committers.register :b_key => :b
+    Committers.committers[:a_key].should == :a
+    Committers.committers[:b_key].should == :b
+  end
+end
+
+
+describe "Committer", :shared => true do
+  it "should support the right constructor interface" do
+    session = mock("session")
+    session.should_receive(:left).any_number_of_times \
+      .and_return(mock("left connection", :null_object => true))
+    session.should_receive(:right).any_number_of_times \
+      .and_return(mock("right connection", :null_object => true))
+    @committer.class.new session
+  end
+  
+  it "should proxy insert_record, update_record and delete_record calls" do
+    left_connection = mock("left connection", :null_object => true)
+    left_connection.should_receive(:insert_record).with("left", :dummy_insert_values)
+
+    right_connection = mock("right connection", :null_object => true)
+    right_connection.should_receive(:update_record).with("right", :dummy_update_values, :dummy_org_key)
+    right_connection.should_receive(:delete_record).with("right", :dummy_delete_values)
+
+    session = mock("session")
+    session.should_receive(:left).any_number_of_times.and_return(left_connection)
+    session.should_receive(:right).any_number_of_times.and_return(right_connection)
+
+    committer = @committer.class.new session
+
+    committer.insert_record :left, 'left', :dummy_insert_values
+    committer.update_record :right, 'right', :dummy_update_values, :dummy_org_key
+    committer.delete_record :right, 'right', :dummy_delete_values
+  end
+  
+  it "should support finalize" do
+    @committer.finalize(false)
+  end
+end
+
+describe Committers::DefaultCommitter do
+  before(:each) do
+    @session = mock("session")
+    @session.should_receive(:left).any_number_of_times.and_return(:left_connection)
+    @session.should_receive(:right).any_number_of_times.and_return(:right_connection)
+    @committer = Committers::DefaultCommitter.new @session
+  end
+
+  it "should register itself" do
+    Committers.committers[:default].should == Committers::DefaultCommitter
+  end
+  
+  it "initialize should store the provided parameters" do
+    @committer.session.should == @session
+    @committer.connections \
+      .should == {:left => @session.left, :right => @session.right}
+  end
+  
+  it_should_behave_like "Committer"
+end
+
+describe Committers::NeverCommitter do
+  before(:each) do
+    @old_session = Committers::NeverCommitter.current_session
+    Committers::NeverCommitter.current_session = nil
+    @session = mock("session")
+    @session.should_receive(:left).any_number_of_times \
+      .and_return(mock("left connection", :null_object => true))
+    @session.should_receive(:right).any_number_of_times \
+      .and_return(mock("right connection", :null_object => true))
+    @committer = Committers::NeverCommitter.new @session
+  end
+  
+  after(:each) do
+    Committers::NeverCommitter.current_session = @old_session
+  end
+
+  it "should register itself" do
+    Committers.committers[:never_commit].should == Committers::NeverCommitter
+  end
+  
+  it "initialize should store the provided parameters" do
+    @committer.session.should == @session
+    @committer.connections \
+      .should == {:left => @session.left, :right => @session.right}
+  end
+  
+  it "initialize should rollback the previous current session and then register the new one as current session" do
+    old_session = mock("old session", :null_object => true)
+    new_session = mock("new session", :null_object => true)
+    Committers::NeverCommitter.current_session = old_session
+    Committers::NeverCommitter.should_receive(:rollback_current_session)
+    
+    Committers::NeverCommitter.new new_session
+    Committers::NeverCommitter.current_session.should == new_session
+  end
+  
+  it "initialize should start new transactions" do
+    # Ensure that initialize handles the case of no previous database session 
+    # being present
+    Committers::NeverCommitter.current_session = nil
+    new_session = mock("new session")
+
+    left_connection = mock("left connection")
+    left_connection.should_receive :begin_db_transaction
+    new_session.should_receive(:left).any_number_of_times.and_return(left_connection)
+
+    right_connection = mock("right connection")
+    right_connection.should_receive :begin_db_transaction
+    new_session.should_receive(:right).any_number_of_times.and_return(right_connection)
+
+    @committer = Committers::NeverCommitter.new new_session
+  end
+  
+  it "rollback_current_session should rollback current session" do
+    old_session = mock("old session")
+
+    left_connection = mock("left connection")
+    left_connection.should_receive :rollback_db_transaction
+    old_session.should_receive(:left).and_return(left_connection)
+
+    right_connection = mock("right connection")
+    right_connection.should_receive :rollback_db_transaction
+    old_session.should_receive(:right).and_return(right_connection)
+    
+    Committers::NeverCommitter.current_session = old_session
+    Committers::NeverCommitter.rollback_current_session
+  end
+  
+  it "should work will real sessions" do
+    session = Session.new(standard_config)
+    Committers::NeverCommitter.new session
+    Committers::NeverCommitter.new session
+    Committers::NeverCommitter.rollback_current_session
+  end
+  
+  it "should work will real proxied sessions" do
+    ensure_proxy
+    session = Session.new(proxied_config)
+    Committers::NeverCommitter.new session
+    Committers::NeverCommitter.new session   
+    Committers::NeverCommitter.rollback_current_session
+  end
+  
+  it_should_behave_like "Committer"
+  
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,198 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe Configuration do
+  before(:each) do
+  end
+
+  it "initialize should set #left and #right to empty hashes" do
+    config = Configuration.new
+    config.left.should == {}
+    config.right.should == {}
+  end
+  
+  it "initialize should set #options to the default options" do
+    config = Configuration.new
+    config.options.should == Configuration::DEFAULT_OPTIONS
+  end
+
+  it "options= should merge the provided into the existing options" do
+    config = Configuration.new
+    config.options = {:bla => :bla}
+    config.options = {:bla => :blub}
+    config.options[:bla].should == :blub
+  end
+
+  it "each_matching_option should yield if general option matches" do
+    config = Configuration.new
+    config.options = {:bla => :blub}
+    yielded = []
+    config.each_matching_option(:bla) {|spec, value| yielded << [spec, value]}
+    yielded.should == [[nil, :blub]]
+  end
+
+  it "each_matching_option should yield if table specific options match" do
+    config = Configuration.new
+    config.options = {:a => 1}
+    config.add_table_options 't1', :a => 2
+    config.add_table_options 't2', :b => 3
+    config.add_table_options 't3', :a => 4
+    yielded = []
+    config.each_matching_option(:a) {|spec, value| yielded << [spec, value]}
+    yielded.should == [
+      [nil,  1],
+      ['t1', 2],
+      ['t3', 4]
+    ]
+  end
+
+  it "each_matching_option should not yield unmatching options" do
+    config = Configuration.new
+    config.options = {:a => :blub}
+    config.add_table_options 'dummy_table', :b => :blub
+    yielded = []
+    config.each_matching_option(:c) {|spec, value| yielded << [spec, value]}
+    yielded.should == []
+  end
+
+  it "options_for_table should return the general options if there are no table specific options at all" do
+    config = Configuration.new
+    config.options_for_table('b').should == \
+      Syncers::TwoWaySyncer.default_options.clone.
+      merge(config.options)
+  end
+
+  it "included_table_specs should return the list of included table specifications" do
+    config = Configuration.new
+    config.include_tables('a', {:bla => :blub})
+    config.include_tables('a, b')
+    config.include_tables(/a/)
+    config.included_table_specs.should == ['a', 'a, b', /a/]
+  end
+
+  it "included_table_specs should save the options if provided" do
+    config = Configuration.new
+    config.include_tables('a', {:bla => :blub})
+    config.options_for_table('a')[:bla].should == :blub
+  end
+
+  it "include_tables should include the specified table specs" do
+    config = Configuration.new
+    config.include_tables('a')
+    config.include_tables(/b/)
+    config.included_table_specs.include?('a').should be_true
+    config.included_table_specs.include?(/b/).should be_true
+  end
+
+  it "include_table should alias to include_tables" do
+    config = Configuration.new
+    config.include_table('a')
+    config.included_table_specs.include?('a').should be_true
+  end
+
+  it "exclude_tables should exclude the specified table specs" do
+    config = Configuration.new
+    config.exclude_tables('a')
+    config.exclude_tables(/b/)
+    config.excluded_table_specs.include?('a').should be_true
+    config.excluded_table_specs.include?(/b/).should be_true
+  end
+
+  it "exclude_table should alias to exclude_tables" do
+    config = Configuration.new
+    config.exclude_table('a')
+    config.excluded_table_specs.include?('a').should be_true
+  end
+
+  it "exclude_rubyrep_tables should exclude the rubyrep infrastructure tables" do
+    config = Configuration.new
+    config.exclude_rubyrep_tables
+    config.excluded_table_specs.include?(/^rr_.*/).should be_true
+  end
+
+  it "excluded_table_specs should return the list of excluded table specifications" do
+    config = Configuration.new
+    config.exclude_tables('a')
+    config.exclude_tables('a, b')
+    config.exclude_tables(/a/)
+    config.excluded_table_specs.should == ['a', 'a, b', /a/]
+  end
+
+  it "options_for_table should return the general options if there are no matching table specific options" do
+    config = Configuration.new
+    config.include_tables(/a/, {:bla => :blub})
+    config.options_for_table('b').should == \
+      Syncers::TwoWaySyncer.default_options.clone.
+      merge(config.options)
+  end
+
+  it "options_for_table should return table specific options mixed in with default options" do
+    config = Configuration.new
+    config.include_tables(/a/, {:bla => :blub})
+    config.options_for_table('a').should == \
+      Syncers::TwoWaySyncer.default_options.clone.
+      merge(config.options).
+      merge(:bla => :blub)
+  end
+
+  it "options_for_table should return last added version of added options for matching table spec" do
+    config = Configuration.new
+    config.include_tables(/a/, {:bla => :blub})
+    config.include_tables('a', {:bla => :blok})
+    config.include_tables(/x/, {:bla => :bar})
+    config.include_tables('y', {:bla => :foo})
+    config.options_for_table('a').should == \
+      Syncers::TwoWaySyncer.default_options.clone.
+      merge(config.options).
+      merge(:bla => :blok)
+  end
+
+  it "options_for_table should match against table pair specs" do
+    config = Configuration.new
+    config.add_table_options('a, b', {:bla => :blub})
+    config.options_for_table('a')[:bla].should == :blub
+  end
+
+  it "options_for_table should match against regular expression specs" do
+    config = Configuration.new
+    config.add_table_options(/a/, {:bla => :blub})
+    config.options_for_table('a')[:bla].should == :blub
+  end
+
+  it "options_for_table should match against pure table name specs" do
+    config = Configuration.new
+    config.add_table_options('a', {:bla => :blub})
+    config.options_for_table('a')[:bla].should == :blub
+  end
+
+  it "add_table_options should not create table_spec duplicates" do
+    config = Configuration.new
+    config.add_table_options(/a/, {:bla => :blub})
+    config.add_table_options(/a/, {:foo => :bar})
+    config.options_for_table('a').should == \
+      Syncers::TwoWaySyncer.default_options.clone.
+      merge(config.options).
+      merge(:bla => :blub, :foo => :bar)
+  end
+
+  it "add_table_option should alias to add_table_options" do
+    config = Configuration.new
+    config.add_table_option(/a/, {:bla => :blub})
+    config.options_for_table('a')[:bla].should == :blub
+  end
+
+  it "add_table_options should include default syncer options" do
+    config = Configuration.new
+    config.options = {:syncer => :one_way}
+
+    # overwrite one syncer option
+    config.add_table_options(/a/, {:delete => true})
+
+    options = config.options_for_table('a')
+    Syncers::OneWaySyncer.default_options.each do |key, value|
+      options[key].should == value unless key == :delete
+    end
+    options[:delete].should == true
+  end
+end

data/spec/connection_extender_interface_spec.rb

@@ -0,0 +1,138 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'yaml'
+
+include RR
+
+# All ConnectionExtenders need to pass this spec
+describe "ConnectionExtender", :shared => true do
+  before(:each) do
+  end
+
+  it "primary_key_names should return primary key names ordered as per primary key index" do
+    session = Session.new
+    session.left.primary_key_names('extender_combined_key').should == ['first_id', 'second_id']
+    
+    session.left.primary_key_names('extender_inverted_combined_key') \
+      .should == ['second_id', 'first_id']
+  end
+  
+  it "primary_key_names should return an empty array for tables without any primary key" do
+    session = Session.new
+    session.left.primary_key_names('extender_without_key') \
+      .should == []
+  end
+  
+  it "primary_key_names called for a non-existing table should throw an exception" do
+    session = Session.new
+    lambda {session.left.primary_key_names('non_existing_table')} \
+      .should raise_error(RuntimeError, /.*non_existing_table.*not exist/)
+  end
+
+  it "referenced_tables should identify the correct table dependencies" do
+    session = Session.new
+    referenced_tables = session.left.referenced_tables(['scanner_records', 'referencing_table'])
+    referenced_tables.size.should == 2
+    referenced_tables['scanner_records'].should == []
+    referenced_tables['referencing_table'].sort.
+      should == ["referenced_table", "referenced_table2"]
+  end
+  
+  it "referenced_tables should return those tables without primary key" do
+    session = Session.new
+    referenced_tables = session.left.referenced_tables(['table_with_manual_key'])
+    referenced_tables.should == {'table_with_manual_key' => []}
+  end
+
+  it "select_cursor should handle zero result queries" do
+    session = Session.new
+    result = session.left.select_cursor :table => 'extender_no_record'
+    result.next?.should be_false
+  end
+  
+  it "select_cursor should work if row_buffer_size is smaller than table size" do
+    session = Session.new
+    result = session.left.select_cursor(:table => 'scanner_records', :row_buffer_size => 2)
+    result.next_row
+    result.next_row
+    result.next_row['id'].should == '3'
+    result.clear
+  end
+
+  it "select_cursor should allow iterating through records" do
+    session = Session.new
+    result = session.left.select_cursor :table => 'extender_one_record'
+    result.next?.should be_true
+    result.next_row.should == {'id' => "1", 'name' => 'Alice'}
+  end
+  
+  it "select_cursor next_row should raise if there are no records" do
+    session = Session.new
+    result = session.left.select_cursor :table => 'extender_no_record'
+    lambda {result.next_row}.should raise_error(RuntimeError, 'no more rows available')  
+  end
+  
+  it "select_cursor next_row should handle multi byte characters correctly" do
+    session = Session.new
+    result = session.left.select_cursor :query => "select id, multi_byte from extender_type_check"
+    row = result.next_row
+    row.should == {
+      'id' => "1", 
+      'multi_byte' => "よろしくお願(ねが)いします yoroshiku onegai shimasu: I humbly ask for your favor."
+    }
+  end
+  
+  it "select_cursor should read null values correctly" do
+    session = Session.new
+    result = session.left.select_cursor(
+      :table => 'extender_combined_key',
+      :row_keys => [{'first_id' => 3, 'second_id' => 1}]
+    )
+    result.next_row.should == {'first_id' => '3', 'second_id' => '1', 'name' => nil}
+  end
+  
+  it "should read and write binary data correctly" do
+    session = Session.new
+
+    org_data = Marshal.dump(['bla',:dummy,1,2,3])
+    result_data = nil
+    begin
+      session.left.begin_db_transaction
+      sql = "insert into extender_type_check(id, binary_test) values(2, '#{org_data}')"
+      session.left.execute sql
+
+      org_cursor = session.left.select_cursor(:query => "select id, binary_test from extender_type_check where id = 2")
+      cursor = TypeCastingCursor.new session.left, 'extender_type_check', org_cursor
+      result_data = cursor.next_row['binary_test']
+    ensure
+      session.left.rollback_db_transaction
+    end
+    result_data.should == org_data
+  end
+  
+  it "should read and write text data correctly" do
+    session = Session.new
+
+    org_data = "よろしくお願(ねが)いします yoroshiku onegai shimasu: I humbly ask for your favor."
+    result_data = nil
+    begin
+      session.left.begin_db_transaction
+      sql = "insert into extender_type_check(id, text_test) values(2, '#{org_data}')"
+      session.left.execute sql
+
+      org_cursor = session.left.select_cursor(:query => "select id, text_test from extender_type_check where id = 2")
+      cursor = TypeCastingCursor.new session.left, 'extender_type_check', org_cursor
+      result_data = cursor.next_row['text_test']
+    ensure
+      session.left.rollback_db_transaction
+    end
+    result_data.should == org_data
+  end
+  
+  it "cursors returned by select_cursor should support clear" do
+    session = Session.new
+    result = session.left.select_cursor :table => 'extender_one_record'
+    result.next?.should be_true
+    result.should respond_to(:clear)
+    result.clear
+  end
+end

data/spec/connection_extenders_registration_spec.rb

@@ -0,0 +1,129 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe ConnectionExtenders, "Registration" do
+  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 "extenders should return list of registered connection extenders" do
+    ConnectionExtenders.extenders.include?(:postgresql).should be_true
+  end
+  
+  it "register should register a new connection extender" do
+    ConnectionExtenders.register(:bla => :blub)
+    
+    ConnectionExtenders.extenders.include?(:bla).should be_true
+  end
+  
+  it "register should replace already existing connection extenders" do
+    ConnectionExtenders.register(:bla => :blub)
+    ConnectionExtenders.register(:bla => :blub2)
+    
+    ConnectionExtenders.extenders[:bla].should == :blub2
+  end
+  
+  it "initialize should establish the database connections" do
+    mock_active_record :once
+    
+    ConnectionExtenders.db_connect Initializer.configuration.left
+  end
+    
+  it "db_connect should use jdbc configuration adapter and extender under jruby" do
+    fake_ruby_platform 'java' do
+      mock_active_record :once
+      used_extender = nil
+      ConnectionExtenders.extenders.should_receive('[]'.to_sym).once \
+        .and_return {|extender| used_extender = extender }
+
+      configuration = deep_copy(Initializer.configuration)
+      configuration.left[:adapter] = 'dummyadapter'
+      
+      ConnectionExtenders.db_connect configuration.left
+      
+      $used_config[:adapter].should == "jdbcdummyadapter"
+      used_extender.should == :jdbc
+    end
+  end
+
+  it "db_connect created connections should be alive" do
+    connection = ConnectionExtenders.db_connect Initializer.configuration.left
+    
+    connection.should be_active
+  end
+  
+  it "db_connect should include the connection extender into connection" do
+    connection = ConnectionExtenders.db_connect Initializer.configuration.left
+    
+    connection.should respond_to(:select_cursor)
+  end
+  
+  it "db_connect should raise an Exception if no fitting connection extender is available" do
+    # If unknown connection adapters are encountered in jruby, then we
+    # automatically use JdbcExtender.
+    # Means that this test only makes sense if not running on jruby
+    if not RUBY_PLATFORM =~ /java/
+      mock_active_record :once
+
+      config = deep_copy(Initializer.configuration)
+
+      config.left[:adapter] = 'dummy'
+
+      lambda {ConnectionExtenders.db_connect  config.left}.should raise_error(RuntimeError, /dummy/)
+    end
+  end
+  
+  it "use_db_connection_cache should set the new cache status and return the old one" do
+    ConnectionExtenders.use_db_connection_cache :first_status
+    first_status = ConnectionExtenders.use_db_connection_cache :second_status
+    second_status = ConnectionExtenders.use_db_connection_cache :whatever
+    first_status.should == :first_status
+    second_status.should == :second_status
+  end
+  
+  it "clear_db_connection_cache should clear the connection cache" do
+    old_cache = ConnectionExtenders.connection_cache
+    begin
+      ConnectionExtenders.connection_cache = :dummy_cache
+      ConnectionExtenders.clear_db_connection_cache
+      ConnectionExtenders.connection_cache.should == {}
+    ensure
+      ConnectionExtenders.connection_cache = old_cache
+    end
+  end
+  
+  it "db_connect should create the database connection if not yet cached" do
+    old_cache = ConnectionExtenders.connection_cache
+    begin
+      ConnectionExtenders.clear_db_connection_cache
+      mock_active_record :once
+      ConnectionExtenders.use_db_connection_cache true
+      ConnectionExtenders.db_connect Initializer.configuration.left
+      ConnectionExtenders.connection_cache.should_not be_empty
+    ensure
+      ConnectionExtenders.connection_cache = old_cache     
+    end    
+  end
+  
+  it "db_connect should not create the database connection if already cached and alive" do
+    old_cache = ConnectionExtenders.connection_cache
+    begin
+      ConnectionExtenders.clear_db_connection_cache
+      mock_active_record :once # only mocked once even though db_connect is called twice
+      ConnectionExtenders.use_db_connection_cache true
+      connection = ConnectionExtenders.db_connect Initializer.configuration.left
+      connection.should_receive(:active?).and_return(:true)
+      ConnectionExtenders.db_connect Initializer.configuration.left
+    ensure
+      ConnectionExtenders.connection_cache = old_cache     
+    end    
+  end
+  
+end
+

data/spec/database_proxy_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe DatabaseProxy do
+  before(:each) do
+    Initializer.configuration = standard_config
+  end
+
+  it "initialize should create an empty session regiser" do
+    proxy =  DatabaseProxy.new
+    proxy.session_register.should == {}
+  end
+
+  def create_proxy_and_session
+    proxy = DatabaseProxy.new
+    session = proxy.create_session Initializer.configuration.left
+    return proxy, session
+  end
+
+  it "create_session should register the created session" do
+    proxy, session = create_proxy_and_session
+
+    session.should be_an_instance_of(ProxyConnection)
+    proxy.session_register.include?(session).should == true
+  end
+
+  it "destroy_session should destroy and unregister the session" do
+    proxy, session = create_proxy_and_session
+    session.should_receive(:destroy)
+    
+    proxy.destroy_session session
+
+    proxy.session_register.include?(session).should == false
+  end
+  
+  it "ping should respond with 'pong'" do
+    proxy = DatabaseProxy.new
+    proxy.ping.should == 'pong' 
+  end
+  
+  it "terminate should exit the proxy" do
+    proxy = DatabaseProxy.new
+    Thread.main.should_receive(:raise).with(SystemExit)
+    
+    proxy.terminate!
+  end
+end