rubyrep 1.2.0 → 2.0.0

data/spec/configuration_spec.rb

@@ -1,203 +0,0 @@
-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(Replicators::TwoWayReplicator.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(Replicators::TwoWayReplicator.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(Replicators::TwoWayReplicator.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(Replicators::TwoWayReplicator.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(Replicators::TwoWayReplicator.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

@@ -1,141 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-require 'yaml'
-require 'digest/md5'
-
-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_record(:table => "extender_type_check")['multi_byte'].
-      should == "よろしくお願(ねが)いします 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_record(
-      :table => 'extender_combined_key',
-      :row_keys => ['first_id' => 3, 'second_id' => 1]
-    ).should == {'first_id' => 3, 'second_id' => 1, 'name' => nil}
-  end
-
-  it "should read and write binary data correctly" do
-    session = Session.new
-
-    org_data = File.new(File.dirname(__FILE__) + '/dolphins.jpg').read
-    result_data = nil
-    begin
-      session.left.begin_db_transaction
-      session.left.insert_record('extender_type_check', {'id' => 6, 'binary_test' => org_data})
-
-      row = session.left.select_one(
-        'select md5(binary_test) as md5 from extender_type_check where id = 6'
-      )
-      row['md5'].should == Digest::MD5.hexdigest(org_data)
-
-      result_data = session.left.select_record(
-        :table => "extender_type_check",
-        :row_keys => ["id" => 6]
-      )['binary_test']
-      Digest::MD5.hexdigest(result_data).should == Digest::MD5.hexdigest(org_data)
-    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
-
-      result_data = session.left.select_record(
-        :table => "extender_type_check",
-        :row_keys => ["id" => 2]
-      )["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

@@ -1,164 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe ConnectionExtenders do
-  before(:each) do
-    Initializer.configuration = standard_config
-  end
-
-  it "db_connect should install the already created logger" do
-    configuration = deep_copy(Initializer.configuration)
-    io = StringIO.new
-    logger = ActiveSupport::BufferedLogger.new(io)
-    configuration.left[:logger] = logger
-    session = Session.new configuration
-
-    session.left.connection.instance_eval {@logger}.should == logger
-    session.right.connection.instance_eval {@logger}.should_not == logger
-
-    session.left.select_one "select 'left_query'"
-    session.right.select_one "select 'right_query'"
-
-    io.string.should =~ /left_query/
-    io.string.should_not =~ /right_query/
-  end
-
-  it "db_connect should create and install the specified logger" do
-    configuration = deep_copy(Initializer.configuration)
-    io = StringIO.new
-    configuration.left[:logger] = io
-    session = Session.new configuration
-    session.left.select_one "select 'left_query'"
-    session.right.select_one "select 'right_query'"
-
-    io.string.should =~ /left_query/
-    io.string.should_not =~ /right_query/
-  end
-end
-
-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(:primary_key_names)
-  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

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

data/spec/database_rake_spec.rb

@@ -1,40 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-load File.dirname(__FILE__) + '/../tasks/database.rake'
-
-describe "database.rake" do
-  before(:each) do
-  end
-
-  it "create_database should create a non-existing database" do
-    RR::ConnectionExtenders.should_receive(:db_connect).and_raise("something")
-    should_receive("`").with("createdb \"dummy\" -E utf8")
-    
-    create_database :adapter => "postgresql", :database => "dummy"
-  end
-  
-  it "create_database should not try to create existing databases" do
-    RR::ConnectionExtenders.should_receive(:db_connect)
-    should_receive(:puts).with("database existing_db already exists")
-    
-    create_database :adapter => 'postgresql', :database => "existing_db"
-  end
-
-  it "create_database should complain about unsupported adapters" do
-    should_receive(:puts).with("adapter unsupported_adapter not supported")
-    
-    create_database :adapter => "unsupported_adapter"
-  end
-  
-  it "drop_database should drop a PostgreSQL database" do
-    should_receive("`").with("dropdb \"dummy\"")
-    
-    drop_database :adapter => "postgresql", :database => "dummy"
-  end
-  
-  it "drop_database should complain about unsupported adapters" do
-    should_receive(:puts).with("adapter unsupported_adapter not supported")
-
-    drop_database :adapter => "unsupported_adapter"
-  end
-end
-

data/spec/db_specific_connection_extenders_spec.rb

@@ -1,34 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-require 'yaml'
-
-include RR
-
-extenders = [:mysql, :postgres]
-
-extenders.each do |extender|
-  describe "#{extender.to_s.capitalize} Connection Extender" do
-    before(:each) do
-      @org_test_db = ENV['RR_TEST_DB']
-      ENV['RR_TEST_DB'] = extender.to_s
-      Initializer.configuration = standard_config
-    end
-
-    after(:each) do
-      ENV['RR_TEST_DB'] = @org_test_db
-    end
-
-    begin
-      if ENV['RR_TEST_DB'] != @org_test_db.to_s
-        # If the current adapter is *not* the adapter for the standard tests
-        # (meaning the adapter which is used to run all other tests)
-        # then only run the extender spec if the database connection is available
-        Session.new read_config(extender)
-      end
-      it_should_behave_like "ConnectionExtender"
-    rescue Exception => e
-      at_exit do
-        puts "#{__FILE__}:#{__LINE__}: DB Connection failed with '#{e}' ==> #{extender.to_s.capitalize} connection extender not tested"
-      end
-    end
-  end
-end

data/spec/db_specific_replication_extenders_spec.rb

@@ -1,38 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-require 'yaml'
-
-require 'replication_extender_interface_spec.rb'
-require 'postgresql_replication_spec.rb'
-
-include RR
-
-extenders = [:postgres, :mysql]
-
-extenders.each do |extender|
-  describe "#{extender.to_s.capitalize} Replication Extender" do
-    before(:each) do
-      @org_test_db = ENV['RR_TEST_DB']
-      ENV['RR_TEST_DB'] = extender.to_s
-      Initializer.configuration = standard_config
-    end
-
-    after(:each) do
-      ENV['RR_TEST_DB'] = @org_test_db
-    end
-
-    begin
-      if ENV['RR_TEST_DB'] != @org_test_db.to_s
-        # If the current adapter is *not* the adapter for the standard tests
-        # (meaning the adapter which is used to run all other tests)
-        # then only run the extender spec if the database connection is available
-        Session.new read_config(extender)
-      end
-      it_should_behave_like "ReplicationExtender"
-      it_should_behave_like "PostgreSQLReplication" if extender == :postgres
-    rescue Exception => e
-      at_exit do
-        puts "#{__FILE__}:#{__LINE__}: DB Connection failed with '#{e}' ==> #{extender.to_s.capitalize} replication extender not tested"
-      end
-    end
-  end
-end